@theia/core 1.22.1 → 1.23.0-next.26

package/src/browser/authentication-service.ts

@@ -26,20 +26,17 @@ import { StorageService } from '../browser/storage-service';
 import { Disposable, DisposableCollection } from '../common/disposable';
 import { ACCOUNTS_MENU, ACCOUNTS_SUBMENU, MenuModelRegistry } from '../common/menu';
 import { Command, CommandRegistry } from '../common/command';
+import { nls } from '../common/nls';
 
-export interface AuthenticationSessionsChangeEvent {
-    added: ReadonlyArray<string>;
-    removed: ReadonlyArray<string>;
-    changed: ReadonlyArray<string>;
+export interface AuthenticationSessionAccountInformation {
+    readonly id: string;
+    readonly label: string;
 }
 
 export interface AuthenticationSession {
     id: string;
     accessToken: string;
-    account: {
-        label: string;
-        id: string;
-    }
+    account: AuthenticationSessionAccountInformation;
     scopes: ReadonlyArray<string>;
 }
 
@@ -48,6 +45,13 @@ export interface AuthenticationProviderInformation {
     label: string;
 }
 
+/** Should match the definition from the theia/vscode types */
+export interface AuthenticationProviderAuthenticationSessionsChangeEvent {
+    readonly added: ReadonlyArray<AuthenticationSession | string | undefined>;
+    readonly removed: ReadonlyArray<AuthenticationSession | string | undefined>;
+    readonly changed: ReadonlyArray<AuthenticationSession | string | undefined>;
+}
+
 export interface SessionRequest {
     disposables: Disposable[];
     requestingExtensionIds: string[];
@@ -57,6 +61,7 @@ export interface SessionRequestInfo {
     [scopes: string]: SessionRequest;
 }
 
+/** Should match the definition from the theia/vscode types */
 export interface AuthenticationProvider {
     id: string;
 
@@ -68,13 +73,40 @@ export interface AuthenticationProvider {
 
     signOut(accountName: string): Promise<void>;
 
-    getSessions(): Promise<ReadonlyArray<AuthenticationSession>>;
+    getSessions(scopes?: string[]): Promise<ReadonlyArray<AuthenticationSession>>;
 
-    updateSessionItems(event: AuthenticationSessionsChangeEvent): Promise<void>;
+    updateSessionItems(event: AuthenticationProviderAuthenticationSessionsChangeEvent): Promise<void>;
 
     login(scopes: string[]): Promise<AuthenticationSession>;
 
     logout(sessionId: string): Promise<void>;
+
+    /**
+     * An [event](#Event) which fires when the array of sessions has changed, or data
+     * within a session has changed.
+     */
+    readonly onDidChangeSessions: Omit<Event<AuthenticationProviderAuthenticationSessionsChangeEvent>, 'maxListeners'>;
+
+    /**
+     * Get a list of sessions.
+     * @param scopes An optional list of scopes. If provided, the sessions returned should match
+     * these permissions, otherwise all sessions should be returned.
+     * @returns A promise that resolves to an array of authentication sessions.
+     */
+    getSessions(scopes?: string[]): Thenable<ReadonlyArray<AuthenticationSession>>;
+
+    /**
+     * Prompts a user to login.
+     * @param scopes A list of scopes, permissions, that the new session should be created with.
+     * @returns A promise that resolves to an authentication session.
+     */
+    createSession(scopes: string[]): Thenable<AuthenticationSession>;
+
+    /**
+     * Removes the session corresponding to session id.
+     * @param sessionId The id of the session to remove.
+     */
+    removeSession(sessionId: string): Thenable<void>;
 }
 export const AuthenticationService = Symbol('AuthenticationService');
 
@@ -84,13 +116,13 @@ export interface AuthenticationService {
     registerAuthenticationProvider(id: string, provider: AuthenticationProvider): void;
     unregisterAuthenticationProvider(id: string): void;
     requestNewSession(id: string, scopes: string[], extensionId: string, extensionName: string): void;
-    updateSessions(providerId: string, event: AuthenticationSessionsChangeEvent): void;
+    updateSessions(providerId: string, event: AuthenticationProviderAuthenticationSessionsChangeEvent): void;
 
     readonly onDidRegisterAuthenticationProvider: Event<AuthenticationProviderInformation>;
     readonly onDidUnregisterAuthenticationProvider: Event<AuthenticationProviderInformation>;
 
-    readonly onDidChangeSessions: Event<{ providerId: string, label: string, event: AuthenticationSessionsChangeEvent }>;
-    getSessions(providerId: string): Promise<ReadonlyArray<AuthenticationSession>>;
+    readonly onDidChangeSessions: Event<{ providerId: string, label: string, event: AuthenticationProviderAuthenticationSessionsChangeEvent }>;
+    getSessions(providerId: string, scopes?: string[]): Promise<ReadonlyArray<AuthenticationSession>>;
     getLabel(providerId: string): string;
     supportsMultipleAccounts(providerId: string): boolean;
     login(providerId: string, scopes: string[]): Promise<AuthenticationSession>;
@@ -99,13 +131,20 @@ export interface AuthenticationService {
     signOutOfAccount(providerId: string, accountName: string): Promise<void>;
 }
 
+export interface SessionChangeEvent {
+    providerId: string,
+    label: string,
+    event: AuthenticationProviderAuthenticationSessionsChangeEvent
+}
+
 @injectable()
 export class AuthenticationServiceImpl implements AuthenticationService {
     private noAccountsMenuItem: Disposable | undefined;
     private noAccountsCommand: Command = { id: 'noAccounts' };
     private signInRequestItems = new Map<string, SessionRequestInfo>();
+    private sessionMap = new Map<string, DisposableCollection>();
 
-    private authenticationProviders: Map<string, AuthenticationProvider> = new Map<string, AuthenticationProvider>();
+    protected authenticationProviders: Map<string, AuthenticationProvider> = new Map<string, AuthenticationProvider>();
 
     private onDidRegisterAuthenticationProviderEmitter: Emitter<AuthenticationProviderInformation> = new Emitter<AuthenticationProviderInformation>();
     readonly onDidRegisterAuthenticationProvider: Event<AuthenticationProviderInformation> = this.onDidRegisterAuthenticationProviderEmitter.event;
@@ -113,9 +152,8 @@ export class AuthenticationServiceImpl implements AuthenticationService {
     private onDidUnregisterAuthenticationProviderEmitter: Emitter<AuthenticationProviderInformation> = new Emitter<AuthenticationProviderInformation>();
     readonly onDidUnregisterAuthenticationProvider: Event<AuthenticationProviderInformation> = this.onDidUnregisterAuthenticationProviderEmitter.event;
 
-    private onDidChangeSessionsEmitter: Emitter<{ providerId: string, label: string, event: AuthenticationSessionsChangeEvent }> =
-        new Emitter<{ providerId: string, label: string, event: AuthenticationSessionsChangeEvent }>();
-    readonly onDidChangeSessions: Event<{ providerId: string, label: string, event: AuthenticationSessionsChangeEvent }> = this.onDidChangeSessionsEmitter.event;
+    private onDidChangeSessionsEmitter: Emitter<SessionChangeEvent> = new Emitter<SessionChangeEvent>();
+    readonly onDidChangeSessions: Event<SessionChangeEvent> = this.onDidChangeSessionsEmitter.event;
 
     @inject(MenuModelRegistry) protected readonly menus: MenuModelRegistry;
     @inject(CommandRegistry) protected readonly commands: CommandRegistry;
@@ -123,48 +161,54 @@ export class AuthenticationServiceImpl implements AuthenticationService {
 
     @postConstruct()
     init(): void {
-        const disposableMap = new Map<string, DisposableCollection>();
-        this.onDidChangeSessions(async e => {
-            if (e.event.added.length > 0) {
-                const sessions = await this.getSessions(e.providerId);
-                sessions.forEach(session => {
-                    if (sessions.find(s => disposableMap.get(s.id))) {
-                        return;
-                    }
-                    const disposables = new DisposableCollection();
-                    const commandId = `account-sign-out-${e.providerId}-${session.id}`;
-                    const command = this.commands.registerCommand({ id: commandId }, {
-                        execute: async () => {
-                            this.signOutOfAccount(e.providerId, session.account.label);
-                        }
-                    });
-                    const subSubMenuPath = [...ACCOUNTS_SUBMENU, 'account-sub-menu'];
-                    this.menus.registerSubmenu(subSubMenuPath, `${session.account.label} (${e.label})`);
-                    const menuAction = this.menus.registerMenuAction(subSubMenuPath, {
-                        label: 'Sign Out',
-                        commandId
-                    });
-                    disposables.push(menuAction);
-                    disposables.push(command);
-                    disposableMap.set(session.id, disposables);
-                });
-            }
-            if (e.event.removed.length > 0) {
-                e.event.removed.forEach(removed => {
-                    const toDispose = disposableMap.get(removed);
-                    if (toDispose) {
-                        toDispose.dispose();
-                        disposableMap.delete(removed);
-                    }
-                });
-            }
-        });
+        this.onDidChangeSessions(event => this.handleSessionChange(event));
         this.commands.registerCommand(this.noAccountsCommand, {
-            execute: () => {},
+            execute: () => { },
             isEnabled: () => false
         });
     }
 
+    protected async handleSessionChange(changeEvent: SessionChangeEvent): Promise<void> {
+        if (changeEvent.event.added.length > 0) {
+            const sessions = await this.getSessions(changeEvent.providerId);
+            sessions.forEach(session => {
+                if (!this.sessionMap.get(session.id)) {
+                    this.sessionMap.set(session.id, this.createAccountUi(changeEvent.providerId, changeEvent.label, session));
+                }
+            });
+        }
+        for (const removed of changeEvent.event.removed) {
+            const sessionId = typeof removed === 'string' ? removed : removed?.id;
+            if (sessionId) {
+                this.sessionMap.get(sessionId)?.dispose();
+                this.sessionMap.delete(sessionId);
+            }
+        }
+    }
+
+    protected createAccountUi(providerId: string, providerLabel: string, session: AuthenticationSession): DisposableCollection {
+        // unregister old commands and menus if present (there is only one per account but there may be several sessions per account)
+        const providerAccountId = `account-sign-out-${providerId}-${session.account.id}`;
+        this.commands.unregisterCommand(providerAccountId);
+
+        const providerAccountSubmenu = [...ACCOUNTS_SUBMENU, providerAccountId];
+        this.menus.unregisterMenuAction({ commandId: providerAccountId }, providerAccountSubmenu);
+
+        // register new command and menu entry for the sessions account
+        const disposables = new DisposableCollection();
+        disposables.push(this.commands.registerCommand({ id: providerAccountId }, {
+            execute: async () => {
+                this.signOutOfAccount(providerId, session.account.label);
+            }
+        }));
+        this.menus.registerSubmenu(providerAccountSubmenu, `${session.account.label} (${providerLabel})`);
+        disposables.push(this.menus.registerMenuAction(providerAccountSubmenu, {
+            label: nls.localizeByDefault('Sign Out'),
+            commandId: providerAccountId
+        }));
+        return disposables;
+    }
+
     getProviderIds(): string[] {
         const providerIds: string[] = [];
         this.authenticationProviders.forEach(provider => {
@@ -219,7 +263,7 @@ export class AuthenticationServiceImpl implements AuthenticationService {
         }
     }
 
-    async updateSessions(id: string, event: AuthenticationSessionsChangeEvent): Promise<void> {
+    async updateSessions(id: string, event: AuthenticationProviderAuthenticationSessionsChangeEvent): Promise<void> {
         const provider = this.authenticationProviders.get(id);
         if (provider) {
             await provider.updateSessionItems(event);
@@ -264,11 +308,11 @@ export class AuthenticationServiceImpl implements AuthenticationService {
             // Activate has already been called for the authentication provider, but it cannot block on registering itself
             // since this is sync and returns a disposable. So, wait for registration event to fire that indicates the
             // provider is now in the map.
-            await new Promise((resolve, _) => {
+            await new Promise<void>((resolve, _) => {
                 this.onDidRegisterAuthenticationProvider(e => {
                     if (e.id === providerId) {
                         provider = this.authenticationProviders.get(providerId);
-                        resolve();
+                        resolve(undefined);
                     }
                 });
             });
@@ -344,10 +388,10 @@ export class AuthenticationServiceImpl implements AuthenticationService {
         }
     }
 
-    async getSessions(id: string): Promise<ReadonlyArray<AuthenticationSession>> {
+    async getSessions(id: string, scopes?: string[]): Promise<ReadonlyArray<AuthenticationSession>> {
         const authProvider = this.authenticationProviders.get(id);
         if (authProvider) {
-            return authProvider.getSessions();
+            return authProvider.getSessions(scopes);
         } else {
             throw new Error(`No authentication provider '${id}' is currently registered.`);
         }

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

@@ -119,6 +119,7 @@ import {
 } from './breadcrumbs';
 import { RendererHost } from './widgets';
 import { TooltipService, TooltipServiceImpl } from './tooltip-service';
+import { bindFrontendStopwatch, bindBackendStopwatch } from './performance';
 
 export { bindResourceProvider, bindMessageService, bindPreferenceService };
 
@@ -390,4 +391,7 @@ export const frontendApplicationModule = new ContainerModule((bind, unbind, isBo
         child.bind(Coordinate).toConstantValue(position);
         return child.get(BreadcrumbPopupContainer);
     });
+
+    bindFrontendStopwatch(bind);
+    bindBackendStopwatch(bind);
 });

package/src/browser/frontend-application.ts

@@ -15,7 +15,7 @@
  ********************************************************************************/
 
 import { inject, injectable, named } from 'inversify';
-import { ContributionProvider, CommandRegistry, MenuModelRegistry, isOSX } from '../common';
+import { ContributionProvider, CommandRegistry, MenuModelRegistry, isOSX, BackendStopwatch, LogLevel, Stopwatch } from '../common';
 import { MaybePromise } from '../common/types';
 import { KeybindingRegistry } from './keybinding';
 import { Widget } from './widgets';
@@ -127,6 +127,12 @@ export class FrontendApplication {
     @inject(TooltipService)
     protected readonly tooltipService: TooltipService;
 
+    @inject(Stopwatch)
+    protected readonly stopwatch: Stopwatch;
+
+    @inject(BackendStopwatch)
+    protected readonly backendStopwatch: BackendStopwatch;
+
     constructor(
         @inject(CommandRegistry) protected readonly commands: CommandRegistry,
         @inject(MenuModelRegistry) protected readonly menus: MenuModelRegistry,
@@ -152,7 +158,9 @@ export class FrontendApplication {
      * - reveal the application shell if it was hidden by a startup indicator
      */
     async start(): Promise<void> {
-        await this.startContributions();
+        const startup = this.backendStopwatch.start('frontend');
+
+        await this.measure('startContributions', () => this.startContributions(), 'Start frontend contributions', false);
         this.stateService.state = 'started_contributions';
 
         const host = await this.getHost();
@@ -161,13 +169,15 @@ export class FrontendApplication {
         await animationFrame();
         this.stateService.state = 'attached_shell';
 
-        await this.initializeLayout();
+        await this.measure('initializeLayout', () => this.initializeLayout(), 'Initialize the workbench layout', false);
         this.stateService.state = 'initialized_layout';
         await this.fireOnDidInitializeLayout();
 
-        await this.revealShell(host);
+        await this.measure('revealShell', () => this.revealShell(host), 'Replace loading indicator with ready workbench UI (animation)', false);
         this.registerEventListeners();
         this.stateService.state = 'ready';
+
+        startup.then(idToken => this.backendStopwatch.stop(idToken, 'Frontend application start', []));
     }
 
     /**
@@ -266,7 +276,6 @@ export class FrontendApplication {
             return new Promise(resolve => {
                 window.requestAnimationFrame(() => {
                     startupElem.classList.add('theia-hidden');
-                    console.log(`Finished loading frontend application after ${(performance.now() / 1000).toFixed(3)} seconds`);
                     const preloadStyle = window.getComputedStyle(startupElem);
                     const transitionDuration = parseCssTime(preloadStyle.transitionDuration, 0);
                     window.setTimeout(() => {
@@ -408,23 +417,9 @@ export class FrontendApplication {
         console.info('<<< All frontend contributions have been stopped.');
     }
 
-    protected async measure<T>(name: string, fn: () => MaybePromise<T>): Promise<T> {
-        const startMark = name + '-start';
-        const endMark = name + '-end';
-        performance.mark(startMark);
-        const result = await fn();
-        performance.mark(endMark);
-        performance.measure(name, startMark, endMark);
-        for (const item of performance.getEntriesByName(name)) {
-            const contribution = `Frontend ${item.name}`;
-            if (item.duration > TIMER_WARNING_THRESHOLD) {
-                console.warn(`${contribution} is slow, took: ${item.duration.toFixed(1)} ms`);
-            } else {
-                console.debug(`${contribution} took: ${item.duration.toFixed(1)} ms`);
-            }
-        }
-        performance.clearMeasures(name);
-        return result;
+    protected async measure<T>(name: string, fn: () => MaybePromise<T>, message = `Frontend ${name}`, threshold = true): Promise<T> {
+        return this.stopwatch.startAsync(name, message, fn,
+            threshold ? { thresholdMillis: TIMER_WARNING_THRESHOLD, defaultLogLevel: LogLevel.DEBUG } : {});
     }
 
 }

package/src/browser/performance/frontend-stopwatch.ts

@@ -0,0 +1,62 @@
+/********************************************************************************
+* Copyright (c) 2019, 2021 TypeFox, STMicroelectronics and others.
+*
+* This program and the accompanying materials are made available under the
+* terms of the Eclipse Public License 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 WITH Classpath-exception-2.0
+*******************************************************************************/
+
+import { injectable } from 'inversify';
+import { Measurement, MeasurementOptions, Stopwatch } from '../../common';
+
+@injectable()
+export class FrontendStopwatch extends Stopwatch {
+
+    constructor() {
+        super({
+            owner: 'frontend',
+            now: () => performance.now(),
+        });
+    }
+
+    start(name: string, options?: MeasurementOptions): Measurement {
+        const startMarker = `${name}-start`;
+        const endMarker = `${name}-end`;
+        performance.clearMeasures(name);
+        performance.clearMarks(startMarker);
+        performance.clearMarks(endMarker);
+
+        performance.mark(startMarker);
+
+        return this.createMeasurement(name, () => {
+            performance.mark(endMarker);
+
+            let duration: number;
+
+            try {
+                performance.measure(name, startMarker, endMarker);
+
+                const entries = performance.getEntriesByName(name);
+                // If no entries, then performance measurement was disabled or failed, so
+                // signal that with a `NaN` result
+                duration = entries.length > 0 ? entries[0].duration : Number.NaN;
+            } catch (e) {
+                console.warn(e);
+                duration = Number.NaN;
+            }
+
+            performance.clearMeasures(name);
+            performance.clearMarks(startMarker);
+            performance.clearMarks(endMarker);
+            return duration;
+        }, options);
+    }
+};

package/src/browser/performance/index.ts

@@ -0,0 +1,18 @@
+/********************************************************************************
+ * Copyright (C) 2021 STMicroelectronics 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 WITH Classpath-exception-2.0
+ ********************************************************************************/
+
+export * from './frontend-stopwatch';
+export * from './measurement-frontend-bindings';

package/src/browser/performance/measurement-frontend-bindings.ts

@@ -0,0 +1,31 @@
+/********************************************************************************
+* Copyright (c) 2021 STMicroelectronics and others.
+*
+* This program and the accompanying materials are made available under the
+* terms of the Eclipse Public License 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 WITH Classpath-exception-2.0
+*******************************************************************************/
+
+import { interfaces } from 'inversify';
+import { BackendStopwatch, Stopwatch, stopwatchPath } from '../../common';
+import { WebSocketConnectionProvider } from '../messaging';
+import { FrontendStopwatch } from './frontend-stopwatch';
+
+export function bindFrontendStopwatch(bind: interfaces.Bind): interfaces.BindingWhenOnSyntax<Stopwatch> {
+    return bind(Stopwatch).to(FrontendStopwatch).inSingletonScope();
+}
+
+export function bindBackendStopwatch(bind: interfaces.Bind): interfaces.BindingWhenOnSyntax<unknown> {
+    return bind(BackendStopwatch).toDynamicValue(({ container }) => {
+        const connection = container.get(WebSocketConnectionProvider);
+        return connection.createProxy<BackendStopwatch>(stopwatchPath);
+    }).inSingletonScope();
+}

package/src/browser/preferences/preference-language-override-service.ts

@@ -42,21 +42,35 @@ export class PreferenceLanguageOverrideService {
         return PreferenceSchemaProperties.is(value) && OVERRIDE_PROPERTY_PATTERN.test(name);
     }
 
+    /**
+     * @param overrideIdentifier the language id associated for a language override, e.g. `typescript`
+     * @returns the form used to mark language overrides in preference files, e.g. `[typescript]`
+     */
+    markLanguageOverride(overrideIdentifier: string): string {
+        return `[${overrideIdentifier}]`;
+    }
+
+    /**
+     * @returns the flat JSON path to an overridden preference, e.g. [typescript].editor.tabSize.
+     */
     overridePreferenceName({ preferenceName, overrideIdentifier }: OverridePreferenceName): string {
-        return `[${overrideIdentifier}].${preferenceName}`;
+        return `${this.markLanguageOverride(overrideIdentifier)}.${preferenceName}`;
     }
 
+    /**
+     * @returns an OverridePreferenceName if the `name` contains a language override, e.g. [typescript].editor.tabSize.
+     */
     overriddenPreferenceName(name: string): OverridePreferenceName | undefined {
         const index = name.indexOf('.');
         if (index === -1) {
             return undefined;
         }
-        const matches = name.substr(0, index).match(OVERRIDE_PROPERTY_PATTERN);
+        const matches = name.substring(0, index).match(OVERRIDE_PROPERTY_PATTERN);
         const overrideIdentifier = matches && matches[1];
         if (!overrideIdentifier || !this.overrideIdentifiers.has(overrideIdentifier)) {
             return undefined;
         }
-        const preferenceName = name.substr(index + 1);
+        const preferenceName = name.substring(index + 1);
         return { preferenceName, overrideIdentifier };
     }
 

package/src/browser/saveable.ts

@@ -93,51 +93,93 @@ export namespace Saveable {
             await saveable.save(options);
         }
     }
-    export function apply(widget: Widget): SaveableWidget | undefined {
-        if (SaveableWidget.is(widget)) {
-            return widget;
-        }
-        const saveable = Saveable.get(widget);
-        if (!saveable) {
-            return undefined;
+
+    async function closeWithoutSaving(this: PostCreationSaveableWidget, doRevert: boolean = true): Promise<void> {
+        const saveable = get(this);
+        if (saveable && doRevert && saveable.dirty && saveable.revert) {
+            await saveable.revert();
         }
-        setDirty(widget, saveable.dirty);
-        saveable.onDirtyChanged(() => setDirty(widget, saveable.dirty));
-        const closeWidget = widget.close.bind(widget);
-        const closeWithoutSaving: SaveableWidget['closeWithoutSaving'] = async () => {
-            if (saveable.dirty && saveable.revert) {
-                await saveable.revert();
-            }
-            closeWidget();
-            return waitForClosed(widget);
-        };
+        this[close]();
+        return waitForClosed(this);
+    }
+
+    function createCloseWithSaving(getOtherSaveables?: () => Array<Widget | SaveableWidget>): (this: SaveableWidget, options?: SaveableWidget.CloseOptions) => Promise<void> {
         let closing = false;
-        const closeWithSaving: SaveableWidget['closeWithSaving'] = async options => {
-            if (closing) {
-                return;
-            }
+        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(widget).open();
+                    return new ShouldSaveDialog(this).open();
                 });
                 if (typeof result === 'boolean') {
                     if (result) {
-                        await Saveable.save(widget);
+                        await Saveable.save(this);
                     }
-                    await closeWithoutSaving();
+                    await this.closeWithoutSaving();
                 }
             } finally {
                 closing = false;
             }
         };
-        return Object.assign(widget, {
+    }
+
+    export async function confirmSaveBeforeClose(toClose: Iterable<Widget>, others: Widget[]): Promise<boolean | undefined> {
+        for (const widget of toClose) {
+            const saveable = Saveable.get(widget);
+            if (saveable?.dirty) {
+                if (!closingWidgetWouldLoseSaveable(widget, others)) {
+                    continue;
+                }
+                const userWantsToSave = await new ShouldSaveDialog(widget).open();
+                if (userWantsToSave === undefined) { // User clicked cancel.
+                    return undefined;
+                } else if (userWantsToSave) {
+                    await saveable.save();
+                } else {
+                    await saveable.revert?.();
+                }
+            }
+        }
+        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>): SaveableWidget | undefined {
+        if (SaveableWidget.is(widget)) {
+            return widget;
+        }
+        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);
+        return Object.assign(saveableWidget, {
             closeWithoutSaving,
             closeWithSaving,
-            close: () => closeWithSaving()
+            close: closeWithSaving,
+            [close]: saveableWidget.close,
         });
     }
     export async function shouldSave(saveable: Saveable, cb: () => MaybePromise<boolean | undefined>): Promise<boolean | undefined> {
@@ -154,9 +196,24 @@ export namespace Saveable {
 }
 
 export interface SaveableWidget extends Widget {
-    closeWithoutSaving(): Promise<void>;
+    /**
+     * @param doRevert whether the saveable should be reverted before being saved. Defaults to `true`.
+     */
+    closeWithoutSaving(doRevert?: boolean): Promise<void>;
     closeWithSaving(options?: SaveableWidget.CloseOptions): Promise<void>;
 }
+
+export const close = Symbol('close');
+/**
+ * An interface describing saveable widgets that are created by the `Saveable.apply` function.
+ * The original `close` function is reassigned to a locally-defined `Symbol`
+ */
+export interface PostCreationSaveableWidget extends SaveableWidget {
+    /**
+     * The original `close` function of the widget
+     */
+    [close](): void;
+}
 export namespace SaveableWidget {
     export function is(widget: Widget | undefined): widget is SaveableWidget {
         return !!widget && 'closeWithoutSaving' in widget;