@theia/editor 1.13.0-next.fd91f213 → 1.13.0

package/src/browser/editor-contribution.ts

@@ -18,9 +18,9 @@ import { EditorManager } from './editor-manager';
 import { TextEditor } from './editor';
 import { injectable, inject } from '@theia/core/shared/inversify';
 import { StatusBarAlignment, StatusBar } from '@theia/core/lib/browser/status-bar/status-bar';
-import { FrontendApplicationContribution, DiffUris } from '@theia/core/lib/browser';
+import { FrontendApplicationContribution, DiffUris, DockLayout } from '@theia/core/lib/browser';
 import { ContextKeyService } from '@theia/core/lib/browser/context-key-service';
-import { DisposableCollection } from '@theia/core';
+import { CommandHandler, DisposableCollection } from '@theia/core';
 import { EditorCommands } from './editor-command';
 import { EditorQuickOpenService } from './editor-quick-open-service';
 import { CommandRegistry, CommandContribution } from '@theia/core/lib/common';
@@ -133,6 +133,25 @@ export class EditorContribution implements FrontendApplicationContribution, Comm
         commands.registerCommand(EditorCommands.SHOW_ALL_OPENED_EDITORS, {
             execute: () => this.editorQuickOpenService.open()
         });
+        const splitHandlerFactory = (splitMode: DockLayout.InsertMode): CommandHandler => ({
+            isEnabled: () => !!this.editorManager.currentEditor,
+            isVisible: () => !!this.editorManager.currentEditor,
+            execute: async () => {
+                const { currentEditor } = this.editorManager;
+                if (currentEditor) {
+                    const selection = currentEditor.editor.selection;
+                    const newEditor = await this.editorManager.openToSide(currentEditor.editor.uri, { selection, widgetOptions: { mode: splitMode } });
+                    const oldEditorState = currentEditor.editor.storeViewState();
+                    newEditor.editor.restoreViewState(oldEditorState);
+                }
+            }
+        });
+        commands.registerCommand(EditorCommands.SPLIT_EDITOR_HORIZONTAL, splitHandlerFactory('split-right'));
+        commands.registerCommand(EditorCommands.SPLIT_EDITOR_VERTICAL, splitHandlerFactory('split-bottom'));
+        commands.registerCommand(EditorCommands.SPLIT_EDITOR_RIGHT, splitHandlerFactory('split-right'));
+        commands.registerCommand(EditorCommands.SPLIT_EDITOR_DOWN, splitHandlerFactory('split-bottom'));
+        commands.registerCommand(EditorCommands.SPLIT_EDITOR_UP, splitHandlerFactory('split-top'));
+        commands.registerCommand(EditorCommands.SPLIT_EDITOR_LEFT, splitHandlerFactory('split-left'));
     }
 
     registerKeybindings(keybindings: KeybindingRegistry): void {
@@ -140,6 +159,14 @@ export class EditorContribution implements FrontendApplicationContribution, Comm
             command: EditorCommands.SHOW_ALL_OPENED_EDITORS.id,
             keybinding: 'ctrlcmd+k ctrlcmd+p'
         });
+        keybindings.registerKeybinding({
+            command: EditorCommands.SPLIT_EDITOR_HORIZONTAL.id,
+            keybinding: 'ctrlcmd+\\',
+        });
+        keybindings.registerKeybinding({
+            command: EditorCommands.SPLIT_EDITOR_VERTICAL.id,
+            keybinding: 'ctrlcmd+k ctrlcmd+\\',
+        });
     }
 
     registerQuickOpenHandlers(handlers: QuickOpenHandlerRegistry): void {

package/src/browser/editor-keybinding.ts

@@ -15,6 +15,7 @@
  ********************************************************************************/
 
 import { injectable } from '@theia/core/shared/inversify';
+import { environment } from '@theia/core/shared/@theia/application-package/lib/environment';
 import { isOSX, isWindows } from '@theia/core/lib/common/os';
 import { KeybindingContribution, KeybindingRegistry } from '@theia/core/lib/browser/keybinding';
 import { EditorCommands } from './editor-command';
@@ -39,8 +40,16 @@ export class EditorKeybindingContribution implements KeybindingContribution {
             {
                 command: EditorCommands.TOGGLE_WORD_WRAP.id,
                 keybinding: 'alt+z'
+            },
+            {
+                command: EditorCommands.REOPEN_CLOSED_EDITOR.id,
+                keybinding: this.isElectron() ? 'ctrlcmd+shift+t' : 'alt+shift+t'
             }
         );
     }
 
