@theia/core 1.49.1 → 1.50.0

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/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/view-column-service.ts

@@ -0,0 +1,125 @@
+// *****************************************************************************
+// Copyright (C) 2019 Red Hat, Inc. 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 { injectable, inject } from 'inversify';
+import { Emitter, Event } from '../../common/event';
+import { ApplicationShell } from './application-shell';
+import { toArray } from '@phosphor/algorithm';
+import { TabBar, Widget } from '@phosphor/widgets';
+
+@injectable()
+export class ViewColumnService {
+    private readonly columnValues = new Map<string, number>();
+    private readonly viewColumnIds = new Map<number, string[]>();
+
+    protected readonly onViewColumnChangedEmitter = new Emitter<{ id: string, viewColumn: number }>();
+
+    constructor(
+        @inject(ApplicationShell) private readonly shell: ApplicationShell,
+    ) {
+        let oldColumnValues = new Map<string, number>();
+        const update = async () => {
+            await new Promise<void>((resolve => setTimeout(resolve)));
+            this.updateViewColumns();
+            this.viewColumnIds.forEach((ids: string[], viewColumn: number) => {
+                ids.forEach((id: string) => {
+                    if (!oldColumnValues.has(id) || oldColumnValues.get(id) !== viewColumn) {
+                        this.onViewColumnChangedEmitter.fire({ id, viewColumn });
+                    }
+                });
+            });
+            oldColumnValues = new Map(this.columnValues.entries());
+        };
+        this.shell.mainPanel.widgetAdded.connect(() => update());
+        this.shell.mainPanel.widgetRemoved.connect(() => update());
+    }
+
+    get onViewColumnChanged(): Event<{ id: string, viewColumn: number }> {
+        return this.onViewColumnChangedEmitter.event;
+    }
+
+    updateViewColumns(): void {
+        this.columnValues.clear();
+        this.viewColumnIds.clear();
+
+        const rows = new Map<number, Set<number>>();
+        const columns = new Map<number, Map<number, TabBar<Widget>>>();
+        for (const tabBar of toArray(this.shell.mainPanel.tabBars())) {
+            if (!tabBar.node.style.top || !tabBar.node.style.left) {
+                continue;
+            }
+            const top = parseInt(tabBar.node.style.top);
+            const left = parseInt(tabBar.node.style.left);
+
+            const row = rows.get(top) || new Set<number>();
+            row.add(left);
+            rows.set(top, row);
+
+            const column = columns.get(left) || new Map<number, TabBar<Widget>>();
+            column.set(top, tabBar);
+            columns.set(left, column);
+        }
+        const firstRow = rows.get([...rows.keys()].sort()[0]);
+        if (!firstRow) {
+            return;
+        }
+        const lefts = [...firstRow.keys()].sort();
+        for (let i = 0; i < lefts.length; i++) {
+            const column = columns.get(lefts[i]);
+            if (!column) {
+                break;
+            }
+            const cellIndexes = [...column.keys()].sort();
+            let viewColumn = Math.min(i, 2);
+            for (let j = 0; j < cellIndexes.length; j++) {
+                const cell = column.get(cellIndexes[j]);
+                if (!cell) {
+                    break;
+                }
+                this.setViewColumn(cell, viewColumn);
+                if (viewColumn < 7) {
+                    viewColumn += 3;
+                }
+            }
+        }
+    }
+
+    protected setViewColumn(tabBar: TabBar<Widget>, viewColumn: number): void {
+        const ids = [];
+        for (const title of tabBar.titles) {
+            const id = title.owner.id;
+            ids.push(id);
+            this.columnValues.set(id, viewColumn);
+        }
+        this.viewColumnIds.set(viewColumn, ids);
+    }
+
+    getViewColumnIds(viewColumn: number): string[] {
+        return this.viewColumnIds.get(viewColumn) || [];
+    }
+
+    getViewColumn(id: string): number | undefined {
+        return this.columnValues.get(id);
+    }
+
+    hasViewColumn(id: string): boolean {
+        return this.columnValues.has(id);
+    }
+
+    viewColumnsSize(): number {
+        return this.viewColumnIds.size;
+    }
+}

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

