@theia/plugin-ext 1.33.0-next.8 → 1.33.0

package/src/main/browser/languages-main.ts

@@ -34,7 +34,8 @@ import {
     WorkspaceTextEditDto,
     PluginInfo,
     LanguageStatus as LanguageStatusDTO,
-    InlayHintDto
+    InlayHintDto,
+    IdentifiableInlineCompletions
 } from '../../common/plugin-api-rpc';
 import { injectable, inject } from '@theia/core/shared/inversify';
 import {
@@ -868,6 +869,22 @@ export class LanguagesMainImpl implements LanguagesMain, Disposable {
         }
     }
 
+    $registerInlineCompletionsSupport(handle: number, selector: SerializedDocumentFilter[]): void {
+        const languageSelector = this.toLanguageSelector(selector);
+        const provider: monaco.languages.InlineCompletionsProvider<IdentifiableInlineCompletions> = {
+            provideInlineCompletions: async (
+                model: monaco.editor.ITextModel,
+                position: monaco.Position,
+                context: monaco.languages.InlineCompletionContext,
+                token: CancellationToken
+            ): Promise<IdentifiableInlineCompletions | undefined> => this.proxy.$provideInlineCompletions(handle, model.uri, position, context, token),
+            freeInlineCompletions: (completions: IdentifiableInlineCompletions): void => {
+                this.proxy.$freeInlineCompletionsList(handle, completions.pid);
+            }
+        };
+        this.register(handle, (monaco.languages.registerInlineCompletionsProvider as RegistrationFunction<monaco.languages.InlineCompletionsProvider>)(languageSelector, provider));
+    }
+
     $registerQuickFixProvider(
         handle: number,
         pluginInfo: PluginInfo,

package/src/main/browser/terminal-main.ts

@@ -260,11 +260,11 @@ export class TerminalServiceMainImpl implements TerminalServiceMain, TerminalLin
         }
     }
 
