@theia/core 1.46.0-next.200 → 1.46.0-next.230

package/src/browser/saveable-service.ts

@@ -0,0 +1,328 @@
+/********************************************************************************
+ * Copyright (C) 2022 Arm 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 type { ApplicationShell } from './shell';
+import { injectable } from 'inversify';
+import { 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';
+import { FrontendApplicationContribution } from './frontend-application-contribution';
+import { FrontendApplication } from './frontend-application';
+import throttle = require('lodash.throttle');
+
+@injectable()
+export class SaveableService implements FrontendApplicationContribution {
+
+    protected saveThrottles = new Map<Widget, AutoSaveThrottle>();
+    protected saveMode: AutoSaveMode = 'off';
+    protected saveDelay = 1000;
+    protected shell: ApplicationShell;
+
+    protected readonly onDidAutoSaveChangeEmitter = new Emitter<AutoSaveMode>();
+    protected readonly onDidAutoSaveDelayChangeEmitter = new Emitter<number>();
+
+    get onDidAutoSaveChange(): Event<AutoSaveMode> {
+        return this.onDidAutoSaveChangeEmitter.event;
+    }
+
+    get onDidAutoSaveDelayChange(): Event<number> {
+        return this.onDidAutoSaveDelayChangeEmitter.event;
+    }
+
+    get autoSave(): AutoSaveMode {
+        return this.saveMode;
+    }
+
+    set autoSave(value: AutoSaveMode) {
+        this.updateAutoSaveMode(value);
+    }
+
+    get autoSaveDelay(): number {
+        return this.saveDelay;
+    }
+
+    set autoSaveDelay(value: number) {
+        this.updateAutoSaveDelay(value);
+    }
+
+    onDidInitializeLayout(app: FrontendApplication): void {
+        this.shell = app.shell;
+        // Register restored editors first
+        for (const widget of this.shell.widgets) {
+            const saveable = Saveable.get(widget);
+            if (saveable) {
+                this.registerSaveable(widget, saveable);
+            }
+        }
+        this.shell.onDidAddWidget(e => {
+            const saveable = Saveable.get(e);
+            if (saveable) {
+                this.registerSaveable(e, saveable);
+            }
+        });
+        this.shell.onDidChangeCurrentWidget(e => {
+            if (this.saveMode === 'onFocusChange') {
+                const widget = e.oldValue;
+                const saveable = Saveable.get(widget);
+                if (saveable && widget && this.shouldAutoSave(widget, saveable)) {
+                    saveable.save({
+                        saveReason: SaveReason.FocusChange
+                    });
+                }
+            }
+        });
+        this.shell.onDidRemoveWidget(e => {
+            this.saveThrottles.get(e)?.dispose();
+            this.saveThrottles.delete(e);
+        });
+    }
+
+    protected updateAutoSaveMode(mode: AutoSaveMode): void {
+        this.saveMode = mode;
+        this.onDidAutoSaveChangeEmitter.fire(mode);
+        if (mode === 'onFocusChange') {
+            // If the new mode is onFocusChange, we need to save all dirty documents that are not focused
+            const widgets = this.shell.widgets;
+            for (const widget of widgets) {
+                const saveable = Saveable.get(widget);
+                if (saveable && widget !== this.shell.currentWidget && this.shouldAutoSave(widget, saveable)) {
+                    saveable.save({
+                        saveReason: SaveReason.FocusChange
+                    });
+                }
+            }
+        }
+    }
+
+    protected updateAutoSaveDelay(delay: number): void {
+        this.saveDelay = delay;
+        this.onDidAutoSaveDelayChangeEmitter.fire(delay);
+    }
+
+    registerSaveable(widget: Widget, saveable: Saveable): Disposable {
+        const saveThrottle = new AutoSaveThrottle(
+            saveable,
+            this,
+            () => {
+                if (this.saveMode === 'afterDelay' && this.shouldAutoSave(widget, saveable)) {
+                    saveable.save({
+                        saveReason: SaveReason.AfterDelay
+                    });
+                }
+            },
+            this.addBlurListener(widget, saveable)
+        );
+        this.saveThrottles.set(widget, saveThrottle);
+        this.applySaveableWidget(widget, saveable);
+        return saveThrottle;
+    }
+
+    protected addBlurListener(widget: Widget, saveable: Saveable): Disposable {
+        const document = widget.node.ownerDocument;
+        const listener = (() => {
+            if (this.saveMode === 'onWindowChange' && !this.windowHasFocus(document) && this.shouldAutoSave(widget, saveable)) {
+                saveable.save({
+                    saveReason: SaveReason.FocusChange
+                });
+            }
+        }).bind(this);
+        document.addEventListener('blur', listener);
+        return Disposable.create(() => {
+            document.removeEventListener('blur', listener);
+        });
+    }
+
+    protected windowHasFocus(document: Document): boolean {
+        if (document.visibilityState === 'hidden') {
+            return false;
+        } else if (document.hasFocus()) {
+            return true;
+        }
+        // TODO: Add support for iframes
+        return false;
+    }
+
+    protected shouldAutoSave(widget: Widget, saveable: Saveable): boolean {
+        const uri = NavigatableWidget.getUri(widget);
+        if (uri?.scheme === UNTITLED_SCHEME) {
+            // Never auto-save untitled documents
+            return false;
+        } else {
+            return saveable.dirty;
+        }
+    }
+
+    protected applySaveableWidget(widget: Widget, saveable: Saveable): void {
+        if (SaveableWidget.is(widget)) {
+            return;
+        }
+        const saveableWidget = widget as PostCreationSaveableWidget;
+        setDirty(saveableWidget, saveable.dirty);
+        saveable.onDirtyChanged(() => setDirty(saveableWidget, saveable.dirty));
+        const closeWithSaving = this.createCloseWithSaving();
+        const closeWithoutSaving = () => this.closeWithoutSaving(saveableWidget, false);
+        Object.assign(saveableWidget, {
+            closeWithoutSaving,
+            closeWithSaving,
+            close: closeWithSaving,
+            [close]: saveableWidget.close,
+        });
+    }
+
+    protected createCloseWithSaving(): (this: SaveableWidget, options?: SaveableWidget.CloseOptions) => Promise<void> {
+        let closing = false;
+        const doSave = this.closeWithSaving.bind(this);
+        return async function (this: SaveableWidget, options?: SaveableWidget.CloseOptions): Promise<void> {
+            if (closing) {
+                return;
+            }
+            closing = true;
+            try {
+                await doSave(this, options);
+            } finally {
+                closing = false;
+            }
+        };
+    }
+
+    protected async closeWithSaving(widget: PostCreationSaveableWidget, options?: SaveableWidget.CloseOptions): Promise<void> {
+        const result = await this.shouldSaveWidget(widget, options);
+        if (typeof result === 'boolean') {
+            if (result) {
+                await this.save(widget, {
+                    saveReason: SaveReason.AfterDelay
+                });
+                if (!Saveable.isDirty(widget)) {
+                    await widget.closeWithoutSaving();
+                }
+            } else {
+                await widget.closeWithoutSaving();
+            }
+        }
+    }
+
+    protected async shouldSaveWidget(widget: PostCreationSaveableWidget, options?: SaveableWidget.CloseOptions): Promise<boolean | undefined> {
+        if (!Saveable.isDirty(widget)) {
+            return false;
+        }
+        if (this.autoSave !== 'off') {
+            return true;
+        }
+        const notLastWithDocument = !Saveable.closingWidgetWouldLoseSaveable(widget, Array.from(this.saveThrottles.keys()));
+        if (notLastWithDocument) {
+            return widget.closeWithoutSaving(false).then(() => undefined);
+        }
+        if (options && options.shouldSave) {
+            return options.shouldSave();
+        }
+        return new ShouldSaveDialog(widget).open();
+    }
+
+    protected async closeWithoutSaving(widget: PostCreationSaveableWidget, doRevert: boolean = true): Promise<void> {
+        const saveable = Saveable.get(widget);
+        if (saveable && doRevert && saveable.dirty && saveable.revert) {
+            await saveable.revert();
+        }
+        widget[close]();
+        return waitForClosed(widget);
+    }
+
+    /**
+     * Indicate if the document can be saved ('Save' command should be disable if not).
+     */
+    canSave(widget?: Widget): widget is Widget & (Saveable | SaveableSource) {
+        return Saveable.isDirty(widget) && (this.canSaveNotSaveAs(widget) || this.canSaveAs(widget));
+    }
+
+    canSaveNotSaveAs(widget?: Widget): widget is Widget & (Saveable | SaveableSource) {
+        // By default, we never allow a document to be saved if it is untitled.
+        return Boolean(widget && NavigatableWidget.getUri(widget)?.scheme !== UNTITLED_SCHEME);
+    }
+
+    /**
+     * Saves the document
+     *
+     * No op if the widget is not saveable.
+     */
+    async save(widget: Widget | undefined, options?: SaveOptions): Promise<URI | undefined> {
+        if (this.canSaveNotSaveAs(widget)) {
+            await Saveable.save(widget, options);
+            return NavigatableWidget.getUri(widget);
+        } else if (this.canSaveAs(widget)) {
+            return this.saveAs(widget, options);
+        }
+    }
+
+    canSaveAs(saveable?: Widget): saveable is Widget & SaveableSource & Navigatable {
+        return false;
+    }
+
+    saveAs(sourceWidget: Widget & SaveableSource & Navigatable, options?: SaveOptions): Promise<URI | undefined> {
+        return Promise.reject('Unsupported: The base SaveResourceService does not support saveAs action.');
+    }
+}
+
+export class AutoSaveThrottle implements Disposable {
+
+    private _saveable: Saveable;
+    private _callback: () => void;
+    private _saveService: SaveableService;
+    private _disposable: DisposableCollection;
+    private _throttle?: ReturnType<typeof throttle>;
+
+    constructor(saveable: Saveable, saveService: SaveableService, callback: () => void, ...disposables: Disposable[]) {
+        this._callback = callback;
+        this._saveable = saveable;
+        this._saveService = saveService;
+        this._disposable = new DisposableCollection(
+            ...disposables,
+            saveable.onContentChanged(() => {
+                this.throttledSave();
+            }),
+            saveable.onDirtyChanged(() => {
+                this.throttledSave();
+            }),
+            saveService.onDidAutoSaveChange(() => {
+                this.throttledSave();
+            }),
+            saveService.onDidAutoSaveDelayChange(() => {
+                this.throttledSave(true);
+            })
+        );
+    }
+
+    protected throttledSave(reset = false): void {
+        this._throttle?.cancel();
+        if (reset) {
+            this._throttle = undefined;
+        }
+        if (this._saveService.autoSave === 'afterDelay' && this._saveable.dirty) {
+            if (!this._throttle) {
+                this._throttle = throttle(() => this._callback(), this._saveService.autoSaveDelay, {
+                    leading: false,
+                    trailing: true
+                });
+            }
+            this._throttle();
+        }
+    }
+
+    dispose(): void {
+        this._disposable.dispose();
+    }
+
+}

