@theia/core 1.53.0-next.6 → 1.53.0-next.64

package/src/browser/context-key-service.ts

@@ -16,6 +16,7 @@
 
 import { injectable } from 'inversify';
 import { Emitter, Event } from '../common/event';
+import { Disposable } from '../common';
 
 export type ContextKeyValue = null | undefined | boolean | number | string
     | Array<null | undefined | boolean | number | string>
@@ -83,11 +84,10 @@ export interface ContextKeyService extends ContextMatcher {
     setContext(key: string, value: unknown): void;
 }
 
-export type ScopedValueStore = Omit<ContextKeyService, 'onDidChange' | 'match' | 'parseKeys' | 'with' | 'createOverlay'>;
+export type ScopedValueStore = Omit<ContextKeyService, 'onDidChange' | 'match' | 'parseKeys' | 'with' | 'createOverlay'> & Disposable;
 
 @injectable()
 export class ContextKeyServiceDummyImpl implements ContextKeyService {
-
     protected readonly onDidChangeEmitter = new Emitter<ContextKeyChangeEvent>();
     readonly onDidChange = this.onDidChangeEmitter.event;
     protected fireDidChange(event: ContextKeyChangeEvent): void {
@@ -122,7 +122,7 @@ export class ContextKeyServiceDummyImpl implements ContextKeyService {
     /**
      * Details should implemented by an extension, e.g. by the monaco extension.
      */
-    createScoped(target: HTMLElement): ContextKeyService {
+    createScoped(target: HTMLElement): ScopedValueStore {
         return this;
     }
 

package/src/browser/core-preferences.ts

@@ -281,6 +281,15 @@ export const corePreferenceSchema: PreferenceSchema = {
             default: 200,
             minimum: 10,
             description: nls.localize('theia/core/tabDefaultSize', 'Specifies the default size for tabs.')
+        },
+        'workbench.editorAssociations': {
+            type: 'object',
+            markdownDescription: nls.localizeByDefault('Configure [glob patterns](https://aka.ms/vscode-glob-patterns) to editors (for example `"*.hex": "hexEditor.hexedit"`). These have precedence over the default behavior.'),
+            patternProperties: {
+                '.*': {
+                    type: 'string'
+                }
+            }
         }
     }
 };

package/src/browser/frontend-application-module.ts

@@ -465,7 +465,6 @@ export const frontendApplicationModule = new ContainerModule((bind, _unbind, _is
     bind(FrontendApplicationContribution).toService(StylingService);
 
     bind(SecondaryWindowHandler).toSelf().inSingletonScope();
-
     bind(ViewColumnService).toSelf().inSingletonScope();
 
     bind(UndoRedoHandlerService).toSelf().inSingletonScope();

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

@@ -18,9 +18,7 @@ import { injectable, inject, named } from 'inversify';
 import { ContributionProvider } from '../common/contribution-provider';
 import { FrontendApplicationContribution } from './frontend-application-contribution';
 import { MaybePromise } from '../common';
-import { Endpoint } from './endpoint';
 import { timeout, Deferred } from '../common/promise-util';
-import { RequestContext, RequestService } from '@theia/request';
 
 export interface JsonSchemaConfiguration {
     fileMatch: string | string[];
@@ -95,16 +93,9 @@ export class JsonSchemaStore implements FrontendApplicationContribution {
 
 @injectable()
 export class DefaultJsonSchemaContribution implements JsonSchemaContribution {
-
-    @inject(RequestService)
-    protected readonly requestService: RequestService;
-
-    protected readonly jsonSchemaUrl = `${new Endpoint().httpScheme}//schemastore.org/api/json/catalog.json`;
-
     async registerSchemas(context: JsonSchemaRegisterContext): Promise<void> {
-        const response = await this.requestService.request({ url: this.jsonSchemaUrl });
-        const schemas = RequestContext.asJson<{ schemas: DefaultJsonSchemaContribution.SchemaData[] }>(response).schemas;
-        for (const s of schemas) {
+        const catalog = require('./catalog.json') as { schemas: DefaultJsonSchemaContribution.SchemaData[] };
+        for (const s of catalog.schemas) {
             if (s.fileMatch) {
                 context.registerSchema({
                     fileMatch: s.fileMatch,

package/src/browser/open-with-service.ts

@@ -19,7 +19,9 @@ import { Disposable } from '../common/disposable';
 import { nls } from '../common/nls';
 import { MaybePromise } from '../common/types';
 import { URI } from '../common/uri';
-import { QuickInputService } from './quick-input';
+import { QuickInputService, QuickPickItem, QuickPickItemOrSeparator } from './quick-input';
+import { PreferenceScope, PreferenceService } from './preferences';
+import { getDefaultHandler } from './opener-service';
 
 export interface OpenWithHandler {
     /**
@@ -46,6 +48,11 @@ export interface OpenWithHandler {
      * A returned value indicating a priority of this handler.
      */
     canHandle(uri: URI): number;
+    /**
+     * Test whether this handler and open the given URI
+     * and return the order of this handler in the list.
+     */
+    getOrder?(uri: URI): number;
     /**
      * Open a widget for the given URI and options.
      * Resolve to an opened widget or undefined, e.g. if a page is opened.
@@ -54,12 +61,19 @@ export interface OpenWithHandler {
     open(uri: URI): MaybePromise<object | undefined>;
 }
 
+export interface OpenWithQuickPickItem extends QuickPickItem {
+    handler: OpenWithHandler;
+}
+
 @injectable()
 export class OpenWithService {
 
     @inject(QuickInputService)
     protected readonly quickInputService: QuickInputService;
 
+    @inject(PreferenceService)
+    protected readonly preferenceService: PreferenceService;
+
     protected readonly handlers: OpenWithHandler[] = [];
 
     registerHandler(handler: OpenWithHandler): Disposable {
@@ -73,17 +87,50 @@ export class OpenWithService {
     }
 
     async openWith(uri: URI): Promise<object | undefined> {
+        // Clone the object, because all objects returned by the preferences service are frozen.
+        const associations: Record<string, unknown> = { ...this.preferenceService.get('workbench.editorAssociations') };
+        const ext = `*${uri.path.ext}`;
         const handlers = this.getHandlers(uri);
-        const result = await this.quickInputService.pick(handlers.map(handler => ({
-            handler: handler,
-            label: handler.label ?? handler.id,
-            detail: handler.providerName
-        })), {
+        const ordered = handlers.slice().sort((a, b) => this.getOrder(b, uri) - this.getOrder(a, uri));
+        const defaultHandler = getDefaultHandler(uri, this.preferenceService) ?? handlers[0]?.id;
+        const items = this.getQuickPickItems(ordered, defaultHandler);
+        // Only offer to select a default editor when the file has a file extension
+        const extraItems: QuickPickItemOrSeparator[] = uri.path.ext ? [{
+            type: 'separator'
+        }, {
+            label: nls.localizeByDefault("Configure default editor for '{0}'...", ext)
+        }] : [];
+        const result = await this.quickInputService.pick<OpenWithQuickPickItem | { label: string }>([...items, ...extraItems], {
             placeHolder: nls.localizeByDefault("Select editor for '{0}'", uri.path.base)
         });
         if (result) {
-            return result.handler.open(uri);
+            if ('handler' in result) {
+                return result.handler.open(uri);
+            } else if (result.label) {
+                const configureResult = await this.quickInputService.pick(items, {
+                    placeHolder: nls.localizeByDefault("Select new default editor for '{0}'", ext)
+                });
+                if (configureResult) {
+                    associations[ext] = configureResult.handler.id;
+                    this.preferenceService.set('workbench.editorAssociations', associations, PreferenceScope.User);
+                    return configureResult.handler.open(uri);
+                }
+            }
         }
+        return undefined;
+    }
+
+    protected getQuickPickItems(handlers: OpenWithHandler[], defaultHandler?: string): OpenWithQuickPickItem[] {
+        return handlers.map(handler => ({
+            handler,
+            label: handler.label ?? handler.id,
+            detail: handler.providerName ?? '',
+            description: handler.id === defaultHandler ? nls.localizeByDefault('Default') : undefined
+        }));
+    }
+
+    protected getOrder(handler: OpenWithHandler, uri: URI): number {
+        return handler.getOrder ? handler.getOrder(uri) : handler.canHandle(uri);
     }
 
     getHandlers(uri: URI): OpenWithHandler[] {

package/src/browser/opener-service.ts

@@ -17,6 +17,8 @@
 import { named, injectable, inject } from 'inversify';
 import URI from '../common/uri';
 import { ContributionProvider, Prioritizeable, MaybePromise, Emitter, Event, Disposable } from '../common';
+import { PreferenceService } from './preferences';
+import { match } from '../common/glob';
 
 export interface OpenerOptions {
 }
@@ -79,6 +81,12 @@ export interface OpenerService {
      * Add open handler i.e. for custom editors
      */
     addHandler?(openHandler: OpenHandler): Disposable;
+
+    /**
+     * Remove open handler
+     */
+    removeHandler?(openHandler: OpenHandler): void;
+
     /**
      * Event that fires when a new opener is added or removed.
      */
@@ -90,6 +98,17 @@ export async function open(openerService: OpenerService, uri: URI, options?: Ope
     return opener.open(uri, options);
 }
 
+export function getDefaultHandler(uri: URI, preferenceService: PreferenceService): string | undefined {
+    const associations = preferenceService.get('workbench.editorAssociations', {});
+    const defaultHandler = Object.entries(associations).find(([key]) => match(key, uri.path.base))?.[1];
+    if (typeof defaultHandler === 'string') {
+        return defaultHandler;
+    }
+    return undefined;
+}
+
+export const defaultHandlerPriority = 100_000;
+
 @injectable()
 export class DefaultOpenerService implements OpenerService {
     // Collection of open-handlers for custom-editor contributions.
@@ -108,11 +127,15 @@ export class DefaultOpenerService implements OpenerService {
         this.onDidChangeOpenersEmitter.fire();
 
         return Disposable.create(() => {
-            this.customEditorOpenHandlers.splice(this.customEditorOpenHandlers.indexOf(openHandler), 1);
-            this.onDidChangeOpenersEmitter.fire();
+            this.removeHandler(openHandler);
         });
     }
 
+    removeHandler(openHandler: OpenHandler): void {
+        this.customEditorOpenHandlers.splice(this.customEditorOpenHandlers.indexOf(openHandler), 1);
+        this.onDidChangeOpenersEmitter.fire();
+    }
+
     async getOpener(uri: URI, options?: OpenerOptions): Promise<OpenHandler> {
         const handlers = await this.prioritize(uri, options);
         if (handlers.length >= 1) {

package/src/browser/saveable-service.ts

@@ -174,7 +174,10 @@ export class SaveableService implements FrontendApplicationContribution {
         setDirty(saveableWidget, saveable.dirty);
         saveable.onDirtyChanged(() => setDirty(saveableWidget, saveable.dirty));
         const closeWithSaving = this.createCloseWithSaving();
-        const closeWithoutSaving = () => this.closeWithoutSaving(saveableWidget, false);
+        const closeWithoutSaving = async () => {
+            const revert = Saveable.closingWidgetWouldLoseSaveable(saveableWidget, Array.from(this.saveThrottles.keys()));
+            await this.closeWithoutSaving(saveableWidget, revert);
+        };
         Object.assign(saveableWidget, {
             closeWithoutSaving,
             closeWithSaving,
@@ -224,7 +227,8 @@ export class SaveableService implements FrontendApplicationContribution {
         }
         const notLastWithDocument = !Saveable.closingWidgetWouldLoseSaveable(widget, Array.from(this.saveThrottles.keys()));
         if (notLastWithDocument) {
-            return widget.closeWithoutSaving(false).then(() => undefined);
+            await widget.closeWithoutSaving(false);
+            return undefined;
         }
         if (options && options.shouldSave) {
             return options.shouldSave();

package/src/browser/saveable.ts

@@ -21,7 +21,7 @@ import { MaybePromise } from '../common/types';
 import { Key } from './keyboard/keys';
 import { AbstractDialog } from './dialogs';
 import { nls } from '../common/nls';
-import { DisposableCollection, isObject } from '../common';
+import { Disposable, DisposableCollection, isObject } from '../common';
 import { BinaryBuffer } from '../common/buffer';
 
 export type AutoSaveMode = 'off' | 'afterDelay' | 'onFocusChange' | 'onWindowChange';
@@ -112,6 +112,74 @@ export class DelegatingSaveable implements Saveable {
 
 }
 
+export class CompositeSaveable implements Saveable {
+    protected isDirty = false;
+    protected readonly onDirtyChangedEmitter = new Emitter<void>();
+    protected readonly onContentChangedEmitter = new Emitter<void>();
+    protected readonly toDispose = new DisposableCollection(this.onDirtyChangedEmitter, this.onContentChangedEmitter);
+    protected readonly saveablesMap = new Map<Saveable, Disposable>();
+
+    get dirty(): boolean {
+        return this.isDirty;
+    }
+
+    get onDirtyChanged(): Event<void> {
+        return this.onDirtyChangedEmitter.event;
+    }
+
+    get onContentChanged(): Event<void> {
+        return this.onContentChangedEmitter.event;
+    }
+
+    async save(options?: SaveOptions): Promise<void> {
+        await Promise.all(this.saveables.map(saveable => saveable.save(options)));
+    }
+
+    async revert(options?: Saveable.RevertOptions): Promise<void> {
+        await Promise.all(this.saveables.map(saveable => saveable.revert?.(options)));
+    }
+
+    get saveables(): readonly Saveable[] {
+        return Array.from(this.saveablesMap.keys());
+    }
+
+    add(saveable: Saveable): void {
+        if (this.saveablesMap.has(saveable)) {
+            return;
+        }
+        const toDispose = new DisposableCollection();
+        this.toDispose.push(toDispose);
+        this.saveablesMap.set(saveable, toDispose);
+        toDispose.push(Disposable.create(() => {
+            this.saveablesMap.delete(saveable);
+        }));
+        toDispose.push(saveable.onDirtyChanged(() => {
+            const wasDirty = this.isDirty;
+            this.isDirty = this.saveables.some(s => s.dirty);
+            if (this.isDirty !== wasDirty) {
+                this.onDirtyChangedEmitter.fire();
+            }
+        }));
+        toDispose.push(saveable.onContentChanged(() => {
+            this.onContentChangedEmitter.fire();
+        }));
+        if (saveable.dirty && !this.isDirty) {
+            this.isDirty = true;
+            this.onDirtyChangedEmitter.fire();
+        }
+    }
+
+    remove(saveable: Saveable): boolean {
+        const toDispose = this.saveablesMap.get(saveable);
+        toDispose?.dispose();
+        return !!toDispose;
+    }
+
+    dispose(): void {
+        this.toDispose.dispose();
+    }
+}
+
 export namespace Saveable {
     export interface RevertOptions {
         /**

package/src/browser/shell/tab-bar-toolbar/tab-bar-toolbar-menu-adapters.ts

@@ -15,12 +15,12 @@
 // *****************************************************************************
 
 import { MenuNode, MenuPath } from '../../../common';
-import { NAVIGATION, TabBarToolbarItem } from './tab-bar-toolbar-types';
+import { NAVIGATION, RenderedToolbarItem } from './tab-bar-toolbar-types';
 
 export const TOOLBAR_WRAPPER_ID_SUFFIX = '-as-tabbar-toolbar-item';
 
-export class ToolbarMenuNodeWrapper implements TabBarToolbarItem {
-    constructor(protected readonly menuNode: MenuNode, readonly group?: string, readonly menuPath?: MenuPath) { }
+export class ToolbarMenuNodeWrapper implements RenderedToolbarItem {
+    constructor(protected readonly menuNode: MenuNode, readonly group: string | undefined, readonly delegateMenuPath: MenuPath, readonly menuPath?: MenuPath) { }
     get id(): string { return this.menuNode.id + TOOLBAR_WRAPPER_ID_SUFFIX; }
     get command(): string { return this.menuNode.command ?? ''; };
     get icon(): string | undefined { return this.menuNode.icon; }

package/src/browser/shell/tab-bar-toolbar/tab-bar-toolbar-registry.ts

@@ -17,11 +17,11 @@
 import debounce = require('lodash.debounce');
 import { inject, injectable, named } from 'inversify';
 // eslint-disable-next-line max-len
-import { CommandMenuNode, CommandRegistry, CompoundMenuNode, ContributionProvider, Disposable, DisposableCollection, Emitter, Event, MenuModelRegistry, MenuNode, MenuPath } from '../../../common';
+import { CommandRegistry, ContributionProvider, Disposable, DisposableCollection, Emitter, Event, MenuModelRegistry, MenuNode, MenuPath } from '../../../common';
 import { ContextKeyService } from '../../context-key-service';
 import { FrontendApplicationContribution } from '../../frontend-application-contribution';
 import { Widget } from '../../widgets';
-import { AnyToolbarItem, ConditionalToolbarItem, MenuDelegate, MenuToolbarItem, ReactTabBarToolbarItem, TabBarToolbarItem } from './tab-bar-toolbar-types';
+import { MenuDelegate, ReactTabBarToolbarItem, RenderedToolbarItem, TabBarToolbarItem } from './tab-bar-toolbar-types';
 import { ToolbarMenuNodeWrapper } from './tab-bar-toolbar-menu-adapters';
 
 /**
@@ -75,7 +75,7 @@ export class TabBarToolbarRegistry implements FrontendApplicationContribution {
      *
      * @param item the item to register.
      */
-    registerItem(item: TabBarToolbarItem | ReactTabBarToolbarItem): Disposable {
+    registerItem(item: RenderedToolbarItem | ReactTabBarToolbarItem): Disposable {
         const { id } = item;
         if (this.items.has(id)) {
             throw new Error(`A toolbar item is already registered with the '${id}' ID.`);
@@ -110,24 +110,18 @@ export class TabBarToolbarRegistry implements FrontendApplicationContribution {
         for (const delegate of this.menuDelegates.values()) {
             if (delegate.isVisible(widget)) {
                 const menu = this.menuRegistry.getMenu(delegate.menuPath);
-                const children = CompoundMenuNode.getFlatChildren(menu.children);
-                for (const child of children) {
+                for (const child of menu.children) {
                     if (!child.when || this.contextKeyService.match(child.when, widget.node)) {
                         if (child.children) {
                             for (const grandchild of child.children) {
                                 if (!grandchild.when || this.contextKeyService.match(grandchild.when, widget.node)) {
-                                    if (CommandMenuNode.is(grandchild)) {
-                                        result.push(new ToolbarMenuNodeWrapper(grandchild, child.id, delegate.menuPath));
-                                    } else if (CompoundMenuNode.is(grandchild)) {
-                                        let menuPath;
-                                        if (menuPath = this.menuRegistry.getPath(grandchild)) {
-                                            result.push(new ToolbarMenuNodeWrapper(grandchild, child.id, menuPath));
-                                        }
-                                    }
+                                    const menuPath = this.menuRegistry.getPath(grandchild);
+                                    result.push(new ToolbarMenuNodeWrapper(grandchild, child.id, delegate.menuPath, menuPath));
                                 }
                             }
                         } else if (child.command) {
-                            result.push(new ToolbarMenuNodeWrapper(child, '', delegate.menuPath));
+                            const menuPath = this.menuRegistry.getPath(child);
+                            result.push(new ToolbarMenuNodeWrapper(child, undefined, delegate.menuPath, menuPath));
                         }
                     }
                 }
@@ -145,15 +139,17 @@ export class TabBarToolbarRegistry implements FrontendApplicationContribution {
      * @returns `false` if the `item` should be suppressed, otherwise `true`
      */
     protected isItemVisible(item: TabBarToolbarItem | ReactTabBarToolbarItem, widget: Widget): boolean {
-        if (TabBarToolbarItem.is(item) && item.command && !this.isTabBarToolbarItemVisible(item, widget)) {
+        if (!this.isConditionalItemVisible(item, widget)) {
             return false;
         }
-        if (MenuToolbarItem.is(item) && !this.isMenuToolbarItemVisible(item, widget)) {
+
+        if (item.command && !this.commandRegistry.isVisible(item.command, widget)) {
             return false;
         }
-        if (AnyToolbarItem.isConditional(item) && !this.isConditionalItemVisible(item, widget)) {
+        if (item.menuPath && !this.isNonEmptyMenu(item, widget)) {
             return false;
         }
+
         // The item is not vetoed. Accept it
         return true;
     }
@@ -166,7 +162,7 @@ export class TabBarToolbarRegistry implements FrontendApplicationContribution {
      * @param widget the widget that is updating the toolbar
      * @returns `false` if the `item` should be suppressed, otherwise `true`
      */
-    protected isConditionalItemVisible(item: ConditionalToolbarItem, widget: Widget): boolean {
+    protected isConditionalItemVisible(item: TabBarToolbarItem, widget: Widget): boolean {
         if (item.isVisible && !item.isVisible(widget)) {
             return false;
         }
@@ -176,19 +172,6 @@ export class TabBarToolbarRegistry implements FrontendApplicationContribution {
         return true;
     }
 
-    /**
-     * Query whether a tab-bar toolbar `item` that has a command should be shown in the toolbar.
-     * This implementation returns `false` if the `item`'s command is not visible in the
-     * `widget` according to the command registry.
-     *
-     * @param item a tab-bar toolbar item that has a non-empty `command`
-     * @param widget the widget that is updating the toolbar
-     * @returns `false` if the `item` should be suppressed, otherwise `true`
-     */
-    protected isTabBarToolbarItemVisible(item: TabBarToolbarItem, widget: Widget): boolean {
-        return this.commandRegistry.isVisible(item.command, widget);
-    }
-
     /**
      * Query whether a menu toolbar `item` should be shown in the toolbar.
      * This implementation returns `false` if the `item` does not have any actual menu to show.
@@ -197,7 +180,10 @@ export class TabBarToolbarRegistry implements FrontendApplicationContribution {
      * @param widget the widget that is updating the toolbar
      * @returns `false` if the `item` should be suppressed, otherwise `true`
      */
-    protected isMenuToolbarItemVisible(item: MenuToolbarItem, widget: Widget): boolean {
+    isNonEmptyMenu(item: TabBarToolbarItem, widget: Widget | undefined): boolean {
+        if (!item.menuPath) {
+            return false;
+        }
         const menu = this.menuRegistry.getMenu(item.menuPath);
         const isVisible: (node: MenuNode) => boolean = node =>
             node.children?.length
@@ -220,7 +206,7 @@ export class TabBarToolbarRegistry implements FrontendApplicationContribution {
         }
     }
 
-    registerMenuDelegate(menuPath: MenuPath, when?: string | ((widget: Widget) => boolean)): Disposable {
+    registerMenuDelegate(menuPath: MenuPath, when?: ((widget: Widget) => boolean)): Disposable {
         const id = this.toElementId(menuPath);
         if (!this.menuDelegates.has(id)) {
             const isVisible: MenuDelegate['isVisible'] = !when