@theia/plugin-ext 1.49.0 → 1.50.0

package/src/main/browser/window-activity-tracker.ts

@@ -0,0 +1,96 @@
+// *****************************************************************************
+// Copyright (C) 2024 STMicroelectronics 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 { Disposable, Emitter, Event } from '@theia/core';
+
+const CHECK_INACTIVITY_LIMIT = 30;
+const CHECK_INACTIVITY_INTERVAL = 1000;
+
+const eventListenerOptions: AddEventListenerOptions = {
+    passive: true,
+    capture: true
+};
+export class WindowActivityTracker implements Disposable {
+
+    private inactivityCounter = 0; // number of times inactivity was checked since last reset
+    private readonly inactivityLimit = CHECK_INACTIVITY_LIMIT; // number of inactivity checks done before sending inactive signal
+    private readonly checkInactivityInterval = CHECK_INACTIVITY_INTERVAL; // check interval in milliseconds
+    private interval: NodeJS.Timeout | undefined;
+
+    protected readonly onDidChangeActiveStateEmitter = new Emitter<boolean>();
+    private _activeState: boolean = true;
+
+    constructor(readonly win: Window) {
+        this.initializeListeners(this.win);
+    }
+
+    get onDidChangeActiveState(): Event<boolean> {
+        return this.onDidChangeActiveStateEmitter.event;
+    }
+
+    private set activeState(newState: boolean) {
+        if (this._activeState !== newState) {
+            this._activeState = newState;
+            this.onDidChangeActiveStateEmitter.fire(this._activeState);
+        }
+    }
+
+    private initializeListeners(win: Window): void {
+        // currently assumes activity based on key/mouse/touch pressed, not on mouse move or scrolling.
+        win.addEventListener('mousedown', this.resetInactivity, eventListenerOptions);
+        win.addEventListener('keydown', this.resetInactivity, eventListenerOptions);
+        win.addEventListener('touchstart', this.resetInactivity, eventListenerOptions);
+    }
+
+    dispose(): void {
+        this.stopTracking();
+        this.win.removeEventListener('mousedown', this.resetInactivity);
+        this.win.removeEventListener('keydown', this.resetInactivity);
+        this.win.removeEventListener('touchstart', this.resetInactivity);
+
+    }
+
+    // Reset inactivity time
+    private resetInactivity = (): void => {
+        this.inactivityCounter = 0;
+        if (!this.interval) {
+            // it was not active. Set as active and restart tracking inactivity
+            this.activeState = true;
+            this.startTracking();
+        }
+    };
+
+    // Check inactivity status
+    private checkInactivity = (): void => {
+        this.inactivityCounter++;
+        if (this.inactivityCounter >= this.inactivityLimit) {
+            this.activeState = false;
+            this.stopTracking();
+        }
+    };
+
+    public startTracking(): void {
+        this.stopTracking();
+        this.interval = setInterval(this.checkInactivity, this.checkInactivityInterval);
+    }
+
+    public stopTracking(): void {
+        if (this.interval) {
+            clearInterval(this.interval);
+            this.interval = undefined;
+        }
+    }
+}

package/src/main/browser/window-state-main.ts

@@ -23,6 +23,7 @@ import { UriComponents } from '../../common/uri-components';
 import { Disposable, DisposableCollection } from '@theia/core/lib/common/disposable';
 import { open, OpenerService } from '@theia/core/lib/browser/opener-service';
 import { ExternalUriService } from '@theia/core/lib/browser/external-uri-service';