@@ -22,7 +22,7 @@ import { injectable } from 'inversify';
  */
 @injectable()
 export class MockStorageService implements StorageService {
-    readonly data = new Map<string, {} | undefined>();
+    readonly data = new Map<string, unknown | undefined>();
 
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     onSetDataCallback?: (key: string, data?: any) => void;

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

@@ -302,6 +302,12 @@ export class TreeWidget extends ReactWidget implements StatefulWidget {
                     }
                 })
             ]);
+
+            this.node.addEventListener('focusin', e => {
+                if (this.model.selectedNodes.length && (!this.selectionService.selection || !TreeWidgetSelection.isSource(this.selectionService.selection, this))) {
+                    this.updateGlobalSelection();
+                }
+            });
         }
         this.toDispose.push(this.corePreferences.onPreferenceChanged(preference => {
             if (preference.preferenceName === 'workbench.tree.renderIndentGuides') {
@@ -339,7 +345,7 @@ export class TreeWidget extends ReactWidget implements StatefulWidget {
             }
         }
         this.rows = new Map(rowsToUpdate);
-        this.updateScrollToRow();
+        this.update();
     }
 
     protected getDepthForNode(node: TreeNode, depths: Map<CompositeTreeNode | undefined, number>): number {

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

@@ -21,6 +21,7 @@ import { ApplicationShell } from '../shell';
 import { Saveable } from '../saveable';
 import { PreferenceService } from '../preferences';
 import { environment } from '../../common';
+import { SaveableService } from '../saveable-service';
 
 @injectable()
 export class DefaultSecondaryWindowService implements SecondaryWindowService {
@@ -43,6 +44,9 @@ export class DefaultSecondaryWindowService implements SecondaryWindowService {
     @inject(PreferenceService)
     protected readonly preferenceService: PreferenceService;
 
+    @inject(SaveableService)
+    protected readonly saveResourceService: SaveableService;
+
     @postConstruct()
     init(): void {
         // Set up messaging with secondary windows
@@ -93,7 +97,7 @@ export class DefaultSecondaryWindowService implements SecondaryWindowService {
             newWindow.addEventListener('DOMContentLoaded', () => {
                 newWindow.addEventListener('beforeunload', evt => {
                     const saveable = Saveable.get(widget);
-                    const wouldLoseState = !!saveable && saveable.dirty && saveable.autoSave === 'off';
+                    const wouldLoseState = !!saveable && saveable.dirty && this.saveResourceService.autoSave === 'off';
                     if (wouldLoseState) {
                         evt.returnValue = '';
                         evt.preventDefault();
@@ -104,7 +108,7 @@ export class DefaultSecondaryWindowService implements SecondaryWindowService {
                 newWindow.addEventListener('unload', () => {
                     const saveable = Saveable.get(widget);
                     shell.closeWidget(widget.id, {
-                        save: !!saveable && saveable.dirty && saveable.autoSave !== 'off'
+                        save: !!saveable && saveable.dirty && this.saveResourceService.autoSave !== 'off'
                     });
 
                     const extIndex = this.secondaryWindows.indexOf(newWindow);

package/src/common/encoding-service.ts

@@ -318,7 +318,7 @@ export class EncodingService {
         });
     }
 
-    encodeStream(value: string | Readable<string>, options?: ResourceEncoding): Promise<BinaryBuffer | BinaryBufferReadable>
+    encodeStream(value: string | Readable<string>, options?: ResourceEncoding): Promise<BinaryBuffer | BinaryBufferReadable>;
     encodeStream(value?: string | Readable<string>, options?: ResourceEncoding): Promise<BinaryBuffer | BinaryBufferReadable | undefined>;
     async encodeStream(value: string | Readable<string> | undefined, options?: ResourceEncoding): Promise<BinaryBuffer | BinaryBufferReadable | undefined> {
         let encoding = options?.encoding;