@theia/core 1.70.0-next.7 → 1.70.0-next.81

package/src/browser/saveable-service.ts

@@ -15,8 +15,8 @@
  ********************************************************************************/
 
 import type { ApplicationShell } from './shell';
-import { injectable } from 'inversify';
-import { UNTITLED_SCHEME, URI, Disposable, DisposableCollection, Emitter, Event } from '../common';
+import { inject, injectable, named } from 'inversify';
+import { ContributionProvider, UNTITLED_SCHEME, URI, Disposable, DisposableCollection, Emitter, Event } from '../common';
 import { Navigatable, NavigatableWidget } from './navigatable-types';
 import { AutoSaveMode, Saveable, SaveableSource, SaveableWidget, SaveOptions, SaveReason, setDirty, close, PostCreationSaveableWidget, ShouldSaveDialog } from './saveable';
 import { waitForClosed, Widget } from './widgets';
@@ -24,16 +24,40 @@ import { FrontendApplicationContribution } from './frontend-application-contribu
 import { FrontendApplication } from './frontend-application';
 import throttle = require('lodash.throttle');
 
+export const SaveErrorChecker = Symbol('SaveErrorChecker');
+
+/**
+ * Contribution point for checking whether a given URI has errors.
+ * When `files.autoSaveWhenNoErrors` is enabled, auto-save will be suppressed
+ * for files where any registered checker reports errors.
+ */
+export interface SaveErrorChecker {
+    /**
+     * Returns `true` if the given URI has errors that should prevent auto-save.
+     */
+    hasErrors(uri: URI): boolean;
+    /**
+     * Event fired when the error state may have changed (e.g. diagnostics updated).
+     * The SaveableService listens to this to re-evaluate auto-save for dirty widgets.
+     */
+    onDidErrorStateChange: Event<void>;
+}
+
 @injectable()
 export class SaveableService implements FrontendApplicationContribution {
 
+    @inject(ContributionProvider) @named(SaveErrorChecker)
+    protected readonly errorCheckers: ContributionProvider<SaveErrorChecker>;
+
     protected saveThrottles = new Map<Widget, AutoSaveThrottle>();
     protected saveMode: AutoSaveMode = 'off';
     protected saveDelay = 1000;
+    protected saveWhenNoErrors = false;
     protected shell: ApplicationShell;
 
     protected readonly onDidAutoSaveChangeEmitter = new Emitter<AutoSaveMode>();
     protected readonly onDidAutoSaveDelayChangeEmitter = new Emitter<number>();
+    protected readonly onDidAutoSaveConditionsChangeEmitter = new Emitter<void>();
 
     get onDidAutoSaveChange(): Event<AutoSaveMode> {
         return this.onDidAutoSaveChangeEmitter.event;
@@ -43,6 +67,10 @@ export class SaveableService implements FrontendApplicationContribution {
         return this.onDidAutoSaveDelayChangeEmitter.event;
     }
 
+    get onDidAutoSaveConditionsChange(): Event<void> {
+        return this.onDidAutoSaveConditionsChangeEmitter.event;
+    }
+
     get autoSave(): AutoSaveMode {
         return this.saveMode;
     }
@@ -59,8 +87,22 @@ export class SaveableService implements FrontendApplicationContribution {
         this.updateAutoSaveDelay(value);
     }
 
+    get autoSaveWhenNoErrors(): boolean {
+        return this.saveWhenNoErrors;
+    }
+
+    set autoSaveWhenNoErrors(value: boolean) {
+        this.saveWhenNoErrors = value;
+    }
+
     onDidInitializeLayout(app: FrontendApplication): void {
         this.shell = app.shell;
+        // Listen to error state changes from all registered error checkers
+        for (const checker of this.errorCheckers.getContributions()) {
+            checker.onDidErrorStateChange(() => {
+                this.onDidAutoSaveConditionsChangeEmitter.fire();
+            });
+        }
         // Register restored editors first
         for (const widget of this.shell.widgets) {
             const saveable = Saveable.get(widget);
@@ -165,9 +207,16 @@ export class SaveableService implements FrontendApplicationContribution {
         if (uri?.scheme === UNTITLED_SCHEME) {
             // Never auto-save untitled documents
             return false;
-        } else {
-            return saveable.autosaveable !== false && saveable.dirty;
         }
+        if (saveable.autosaveable === false || !saveable.dirty) {
+            return false;
+        }
+        if (this.saveWhenNoErrors && uri) {
+            if (this.errorCheckers.getContributions().some(checker => checker.hasErrors(uri))) {
+                return false;
+            }
+        }
+        return true;
     }
 
     protected applySaveableWidget(widget: Widget, saveable: Saveable): void {
@@ -314,6 +363,9 @@ export class AutoSaveThrottle implements Disposable {
             }),
             saveService.onDidAutoSaveDelayChange(() => {
                 this.throttledSave(true);
+            }),
+            saveService.onDidAutoSaveConditionsChange(() => {
+                this.throttledSave();
             })
         );
     }

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

@@ -24,6 +24,7 @@ import { ContextMenuRenderer } from '../../context-menu-renderer';
 import { TabBarToolbarItem } from './tab-toolbar-item';
 import { ContextKeyService, ContextMatcher } from '../../context-key-service';
 import { CommandMenu, CompoundMenuNode, ContextExpressionMatcher, Group, MenuModelRegistry, MenuNode, MenuPath, RenderedMenuNode, Submenu } from '../../../common/menu';
+import { combineWhenExpressions } from '../../menu/utils';
 
 export const TOOLBAR_WRAPPER_ID_SUFFIX = '-as-tabbar-toolbar-item';
 
@@ -128,6 +129,9 @@ export class SubmenuAsToolbarItemWrapper extends AbstractToolbarMenuWrapper impl
         super(effectiveMenuPath, commandRegistry, menuRegistry, contextKeyService, contextMenuRenderer);
     }
     priority?: number | undefined;
+    get when(): string | undefined {
+        return this.menuNode.when;
+    }
 
     executeCommand(widget: Widget, e: React.MouseEvent<HTMLDivElement, MouseEvent>): void {
     }
@@ -164,6 +168,10 @@ export class CommandMenuAsToolbarItemWrapper extends AbstractToolbarMenuWrapper
         super(effectiveMenuPath, commandRegistry, menuRegistry, contextKeyService, contextMenuRenderer);
     }
 