+    private isElectron(): boolean {
+        return environment.electron.is();
+    }
+
 }

package/src/browser/editor-manager.ts

@@ -17,15 +17,21 @@
 import { injectable, postConstruct, inject } from '@theia/core/shared/inversify';
 import URI from '@theia/core/lib/common/uri';
 import { RecursivePartial, Emitter, Event } from '@theia/core/lib/common';
-import { WidgetOpenerOptions, NavigatableWidgetOpenHandler } from '@theia/core/lib/browser';
+import { WidgetOpenerOptions, NavigatableWidgetOpenHandler, NavigatableWidgetOptions } from '@theia/core/lib/browser';
 import { EditorWidget } from './editor-widget';
 import { Range, Position, Location } from './editor';
 import { EditorWidgetFactory } from './editor-widget-factory';
 import { TextEditor } from './editor';
 
+export interface WidgetId {
+    id: number;
+    uri: string;
+}
+
 export interface EditorOpenerOptions extends WidgetOpenerOptions {
     selection?: RecursivePartial<Range>;
     preview?: boolean;
+    counter?: number
 }
 
 @injectable()
@@ -35,6 +41,8 @@ export class EditorManager extends NavigatableWidgetOpenHandler<EditorWidget> {
 
     readonly label = 'Code Editor';
 
+    protected readonly editorCounters = new Map<string, number>();
+
     protected readonly onActiveEditorChangedEmitter = new Emitter<EditorWidget | undefined>();
     /**
      * Emit when the active editor is changed.
@@ -50,8 +58,8 @@ export class EditorManager extends NavigatableWidgetOpenHandler<EditorWidget> {
     @postConstruct()
     protected init(): void {
         super.init();
-        this.shell.activeChanged.connect(() => this.updateActiveEditor());
-        this.shell.currentChanged.connect(() => this.updateCurrentEditor());
+        this.shell.onDidChangeActiveWidget(() => this.updateActiveEditor());
+        this.shell.onDidChangeCurrentWidget(() => this.updateCurrentEditor());
         this.onCreated(widget => {
             widget.onDidChangeVisibility(() => {
                 if (widget.isVisible) {
@@ -61,7 +69,9 @@ export class EditorManager extends NavigatableWidgetOpenHandler<EditorWidget> {
                 }
                 this.updateCurrentEditor();
             });
+            this.checkCounterForWidget(widget);
             widget.disposed.connect(() => {
+                this.removeFromCounter(widget);
                 this.removeRecentlyVisible(widget);
                 this.updateCurrentEditor();
             });
@@ -75,21 +85,30 @@ export class EditorManager extends NavigatableWidgetOpenHandler<EditorWidget> {
     }
 
     async getByUri(uri: URI, options?: EditorOpenerOptions): Promise<EditorWidget | undefined> {
-        const widget = await super.getByUri(uri);
-        if (widget) {
-            // Reveal selection before attachment to manage nav stack. (https://github.com/eclipse-theia/theia/issues/8955)
-            this.revealSelection(widget, options, uri);
-        }
-        return widget;
+        return this.getWidget(uri, options);
     }
 
-    async getOrCreateByUri(uri: URI, options?: EditorOpenerOptions): Promise<EditorWidget> {
-        const widget = await super.getOrCreateByUri(uri);
-        if (widget) {
+    getOrCreateByUri(uri: URI, options?: EditorOpenerOptions): Promise<EditorWidget> {
+        return this.getOrCreateWidget(uri, options);
+    }
+
+    protected async getWidget(uri: URI, options?: EditorOpenerOptions): Promise<EditorWidget | undefined> {
+        const optionsWithCounter: EditorOpenerOptions = { counter: this.getCounterForUri(uri), ...options };
+        const editor = await super.getWidget(uri, optionsWithCounter);
+        if (editor) {
             // Reveal selection before attachment to manage nav stack. (https://github.com/eclipse-theia/theia/issues/8955)
-            this.revealSelection(widget, options, uri);
+            this.revealSelection(editor, optionsWithCounter, uri);
         }
-        return widget;
+        return editor;
+    }
+
+    protected async getOrCreateWidget(uri: URI, options?: EditorOpenerOptions): Promise<EditorWidget> {
+        const counter = options?.counter === undefined ? this.getOrCreateCounterForUri(uri) : options.counter;
+        const optionsWithCounter: EditorOpenerOptions = { ...options, counter };
+        const editor = await super.getOrCreateWidget(uri, optionsWithCounter);
+        // Reveal selection before attachment to manage nav stack. (https://github.com/eclipse-theia/theia/issues/8955)
+        this.revealSelection(editor, options, uri);
+        return editor;
     }
 
     protected readonly recentlyVisibleIds: string[] = [];
@@ -154,14 +173,23 @@ export class EditorManager extends NavigatableWidgetOpenHandler<EditorWidget> {
         return 100;
     }
 
-    async open(uri: URI, options?: EditorOpenerOptions): Promise<EditorWidget> {
-        const editor = await this.getOrCreateByUri(uri, options);
-        await super.open(uri, options);
-        return editor;
+    // This override only serves to inform external callers that they can use EditorOpenerOptions.
+    open(uri: URI, options?: EditorOpenerOptions): Promise<EditorWidget> {
+        return super.open(uri, options);
+    }
+
+    /**
+     * Opens an editor to the side of the current editor. Defaults to opening to the right.
+     * To modify direction, pass options with `{widgetOptions: {mode: ...}}`
+     */
+    openToSide(uri: URI, options?: EditorOpenerOptions): Promise<EditorWidget> {
+        const counter = this.createCounterForUri(uri);
+        const splitOptions: EditorOpenerOptions = { widgetOptions: { mode: 'split-right' }, ...options, counter };
+        return this.open(uri, splitOptions);
     }
 
     protected revealSelection(widget: EditorWidget, input?: EditorOpenerOptions, uri?: URI): void {
-        let inputSelection = input && input.selection;
+        let inputSelection = input?.selection;
         if (!inputSelection && uri) {
             const match = /^L?(\d+)(?:,(\d+))?/.exec(uri.fragment);
             if (match) {
@@ -207,6 +235,63 @@ export class EditorManager extends NavigatableWidgetOpenHandler<EditorWidget> {
         };
     }
 
+    protected removeFromCounter(widget: EditorWidget): void {
+        const { id, uri } = this.extractIdFromWidget(widget);
+        if (uri && !Number.isNaN(id)) {
+            let max = -Infinity;
+            this.all.forEach(editor => {
+                const candidateID = this.extractIdFromWidget(editor);
+                if ((candidateID.uri === uri) && (candidateID.id > max)) {
+                    max = candidateID.id!;
+                }
+            });
+
+            if (max > -Infinity) {
+                this.editorCounters.set(uri, max);
+            } else {
+                this.editorCounters.delete(uri);
+            }
+        }
+    }
+
+    protected extractIdFromWidget(widget: EditorWidget): WidgetId {
+        const uri = widget.editor.uri.toString();
+        const id = Number(widget.id.slice(widget.id.lastIndexOf(':') + 1));
+        return { id, uri };
+    }
+
+    protected checkCounterForWidget(widget: EditorWidget): void {
+        const { id, uri } = this.extractIdFromWidget(widget);
+        const numericalId = Number(id);
+        if (uri && !Number.isNaN(numericalId)) {
+            const highestKnownId = this.editorCounters.get(uri) ?? -Infinity;
+            if (numericalId > highestKnownId) {
+                this.editorCounters.set(uri, numericalId);
+            }
+        }
+    }
+
+    protected createCounterForUri(uri: URI): number {
+        const identifier = uri.toString();
+        const next = (this.editorCounters.get(identifier) ?? 0) + 1;
+        return next;
+    }
+
+    protected getCounterForUri(uri: URI): number | undefined {
+        return this.editorCounters.get(uri.toString());
+    }
+
+    protected getOrCreateCounterForUri(uri: URI): number {
+        return this.getCounterForUri(uri) ?? this.createCounterForUri(uri);
+    }
+
+    protected createWidgetOptions(uri: URI, options?: EditorOpenerOptions): NavigatableWidgetOptions {
+        const navigatableOptions = super.createWidgetOptions(uri, options);
+        if (options?.counter !== undefined) {
+            navigatableOptions.counter = options.counter;
+        }
+        return navigatableOptions;
+    }
 }
 
 /**

package/src/browser/editor-navigation-contribution.ts

@@ -24,7 +24,7 @@ import { EditorCommands } from './editor-command';
 import { EditorWidget } from './editor-widget';
 import { EditorManager } from './editor-manager';
 import { TextEditor, Position, Range, TextDocumentChangeEvent } from './editor';
-import { NavigationLocation } from './navigation/navigation-location';
+import { NavigationLocation, RecentlyClosedEditor } from './navigation/navigation-location';
 import { NavigationLocationService } from './navigation/navigation-location-service';
 import { PreferenceService, PreferenceScope } from '@theia/core/lib/browser';
 
@@ -32,6 +32,7 @@ import { PreferenceService, PreferenceScope } from '@theia/core/lib/browser';
 export class EditorNavigationContribution implements Disposable, FrontendApplicationContribution {
 
     private static ID = 'editor-navigation-contribution';
+    private static CLOSED_EDITORS_KEY = 'recently-closed-editors';
 
     protected readonly toDispose = new DisposableCollection();
     protected readonly toDisposePerCurrentEditor = new DisposableCollection();
@@ -59,7 +60,14 @@ export class EditorNavigationContribution implements Disposable, FrontendApplica
         this.toDispose.pushAll([
             // TODO listen on file resource changes, if a file gets deleted, remove the corresponding navigation locations (if any).
             // This would require introducing the FS dependency in the editor extension.
-            this.editorManager.onCurrentEditorChanged(this.onCurrentEditorChanged.bind(this))
+            this.editorManager.onCurrentEditorChanged(this.onCurrentEditorChanged.bind(this)),
+            this.editorManager.onCreated(widget => {
+                this.locationStack.removeClosedEditor(widget.editor.uri);
+                widget.disposed.connect(() => this.locationStack.addClosedEditor({
+                    uri: widget.editor.uri,
+                    viewState: widget.editor.storeViewState()
+                }));
+            })
         ]);
         this.commandRegistry.registerHandler(EditorCommands.GO_BACK.id, {
             execute: () => this.locationStack.back(),
@@ -91,6 +99,28 @@ export class EditorNavigationContribution implements Disposable, FrontendApplica
             execute: () => this.toggleWordWrap(),
             isEnabled: () => true,
         });
+        this.commandRegistry.registerHandler(EditorCommands.REOPEN_CLOSED_EDITOR.id, {
+            execute: () => this.reopenLastClosedEditor()
+        });
+    }
+
+    /**
+     * Reopens the last closed editor with its stored view state if possible from history.
+     * If the editor cannot be restored, continue to the next editor in history.
+     */
+    protected async reopenLastClosedEditor(): Promise<void> {
+        const lastClosedEditor = this.locationStack.getLastClosedEditor();
+        if (lastClosedEditor === undefined) {
+            return;
+        }
+
+        try {
+            const widget = await this.editorManager.open(lastClosedEditor.uri);
+            widget.editor.restoreViewState(lastClosedEditor.viewState);
+        } catch {
+            this.locationStack.removeClosedEditor(lastClosedEditor.uri);
+            this.reopenLastClosedEditor();
+        }
     }
 
     async onStart(): Promise<void> {
@@ -190,9 +220,17 @@ export class EditorNavigationContribution implements Disposable, FrontendApplica
         this.storageService.setData(EditorNavigationContribution.ID, {
             locations: this.locationStack.locations().map(NavigationLocation.toObject)
         });
+        this.storageService.setData(EditorNavigationContribution.CLOSED_EDITORS_KEY, {
+            closedEditors: this.shouldStoreClosedEditors() ? this.locationStack.closedEditorsStack.map(RecentlyClosedEditor.toObject) : []
+        });
     }
 
     protected async restoreState(): Promise<void> {
+        await this.restoreNavigationLocations();
+        await this.restoreClosedEditors();
+    }
+
+    protected async restoreNavigationLocations(): Promise<void> {
         const raw: { locations?: ArrayLike<object> } | undefined = await this.storageService.getData(EditorNavigationContribution.ID);
         if (raw && raw.locations) {
             const locations: NavigationLocation[] = [];
@@ -209,6 +247,20 @@ export class EditorNavigationContribution implements Disposable, FrontendApplica
         }
     }
 
+    protected async restoreClosedEditors(): Promise<void> {
+        const raw: { closedEditors?: ArrayLike<object> } | undefined = await this.storageService.getData(EditorNavigationContribution.CLOSED_EDITORS_KEY);
+        if (raw && raw.closedEditors) {
+            for (let i = 0; i < raw.closedEditors.length; i++) {
+                const editor = RecentlyClosedEditor.fromObject(raw.closedEditors[i]);
+                if (editor) {
+                    this.locationStack.addClosedEditor(editor);
+                } else {
+                    this.logger.warn('Could not restore the state of the closed editors stack.');
+                }
+            }
+        }
+    }
+
     private isMinimapEnabled(): boolean {
         return !!this.preferenceService.get('editor.minimap.enabled');
     }
@@ -218,4 +270,8 @@ export class EditorNavigationContribution implements Disposable, FrontendApplica
         return renderWhitespace === 'none' ? false : true;
     }
 
+    private shouldStoreClosedEditors(): boolean {
+        return !!this.preferenceService.get('editor.history.persistClosedEditors');
+    }
+
 }