+import { WindowActivityTracker } from './window-activity-tracker';
 
 export class WindowStateMain implements WindowMain, Disposable {
 
@@ -46,6 +47,10 @@ export class WindowStateMain implements WindowMain, Disposable {
         const fireDidBlur = () => this.onFocusChanged(false);
         window.addEventListener('blur', fireDidBlur);
         this.toDispose.push(Disposable.create(() => window.removeEventListener('blur', fireDidBlur)));
+
+       const tracker = new WindowActivityTracker(window);
+       this.toDispose.push(tracker.onDidChangeActiveState(isActive => this.onActiveStateChanged(isActive)));
+       this.toDispose.push(tracker);
     }
 
     dispose(): void {
@@ -53,7 +58,11 @@ export class WindowStateMain implements WindowMain, Disposable {
     }
 
     private onFocusChanged(focused: boolean): void {
-        this.proxy.$onWindowStateChanged(focused);
+        this.proxy.$onDidChangeWindowFocus(focused);
+    }
+
+    private onActiveStateChanged(isActive: boolean): void {
+        this.proxy.$onDidChangeWindowActive(isActive);
     }
 
     async $openUri(uriComponent: UriComponents): Promise<boolean> {

package/src/main/node/plugin-ext-backend-module.ts

@@ -42,6 +42,10 @@ import { PluginUninstallationManager } from './plugin-uninstallation-manager';
 import { LocalizationServerImpl } from '@theia/core/lib/node/i18n/localization-server';
 import { PluginLocalizationServer } from './plugin-localization-server';
 import { PluginMgmtCliContribution } from './plugin-mgmt-cli-contribution';
+import { PluginRemoteCliContribution } from './plugin-remote-cli-contribution';
+import { RemoteCliContribution } from '@theia/core/lib/node/remote/remote-cli-contribution';
+import { PluginRemoteCopyContribution } from './plugin-remote-copy-contribution';
+import { RemoteCopyContribution } from '@theia/core/lib/node/remote/remote-copy-contribution';
 
 export function bindMainBackend(bind: interfaces.Bind, unbind: interfaces.Unbind, isBound: interfaces.IsBound, rebind: interfaces.Rebind): void {
     bind(PluginApiContribution).toSelf().inSingletonScope();
@@ -89,6 +93,11 @@ export function bindMainBackend(bind: interfaces.Bind, unbind: interfaces.Unbind
     bind(PluginMgmtCliContribution).toSelf().inSingletonScope();
     bind(CliContribution).toService(PluginMgmtCliContribution);
 
+    bind(PluginRemoteCliContribution).toSelf().inSingletonScope();
+    bind(RemoteCliContribution).toService(PluginRemoteCliContribution);
+    bind(PluginRemoteCopyContribution).toSelf().inSingletonScope();
+    bind(RemoteCopyContribution).toService(PluginRemoteCopyContribution);
+
     bind(WebviewBackendSecurityWarnings).toSelf().inSingletonScope();
     bind(BackendApplicationContribution).toService(WebviewBackendSecurityWarnings);
 

package/src/main/node/plugin-remote-cli-contribution.ts

@@ -0,0 +1,36 @@
+// *****************************************************************************
+// Copyright (C) 2024 TypeFox 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 { MaybePromise } from '@theia/core';
+import { RemoteCliContext, RemoteCliContribution } from '@theia/core/lib/node/remote/remote-cli-contribution';
+import { inject, injectable } from '@theia/core/shared/inversify';
+import { PluginCliContribution } from './plugin-cli-contribution';
+
+@injectable()
+export class PluginRemoteCliContribution implements RemoteCliContribution {
+
+    @inject(PluginCliContribution)
+    protected readonly pluginCliContribution: PluginCliContribution;
+
+    enhanceArgs(context: RemoteCliContext): MaybePromise<string[]> {
+        const pluginsFolder = this.pluginCliContribution.localDir();
+        if (!pluginsFolder) {
+            return [];
+        } else {
+            return ['--plugins=local-dir:./plugins'];
+        }
+    }
+}

package/src/main/node/plugin-remote-copy-contribution.ts

@@ -0,0 +1,36 @@
+// *****************************************************************************
+// Copyright (C) 2024 TypeFox 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 { RemoteCopyContribution, RemoteCopyRegistry } from '@theia/core/lib/node/remote/remote-copy-contribution';
+import { inject, injectable } from '@theia/core/shared/inversify';
+import { PluginCliContribution } from './plugin-cli-contribution';
+import { FileUri } from '@theia/core/lib/common/file-uri';
+
+@injectable()
+export class PluginRemoteCopyContribution implements RemoteCopyContribution {
+
+    @inject(PluginCliContribution)
+    protected readonly pluginCliContribution: PluginCliContribution;
+
+    async copy(registry: RemoteCopyRegistry): Promise<void> {
+        const localDir = this.pluginCliContribution.localDir();
+        if (localDir) {
+            const fsPath = FileUri.fsPath(localDir);
+            await registry.directory(fsPath, 'plugins');
+        }
+
+    }
+}

package/src/main/node/plugin-service.ts

@@ -26,7 +26,7 @@ import { environment } from '@theia/core/shared/@theia/application-package/lib/e
 import { WsRequestValidatorContribution } from '@theia/core/lib/node/ws-request-validators';
 import { MaybePromise } from '@theia/core/lib/common';
 import { ApplicationPackage } from '@theia/core/shared/@theia/application-package';
-import { BackendRemoteService } from '@theia/core/lib/node/backend-remote-service';
+import { BackendRemoteService } from '@theia/core/lib/node/remote/backend-remote-service';
 
 @injectable()
 export class PluginApiContribution implements BackendApplicationContribution, WsRequestValidatorContribution {

package/src/plugin/authentication-ext.ts

@@ -63,6 +63,17 @@ export class AuthenticationExtImpl implements AuthenticationExt {
         }
 
         this.authenticationProviders.set(id, provider);
+
+        provider.getSessions().then(sessions => { // sessions might have been restored from secret storage
+            if (sessions.length > 0) {
+                this.proxy.$onDidChangeSessions(id, {
+                    added: sessions,
+                    removed: [],
+                    changed: []
+                });
+            }
+        });
+
         const listener = provider.onDidChangeSessions(e => {
             this.proxy.$onDidChangeSessions(id, e);
         });

package/src/plugin/custom-editors.ts

@@ -121,7 +121,7 @@ export class CustomEditorsExtImpl implements CustomEditorsExt {
         handler: string,
         viewType: string,
         title: string,
-        widgetOpenerOptions: T | undefined,
+        widgetOpenerOptions: object | undefined,
         options: theia.WebviewPanelOptions & theia.WebviewOptions,
         cancellation: CancellationToken
     ): Promise<void> {

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

@@ -46,6 +46,10 @@ export class EditorsAndDocumentsExtImpl implements EditorsAndDocumentsExt {
     private readonly editors = new Map<string, TextEditorExt>();
 
     async $acceptEditorsAndDocumentsDelta(delta: EditorsAndDocumentsDelta): Promise<void> {
+        this.acceptEditorsAndDocumentsDelta(delta);
+    }
+
+    acceptEditorsAndDocumentsDelta(delta: EditorsAndDocumentsDelta): void {
         const removedDocuments = new Array<DocumentDataExt>();
         const addedDocuments = new Array<DocumentDataExt>();
         const removedEditors = new Array<TextEditorExt>();

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

@@ -27,6 +27,7 @@ import * as typeConverters from '../type-converters';
 import { ModelAddedData, NotebookCellDto, NotebookCellsChangedEventDto, NotebookModelAddedData, NotebookOutputDto } from '../../common';
 import { NotebookRange } from '../types-impl';
 import { DocumentsExtImpl } from '../documents';
+import { UriComponents } from '../../common/uri-components';
 
 class RawContentChangeEvent {
 
@@ -345,6 +346,9 @@ export class NotebookDocument implements Disposable {
             return;
         }
 
+        const addedDocuments: ModelAddedData[] = [];
+        const removedDocuments: UriComponents[] = [];
+
         const contentChangeEvents: RawContentChangeEvent[] = [];
 
         splices.reverse().forEach(splice => {
@@ -353,9 +357,7 @@ export class NotebookDocument implements Disposable {
 
                 const extCell = new Cell(this, this.editorsAndDocuments, cell);
                 if (!initialization) {
-                    this.editorsAndDocuments.$acceptEditorsAndDocumentsDelta({
-                        addedDocuments: [Cell.asModelAddData(cell)]
-                    });
+                    addedDocuments.push(Cell.asModelAddData(cell));
                 }
                 return extCell;
             });
@@ -364,10 +366,18 @@ export class NotebookDocument implements Disposable {
             const deletedItems = this.cells.splice(splice.start, splice.deleteCount, ...newCells);
             for (const cell of deletedItems) {
                 changeEvent.deletedItems.push(cell.apiCell);
+                removedDocuments.push(cell.uri.toComponents());
             }
             contentChangeEvents.push(changeEvent);
         });
 
+        if (addedDocuments.length > 0 || removedDocuments.length > 0) {
+            this.editorsAndDocuments.acceptEditorsAndDocumentsDelta({
+                addedDocuments,
+                removedDocuments
+            });
+        }
+
         if (bucket) {
             for (const changeEvent of contentChangeEvents) {
                 bucket.push(changeEvent.asApiEvent());

package/src/plugin/notebook/notebooks.ts

@@ -22,7 +22,7 @@ import { CancellationToken, Disposable, DisposableCollection, Emitter, Event, UR
 import { URI as TheiaURI } from '../types-impl';
 import * as theia from '@theia/plugin';
 import {
-    CommandRegistryExt, ModelAddedData, NotebookCellStatusBarListDto, NotebookDataDto,
+    CommandRegistryExt, NotebookCellStatusBarListDto, NotebookDataDto,
     NotebookDocumentsAndEditorsDelta, NotebookDocumentShowOptions, NotebookDocumentsMain, NotebookEditorAddData, NotebookEditorsMain, NotebooksExt, NotebooksMain, Plugin,
     PLUGIN_RPC_CONTEXT
 } from '../../common';
@@ -205,7 +205,6 @@ export class NotebooksExtImpl implements NotebooksExt {
 
     async $acceptDocumentsAndEditorsDelta(delta: NotebookDocumentsAndEditorsDelta): Promise<void> {
         const removedCellDocuments: UriComponents[] = [];
-        const addedCellDocuments: ModelAddedData[] = [];
         if (delta.removedDocuments) {
             for (const uri of delta.removedDocuments) {
                 const revivedUri = URI.fromComponents(uri);
@@ -226,10 +225,12 @@ export class NotebooksExtImpl implements NotebooksExt {
             }
         }
 
-        // publish all removed cell documents first
-        await this.textDocumentsAndEditors.$acceptEditorsAndDocumentsDelta({
-            removedDocuments: removedCellDocuments
-        });
+        if (removedCellDocuments.length > 0) {
+            // publish all removed cell documents first
+            this.textDocumentsAndEditors.acceptEditorsAndDocumentsDelta({
+                removedDocuments: removedCellDocuments
+            });
+        }
 
         if (delta.addedDocuments) {
             for (const modelData of delta.addedDocuments) {
@@ -250,17 +251,18 @@ export class NotebooksExtImpl implements NotebooksExt {
                 this.documents.get(uri.toString())?.dispose();
                 this.documents.set(uri.toString(), document);
 
-                addedCellDocuments.push(...modelData.cells.map(cell => Cell.asModelAddData(cell)));
+                if (modelData.cells.length > 0) {
+                    // Publish new cell documents before calling the notebook document open event
+                    // During this event, extensions might request the cell document and we want to make sure it is available
+                    this.textDocumentsAndEditors.acceptEditorsAndDocumentsDelta({
+                        addedDocuments: modelData.cells.map(cell => Cell.asModelAddData(cell))
+                    });
+                }
 
                 this.onDidOpenNotebookDocumentEmitter.fire(document.apiNotebook);
             }
         }
 
-        // publish all added cell documents in a separate call
-        await this.textDocumentsAndEditors.$acceptEditorsAndDocumentsDelta({
-            addedDocuments: addedCellDocuments
-        });
-
         if (delta.addedEditors) {
             for (const editorModelData of delta.addedEditors) {
                 if (this.editors.has(editorModelData.id)) {
@@ -370,6 +372,27 @@ export class NotebooksExtImpl implements NotebooksExt {
         this.editors.set(editorId, editor);
     }
 
+    private waitForNotebookEditor(editorId: string, duration = 2000): Promise<theia.NotebookEditor> {
+        const existing = this.editors.get(editorId);
+        if (existing) {
+            return Promise.resolve(existing.apiEditor);
+        }
+        return new Promise<theia.NotebookEditor>((resolve, reject) => {
+            const listener = this.onDidChangeVisibleNotebookEditors(() => {
+                const editor = this.editors.get(editorId);
+                if (editor) {
+                    clearTimeout(timeout);
+                    listener.dispose();
+                    resolve(editor.apiEditor);
+                }
+            });
+            const timeout = setTimeout(() => {
+                listener.dispose();
+                reject(new Error(`Notebook editor did NOT open in ${duration}ms: ${editorId}`));
+            }, duration);
+        });
+    }
+
     async createNotebookDocument(options: { viewType: string; content?: theia.NotebookData }): Promise<TheiaURI> {
         const canonicalUri = await this.notebookDocumentsProxy.$tryCreateNotebook({
             viewType: options.viewType,
@@ -393,7 +416,7 @@ export class NotebooksExtImpl implements NotebooksExt {
             notebookOrUri = await this.openNotebookDocument(notebookOrUri as TheiaURI);
         }
 
-        const notebook = notebookOrUri as theia.NotebookDocument;
+        const notebook = notebookOrUri;
 
         let resolvedOptions: NotebookDocumentShowOptions;
         if (typeof options === 'object') {
@@ -410,7 +433,7 @@ export class NotebooksExtImpl implements NotebooksExt {
         }
 
         const editorId = await this.notebookEditors.$tryShowNotebookDocument(notebook.uri, notebook.notebookType, resolvedOptions);
-        const editor = editorId && this.editors.get(editorId)?.apiEditor;
+        const editor = editorId && await this.waitForNotebookEditor(editorId);
 
         if (editor) {
             return editor;

package/src/plugin/plugin-context.ts

@@ -200,6 +200,7 @@ import {
     DocumentPasteEdit,
     DocumentPasteEditKind,
     DocumentPasteTriggerKind,
+    DocumentDropOrPasteEditKind,
     ExternalUriOpenerPriority,
     EditSessionIdentityMatch,
     TerminalOutputAnchor,
@@ -1218,9 +1219,17 @@ export function createAPIFactory(
             }
         };
 
+        const chat: typeof theia.chat    = {
+            /** @stubbed MappedEditsProvider */
+            registerMappedEditsProvider(documentSelector: theia.DocumentSelector, provider: theia.MappedEditsProvider): Disposable {
+                return Disposable.NULL;
+            }
+        };
+
         return <typeof theia>{
             version: require('../../package.json').version,
             authentication,
+            chat,
             commands,
             comments,
             window,
@@ -1294,6 +1303,7 @@ export function createAPIFactory(
             MultiDocumentHighlight,
             DocumentLink,
             DocumentDropEdit,
+            DocumentDropOrPasteEditKind,
             CodeLens,
             CodeActionKind,
             CodeActionTrigger,

package/src/plugin/quick-open.ts

@@ -30,8 +30,8 @@ import { convertToTransferQuickPickItems } from './type-converters';
 import { PluginPackage } from '../common/plugin-protocol';
 import { QuickInputButtonHandle } from '@theia/core/lib/browser';
 import { MaybePromise } from '@theia/core/lib/common/types';
-import Severity from '@theia/monaco-editor-core/esm/vs/base/common/severity';
 import { ThemeIcon as MonacoThemeIcon } from '@theia/monaco-editor-core/esm/vs/base/common/themables';
+import { Severity } from '@theia/core/lib/common/severity';
 
 const canceledName = 'Canceled';
 /**

package/src/plugin/tabs.ts

@@ -325,8 +325,13 @@ export class TabsExtImpl implements TabsExt {
                 this.activeGroupId = activeTabGroupId;
             }
         }
-        this.onDidChangeTabGroups.fire(Object.freeze({ opened, closed, changed }));
-        this.onDidChangeTabs.fire({ opened: tabsOpened, changed: [], closed: [] });
+
+        if (closed.length > 0 || opened.length > 0 || changed.length > 0) {
+            this.onDidChangeTabGroups.fire(Object.freeze({ opened, closed, changed }));
+        }
+        if (tabsOpened.length > 0) {
+            this.onDidChangeTabs.fire({ opened: tabsOpened, changed: [], closed: [] });
+        }
     }
 
     $acceptTabGroupUpdate(groupDto: TabGroupDto): void {

package/src/plugin/text-editor.ts

@@ -499,7 +499,7 @@ export interface TextEditOperation {
 export interface EditData {
     documentVersionId: number;
     edits: TextEditOperation[];
-    setEndOfLine: EndOfLine;
+    setEndOfLine: EndOfLine | undefined;
     undoStopBefore: boolean;
     undoStopAfter: boolean;
 }
@@ -507,13 +507,12 @@ export interface EditData {
 export class TextEditorEdit {
     private readonly documentVersionId: number;
     private collectedEdits: TextEditOperation[];
-    private eol: EndOfLine;
+    private eol: EndOfLine | undefined;
     private readonly undoStopBefore: boolean;
     private readonly undoStopAfter: boolean;
     constructor(private document: theia.TextDocument, options: { undoStopBefore: boolean; undoStopAfter: boolean }) {
         this.documentVersionId = document.version;
         this.collectedEdits = [];
-        this.eol = 0;
         this.undoStopBefore = options.undoStopBefore;
         this.undoStopAfter = options.undoStopAfter;
     }

package/src/plugin/types-impl.ts

@@ -79,7 +79,7 @@ export class URI extends CodeURI implements theia.Uri {
      */
     static override revive(data: UriComponents | CodeURI): URI;
     static override revive(data: UriComponents | CodeURI | null): URI | null;
-    static override revive(data: UriComponents | CodeURI | undefined): URI | undefined
+    static override revive(data: UriComponents | CodeURI | undefined): URI | undefined;
     static override revive(data: UriComponents | CodeURI | undefined | null): URI | undefined | null {
         const uri = CodeURI.revive(data);
         return uri ? new URI(uri) : undefined;
@@ -882,7 +882,7 @@ export class TextEdit {
 
     protected _range: Range;
     protected _newText: string;
-    protected _newEol: EndOfLine;
+    protected _newEol: EndOfLine | undefined;
 
     get range(): Range {
         return this._range;
@@ -906,7 +906,7 @@ export class TextEdit {
         this._newText = value;
     }
 
-    get newEol(): EndOfLine {
+    get newEol(): EndOfLine | undefined {
         return this._newEol;
     }
 
@@ -1641,12 +1641,35 @@ export class DocumentLink {
     }
 }
 
+@es5ClassCompat
+export class DocumentDropOrPasteEditKind {
+    static readonly Empty: DocumentDropOrPasteEditKind = new DocumentDropOrPasteEditKind('');
+
+    private static sep = '.';
+
+    constructor(
+        public readonly value: string
+    ) { }
+
+    public append(...parts: string[]): DocumentDropOrPasteEditKind {
+        return new DocumentDropOrPasteEditKind((this.value ? [this.value, ...parts] : parts).join(DocumentDropOrPasteEditKind.sep));
+    }
+
+    public intersects(other: DocumentDropOrPasteEditKind): boolean {
+        return this.contains(other) || other.contains(this);
+    }
+
+    public contains(other: DocumentDropOrPasteEditKind): boolean {
+        return this.value === other.value || other.value.startsWith(this.value + DocumentDropOrPasteEditKind.sep);
+    }
+}
+
 @es5ClassCompat
 export class DocumentDropEdit {
     title?: string;
-    kind: DocumentPasteEditKind;
+    kind: DocumentDropOrPasteEditKind;
     handledMimeType?: string;
-    yieldTo?: ReadonlyArray<DocumentPasteEditKind>;
+    yieldTo?: ReadonlyArray<DocumentDropOrPasteEditKind>;
     insertText: string | SnippetString;
     additionalEdit?: WorkspaceEdit;
 
@@ -2060,8 +2083,8 @@ export class TreeItem {
         readonly accessibilityInformation?: AccessibilityInformation
     };
 
-    constructor(label: string | theia.TreeItemLabel, collapsibleState?: theia.TreeItemCollapsibleState)
-    constructor(resourceUri: URI, collapsibleState?: theia.TreeItemCollapsibleState)
+    constructor(label: string | theia.TreeItemLabel, collapsibleState?: theia.TreeItemCollapsibleState);
+    constructor(resourceUri: URI, collapsibleState?: theia.TreeItemCollapsibleState);
     constructor(arg1: string | theia.TreeItemLabel | URI, public collapsibleState: theia.TreeItemCollapsibleState = TreeItemCollapsibleState.None) {
         if (arg1 instanceof URI) {
             this.resourceUri = arg1;
@@ -3760,16 +3783,16 @@ DocumentPasteEditKind.Empty = new DocumentPasteEditKind('');
 
 @es5ClassCompat
 export class DocumentPasteEdit {
-    constructor(insertText: string | SnippetString, title: string, kind: DocumentPasteEditKind) {
+    constructor(insertText: string | SnippetString, title: string, kind: DocumentDropOrPasteEditKind) {
         this.insertText = insertText;
         this.title = title;
         this.kind = kind;
     }
     title: string;
-    kind: DocumentPasteEditKind;
+    kind: DocumentDropOrPasteEditKind;
     insertText: string | SnippetString;
     additionalEdit?: WorkspaceEdit;
-    yieldTo?: readonly DocumentPasteEditKind[];
+    yieldTo?: ReadonlyArray<DocumentDropOrPasteEditKind>;
 }
 
 /**

package/src/plugin/window-state.ts

@@ -31,21 +31,28 @@ export class WindowStateExtImpl implements WindowStateExt {
 
     constructor(rpc: RPCProtocol) {
         this.proxy = rpc.getProxy(PLUGIN_RPC_CONTEXT.WINDOW_MAIN);
-        this.windowStateCached = { focused: true }; // supposed tab is active on start
+        this.windowStateCached = { focused: true, active: true }; // supposed tab is active on start
     }
 
     getWindowState(): WindowState {
         return this.windowStateCached;
     }
 
-    $onWindowStateChanged(focused: boolean): void {
-        const state = { focused: focused };
-        if (state === this.windowStateCached) {
+    $onDidChangeWindowFocus(focused: boolean): void {
+        this.onDidChangeWindowProperty('focused', focused);
+    }
+
+    $onDidChangeWindowActive(active: boolean): void {
+        this.onDidChangeWindowProperty('active', active);
+    }
+
+    onDidChangeWindowProperty(property: keyof WindowState, value: boolean): void {
+        if (value === this.windowStateCached[property]) {
             return;
         }
 
-        this.windowStateCached = state;
-        this.windowStateChangedEmitter.fire(state);
+        this.windowStateCached = { ...this.windowStateCached, [property]: value };
+        this.windowStateChangedEmitter.fire(this.windowStateCached);
     }
 
     openUri(uri: URI): Promise<boolean> {