+    get when(): string | undefined {
+        return this.menuNode.when;
+    }
+
     isVisible(widget: Widget): boolean {
         return this.menuNode.isVisible(this.effectiveMenuPath, this.contextKeyService, widget.node, widget);
     }
@@ -199,6 +207,10 @@ export class ToolbarActionWrapper extends AbstractToolbarMenuWrapper implements
         super(effectiveMenuPath, commandRegistry, menuRegistry, contextKeyService, contextMenuRenderer);
     }
 
+    get when(): string | undefined {
+        return combineWhenExpressions(this.toolbarItem.when, this.menuNode?.when);
+    }
+
     override isEnabled(widget?: Widget): boolean {
         return this.toolbarItem.command ? this.commandRegistry.isEnabled(this.toolbarItem.command, widget) : !!this.toolbarItem.menuPath;
     }

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

@@ -26,7 +26,7 @@ import { CommandMenuAsToolbarItemWrapper, SubmenuAsToolbarItemWrapper, ToolbarAc
 import { KeybindingRegistry } from '../../keybinding';
 import { LabelParser } from '../../label-parser';
 import { ContextMenuRenderer } from '../../context-menu-renderer';
-import { CommandMenu, CompoundMenuNode, RenderedMenuNode } from '../../../common/menu';
+import { CommandMenu, CompoundMenuNode, MenuNode, RenderedMenuNode } from '../../../common/menu';
 import { ReactToolbarItemImpl, RenderedToolbarItemImpl, TabBarToolbarItem } from './tab-toolbar-item';
 
 /**
@@ -168,6 +168,45 @@ export class TabBarToolbarRegistry implements FrontendApplicationContribution {
         return result;
     }
 
+    /**
+     * Collects all context keys referenced by toolbar items and delegated menu nodes
+     * that may participate in rendering for the given widget.
+     */
+    collectContextKeys(widget: Widget): Set<string> {
+        const contextKeys = new Set<string>();
+        if (widget.isDisposed) {
+            return contextKeys;
+        }
+
+        for (const item of this.items.values()) {
+            if (item.when) {
+                this.contextKeyService.parseKeys(item.when)?.forEach(key => contextKeys.add(key));
+            }
+        }
+
+        for (const delegate of this.menuDelegates.values()) {
+            if (!delegate.isVisible(widget)) {
+                continue;
+            }
+            const menu = this.menuRegistry.getMenu(delegate.menuPath);
+            if (menu) {
+                this.collectMenuContextKeys(menu, contextKeys);
+            }
+        }
+        return contextKeys;
+    }
+
+    protected collectMenuContextKeys(menuNode: MenuNode, contextKeys: Set<string>): void {
+        if (menuNode.when) {
+            this.contextKeyService.parseKeys(menuNode.when)?.forEach(key => contextKeys.add(key));
+        }
+        if (CompoundMenuNode.is(menuNode)) {
+            for (const child of menuNode.children) {
+                this.collectMenuContextKeys(child, contextKeys);
+            }
+        }
+    }
+
     unregisterItem(id: string): void {
         if (this.items.delete(id)) {
             this.fireOnDidChange();

package/src/browser/shell/tab-bar-toolbar/tab-bar-toolbar.tsx

@@ -53,6 +53,7 @@ export class TabBarToolbar extends ReactWidget {
     protected contextKeyListener: Disposable | undefined;
     protected toDisposeOnUpdateItems: DisposableCollection = new DisposableCollection();
 
+    protected toolbarContextKeys = new Set<string>();
     protected keybindingContextKeys = new Set<string>();
 
     @inject(CommandRegistry) protected readonly commands: CommandRegistry;
@@ -74,7 +75,9 @@ export class TabBarToolbar extends ReactWidget {
         this.toDispose.pushAll([
             this.keybindings.onKeybindingsChanged(() => this.maybeUpdate()),
             this.contextKeyService.onDidChange(e => {
-                if (e.affects(this.keybindingContextKeys)) {
+                if (this.current && e.affects(this.toolbarContextKeys)) {
+                    this.updateTarget(this.current);
+                } else if (e.affects(this.keybindingContextKeys)) {
                     this.maybeUpdate();
                 }
             }),
@@ -85,11 +88,12 @@ export class TabBarToolbar extends ReactWidget {
         ]);
     }
 
-    updateItems(items: Array<TabBarToolbarItem>, current: Widget | undefined): void {
+    updateItems(items: Array<TabBarToolbarItem>, current: Widget | undefined, contextKeys: Set<string> = new Set()): void {
         this.toDisposeOnUpdateItems.dispose();
         this.toDisposeOnUpdateItems = new DisposableCollection();
         this.inline.clear();
         this.more.clear();
+        this.toolbarContextKeys = contextKeys;
 
         for (const item of items.sort(TabBarToolbarAction.PRIORITY_COMPARATOR).reverse()) {
 
@@ -98,7 +102,6 @@ export class TabBarToolbar extends ReactWidget {
             } else {
                 this.more.set(item.id, item);
             }
-
             if (item.onDidChange) {
                 this.toDisposeOnUpdateItems.push(item.onDidChange(() => this.maybeUpdate()));
             }
@@ -116,7 +119,8 @@ export class TabBarToolbar extends ReactWidget {
     updateTarget(current?: Widget): void {
         const operativeWidget = TabBarDelegator.is(current) ? current.getTabBarDelegate() : current;
         const items = operativeWidget ? this.toolbarRegistry.visibleItems(operativeWidget) : [];
-        this.updateItems(items, operativeWidget);
+        const contextKeys = operativeWidget ? this.toolbarRegistry.collectContextKeys(operativeWidget) : new Set<string>();
+        this.updateItems(items, operativeWidget, contextKeys);
     }
 
     protected readonly toDisposeOnSetCurrent = new DisposableCollection();

package/src/browser/shell/tab-bar-toolbar/tab-toolbar-item.tsx

@@ -27,6 +27,7 @@ import { ActionMenuNode, GroupImpl, MenuNode } from '../../../common/menu';
 
 export interface TabBarToolbarItem {
     id: string;
+    when?: string;
     isVisible(widget: Widget): boolean;
     isEnabled(widget: Widget): boolean;
     isToggled(widget: Widget): boolean;
@@ -52,6 +53,9 @@ class AbstractToolbarItemImpl<T extends TabBarToolbarActionBase> {
     get id(): string {
         return this.action.id;
     }
+    get when(): string | undefined {
+        return this.action.when;
+    }
     get group(): string | undefined {
         return this.action.group;
     }

package/src/browser/style/hover-service.css

@@ -29,6 +29,7 @@
   border: 1px solid var(--theia-editorHoverWidget-border);
   padding: var(--theia-ui-padding);
   max-width: var(--theia-hover-max-width);
+  user-select: text;
 }
 
 /* overwrite potentially different default user agent styles */

package/src/browser/style/index.css

@@ -78,13 +78,13 @@
 
 html,
 body {
+    overflow: hidden;
     height: 100vh;
 }
 
 body {
     margin: 0;
     padding: 0;
-    overflow: hidden;
     font-family: var(--theia-ui-font-family);
     background: var(--theia-editor-background);
     color: var(--theia-foreground);

package/src/browser/tree/fuzzy-search.ts

@@ -14,123 +14,5 @@
 // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
 // *****************************************************************************
 
-import * as fuzzy from 'fuzzy';
-import { injectable } from 'inversify';
-
-@injectable()
-export class FuzzySearch {
-
-    private static readonly PRE = '\x01';
-    private static readonly POST = '\x02';
-
-    /**
-     * Filters the input and returns with an array that contains all items that match the pattern.
-     */
-    async filter<T>(input: FuzzySearch.Input<T>): Promise<FuzzySearch.Match<T>[]> {
-        return fuzzy.filter(input.pattern, input.items.slice(), {
-            pre: FuzzySearch.PRE,
-            post: FuzzySearch.POST,
-            extract: input.transform
-        }).sort(this.sortResults.bind(this)).map(this.mapResult.bind(this));
-    }
-
-    protected sortResults<T>(left: fuzzy.FilterResult<T>, right: fuzzy.FilterResult<T>): number {
-        return left.index - right.index;
-    }
-
-    protected mapResult<T>(result: fuzzy.FilterResult<T>): FuzzySearch.Match<T> {
-        return {
-            item: result.original,
-            ranges: this.mapRanges(result.string)
-        };
-    }
-
-    protected mapRanges(input: string): ReadonlyArray<FuzzySearch.Range> {
-        const copy = input.split('').filter(s => s !== '');
-        const ranges: FuzzySearch.Range[] = [];
-        const validate = (pre: number, post: number) => {
-            if (preIndex > postIndex || (preIndex === -1) !== (postIndex === -1)) {
-                throw new Error(`Error when trying to map ranges. Escaped string was: '${input}. [${[...input].join('|')}]'`);
-            }
-        };
-        let preIndex = copy.indexOf(FuzzySearch.PRE);
-        let postIndex = copy.indexOf(FuzzySearch.POST);
-        validate(preIndex, postIndex);
-        while (preIndex !== -1 && postIndex !== -1) {
-            ranges.push({
-                offset: preIndex,
-                length: postIndex - preIndex - 1
-            });
-            copy.splice(postIndex, 1);
-            copy.splice(preIndex, 1);
-            preIndex = copy.indexOf(FuzzySearch.PRE);
-            postIndex = copy.indexOf(FuzzySearch.POST);
-        }
-        if (ranges.length === 0) {
-            throw new Error(`Unexpected zero ranges for match-string: ${input}.`);
-        }
-        return ranges;
-    }
-
-}
-
-/**
- * Fuzzy searcher.
- */
-export namespace FuzzySearch {
-
-    /**
-     * A range representing the match region.
-     */
-    export interface Range {
-
-        /**
-         * The zero based offset of the match region.
-         */
-        readonly offset: number;
-
-        /**
-         * The length of the match region.
-         */
-        readonly length: number;
-    }
-
-    /**
-     * A fuzzy search match.
-     */
-    export interface Match<T> {
-
-        /**
-         * The original item.
-         */
-        readonly item: T;
-
-        /**
-         * An array of ranges representing the match regions.
-         */
-        readonly ranges: ReadonlyArray<Range>;
-    }
-
-    /**
-     * The fuzzy search input.
-     */
-    export interface Input<T> {
-
-        /**
-         * The pattern to match.
-         */
-        readonly pattern: string;
-
-        /**
-         * The items to filter based on the `pattern`.
-         */
-        readonly items: ReadonlyArray<T>;
-
-        /**
-         * Function that extracts the string from the inputs which will be used to evaluate the fuzzy matching filter.
-         */
-        readonly transform: (item: T) => string;
-
-    }
-
-}
+// Re-export from common location for backward compatibility.
+export { FuzzySearch } from '../../common/fuzzy-search';

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

@@ -257,8 +257,7 @@ export class TreeViewWelcomeWidget extends TreeWidget {
         event.stopPropagation();
 
         if (value.startsWith('command:')) {
-            const command = value.replace('command:', '');
-            this.commands.executeCommand(command);
+            open(this.openerService, new URI(value));
         } else if (value.startsWith('file:')) {
             const uri = value.replace('file:', '');
             open(this.openerService, new URI(CodeUri.file(uri).toString()));

package/src/browser/widgets/select-component.tsx

@@ -60,6 +60,7 @@ export class SelectComponent extends React.Component<SelectComponentProps, Selec
     protected mountedListeners: Map<string, EventListenerOrEventListenerObject> = new Map();
     protected optimalWidth = 0;
     protected optimalHeight = 0;
+    protected resizeObserver: ResizeObserver | undefined;
 
     constructor(props: SelectComponentProps) {
         super(props);
@@ -148,14 +149,16 @@ export class SelectComponent extends React.Component<SelectComponentProps, Selec
         return optimal + 20; // Just to be safe, add another 20 pixels here
     }
 
-    protected attachListeners(): void {
-        const hide = (event: MouseEvent) => {
+   protected attachListeners(): void {
+        const hide = (event: Event) => {
             if (!this.dropdownRef.current?.contains(event.target as Node)) {
                 this.hide();
             }
         };
+        const hideOnResize = () => this.hide();
         this.mountedListeners.set('scroll', hide);
         this.mountedListeners.set('wheel', hide);
+        this.mountedListeners.set('resize', hideOnResize);
 
         let parent = this.fieldRef.current?.parentElement;
         while (parent) {
@@ -170,9 +173,43 @@ export class SelectComponent extends React.Component<SelectComponentProps, Selec
         for (const [key, listener] of this.mountedListeners.entries()) {
             window.addEventListener(key, listener);
         }
+
+        // Catch Lumino sash drags globally - observe the closest lm-Widget panel
+        const fieldEl = this.fieldRef.current;
+        const resizablePanel = fieldEl?.closest('.lm-Widget') ?? fieldEl?.parentElement;
+
+        if (resizablePanel && typeof ResizeObserver !== 'undefined') {
+            let lastWidth = 0;
+            let lastHeight = 0;
+            let isFirstFire = true;
+
+            this.resizeObserver = new ResizeObserver(entries => {
+                for (const entry of entries) {
+                    const { width, height } = entry.contentRect;
+
+                    // Ignore the initial automatic fire when the observer attaches
+                    if (isFirstFire) {
+                        lastWidth = width;
+                        lastHeight = height;
+                        isFirstFire = false;
+                        continue;
+                    }
+
+                    // Only hide if the panel dimensions actually changed by more than 2 pixels
+                    if (this.state.dimensions && (Math.abs(width - lastWidth) > 2 || Math.abs(height - lastHeight) > 2)) {
+                        this.hide();
+                    }
+
+                    lastWidth = width;
+                    lastHeight = height;
+                }
+            });
+            this.resizeObserver.observe(resizablePanel);
+        }
     }
 
     override componentWillUnmount(): void {
+        this.resizeObserver?.disconnect();
         if (this.mountedListeners.size > 0) {
             const eventListener = this.mountedListeners.get('scroll')!;
             let parent = this.fieldRef.current?.parentElement;

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

@@ -53,8 +53,13 @@ export class DefaultWindowService implements WindowService, FrontendApplicationC
         return undefined;
     }
 
-    openNewDefaultWindow(): void {
+    async openNewDefaultWindow(): Promise<number> {
         this.openNewWindow(`#${DEFAULT_WINDOW_HASH}`);
+        return -1;
+    }
+
+    closeWindow(windowId: number): void {
+        // No-op in browser-only mode
     }
 
     focus(): void {

package/src/browser/window/test/mock-window-service.ts

@@ -20,7 +20,8 @@ import { WindowService } from '../window-service';
 @injectable()
 export class MockWindowService implements WindowService {
     openNewWindow(): undefined { return undefined; }
-    openNewDefaultWindow(): void { }
+    async openNewDefaultWindow(): Promise<number> { return -1; }
+    closeWindow(): void { }
     focus(): void { }
     reload(): void { }
     isSafeToShutDown(): Promise<boolean> { return Promise.resolve(true); }

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

@@ -39,8 +39,16 @@ export interface WindowService {
     /**
      * Opens a new default window.
      * - In electron and in the browser it will open the default window without a pre-defined content.
+     * @returns a window identifier that can be passed to {@link closeWindow}, or -1 if not supported.
      */
-    openNewDefaultWindow(params?: WindowReloadOptions): void;
+    openNewDefaultWindow(params?: WindowReloadOptions): Promise<number>;
+
+    /**
+     * Closes a window previously opened by {@link openNewDefaultWindow}.
+     * @param windowId the identifier returned by {@link openNewDefaultWindow}.
+     * No-op if the window does not exist or the platform does not support it.
+     */
+    closeWindow(windowId: number): void;
 
     /**
      * Reveal and focuses the current window