-    async provideLinks(line: string, terminal: TerminalWidget, cancelationToken?: CancellationToken | undefined): Promise<TerminalLink[]> {
+    async provideLinks(line: string, terminal: TerminalWidget, cancellationToken?: CancellationToken | undefined): Promise<TerminalLink[]> {
         if (this.terminalLinkProviders.length < 1) {
             return [];
         }
-        const links = await this.extProxy.$provideTerminalLinks(line, terminal.id, cancelationToken ?? CancellationToken.None);
+        const links = await this.extProxy.$provideTerminalLinks(line, terminal.id, cancellationToken ?? CancellationToken.None);
         return links.map(link => ({ ...link, handle: () => this.extProxy.$handleTerminalLink(link) }));
     }
 

package/src/main/browser/webview/pre/main.js

@@ -479,7 +479,14 @@
                 const newFrame = document.createElement('iframe');
                 newFrame.setAttribute('id', 'pending-frame');
                 newFrame.setAttribute('frameborder', '0');
-                newFrame.setAttribute('sandbox', options.allowScripts ? 'allow-scripts allow-forms allow-same-origin allow-downloads' : 'allow-same-origin');
+                const sandboxOptions = ['allow-same-origin'];
+                if (options.allowScripts) {
+                    sandboxOptions.push('allow-scripts', 'allow-downloads');
+                }
+                if (options.allowForms ?? options.allowScripts) {
+                    sandboxOptions.push('allow-forms');
+                }
+                newFrame.setAttribute('sandbox', sandboxOptions.join(' '));
                 if (host.fakeLoad) {
                     // We should just be able to use srcdoc, but I wasn't
                     // seeing the service worker applying properly.

package/src/main/browser/webview/webview.ts

@@ -73,6 +73,7 @@ export const enum WebviewMessageChannels {
 
 export interface WebviewContentOptions {
     readonly allowScripts?: boolean;
+    readonly allowForms?: boolean;
     readonly localResourceRoots?: ReadonlyArray<string>;
     readonly portMapping?: ReadonlyArray<WebviewPortMapping>;
     readonly enableCommandUris?: boolean;

package/src/main/browser/webviews-main.ts

@@ -67,10 +67,11 @@ export class WebviewsMainImpl implements WebviewsMain, Disposable {
         this.hookWebview(view);
         view.viewType = viewType;
         view.title.label = title;
-        const { enableFindWidget, retainContextWhenHidden, enableScripts, localResourceRoots, ...contentOptions } = options;
+        const { enableFindWidget, retainContextWhenHidden, enableScripts, enableForms, localResourceRoots, ...contentOptions } = options;
         view.options = { enableFindWidget, retainContextWhenHidden };
         view.setContentOptions({
             allowScripts: enableScripts,
+            allowForms: enableForms,
             localResourceRoots: localResourceRoots && localResourceRoots.map(root => root.toString()),
             ...contentOptions
         });
@@ -171,9 +172,10 @@ export class WebviewsMainImpl implements WebviewsMain, Disposable {
 
     async $setOptions(handle: string, options: WebviewOptions): Promise<void> {
         const webview = await this.getWebview(handle);
-        const { enableScripts, localResourceRoots, ...contentOptions } = options;
+        const { enableScripts, enableForms, localResourceRoots, ...contentOptions } = options;
         webview.setContentOptions({
             allowScripts: enableScripts,
+            allowForms: enableForms,
             localResourceRoots: localResourceRoots && localResourceRoots.map(root => root.toString()),
             ...contentOptions
         });
@@ -210,10 +212,11 @@ export class WebviewsMainImpl implements WebviewsMain, Disposable {
         }
 
         const options = widget.options;
-        const { allowScripts, localResourceRoots, ...contentOptions } = widget.contentOptions;
+        const { allowScripts, allowForms, localResourceRoots, ...contentOptions } = widget.contentOptions;
         this.updateViewState(widget);
         await this.proxy.$deserializeWebviewPanel(handle, widget.viewType, title, state, widget.viewState, {
             enableScripts: allowScripts,
+            enableForms: allowForms,
             localResourceRoots: localResourceRoots && localResourceRoots.map(root => URI.parse(root)),
             ...contentOptions,
             ...options

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

@@ -137,7 +137,7 @@ class FsLinkProvider {
 
 class ConsumerFileSystem implements vscode.FileSystem {
 
-    constructor(private _proxy: FileSystemMain) { }
+    constructor(private _proxy: FileSystemMain, private _capabilities: Map<string, number>) { }
 
     stat(uri: vscode.Uri): Promise<vscode.FileStat> {
         return this._proxy.$stat(uri).catch(ConsumerFileSystem._handleError);
@@ -148,7 +148,7 @@ class ConsumerFileSystem implements vscode.FileSystem {
     createDirectory(uri: vscode.Uri): Promise<void> {
         return this._proxy.$mkdir(uri).catch(ConsumerFileSystem._handleError);
     }
-    async readFile(uri: vscode.Uri): Promise<Uint8Array> {
+    readFile(uri: vscode.Uri): Promise<Uint8Array> {
         return this._proxy.$readFile(uri).then(buff => buff.buffer).catch(ConsumerFileSystem._handleError);
     }
     writeFile(uri: vscode.Uri, content: Uint8Array): Promise<void> {
@@ -163,6 +163,13 @@ class ConsumerFileSystem implements vscode.FileSystem {
     copy(source: vscode.Uri, destination: vscode.Uri, options?: { overwrite?: boolean }): Promise<void> {
         return this._proxy.$copy(source, destination, { ...{ overwrite: false }, ...options }).catch(ConsumerFileSystem._handleError);
     }
+    isWritableFileSystem(scheme: string): boolean | undefined {
+        const capabilities = this._capabilities.get(scheme);
+        if (typeof capabilities === 'number') {
+            return (capabilities & files.FileSystemProviderCapabilities.Readonly) === 0;
+        }
+        return undefined;
+    }
     private static _handleError(err: any): never {
         // generic error
         if (!(err instanceof Error)) {
@@ -193,6 +200,7 @@ export class FileSystemExtImpl implements FileSystemExt {
     private readonly _proxy: FileSystemMain;
     private readonly _linkProvider = new FsLinkProvider();
     private readonly _fsProvider = new Map<number, vscode.FileSystemProvider>();
+    private readonly _capabilities = new Map<string, number>();
     private readonly _usedSchemes = new Set<string>();
     private readonly _watches = new Map<number, IDisposable>();
 
@@ -203,7 +211,7 @@ export class FileSystemExtImpl implements FileSystemExt {
 
     constructor(rpc: RPCProtocol, private _extHostLanguageFeatures: LanguagesExtImpl) {
         this._proxy = rpc.getProxy(PLUGIN_RPC_CONTEXT.FILE_SYSTEM_MAIN);
-        this.fileSystem = new ConsumerFileSystem(this._proxy);
+        this.fileSystem = new ConsumerFileSystem(this._proxy, this._capabilities);
 
         // register used schemes
         Object.keys(Schemas).forEach(scheme => this._usedSchemes.add(scheme));
@@ -295,8 +303,16 @@ export class FileSystemExtImpl implements FileSystemExt {
     }
 
     private static _asIStat(stat: vscode.FileStat): files.Stat {
-        const { type, ctime, mtime, size } = stat;
-        return { type, ctime, mtime, size };
+        const { type, ctime, mtime, size, permissions } = stat;
+        return { type, ctime, mtime, size, permissions };
+    }
+
+    $acceptProviderInfos(scheme: string, capabilities?: files.FileSystemProviderCapabilities): void {
+        if (typeof capabilities === 'number') {
+            this._capabilities.set(scheme, capabilities);
+        } else {
+            this._capabilities.delete(scheme);
+        }
     }
 
     $stat(handle: number, resource: UriComponents): Promise<files.Stat> {

package/src/plugin/languages/inline-completion.ts

@@ -0,0 +1,126 @@
+// *****************************************************************************
+// Copyright (C) 2022 Ericsson 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 WITH Classpath-exception-2.0
+// *****************************************************************************
+
+// copied from https://github.com/microsoft/vscode/blob/6261075646f055b99068d3688932416f2346dd3b/src/vs/workbench/api/common/extHostLanguageFeatures.ts#L1069-L1185.
+
+import * as theia from '@theia/plugin';
+import * as Converter from '../type-converters';
+import { DocumentsExtImpl } from '../documents';
+import { URI } from '@theia/core/shared/vscode-uri';
+import { CommandRegistryImpl } from '../command-registry';
+import { ReferenceMap } from '../../common/reference-map';
+import { DisposableCollection } from '@theia/core/lib/common/disposable';
+import { InlineCompletionTriggerKind as TriggerKind } from '../../plugin/types-impl';
+import { Command, InlineCompletionContext, InlineCompletionTriggerKind } from '../../common/plugin-api-rpc-model';
+import { IdentifiableInlineCompletion, IdentifiableInlineCompletions, Position } from '../../common/plugin-api-rpc';
+
+export class InlineCompletionAdapterBase {
+
+    async provideInlineCompletions(
+        _resource: URI,
+        _position: Position,
+        _context: InlineCompletionContext,
+        _token: theia.CancellationToken
+    ): Promise<IdentifiableInlineCompletions | undefined> {
+        return undefined;
+    }
+
+    disposeCompletions(pid: number): void { return; };
+}
+
+export class InlineCompletionAdapter extends InlineCompletionAdapterBase {
+
+    private readonly references = new ReferenceMap<{
+        dispose(): void;
+        items: readonly theia.InlineCompletionItem[];
+    }>();
+
+    constructor(
+        private readonly documents: DocumentsExtImpl,
+        private readonly provider: theia.InlineCompletionItemProvider,
+        private readonly commands: CommandRegistryImpl,
+    ) {
+        super();
+    }
+
+    private readonly languageTriggerKindToVSCodeTriggerKind: Record<InlineCompletionTriggerKind, TriggerKind> = {
+        [InlineCompletionTriggerKind.Automatic]: TriggerKind.Automatic,
+        [InlineCompletionTriggerKind.Explicit]: TriggerKind.Invoke,
+    };
+
+    override async provideInlineCompletions(
+        resource: URI,
+        position: Position,
+        context: InlineCompletionContext,
+        token: theia.CancellationToken
+    ): Promise<IdentifiableInlineCompletions | undefined> {
+        const doc = this.documents.getDocument(resource);
+        const pos = Converter.toPosition(position);
+
+        const result = await this.provider.provideInlineCompletionItems(doc, pos, {
+            selectedCompletionInfo:
+                context.selectedSuggestionInfo
+                    ? {
+                        range: Converter.toRange(context.selectedSuggestionInfo.range),
+                        text: context.selectedSuggestionInfo.text
+                    }
+                    : undefined,
+            triggerKind: this.languageTriggerKindToVSCodeTriggerKind[context.triggerKind]
+        }, token);
+
+        if (!result || token.isCancellationRequested) {
+            return undefined;
+        }
+
+        const normalizedResult = Array.isArray(result) ? result : result.items;
+
+        let disposableCollection: DisposableCollection | undefined = undefined;
+        const pid = this.references.createReferenceId({
+            dispose(): void {
+                disposableCollection?.dispose();
+            },
+            items: normalizedResult
+        });
+
+        return {
+            pid,
+            items: normalizedResult.map<IdentifiableInlineCompletion>((item, idx) => {
+                let command: Command | undefined = undefined;
+                if (item.command) {
+                    if (!disposableCollection) {
+                        disposableCollection = new DisposableCollection();
+                    }
+                    command = this.commands.converter.toSafeCommand(item.command, disposableCollection);
+                }
+
+                const insertText = item.insertText;
+                return ({
+                    insertText: typeof insertText === 'string' ? insertText : { snippet: insertText.value },
+                    filterText: item.filterText,
+                    range: item.range ? Converter.fromRange(item.range) : undefined,
+                    command,
+                    idx: idx
+                });
+            })
+        };
+    }
+
+    override disposeCompletions(pid: number): void {
+        const data = this.references.disposeReferenceId(pid);
+        data?.dispose();
+    }
+
+}

package/src/plugin/languages.ts

@@ -27,6 +27,7 @@ import {
     Plugin,
     InlayHintsDto,
     InlayHintDto,
+    IdentifiableInlineCompletions,
 } from '../common/plugin-api-rpc';
 import { RPCProtocol } from '../common/rpc-protocol';
 import * as theia from '@theia/plugin';
@@ -67,7 +68,8 @@ import {
     EvaluatableExpression,
     InlineValue,
     InlineValueContext,
-    TypeHierarchyItem
+    TypeHierarchyItem,
+    InlineCompletionContext
 } from '../common/plugin-api-rpc-model';
 import { CompletionAdapter } from './languages/completion';
 import { Diagnostics } from './languages/diagnostics';
@@ -106,6 +108,7 @@ import { Severity } from '@theia/core/lib/common/severity';
 import { LinkedEditingRangeAdapter } from './languages/linked-editing-range';
 import { serializeEnterRules, serializeIndentation, serializeRegExp } from './languages-utils';
 import { InlayHintsAdapter } from './languages/inlay-hints';
+import { InlineCompletionAdapter, InlineCompletionAdapterBase } from './languages/inline-completion';
 
 type Adapter = CompletionAdapter |
     SignatureHelpAdapter |
@@ -135,7 +138,8 @@ type Adapter = CompletionAdapter |
     DocumentRangeSemanticTokensAdapter |
     DocumentSemanticTokensAdapter |
     LinkedEditingRangeAdapter |
-    TypeHierarchyAdapter;
+    TypeHierarchyAdapter |
+    InlineCompletionAdapter;
 
 export class LanguagesExtImpl implements LanguagesExt {
 
@@ -246,7 +250,8 @@ export class LanguagesExtImpl implements LanguagesExt {
                 $serialized: true,
                 language: selector.language,
                 scheme: selector.scheme,
-                pattern: selector.pattern
+                pattern: selector.pattern,
+                notebookType: selector.notebookType
             };
         }
 
@@ -275,6 +280,28 @@ export class LanguagesExtImpl implements LanguagesExt {
     }
     // ### Completion end
 
+    // ### Inline completion provider begin
+    registerInlineCompletionsProvider(selector: theia.DocumentSelector, provider: theia.InlineCompletionItemProvider): theia.Disposable {
+        const callId = this.addNewAdapter(new InlineCompletionAdapter(this.documents, provider, this.commands));
+        this.proxy.$registerInlineCompletionsSupport(callId, this.transformDocumentSelector(selector));
+        return this.createDisposable(callId);
+    }
+
+    $provideInlineCompletions(
+        handle: number,
+        resource: UriComponents,
+        position: Position,
+        context: InlineCompletionContext,
+        token: theia.CancellationToken
+    ): Promise<IdentifiableInlineCompletions | undefined> {
+        return this.withAdapter(handle, InlineCompletionAdapterBase, adapter => adapter.provideInlineCompletions(URI.revive(resource), position, context, token), undefined);
+    }
+
+    $freeInlineCompletionsList(handle: number, pid: number): void {
+        this.withAdapter(handle, InlineCompletionAdapterBase, async adapter => { adapter.disposeCompletions(pid); }, undefined);
+    }
+    // ### Inline completion provider end
+
     // ### Definition provider begin
     $provideDefinition(handle: number, resource: UriComponents, position: Position, token: theia.CancellationToken): Promise<Definition | undefined> {
         return this.withAdapter(handle, DefinitionAdapter, adapter => adapter.provideDefinition(URI.revive(resource), position, token), undefined);

package/src/plugin/plugin-context.ts

@@ -155,11 +155,27 @@ import {
     InlayHint,
     InlayHintKind,
     InlayHintLabelPart,
+    NotebookCell,
+    NotebookCellKind,
+    NotebookCellStatusBarAlignment,
+    NotebookEditorRevealType,
+    NotebookControllerAffinity,
+    NotebookCellData,
+    NotebookCellOutput,
+    NotebookCellOutputItem,
+    NotebookData,
+    NotebookDocument,
+    NotebookRange,
+    NotebookCellStatusBarItem,
+    NotebookEdit,
     TestRunProfileKind,
     TestTag,
     TestRunRequest,
     TestMessage,
-    ExtensionKind
+    ExtensionKind,
+    InlineCompletionItem,
+    InlineCompletionList,
+    InlineCompletionTriggerKind
 } from './types-impl';
 import { AuthenticationExtImpl } from './authentication-ext';
 import { SymbolKind } from '../common/plugin-api-rpc-model';
@@ -201,6 +217,7 @@ import { CustomEditorsExtImpl } from './custom-editors';
 import { WebviewViewsExtImpl } from './webview-views';
 import { PluginPackage } from '../common';
 import { Endpoint } from '@theia/core/lib/browser/endpoint';
+import { FilePermission } from '@theia/filesystem/lib/common/files';
 
 export function createAPIFactory(
     rpc: RPCProtocol,
@@ -381,6 +398,26 @@ export function createAPIFactory(
                     throw new Error(`Failed to show text document ${documentArg.toString()}`);
                 }
             },
+            get visibleNotebookEditors(): theia.NotebookEditor[] {
+                return [] as theia.NotebookEditor[];
+            },
+            onDidChangeVisibleNotebookEditors(listener, thisArg?, disposables?) {
+                return Disposable.NULL;
+            },
+            get activeNotebookEditor(): theia.NotebookEditor | undefined {
+                return undefined;
+            }, onDidChangeActiveNotebookEditor(listener, thisArg?, disposables?) {
+                return Disposable.NULL;
+            },
+            onDidChangeNotebookEditorSelection(listener, thisArg?, disposables?) {
+                return Disposable.NULL;
+            },
+            onDidChangeNotebookEditorVisibleRanges(listener, thisArg?, disposables?) {
+                return Disposable.NULL;
+            },
+            showNotebookDocument(document: NotebookDocument, options?: theia.NotebookDocumentShowOptions) {
+                return Promise.resolve({} as theia.NotebookEditor);
+            },
             // eslint-disable-next-line @typescript-eslint/no-explicit-any
             showQuickPick(items: any, options?: theia.QuickPickOptions, token?: theia.CancellationToken): any {
                 return quickOpenExt.showQuickPick(items, options, token);
@@ -528,6 +565,9 @@ export function createAPIFactory(
             onDidChangeWorkspaceFolders(listener, thisArg?, disposables?): theia.Disposable {
                 return workspaceExt.onDidChangeWorkspaceFolders(listener, thisArg, disposables);
             },
+            get notebookDocuments(): theia.NotebookDocument[] {
+                return [] as theia.NotebookDocument[];
+            },
             get textDocuments(): theia.TextDocument[] {
                 return documents.getAllDocumentData().map(data => data.document);
             },
@@ -537,6 +577,18 @@ export function createAPIFactory(
             onDidCloseTextDocument(listener, thisArg?, disposables?) {
                 return documents.onDidRemoveDocument(listener, thisArg, disposables);
             },
+            onDidOpenNotebookDocument(listener, thisArg?, disposables?) {
+                return Disposable.NULL;
+            },
+            onDidCloseNotebookDocument(listener, thisArg?, disposables?) {
+                return Disposable.NULL;
+            },
+            onDidChangeNotebookDocument(listener, thisArg?, disposables?) {
+                return Disposable.NULL;
+            },
+            onDidSaveNotebookDocument(listener, thisArg?, disposables?) {
+                return Disposable.NULL;
+            },
             onDidOpenTextDocument(listener, thisArg?, disposables?) {
                 return documents.onDidAddDocument(listener, thisArg, disposables);
             },
@@ -581,6 +633,9 @@ export function createAPIFactory(
                 const data = await documents.openDocument(uri);
                 return data && data.document;
             },
+            openNotebookDocument(uriOrString: theia.Uri | string, content?: NotebookData): Promise<theia.NotebookDocument | undefined> {
+                return Promise.reject(new Error('Notebook API is stubbed'));
+            },
             createFileSystemWatcher: (pattern, ignoreCreate, ignoreChange, ignoreDelete): theia.FileSystemWatcher =>
                 extHostFileSystemEvent.createFileSystemWatcher(fromGlobPattern(pattern), ignoreCreate, ignoreChange, ignoreDelete),
             findFiles(include: theia.GlobPattern, exclude?: theia.GlobPattern | null, maxResults?: number, token?: CancellationToken): PromiseLike<URI[]> {
@@ -599,8 +654,8 @@ export function createAPIFactory(
             registerTextDocumentContentProvider(scheme: string, provider: theia.TextDocumentContentProvider): theia.Disposable {
                 return workspaceExt.registerTextDocumentContentProvider(scheme, provider);
             },
-            registerFileSystemProvider(scheme: string, provider: theia.FileSystemProvider): theia.Disposable {
-                return fileSystemExt.registerFileSystemProvider(scheme, provider);
+            registerFileSystemProvider(scheme: string, provider: theia.FileSystemProvider, options?: { isCaseSensitive?: boolean, isReadonly?: boolean }): theia.Disposable {
+                return fileSystemExt.registerFileSystemProvider(scheme, provider, options);
             },
             getWorkspaceFolder(uri: theia.Uri): theia.WorkspaceFolder | undefined {
                 return workspaceExt.getWorkspaceFolder(uri);
@@ -620,6 +675,9 @@ export function createAPIFactory(
             registerTimelineProvider(scheme: string | string[], provider: theia.TimelineProvider): theia.Disposable {
                 return timelineExt.registerTimelineProvider(plugin, scheme, provider);
             },
+            registerNotebookSerializer(notebookType: string, serializer: theia.NotebookSerializer, options?: theia.NotebookDocumentContentOptions): theia.Disposable {
+                return Disposable.NULL;
+            },
             get isTrusted(): boolean {
                 return workspaceExt.trusted;
             },
@@ -715,6 +773,9 @@ export function createAPIFactory(
             registerCompletionItemProvider(selector: theia.DocumentSelector, provider: theia.CompletionItemProvider, ...triggerCharacters: string[]): theia.Disposable {
                 return languagesExt.registerCompletionItemProvider(selector, provider, triggerCharacters, pluginToPluginInfo(plugin));
             },
+            registerInlineCompletionItemProvider(selector: theia.DocumentSelector, provider: theia.InlineCompletionItemProvider): theia.Disposable {
+                return languagesExt.registerInlineCompletionsProvider(selector, provider);
+            },
             registerDefinitionProvider(selector: theia.DocumentSelector, provider: theia.DefinitionProvider): theia.Disposable {
                 return languagesExt.registerDefinitionProvider(selector, provider, pluginToPluginInfo(plugin));
             },
@@ -981,6 +1042,66 @@ export function createAPIFactory(
             }
         };
 
+        // notebooks API (@stubbed)
+        // The following implementation is temporarily `@stubbed` and marked as such under `theia.d.ts`
+        const notebooks: typeof theia.notebooks = {
+            createNotebookController(
+                id,
+                notebookType,
+                label,
+                handler?: (cells: theia.NotebookCell[],
+                    notebook: theia.NotebookDocument,
+                    controller: theia.NotebookController) => void | Thenable<void>
+            ) {
+                return {
+                    id,
+                    notebookType,
+                    label,
+                    handler,
+                    createNotebookCellExecution: (cell: NotebookCell) => ({
+                        cell,
+                        token: CancellationToken.None,
+                        executionOrder: undefined,
+                        start: () => undefined,
+                        end: () => undefined,
+                        clearOutput: () => ({} as Thenable<void>),
+                        replaceOutput: () => ({} as Thenable<void>),
+                        appendOutput: () => ({} as Thenable<void>),
+                        replaceOutputItems: () => ({} as Thenable<void>),
+                        appendOutputItems: () => ({} as Thenable<void>)
+                    }),
+                    executeHandler(
+                        cells: theia.NotebookCell[],
+                        notebook: theia.NotebookDocument,
+                        controller: theia.NotebookController
+                    ): (void | Thenable<void>) { },
+                    onDidChangeSelectedNotebooks: () => Disposable.create(() => {}),
+                    updateNotebookAffinity: (notebook: theia.NotebookDocument, affinity: theia.NotebookControllerAffinity) => undefined,
+                    dispose: () => undefined,
+                };
+
+            },
+            createRendererMessaging(
+                rendererId
+            ) {
+                return {
+                    rendererId,
+                    onDidReceiveMessage: () => Disposable.create(() => {} ),
+                    postMessage: () => Promise.resolve({}),
+                };
+            },
+            registerNotebookCellStatusBarItemProvider(
+                notebookType,
+                provider
+            ) {
+                return {
+                    notebookType,
+                    provider,
+                    dispose: () => undefined,
+                };
+            }
+        };
+
         return <typeof theia>{
             version: require('../../package.json').version,
             authentication,
@@ -995,6 +1116,7 @@ export function createAPIFactory(
             debug,
             tasks,
             scm,
+            notebooks,
             tests,
             // Types
             StatusBarAlignment: StatusBarAlignment,
@@ -1065,6 +1187,7 @@ export function createAPIFactory(
             WorkspaceEdit,
             SymbolInformation,
             FileType,
+            FilePermission,
             FileChangeType,
             ShellQuoting,
             ShellExecution,
@@ -1120,11 +1243,26 @@ export function createAPIFactory(
             InlayHint,
             InlayHintKind,
             InlayHintLabelPart,
+            NotebookCellData,
+            NotebookCellKind,
+            NotebookCellOutput,
+            NotebookCellOutputItem,
+            NotebookCellStatusBarAlignment,
+            NotebookCellStatusBarItem,
+            NotebookControllerAffinity,
+            NotebookData,
+            NotebookEditorRevealType,
+            NotebookDocument,
+            NotebookRange,
+            NotebookEdit,
             TestRunProfileKind,
             TestTag,
             TestRunRequest,
             TestMessage,
-            ExtensionKind
+            ExtensionKind,
+            InlineCompletionItem,
+            InlineCompletionList,
+            InlineCompletionTriggerKind
         };
     };
 }

package/src/plugin/theming.ts

@@ -59,6 +59,9 @@ export class ThemingExtImpl implements ThemingExt {
             case 'hc':
                 kind = ColorThemeKind.HighContrast;
                 break;
+            case 'hcLight':
+                kind = ColorThemeKind.HighContrastLight;
+                break;
         }
         return kind;
     }