package/src/browser/editor-preferences.ts

@@ -1268,6 +1268,11 @@ export const editorPreferenceSchema: PreferenceSchema = {
             'default': 750,
             'description': 'Timeout in milliseconds after which the formatting that is run on file save is cancelled.'
         },
+        'editor.history.persistClosedEditors': {
+            'type': 'boolean',
+            'default': false,
+            'description': 'Controls whether to persist closed editor history for the workspace across window reloads.'
+        },
         'files.eol': {
             'type': 'string',
             'enum': [
@@ -1299,6 +1304,7 @@ export interface EditorConfiguration extends CodeEditorConfiguration {
     'editor.autoSaveDelay': number
     'editor.formatOnSave': boolean
     'editor.formatOnSaveTimeout': number
+    'editor.history.persistClosedEditors': boolean
     'files.eol': EndOfLinePreference
 }
 export type EndOfLinePreference = '\n' | '\r\n' | 'auto';

package/src/browser/editor-widget-factory.ts

@@ -39,10 +39,10 @@ export class EditorWidgetFactory implements WidgetFactory {
 
     createWidget(options: NavigatableWidgetOptions): Promise<EditorWidget> {
         const uri = new URI(options.uri);
-        return this.createEditor(uri);
+        return this.createEditor(uri, options);
     }
 
-    protected async createEditor(uri: URI): Promise<EditorWidget> {
+    protected async createEditor(uri: URI, options?: NavigatableWidgetOptions): Promise<EditorWidget> {
         const textEditor = await this.editorProvider(uri);
         const newEditor = new EditorWidget(textEditor, this.selectionService);
 
@@ -55,6 +55,9 @@ export class EditorWidgetFactory implements WidgetFactory {
         newEditor.onDispose(() => labelListener.dispose());
 
         newEditor.id = this.id + ':' + uri.toString();
+        if (options?.counter !== undefined) {
+            newEditor.id += `:${options.counter}`;
+        }
         newEditor.title.closable = true;
         return newEditor;
     }

package/src/browser/navigation/navigation-location-service.spec.ts

@@ -19,6 +19,7 @@ let disableJSDOM = enableJSDOM();
 
 import { expect } from 'chai';
 import { Container } from '@theia/core/shared/inversify';
+import URI from '@theia/core/lib/common/uri';
 import { ILogger } from '@theia/core/lib/common/logger';
 import { MockLogger } from '@theia/core/lib/common/test/mock-logger';
 import { OpenerService } from '@theia/core/lib/browser/opener-service';
@@ -26,7 +27,7 @@ import { MockOpenerService } from '@theia/core/lib/browser/test/mock-opener-serv
 import { NavigationLocationUpdater } from './navigation-location-updater';
 import { NoopNavigationLocationUpdater } from './test/mock-navigation-location-updater';
 import { NavigationLocationSimilarity } from './navigation-location-similarity';
-import { CursorLocation, Position, NavigationLocation } from './navigation-location';
+import { CursorLocation, Position, NavigationLocation, RecentlyClosedEditor } from './navigation-location';
 import { NavigationLocationService } from './navigation-location-service';
 
 disableJSDOM();
@@ -79,8 +80,28 @@ describe('navigation-location-service', () => {
     });
 
     it('should not exceed the max stack item', () => {
-        stack.register(...[...Array(100).keys()].map(i => createCursorLocation({ line: i * 10, character: i }, `file://${i}`)));
-        expect(stack.locations().length).to.be.lessThan(100);
+        const max = NavigationLocationService['MAX_STACK_ITEMS'];
+        const locations: NavigationLocation[] = [...Array(max + 10).keys()].map(i => createCursorLocation({ line: i * 10, character: i }, `file://${i}`));
+        stack.register(...locations);
+        expect(stack.locations().length).to.not.be.greaterThan(max);
+    });
+
+    it('should successfully clear the history', () => {
+        expect(stack['recentlyClosedEditors'].length).equal(0);
+        const editor = createMockClosedEditor(new URI('file://foo/a.ts'));
+        stack.addClosedEditor(editor);
+        expect(stack['recentlyClosedEditors'].length).equal(1);
+
+        expect(stack['stack'].length).equal(0);
+        stack.register(
+            createCursorLocation(),
+        );
+        expect(stack['stack'].length).equal(1);
+
+        stack['clearHistory']();
+
+        expect(stack['recentlyClosedEditors'].length).equal(0);
+        expect(stack['stack'].length).equal(0);
     });
 
     describe('last-edit-location', async () => {
@@ -132,6 +153,76 @@ describe('navigation-location-service', () => {
 
     });
 
+    describe('recently-closed-editors', () => {
+
+        describe('#getLastClosedEditor', () => {
+
+            it('should return the last closed editor from the history', () => {
+                const uri = new URI('file://foo/a.ts');
+                stack.addClosedEditor(createMockClosedEditor(uri));
+                const editor = stack.getLastClosedEditor();
+                expect(editor?.uri).equal(uri);
+            });
+
+            it('should return `undefined` when no history is found', () => {
+                expect(stack['recentlyClosedEditors'].length).equal(0);
+                const editor = stack.getLastClosedEditor();
+                expect(editor).equal(undefined);
+            });
+
+            it('should not exceed the max history', () => {
+                expect(stack['recentlyClosedEditors'].length).equal(0);
+                const max = NavigationLocationService['MAX_RECENTLY_CLOSED_EDITORS'];
+                for (let i = 0; i < max + 10; i++) {
+                    const uri = new URI(`file://foo/bar-${i}.ts`);
+                    stack.addClosedEditor(createMockClosedEditor(uri));
+                }
+                expect(stack['recentlyClosedEditors'].length <= max).be.true;
+            });
+
+        });
+
+        describe('#addToRecentlyClosedEditors', () => {
+
+            it('should include unique recently closed editors in the history', () => {
+                expect(stack['recentlyClosedEditors'].length).equal(0);
+                const a = createMockClosedEditor(new URI('file://foo/a.ts'));
+                const b = createMockClosedEditor(new URI('file://foo/b.ts'));
+                stack.addClosedEditor(a);
+                stack.addClosedEditor(b);
+                expect(stack['recentlyClosedEditors'].length).equal(2);
+            });
+
+            it('should not include duplicate recently closed editors in the history', () => {
+                const uri = new URI('file://foo/a.ts');
+                [1, 2, 3].forEach(i => {
+                    stack.addClosedEditor(createMockClosedEditor(uri));
+                });
+                expect(stack['recentlyClosedEditors'].length).equal(1);
+            });
+
+        });
+
+        describe('#removeFromRecentlyClosedEditors', () => {
+
+            it('should successfully remove editors from the history that match the given editor uri', () => {
+                expect(stack['recentlyClosedEditors'].length).equal(0);
+                const editor = createMockClosedEditor(new URI('file://foo/a.ts'));
+
+                [1, 2, 3].forEach(() => {
+                    stack['recentlyClosedEditors'].push(editor);
+                });
+                expect(stack['recentlyClosedEditors'].length).equal(3);
+
+                // Remove the given editor from the recently closed history.
+                stack['removeClosedEditor'](editor.uri);
+                expect(stack['recentlyClosedEditors'].length).equal(0);
+            });
+
+        });
+
+    });
+
     function createCursorLocation(context: Position = { line: 0, character: 0, }, uri: string = 'file://path/to/file'): CursorLocation {
         return NavigationLocation.create(uri, context);
     }
@@ -149,4 +240,8 @@ describe('navigation-location-service', () => {
         return container.get(NavigationLocationService);
     }
 
+    function createMockClosedEditor(uri: URI): RecentlyClosedEditor {
+        return { uri, viewState: {} };
+    }
+
 });

package/src/browser/navigation/navigation-location-service.ts

@@ -20,15 +20,18 @@ import { OpenerService, OpenerOptions, open } from '@theia/core/lib/browser/open
 import { EditorOpenerOptions } from '../editor-manager';
 import { NavigationLocationUpdater } from './navigation-location-updater';
 import { NavigationLocationSimilarity } from './navigation-location-similarity';
-import { NavigationLocation, Range, ContentChangeLocation } from './navigation-location';
+import { NavigationLocation, Range, ContentChangeLocation, RecentlyClosedEditor } from './navigation-location';
+import URI from '@theia/core/lib/common/uri';
 
 /**
- * The navigation location service. Also, stores and manages navigation locations.
+ * The navigation location service.
+ * It also stores and manages navigation locations and recently closed editors.
  */
 @injectable()
 export class NavigationLocationService {
 
     private static MAX_STACK_ITEMS = 30;
+    private static readonly MAX_RECENTLY_CLOSED_EDITORS = 20;
 
     @inject(ILogger)
     protected readonly logger: ILogger;
@@ -47,6 +50,8 @@ export class NavigationLocationService {
     protected canRegister = true;
     protected _lastEditLocation: ContentChangeLocation | undefined;
 
+    protected recentlyClosedEditors: RecentlyClosedEditor[] = [];
+
     /**
      * Registers the give locations into the service.
      */
@@ -165,12 +170,13 @@ export class NavigationLocationService {
     }
 
     /**
-     * Clears the navigation history.
+     * Clears the total history.
      */
     clearHistory(): void {
         this.stack = [];
         this.pointer = -1;
         this._lastEditLocation = undefined;
+        this.recentlyClosedEditors = [];
     }
 
     /**
@@ -233,4 +239,46 @@ ${this.stack.map((location, i) => `${i}: ${JSON.stringify(NavigationLocation.toO
 ----- o -----`;
     }
 
+    /**
+     * Get the recently closed editors stack in chronological order.
+     *
+     * @returns readonly closed editors stack.
+     */
+    get closedEditorsStack(): ReadonlyArray<RecentlyClosedEditor> {
+        return this.recentlyClosedEditors;
+    }
+
+    /**
+     * Get the last recently closed editor.
+     *
+     * @returns the recently closed editor if it exists.
+     */
+    getLastClosedEditor(): RecentlyClosedEditor | undefined {
+        return this.recentlyClosedEditors[this.recentlyClosedEditors.length - 1];
+    }
+
+    /**
+     * Add the recently closed editor to the history.
+     *
+     * @param editor the recently closed editor.
+     */
+    addClosedEditor(editor: RecentlyClosedEditor): void {
+        this.removeClosedEditor(editor.uri);
+        this.recentlyClosedEditors.push(editor);
+
+        // Removes the oldest entry from the history if the maximum size is reached.
+        if (this.recentlyClosedEditors.length > NavigationLocationService.MAX_RECENTLY_CLOSED_EDITORS) {
+            this.recentlyClosedEditors.shift();
+        }
+    }
+
+    /**
+     * Remove all occurrences of the given editor in the history if they exist.
+     *
+     * @param uri the uri of the editor that should be removed from the history.
+     */
+    removeClosedEditor(uri: URI): void {
+        this.recentlyClosedEditors = this.recentlyClosedEditors.filter(e => !uri.isEqual(e.uri));
+    }
+
 }