package/src/browser/saveable.ts

@@ -20,14 +20,23 @@ import { Emitter, Event } from '../common/event';
 import { MaybePromise } from '../common/types';
 import { Key } from './keyboard/keys';
 import { AbstractDialog } from './dialogs';
-import { waitForClosed } from './widgets';
 import { nls } from '../common/nls';
-import { Disposable, isObject } from '../common';
+import { DisposableCollection, isObject } from '../common';
+
+export type AutoSaveMode = 'off' | 'afterDelay' | 'onFocusChange' | 'onWindowChange';
 
 export interface Saveable {
     readonly dirty: boolean;
+    /**
+     * This event is fired when the content of the `dirty` variable changes.
+     */
     readonly onDirtyChanged: Event<void>;
-    readonly autoSave: 'off' | 'afterDelay' | 'onFocusChange' | 'onWindowChange';
+    /**
+     * This event is fired when the content of the saveable changes.
+     * While `onDirtyChanged` is fired to notify the UI that the widget is dirty,
+     * `onContentChanged` is used for the auto save throttling.
+     */
+    readonly onContentChanged: Event<void>;
     /**
      * Saves dirty changes.
      */
@@ -53,11 +62,15 @@ export interface SaveableSource {
 export class DelegatingSaveable implements Saveable {
     dirty = false;
     protected readonly onDirtyChangedEmitter = new Emitter<void>();
+    protected readonly onContentChangedEmitter = new Emitter<void>();
 
     get onDirtyChanged(): Event<void> {
         return this.onDirtyChangedEmitter.event;
     }
-    autoSave: 'off' | 'afterDelay' | 'onFocusChange' | 'onWindowChange' = 'off';
+
+    get onContentChanged(): Event<void> {
+        return this.onContentChangedEmitter.event;
+    }
 
     async save(options?: SaveOptions): Promise<void> {
         await this._delegate?.save(options);
@@ -68,16 +81,19 @@ export class DelegatingSaveable implements Saveable {
     applySnapshot?(snapshot: object): void;
 
     protected _delegate?: Saveable;
-    protected toDispose?: Disposable;
+    protected toDispose = new DisposableCollection();
 
     set delegate(delegate: Saveable) {
-        this.toDispose?.dispose();
+        this.toDispose.dispose();
+        this.toDispose = new DisposableCollection();
         this._delegate = delegate;
-        this.toDispose = delegate.onDirtyChanged(() => {
+        this.toDispose.push(delegate.onDirtyChanged(() => {
             this.dirty = delegate.dirty;
             this.onDirtyChangedEmitter.fire();
-        });
-        this.autoSave = delegate.autoSave;
+        }));
+        this.toDispose.push(delegate.onContentChanged(() => {
+            this.onContentChangedEmitter.fire();
+        }));
         if (this.dirty !== delegate.dirty) {
             this.dirty = delegate.dirty;
             this.onDirtyChangedEmitter.fire();
@@ -131,52 +147,6 @@ export namespace Saveable {
         }
     }
 
-    async function closeWithoutSaving(this: PostCreationSaveableWidget, doRevert: boolean = true): Promise<void> {
-        const saveable = get(this);
-        if (saveable && doRevert && saveable.dirty && saveable.revert) {
-            await saveable.revert();
-        }
-        this[close]();
-        return waitForClosed(this);
-    }
-
-    function createCloseWithSaving(
-        getOtherSaveables?: () => Array<Widget | SaveableWidget>,
-        doSave?: (widget: Widget, options?: SaveOptions) => Promise<void>
-    ): (this: SaveableWidget, options?: SaveableWidget.CloseOptions) => Promise<void> {
-        let closing = false;
-        return async function (this: SaveableWidget, options: SaveableWidget.CloseOptions): Promise<void> {
-            if (closing) { return; }
-            const saveable = get(this);
-            if (!saveable) { return; }
-            closing = true;
-            try {
-                const result = await shouldSave(saveable, () => {
-                    const notLastWithDocument = !closingWidgetWouldLoseSaveable(this, getOtherSaveables?.() ?? []);
-                    if (notLastWithDocument) {
-                        return this.closeWithoutSaving(false).then(() => undefined);
-                    }
-                    if (options && options.shouldSave) {
-                        return options.shouldSave();
-                    }
-                    return new ShouldSaveDialog(this).open();
-                });
-                if (typeof result === 'boolean') {
-                    if (result) {
-                        await (doSave?.(this) ?? Saveable.save(this));
-                        if (!isDirty(this)) {
-                            await this.closeWithoutSaving();
-                        }
-                    } else {
-                        await this.closeWithoutSaving();
-                    }
-                }
-            } finally {
-                closing = false;
-            }
-        };
-    }
-
     export async function confirmSaveBeforeClose(toClose: Iterable<Widget>, others: Widget[]): Promise<boolean | undefined> {
         for (const widget of toClose) {
             const saveable = Saveable.get(widget);
@@ -197,49 +167,9 @@ export namespace Saveable {
         return true;
     }
 
-    /**
-     * @param widget the widget that may be closed
-     * @param others widgets that will not be closed.
-     * @returns `true` if widget is saveable and no widget among the `others` refers to the same saveable. `false` otherwise.
-     */
-    function closingWidgetWouldLoseSaveable(widget: Widget, others: Widget[]): boolean {
-        const saveable = get(widget);
-        return !!saveable && !others.some(otherWidget => otherWidget !== widget && get(otherWidget) === saveable);
-    }
-
-    export function apply(
-        widget: Widget,
-        getOtherSaveables?: () => Array<Widget | SaveableWidget>,
-        doSave?: (widget: Widget, options?: SaveOptions) => Promise<void>,
-    ): SaveableWidget | undefined {
-        if (SaveableWidget.is(widget)) {
-            return widget;
-        }
+    export function closingWidgetWouldLoseSaveable(widget: Widget, others: Widget[]): boolean {
         const saveable = Saveable.get(widget);
-        if (!saveable) {
-            return undefined;
-        }
-        const saveableWidget = widget as SaveableWidget;
-        setDirty(saveableWidget, saveable.dirty);
-        saveable.onDirtyChanged(() => setDirty(saveableWidget, saveable.dirty));
-        const closeWithSaving = createCloseWithSaving(getOtherSaveables, doSave);
-        return Object.assign(saveableWidget, {
-            closeWithoutSaving,
-            closeWithSaving,
-            close: closeWithSaving,
-            [close]: saveableWidget.close,
-        });
-    }
-    export async function shouldSave(saveable: Saveable, cb: () => MaybePromise<boolean | undefined>): Promise<boolean | undefined> {
-        if (!saveable.dirty) {
-            return false;
-        }
-
-        if (saveable.autoSave !== 'off') {
-            return true;
-        }
-
-        return cb();
+        return !!saveable && !others.some(otherWidget => otherWidget !== widget && Saveable.get(otherWidget) === saveable);
     }
 }
 
@@ -302,11 +232,27 @@ export const enum FormatType {
     DIRTY
 };
 
+export enum SaveReason {
+    Manual = 1,
+    AfterDelay = 2,
+    FocusChange = 3
+}
+
+export namespace SaveReason {
+    export function isManual(reason?: number): reason is typeof SaveReason.Manual {
+        return reason === SaveReason.Manual;
+    }
+}
+
 export interface SaveOptions {
     /**
      * Formatting type to apply when saving.
      */
     readonly formatType?: FormatType;
+    /**
+     * The reason for saving the resource.
+     */
+    readonly saveReason?: SaveReason;
 }
 
 /**

package/src/browser/shell/additional-views-menu-widget.tsx

@@ -23,13 +23,13 @@ import { SideTabBar } from './tab-bars';
 export const AdditionalViewsMenuWidgetFactory = Symbol('AdditionalViewsMenuWidgetFactory');
 export type AdditionalViewsMenuWidgetFactory = (side: 'left' | 'right') => AdditionalViewsMenuWidget;
 
-export const ADDITIONAL_VIEWS_MENU_PATH: MenuPath = ['additional_views_menu'];
-
+export const AdditionalViewsMenuPath = Symbol('AdditionalViewsMenuPath');
 @injectable()
 export class AdditionalViewsMenuWidget extends SidebarMenuWidget {
     static readonly ID = 'sidebar.additional.views';
 
-    side: 'left' | 'right';
+    @inject(AdditionalViewsMenuPath)
+    protected menuPath: MenuPath;
 
     @inject(CommandRegistry)
     protected readonly commandRegistry: CommandRegistry;
@@ -47,7 +47,7 @@ export class AdditionalViewsMenuWidget extends SidebarMenuWidget {
                 title: nls.localizeByDefault('Additional Views'),
                 iconClass: codicon('ellipsis'),
                 id: AdditionalViewsMenuWidget.ID,
-                menuPath: ADDITIONAL_VIEWS_MENU_PATH,
+                menuPath: this.menuPath,
                 order: 0
             });
         }
@@ -66,6 +66,6 @@ export class AdditionalViewsMenuWidget extends SidebarMenuWidget {
                 });
             }
         }));
-        this.menuDisposables.push(this.menuModelRegistry.registerMenuAction(ADDITIONAL_VIEWS_MENU_PATH, { commandId: command.id, order: index.toString() }));
+        this.menuDisposables.push(this.menuModelRegistry.registerMenuAction(this.menuPath, { commandId: command.id, order: index.toString() }));
     }
 }

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

@@ -24,7 +24,7 @@ import { Message } from '@phosphor/messaging';
 import { IDragEvent } from '@phosphor/dragdrop';
 import { RecursivePartial, Event as CommonEvent, DisposableCollection, Disposable, environment, isObject } from '../../common';
 import { animationFrame } from '../browser';
-import { Saveable, SaveableWidget, SaveOptions, SaveableSource } from '../saveable';
+import { Saveable, SaveableWidget, SaveOptions } from '../saveable';
 import { StatusBarImpl, StatusBarEntry, StatusBarAlignment } from '../status-bar/status-bar';
 import { TheiaDockPanel, BOTTOM_AREA_ID, MAIN_AREA_ID } from './theia-dock-panel';
 import { SidePanelHandler, SidePanel, SidePanelHandlerFactory } from './side-panel-handler';
@@ -38,7 +38,7 @@ import { waitForRevealed, waitForClosed, PINNED_CLASS } from '../widgets';
 import { CorePreferences } from '../core-preferences';
 import { BreadcrumbsRendererFactory } from '../breadcrumbs/breadcrumbs-renderer';
 import { Deferred } from '../../common/promise-util';
-import { SaveResourceService } from '../save-resource-service';
+import { SaveableService } from '../saveable-service';
 import { nls } from '../../common/nls';
 import { SecondaryWindowHandler } from '../secondary-window-handler';
 import URI from '../../common/uri';
@@ -272,7 +272,7 @@ export class ApplicationShell extends Widget {
         @inject(FrontendApplicationStateService) protected readonly applicationStateService: FrontendApplicationStateService,
         @inject(ApplicationShellOptions) @optional() options: RecursivePartial<ApplicationShell.Options> = {},
         @inject(CorePreferences) protected readonly corePreferences: CorePreferences,
-        @inject(SaveResourceService) protected readonly saveResourceService: SaveResourceService,
+        @inject(SaveableService) protected readonly saveableService: SaveableService,
         @inject(SecondaryWindowHandler) protected readonly secondaryWindowHandler: SecondaryWindowHandler,
         @inject(WindowService) protected readonly windowService: WindowService
     ) {
@@ -1231,13 +1231,6 @@ export class ApplicationShell extends Widget {
         }
         this.tracker.add(widget);
         this.checkActivation(widget);
-        Saveable.apply(
-            widget,
-            () => this.widgets.filter((maybeSaveable): maybeSaveable is Widget & SaveableSource => !!Saveable.get(maybeSaveable)),
-            async (toSave, options) => {
-                await this.saveResourceService.save(toSave, options);
-            },
-        );
         if (ApplicationShell.TrackableWidgetProvider.is(widget)) {
             for (const toTrack of widget.getTrackableWidgets()) {
                 this.track(toTrack);
@@ -2043,21 +2036,21 @@ export class ApplicationShell extends Widget {
      * Test whether the current widget is dirty.
      */
     canSave(): boolean {
-        return this.saveResourceService.canSave(this.currentWidget);
+        return this.saveableService.canSave(this.currentWidget);
     }
 
     /**
      * Save the current widget if it is dirty.
      */
     async save(options?: SaveOptions): Promise<void> {
-        await this.saveResourceService.save(this.currentWidget, options);
+        await this.saveableService.save(this.currentWidget, options);
     }
 
     /**
      * Test whether there is a dirty widget.
      */
     canSaveAll(): boolean {
-        return this.tracker.widgets.some(widget => this.saveResourceService.canSave(widget));
+        return this.tracker.widgets.some(widget => this.saveableService.canSave(widget));
     }
 
     /**
@@ -2065,8 +2058,8 @@ export class ApplicationShell extends Widget {
      */
     async saveAll(options?: SaveOptions): Promise<void> {
         for (const widget of this.widgets) {
-            if (this.saveResourceService.canSaveNotSaveAs(widget)) {
-                await this.saveResourceService.save(widget, options);
+            if (this.saveableService.canSaveNotSaveAs(widget)) {
+                await this.saveableService.save(widget, options);
             }
         }
     }

package/src/browser/shell/side-panel-handler.ts

@@ -211,6 +211,7 @@ export class SidePanelHandler {
     protected createAdditionalViewsWidget(): AdditionalViewsMenuWidget {
         const widget = this.additionalViewsMenuFactory(this.side);
         widget.addClass('theia-sidebar-menu');
+        widget.addClass('theia-additional-views-menu');
         return widget;
     }
 
@@ -653,7 +654,7 @@ export class SidePanelHandler {
     }
 
     protected onTabsOverflowChanged(sender: SideTabBar, event: { titles: Title<Widget>[], startIndex: number }): void {
-        if (event.startIndex >= 0 && event.startIndex <= sender.currentIndex) {
+        if (event.startIndex > 0 && event.startIndex <= sender.currentIndex) {
             sender.revealTab(sender.currentIndex);
         } else {
             this.additionalViewsMenu.updateAdditionalViews(sender, event);