@theia/core 1.56.0 → 1.57.0-next.112

package/src/browser/json-schema-store.ts

@@ -17,8 +17,9 @@
 import { injectable, inject, named } from 'inversify';
 import { ContributionProvider } from '../common/contribution-provider';
 import { FrontendApplicationContribution } from './frontend-application-contribution';
-import { MaybePromise } from '../common';
+import { Emitter, MaybePromise, URI } from '../common';
 import { timeout, Deferred } from '../common/promise-util';
+import { IJSONSchema } from '../common/json-schema';
 
 export interface JsonSchemaConfiguration {
     fileMatch: string | string[];
@@ -91,6 +92,39 @@ export class JsonSchemaStore implements FrontendApplicationContribution {
 
 }
 
+@injectable()
+export class JsonSchemaDataStore {
+
+    protected readonly _schemas = new Map<string, string>();
+
+    protected readonly onDidSchemaUpdateEmitter = new Emitter<URI>();
+    readonly onDidSchemaUpdate = this.onDidSchemaUpdateEmitter.event;
+
+    hasSchema(uri: URI): boolean {
+        return this._schemas.has(uri.toString());
+    }
+
+    getSchema(uri: URI): string | undefined {
+        return this._schemas.get(uri.toString());
+    }
+
+    setSchema(uri: URI, schema: IJSONSchema | string): void {
+        this._schemas.set(uri.toString(), typeof schema === 'string' ? schema : JSON.stringify(schema));
+        this.notifySchemaUpdate(uri);
+    }
+
+    deleteSchema(uri: URI): void {
+        if (this._schemas.delete(uri.toString())) {
+            this.notifySchemaUpdate(uri);
+        }
+    }
+
+    notifySchemaUpdate(uri: URI): void {
+        this.onDidSchemaUpdateEmitter.fire(uri);
+    }
+
+}
+
 @injectable()
 export class DefaultJsonSchemaContribution implements JsonSchemaContribution {
     async registerSchemas(context: JsonSchemaRegisterContext): Promise<void> {

package/src/browser/keybinding.ts

@@ -622,15 +622,15 @@ export class KeybindingRegistry {
     matchKeybinding(keySequence: KeySequence, event?: KeyboardEvent): KeybindingRegistry.Match {
         let disabled: Set<string> | undefined;
         const isEnabled = (binding: ScopedKeybinding) => {
-            if (event && !this.isEnabled(binding, event)) {
-                return false;
-            }
             const { command, context, when, keybinding } = binding;
             if (!this.isUsable(binding)) {
                 disabled = disabled || new Set<string>();
                 disabled.add(JSON.stringify({ command: command.substring(1), context, when, keybinding }));
                 return false;
             }
+            if (event && !this.isEnabled(binding, event)) {
+                return false;
+            }
             return !disabled?.has(JSON.stringify({ command, context, when, keybinding }));
         };
 

package/src/browser/saveable.ts

@@ -392,4 +392,7 @@ export class ShouldSaveDialog extends AbstractDialog<boolean> {
         return this.shouldSave;
     }
 
+    override async open(disposeOnResolve?: boolean): Promise<boolean | undefined> {
+        return super.open(disposeOnResolve);
+    }
 }

package/src/browser/secondary-window-handler.ts

@@ -140,6 +140,7 @@ export class SecondaryWindowHandler {
             widget.secondaryWindow = newWindow;
             const rootWidget = new SecondaryWindowRootWidget();
             rootWidget.addClass('secondary-widget-root');
+            rootWidget.addClass('monaco-workbench'); // needed for compatility with VSCode styles
             Widget.attach(rootWidget, element);
             rootWidget.addWidget(widget);
             widget.show();

package/src/browser/shell/application-shell.ts

@@ -22,7 +22,7 @@ import {
 } from '@phosphor/widgets';
 import { Message } from '@phosphor/messaging';
 import { IDragEvent } from '@phosphor/dragdrop';
-import { RecursivePartial, Event as CommonEvent, DisposableCollection, Disposable, environment, isObject } from '../../common';
+import { RecursivePartial, Event as CommonEvent, DisposableCollection, Disposable, environment, isObject, UntitledResourceResolver, UNTITLED_SCHEME } from '../../common';
 import { animationFrame } from '../browser';
 import { Saveable, SaveableWidget, SaveOptions } from '../saveable';
 import { StatusBarImpl, StatusBarEntry, StatusBarAlignment } from '../status-bar/status-bar';
@@ -232,6 +232,9 @@ export class ApplicationShell extends Widget {
     @inject(OpenerService)
     protected readonly openerService: OpenerService;
 
+    @inject(UntitledResourceResolver)
+    protected readonly untitledResourceResolver: UntitledResourceResolver;
+
     protected readonly onDidAddWidgetEmitter = new Emitter<Widget>();
     readonly onDidAddWidget = this.onDidAddWidgetEmitter.event;
     protected fireDidAddWidget(widget: Widget): void {
@@ -323,6 +326,7 @@ export class ApplicationShell extends Widget {
 
     protected initializeShell(): void {
         this.addClass(APPLICATION_SHELL_CLASS);
+        this.addClass('monaco-workbench'); // needed for compatility with VSCode styles
         this.id = 'theia-app-shell';
 
         this.mainPanel = this.createMainPanel();
@@ -572,16 +576,28 @@ export class ApplicationShell extends Widget {
                     uris.forEach(openUri);
                 } else if (event.dataTransfer.files?.length > 0) {
                     // the files were dragged from the outside the workspace
-                    Array.from(event.dataTransfer.files).forEach(file => {
-                        if (file.path) {
-                            const fileUri = URI.fromComponents({
-                                scheme: 'file',
-                                path: file.path,
-                                authority: '',
-                                query: '',
-                                fragment: ''
-                            });
-                            openUri(fileUri);
+                    Array.from(event.dataTransfer.files).forEach(async file => {
+                        if (environment.electron.is()) {
+                            if (file.path) {
+                                const fileUri = URI.fromFilePath(file.path);
+                                openUri(fileUri);
+                            }
+                        } else {
+                            const fileContent = await file.text();
+                            const fileName = file.name;
+                            const uri = new URI(`${UNTITLED_SCHEME}:/${fileName}`);
+                            // Only create a new untitled resource if it doesn't already exist.
+                            // VS Code does the same thing, and there's not really a better solution,
+                            // since we want to keep the original name of the file,
+                            // but also to prevent duplicates of the same file.
+                            if (!this.untitledResourceResolver.has(uri)) {
+                                const untitledResource = await this.untitledResourceResolver.createUntitledResource(
+                                    fileContent,
+                                    undefined,
+                                    new URI(`${UNTITLED_SCHEME}:/${fileName}`)
+                                );
+                                openUri(untitledResource.uri);
+                            }
                         }
                     });
                 }

package/src/browser/style/dockpanel.css

@@ -14,6 +14,16 @@
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
  ********************************************************************************/
 
+/*
+ * phosphor.js sets the z-index of its panels to 0, which causes overlay issues
+ * See also https://github.com/eclipse-theia/theia/issues/14290
+ */
+.p-SplitPanel-child,
+.p-DockPanel,
+.p-DockPanel-widget {
+  z-index: initial;
+}
+
 .p-DockPanel.p-SplitPanel-child {
   padding: 0px;
 }

package/src/browser/test/jsdom.ts

@@ -43,7 +43,12 @@ export function enableJSDOM(): () => void {
     });
     (global as any)['document'] = dom.window.document;
     (global as any)['window'] = dom.window;
-    (global as any)['navigator'] = { userAgent: 'node.js', platform: 'Mac' };
+    try {
+        (global as any)['navigator'] = { userAgent: 'node.js', platform: 'Mac' };
+
+    } catch (e) {
+        // node 21+ already has a navigator object
+    }
 
     const toCleanup: string[] = [];
     Object.getOwnPropertyNames((dom.window as any)).forEach(property => {

package/src/browser/tree/tree-widget.tsx

@@ -32,7 +32,7 @@ import { notEmpty } from '../../common/objects';
 import { isOSX } from '../../common/os';
 import { ReactWidget } from '../widgets/react-widget';
 import * as React from 'react';
-import { Virtuoso, VirtuosoHandle } from 'react-virtuoso';
+import { Virtuoso, VirtuosoHandle, VirtuosoProps } from 'react-virtuoso';
 import { TopDownTreeIterator } from './tree-iterator';
 import { SearchBox, SearchBoxFactory, SearchBoxProps } from './search-box';
 import { TreeSearch } from './tree-search';
@@ -111,6 +111,10 @@ export interface TreeProps {
      */
     readonly expandOnlyOnExpansionToggleClick?: boolean;
 
+    /**
+     * Props that are forwarded to the virtuoso list rendered. Defaults to `{}`.
+     */
+    readonly viewProps?: VirtuosoProps<unknown, unknown>;
 }
 
 /**
@@ -498,6 +502,7 @@ export class TreeWidget extends ReactWidget implements StatefulWidget {
                 rows={rows}
                 renderNodeRow={this.renderNodeRow}
                 scrollToRow={this.scrollToRow}
+                {...this.props.viewProps}
             />;
         }
         // eslint-disable-next-line no-null/no-null
@@ -1546,7 +1551,7 @@ export namespace TreeWidget {
     /**
      * Representation of the tree view properties.
      */
-    export interface ViewProps {
+    export interface ViewProps extends VirtuosoProps<unknown, unknown> {
         /**
          * The width property.
          */
@@ -1568,7 +1573,7 @@ export namespace TreeWidget {
     export class View extends React.Component<ViewProps> {
         list: VirtuosoHandle | undefined;
         override render(): React.ReactNode {
-            const { rows, width, height, scrollToRow } = this.props;
+            const { rows, width, height, scrollToRow, renderNodeRow, ...other } = this.props;
             return <Virtuoso
                 ref={list => {
                     this.list = (list || undefined);
@@ -1580,11 +1585,12 @@ export namespace TreeWidget {
                     }
                 }}
                 totalCount={rows.length}
-                itemContent={index => this.props.renderNodeRow(rows[index])}
+                itemContent={index => renderNodeRow(rows[index])}
                 width={width}
                 height={height}
                 // This is a pixel value, it will scan 200px to the top and bottom of the current view
                 overscan={500}
+                {...other}
             />;
         }
     }

package/src/browser/window/browser-window-module.ts

@@ -22,6 +22,8 @@ import { ClipboardService } from '../clipboard-service';
 import { BrowserClipboardService } from '../browser-clipboard-service';
 import { SecondaryWindowService } from './secondary-window-service';
 import { DefaultSecondaryWindowService } from './default-secondary-window-service';
+import { bindContributionProvider } from '../../common';
+import { WindowTitleContribution } from './window-title-service';
 
 export default new ContainerModule(bind => {
     bind(DefaultWindowService).toSelf().inSingletonScope();
@@ -29,4 +31,5 @@ export default new ContainerModule(bind => {
     bind(FrontendApplicationContribution).toService(DefaultWindowService);
     bind(ClipboardService).to(BrowserClipboardService).inSingletonScope();
     bind(SecondaryWindowService).to(DefaultSecondaryWindowService).inSingletonScope();
+    bindContributionProvider(bind, WindowTitleContribution);
 });

package/src/browser/window/default-secondary-window-service.ts

@@ -20,11 +20,15 @@ import { ExtractableWidget } from '../widgets';
 import { ApplicationShell } from '../shell';
 import { Saveable } from '../saveable';
 import { PreferenceService } from '../preferences';
-import { environment } from '../../common';
+import { Emitter, environment, Event } from '../../common';
 import { SaveableService } from '../saveable-service';
 
 @injectable()
 export class DefaultSecondaryWindowService implements SecondaryWindowService {
+    protected readonly onWindowOpenedEmitter = new Emitter<Window>;
+    readonly onWindowOpened: Event<Window> = this.onWindowOpenedEmitter.event;
+    protected readonly onWindowClosedEmitter = new Emitter<Window>;
+    readonly onWindowClosed: Event<Window> = this.onWindowClosedEmitter.event;
     // secondary-window.html is part of Theia's generated code. It is generated by dev-packages/application-manager/src/generator/frontend-generator.ts
     protected static SECONDARY_WINDOW_URL = 'secondary-window.html';
 
@@ -94,6 +98,7 @@ export class DefaultSecondaryWindowService implements SecondaryWindowService {
         const newWindow = window.open(DefaultSecondaryWindowService.SECONDARY_WINDOW_URL, this.nextWindowId(), options) ?? undefined;
         if (newWindow) {
             this.secondaryWindows.push(newWindow);
+            this.onWindowOpenedEmitter.fire(newWindow);
             newWindow.addEventListener('DOMContentLoaded', () => {
                 newWindow.addEventListener('beforeunload', evt => {
                     const saveable = Saveable.get(widget);
@@ -113,6 +118,7 @@ export class DefaultSecondaryWindowService implements SecondaryWindowService {
 
                     const extIndex = this.secondaryWindows.indexOf(newWindow);
                     if (extIndex > -1) {
+                        this.onWindowClosedEmitter.fire(newWindow);
                         this.secondaryWindows.splice(extIndex, 1);
                     };
                 });

package/src/browser/window/secondary-window-service.ts

@@ -14,6 +14,7 @@
 // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
 // *****************************************************************************
 
+import { Event } from '../../common';
 import { ApplicationShell } from '../shell';
 import { ExtractableWidget } from '../widgets';
 
@@ -33,6 +34,8 @@ export interface SecondaryWindowService {
      * @returns the created window or `undefined` if it could not be created
      */
     createSecondaryWindow(widget: ExtractableWidget, shell: ApplicationShell): Window | undefined;
+    readonly onWindowOpened: Event<Window>;
+    readonly onWindowClosed: Event<Window>;
 
     /** Handles focussing the given secondary window in the browser and on Electron. */
     focus(win: Window): void;

package/src/browser/window/window-title-service.ts

@@ -14,11 +14,17 @@
 // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
 // *****************************************************************************
 
-import { inject, injectable, postConstruct } from 'inversify';
+import { inject, injectable, named, postConstruct } from 'inversify';
 import { escapeRegExpCharacters } from '../../common/strings';
 import { Emitter, Event } from '../../common/event';
 import { CorePreferences } from '../core-preferences';
 import { FrontendApplicationConfigProvider } from '../frontend-application-config-provider';
+import { ContributionProvider } from '../../common';
+
+export const WindowTitleContribution = Symbol('WindowTitleAddOnContribution');
+export interface WindowTitleContribution {
+    enhanceTitle(title: string, parts: Map<string, string | undefined>): string;
+}
 
 export const InitialWindowTitleParts = {
     activeEditorShort: undefined,
@@ -43,6 +49,9 @@ export class WindowTitleService {
     @inject(CorePreferences)
     protected readonly preferences: CorePreferences;
 
+    @inject(ContributionProvider) @named(WindowTitleContribution)
+    protected readonly titleContributions: ContributionProvider<WindowTitleContribution>;
+
     protected _title = '';
     protected titleTemplate?: string;
 
@@ -95,6 +104,10 @@ export class WindowTitleService {
             }
             const separatedTitle = title.split('${separator}').filter(e => e.trim().length > 0);
             this._title = separatedTitle.join(this.separator);
+            const contributions = this.titleContributions.getContributions();
+            for (const contribution of contributions) {
+                this._title = contribution.enhanceTitle(this.title, this.titleParts);
+            }
         }
         const developmentHost = this.titleParts.get('developmentHost');
         if (developmentHost) {

package/src/common/resource.ts

@@ -60,6 +60,8 @@ export interface Resource extends Disposable {
     readonly onDidChangeReadOnly?: Event<boolean | MarkdownString>;
 
     readonly readOnly?: boolean | MarkdownString;
+
+    readonly initiallyDirty?: boolean;
     /**
      * Reads latest content of this resource.
      *
@@ -378,11 +380,13 @@ export class UntitledResourceResolver implements ResourceResolver {
 export class UntitledResource implements Resource {
 
     protected readonly onDidChangeContentsEmitter = new Emitter<void>();
+    initiallyDirty: boolean;
     get onDidChangeContents(): Event<void> {
         return this.onDidChangeContentsEmitter.event;
     }
 
     constructor(private resources: Map<string, UntitledResource>, public uri: URI, private content?: string) {
+        this.initiallyDirty = (content !== undefined && content.length > 0);
         this.resources.set(this.uri.toString(), this);
     }
 

package/src/electron-browser/messaging/electron-local-ws-connection-source.ts

@@ -23,6 +23,11 @@ export function getLocalPort(): string | undefined {
     return params.get('localPort') ?? undefined;
 }
 
+export function getCurrentPort(): string | undefined {
+    const params = new URLSearchParams(location.search);
+    return params.get('port') ?? undefined;
+}
+
 @injectable()
 export class ElectronLocalWebSocketConnectionSource extends WebSocketConnectionSource {
 

package/src/electron-browser/window/electron-window-module.ts

@@ -30,6 +30,8 @@ import { bindWindowPreferences } from './electron-window-preferences';
 import { ElectronWindowService } from './electron-window-service';
 import { ExternalAppOpenHandler } from './external-app-open-handler';
 import { ElectronUriHandlerContribution } from '../electron-uri-handler';
+import { bindContributionProvider } from '../../common';
+import { WindowTitleContribution } from '../../browser/window/window-title-service';
 
 export default new ContainerModule((bind, unbind, isBound, rebind) => {
     bind(ElectronMainWindowService).toDynamicValue(context =>
@@ -45,4 +47,5 @@ export default new ContainerModule((bind, unbind, isBound, rebind) => {
     bind(SecondaryWindowService).to(ElectronSecondaryWindowService).inSingletonScope();
     bind(ExternalAppOpenHandler).toSelf().inSingletonScope();
     bind(OpenHandler).toService(ExternalAppOpenHandler);
+    bindContributionProvider(bind, WindowTitleContribution);
 });

package/src/electron-main/electron-main-application.ts

@@ -396,7 +396,7 @@ export class ElectronMainApplication {
     }
 
     protected isShowSplashScreen(): boolean {
-        return typeof this.config.electron.splashScreenOptions === 'object' && !!this.config.electron.splashScreenOptions.content;
+        return !process.env.THEIA_NO_SPLASH && typeof this.config.electron.splashScreenOptions === 'object' && !!this.config.electron.splashScreenOptions.content;
     }
 
     protected getSplashScreenOptions(): ElectronFrontendApplicationConfig.SplashScreenOptions | undefined {
@@ -522,21 +522,21 @@ export class ElectronMainApplication {
     }
 
     protected async handleMainCommand(options: ElectronMainCommandOptions): Promise<void> {
-        if (options.secondInstance === false) {
-            await this.openWindowWithWorkspace(''); // restore previous workspace.
-        } else if (options.file === undefined) {
-            await this.openDefaultWindow();
-        } else {
-            let workspacePath: string | undefined;
+        let workspacePath: string | undefined;
+        if (options.file) {
             try {
                 workspacePath = await fs.realpath(path.resolve(options.cwd, options.file));
             } catch {
                 console.error(`Could not resolve the workspace path. "${options.file}" is not a valid 'file' option. Falling back to the default workspace location.`);
             }
-            if (workspacePath === undefined) {
+        }
+        if (workspacePath !== undefined) {
+            await this.openWindowWithWorkspace(workspacePath);
+        } else {
+            if (options.secondInstance === false) {
+                await this.openWindowWithWorkspace(''); // restore previous workspace.
+            } else if (options.file === undefined) {
                 await this.openDefaultWindow();
-            } else {
-                await this.openWindowWithWorkspace(workspacePath);
             }
         }
     }

package/src/electron-main/theia-electron-window.ts

@@ -186,10 +186,18 @@ export class TheiaElectronWindow {
     }
 
     protected restoreMaximizedState(): void {
-        if (this.options.isMaximized) {
-            this._window.maximize();
+        const restore = () => {
+            if (this.options.isMaximized) {
+                this._window.maximize();
+            } else {
+                this._window.unmaximize();
+            }
+        };
+
+        if (this._window.isVisible()) {
+            restore();
         } else {
-            this._window.unmaximize();
+            this._window.once('show', () => restore());
         }
     }
 

package/src/node/messaging/test/test-web-socket-channel.ts

@@ -47,7 +47,12 @@ export class TestWebSocketChannelSetup {
         path: string
     }) {
         const address = (server.address() as AddressInfo);
-        const url = `ws://${address.address}:${address.port}${servicesPath}`;
+        let url;
+        if (address.family === 'IPv6') {
+            url = `ws://[${address.address}]:${address.port}${servicesPath}`;
+        } else {
+            url = `ws://${address.address}:${address.port}${servicesPath}`;
+        }
         this.connectionProvider = this.createConnectionProvider(url);
     }