@theia/core 1.40.1 → 1.41.0

package/src/browser/common-frontend-contribution.ts

@@ -36,7 +36,7 @@ import { OS, isOSX, isWindows, EOL } from '../common/os';
 import { ResourceContextKey } from './resource-context-key';
 import { UriSelection } from '../common/selection';
 import { StorageService } from './storage-service';
-import { Navigatable } from './navigatable';
+import { Navigatable, NavigatableWidget } from './navigatable';
 import { QuickViewService } from './quick-input/quick-view-service';
 import { environment } from '@theia/application-package/lib/environment';
 import { IconTheme, IconThemeService } from './icon-theme-service';
@@ -52,7 +52,7 @@ import { UTF8 } from '../common/encodings';
 import { EnvVariablesServer } from '../common/env-variables';
 import { AuthenticationService } from './authentication-service';
 import { FormatType, Saveable, SaveOptions } from './saveable';
-import { QuickInputService, QuickPickItem, QuickPickItemOrSeparator } from './quick-input';
+import { QuickInputService, QuickPickItem, QuickPickItemOrSeparator, QuickPickSeparator } from './quick-input';
 import { AsyncLocalizationProvider } from '../common/i18n/localization';
 import { nls } from '../common/nls';
 import { CurrentWidgetCommandAdapter } from './shell/current-widget-command-adapter';
@@ -63,12 +63,13 @@ import { DecorationStyle } from './decoration-style';
 import { isPinned, Title, togglePinned, Widget } from './widgets';
 import { SaveResourceService } from './save-resource-service';
 import { UserWorkingDirectoryProvider } from './user-working-directory-provider';
-import { UntitledResourceResolver } from '../common';
+import { UNTITLED_SCHEME, UntitledResourceResolver } from '../common';
 import { LanguageQuickPickService } from './i18n/language-quick-pick-service';
 
 export namespace CommonMenus {
 
     export const FILE = [...MAIN_MENU_BAR, '1_file'];
+    export const FILE_NEW_TEXT = [...FILE, '1_new_text'];
     export const FILE_NEW = [...FILE, '1_new'];
     export const FILE_OPEN = [...FILE, '2_open'];
     export const FILE_SAVE = [...FILE, '3_save'];
@@ -79,6 +80,8 @@ export namespace CommonMenus {
     export const FILE_SETTINGS_SUBMENU_THEME = [...FILE_SETTINGS_SUBMENU, '2_settings_submenu_theme'];
     export const FILE_CLOSE = [...FILE, '6_close'];
 
+    export const FILE_NEW_CONTRIBUTIONS = 'file/newFile';
+
     export const EDIT = [...MAIN_MENU_BAR, '2_edit'];
     export const EDIT_UNDO = [...EDIT, '1_undo'];
     export const EDIT_CLIPBOARD = [...EDIT, '2_clipboard'];
@@ -108,6 +111,7 @@ export namespace CommonCommands {
 
     export const FILE_CATEGORY = 'File';
     export const VIEW_CATEGORY = 'View';
+    export const CREATE_CATEGORY = 'Create';
     export const PREFERENCES_CATEGORY = 'Preferences';
     export const FILE_CATEGORY_KEY = nls.getDefaultKey(FILE_CATEGORY);
     export const VIEW_CATEGORY_KEY = nls.getDefaultKey(VIEW_CATEGORY);
@@ -272,11 +276,16 @@ export namespace CommonCommands {
         category: VIEW_CATEGORY,
         label: 'Toggle Menu Bar'
     });
-    export const NEW_UNTITLED_FILE = Command.toDefaultLocalizedCommand({
-        id: 'workbench.action.files.newUntitledFile',
+    export const NEW_UNTITLED_TEXT_FILE = Command.toDefaultLocalizedCommand({
+        id: 'workbench.action.files.newUntitledTextFile',
         category: FILE_CATEGORY,
         label: 'New Untitled Text File'
     });
+    export const NEW_UNTITLED_FILE = Command.toDefaultLocalizedCommand({
+        id: 'workbench.action.files.newUntitledFile',
+        category: CREATE_CATEGORY,
+        label: 'New File...'
+    });
     export const SAVE = Command.toDefaultLocalizedCommand({
         id: 'core.save',
         category: FILE_CATEGORY,
@@ -371,6 +380,9 @@ export class CommonFrontendContribution implements FrontendApplicationContributi
     @inject(CommandRegistry)
     protected readonly commandRegistry: CommandRegistry;
 
+    @inject(MenuModelRegistry)
+    protected readonly menuRegistry: MenuModelRegistry;
+
     @inject(StorageService)
     protected readonly storageService: StorageService;
 
@@ -545,6 +557,9 @@ export class CommonFrontendContribution implements FrontendApplicationContributi
         registry.registerSubmenu(CommonMenus.VIEW, nls.localizeByDefault('View'));
         registry.registerSubmenu(CommonMenus.HELP, nls.localizeByDefault('Help'));
 
+        // For plugins contributing create new file commands/menu-actions
+        registry.registerIndependentSubmenu(CommonMenus.FILE_NEW_CONTRIBUTIONS, nls.localizeByDefault('New File...'));
+
         registry.registerMenuAction(CommonMenus.FILE_SAVE, {
             commandId: CommonCommands.SAVE.id
         });
@@ -693,10 +708,16 @@ export class CommonFrontendContribution implements FrontendApplicationContributi
 
         registry.registerSubmenu(CommonMenus.VIEW_APPEARANCE_SUBMENU, nls.localizeByDefault('Appearance'));
 
-        registry.registerMenuAction(CommonMenus.FILE_NEW, {
+        registry.registerMenuAction(CommonMenus.FILE_NEW_TEXT, {
+            commandId: CommonCommands.NEW_UNTITLED_TEXT_FILE.id,
+            label: nls.localizeByDefault('New Text File'),
+            order: 'a'
+        });
+
+        registry.registerMenuAction(CommonMenus.FILE_NEW_TEXT, {
             commandId: CommonCommands.NEW_UNTITLED_FILE.id,
             label: nls.localizeByDefault('New File...'),
-            order: 'a'
+            order: 'a1'
         });
     }
 
@@ -941,13 +962,17 @@ export class CommonFrontendContribution implements FrontendApplicationContributi
             execute: () => this.toggleBreadcrumbs(),
             isToggled: () => this.isBreadcrumbsEnabled(),
         });
-        commandRegistry.registerCommand(CommonCommands.NEW_UNTITLED_FILE, {
+        commandRegistry.registerCommand(CommonCommands.NEW_UNTITLED_TEXT_FILE, {
             execute: async () => {
                 const untitledUri = this.untitledResourceResolver.createUntitledURI('', await this.workingDirProvider.getUserWorkingDir());
                 this.untitledResourceResolver.resolve(untitledUri);
                 return open(this.openerService, untitledUri);
             }
         });
+        commandRegistry.registerCommand(CommonCommands.NEW_UNTITLED_FILE, {
+            execute: async () => this.showNewFilePicker()
+        });
+
         for (const [index, ordinal] of this.getOrdinalNumbers().entries()) {
             commandRegistry.registerCommand({ id: `workbench.action.focus${ordinal}EditorGroup`, label: index === 0 ? nls.localizeByDefault('Focus First Editor Group') : '', category: nls.localize(CommonCommands.VIEW_CATEGORY_KEY, CommonCommands.VIEW_CATEGORY) }, {
                 isEnabled: () => this.shell.mainAreaTabBars.length > index,
@@ -1097,8 +1122,12 @@ export class CommonFrontendContribution implements FrontendApplicationContributi
                 when: 'activeEditorIsPinned'
             },
             {
-                command: CommonCommands.NEW_UNTITLED_FILE.id,
+                command: CommonCommands.NEW_UNTITLED_TEXT_FILE.id,
                 keybinding: this.isElectron() ? 'ctrlcmd+n' : 'alt+n',
+            },
+            {
+                command: CommonCommands.NEW_UNTITLED_FILE.id,
+                keybinding: 'ctrlcmd+alt+n'
             }
         );
         for (const [index, ordinal] of this.getOrdinalNumbers().entries()) {
@@ -1142,14 +1171,26 @@ export class CommonFrontendContribution implements FrontendApplicationContributi
     }
 
     onWillStop(): OnWillStopAction | undefined {
-        try {
-            if (this.shouldPreventClose || this.shell.canSaveAll()) {
-                const captionsToSave = this.unsavedTabsCaptions();
+        if (this.shouldPreventClose || this.shell.canSaveAll()) {
+            return {
+                reason: 'Dirty editors present',
+                action: async () => {
+                    const captionsToSave = this.unsavedTabsCaptions();
+                    const untitledCaptionsToSave = this.unsavedUntitledTabsCaptions();
+                    const result = await confirmExitWithOrWithoutSaving(captionsToSave, async () => {
+                        await this.saveDirty(untitledCaptionsToSave);
+                        await this.shell.saveAll();
+                    });
+                    if (this.shell.canSaveAll()) {
+                        this.shouldPreventClose = true;
+                        return false;
+                    } else {
+                        this.shouldPreventClose = false;
+                        return result;
+                    }
 
-                return { reason: 'Dirty editors present', action: async () => confirmExitWithOrWithoutSaving(captionsToSave, async () => this.shell.saveAll()) };
-            }
-        } finally {
-            this.shouldPreventClose = false;
+                }
+            };
         }
     }
     protected unsavedTabsCaptions(): string[] {
@@ -1157,6 +1198,11 @@ export class CommonFrontendContribution implements FrontendApplicationContributi
             .filter(widget => this.saveResourceService.canSave(widget))
             .map(widget => widget.title.label);
     }
+    protected unsavedUntitledTabsCaptions(): Widget[] {
+        return this.shell.widgets.filter(widget =>
+            NavigatableWidget.getUri(widget)?.scheme === UNTITLED_SCHEME && this.saveResourceService.canSaveAs(widget)
+        );
+    }
     protected async configureDisplayLanguage(): Promise<void> {
         const languageInfo = await this.languageQuickPickService.pickDisplayLanguage();
         if (languageInfo && !nls.isSelectedLocale(languageInfo.languageId) && await this.confirmRestart(
@@ -1167,7 +1213,14 @@ export class CommonFrontendContribution implements FrontendApplicationContributi
             this.windowService.reload();
         }
     }
-
+    protected async saveDirty(toSave: Widget[]): Promise<void> {
+        for (const widget of toSave) {
+            const saveable = Saveable.get(widget);
+            if (saveable?.dirty) {
+                await this.saveResourceService.save(widget);
+            }
+        }
+    }
     protected toggleBreadcrumbs(): void {
         const value: boolean | undefined = this.preferenceService.get('breadcrumbs.enabled');
         this.preferenceService.set('breadcrumbs.enabled', !value, PreferenceScope.User);
@@ -1294,6 +1347,43 @@ export class CommonFrontendContribution implements FrontendApplicationContributi
             });
     }
 
+    /**
+     * @todo https://github.com/eclipse-theia/theia/issues/12824
+     */
+    protected async showNewFilePicker(): Promise<void> {
+        const newFileContributions = this.menuRegistry.getMenuNode(CommonMenus.FILE_NEW_CONTRIBUTIONS); // Add menus
+        const items: QuickPickItemOrSeparator[] = [
+            {
+                label: nls.localizeByDefault('New Text File'),
+                execute: async () => this.commandRegistry.executeCommand(CommonCommands.NEW_UNTITLED_TEXT_FILE.id)
+            },
+            ...newFileContributions.children
+                .flatMap(node => {
+                    if (node.children && node.children.length > 0) {
+                        return node.children;
+                    }
+                    return node;
+                })
+                .filter(node => node.role || node.command)
+                .map(node => {
+                    if (node.role) {
+                        return { type: 'separator' } as QuickPickSeparator;
+                    }
+                    const command = this.commandRegistry.getCommand(node.command!);
+                    return {
+                        label: command!.label!,
+                        execute: async () => this.commandRegistry.executeCommand(command!.id!)
+                    };
+
+                })
+        ];
+        this.quickInputService.showQuickPick(items, {
+            title: nls.localizeByDefault('New File...'),
+            placeholder: nls.localizeByDefault('Select File Type or Enter File Name...'),
+            canSelectMany: false
+        });
+    }
+
     registerColors(colors: ColorRegistry): void {
         colors.register(
             // Base Colors should be aligned with https://code.visualstudio.com/api/references/theme-color#base-colors

package/src/browser/context-menu-renderer.ts

@@ -120,4 +120,9 @@ export interface RenderContextMenuOptions {
     context?: HTMLElement;
     contextKeyService?: ContextMatcher;
     onHide?: () => void;
+    /**
+     * If true a single submenu in the context menu is not rendered but its children are rendered on the top level.
+     * Default is `false`.
+     */
+    skipSingleRootNode?: boolean;
 }

package/src/browser/label-parser.spec.ts

@@ -124,4 +124,42 @@ describe('StatusBarEntryUtility', () => {
         expect((iconArr[3] as LabelIcon).name).equals('icon3');
     });
 
+    it('should strip nothing from an empty string', () => {
+        text = '';
+        const stripped: string = statusBarEntryUtility.stripIcons(text);
+        expect(stripped).to.be.equal(text);
+    });
+
+    it('should strip nothing from an string containing no icons', () => {
+        // Deliberate double space to verify not concatenating these words
+        text = 'foo  bar';
+        const stripped: string = statusBarEntryUtility.stripIcons(text);
+        expect(stripped).to.be.equal(text);
+    });
+
+    it("should strip a medial '$(icon)' from a string", () => {
+        text = 'foo $(icon) bar';
+        const stripped: string = statusBarEntryUtility.stripIcons(text);
+        expect(stripped).to.be.equal('foo bar');
+    });
+
+    it("should strip a terminal '$(icon)' from a string", () => {
+        // Deliberate double space to verify not concatenating these words
+        text = 'foo  bar $(icon)';
+        const stripped: string = statusBarEntryUtility.stripIcons(text);
+        expect(stripped).to.be.equal('foo  bar');
+    });
+
+    it("should strip an initial '$(icon)' from a string", () => {
+        // Deliberate double space to verify not concatenating these words
+        text = '$(icon) foo  bar';
+        const stripped: string = statusBarEntryUtility.stripIcons(text);
+        expect(stripped).to.be.equal('foo  bar');
+    });
+
+    it("should strip multiple '$(icon)' specifiers from a string", () => {
+        text = '$(icon1) foo $(icon2)$(icon3)  bar $(icon4) $(icon5)';
+        const stripped: string = statusBarEntryUtility.stripIcons(text);
+        expect(stripped).to.be.equal('foo bar');
+    });
 });

package/src/browser/label-parser.ts

@@ -90,4 +90,19 @@ export class LabelParser {
         return parserArray;
     }
 
+    /**
+     * Strips icon specifiers from the given `text`, leaving only a
+     * space-separated concatenation of the non-icon segments.
+     *
+     * @param text text to be stripped of icon specifiers
+     * @returns the `text` with icon specifiers stripped out
+     */
+    stripIcons(text: string): string {
+        return this.parse(text)
+            .filter(item => !LabelIcon.is(item))
+            .map(s => (s as string).trim())
+            .filter(s => s.length)
+            .join(' ');
+    }
+
 }

package/src/browser/menu/browser-context-menu-renderer.ts

@@ -34,8 +34,8 @@ export class BrowserContextMenuRenderer extends ContextMenuRenderer {
         super();
     }
 
-    protected doRender({ menuPath, anchor, args, onHide, context, contextKeyService }: RenderContextMenuOptions): ContextMenuAccess {
-        const contextMenu = this.menuFactory.createContextMenu(menuPath, args, context, contextKeyService);
+    protected doRender({ menuPath, anchor, args, onHide, context, contextKeyService, skipSingleRootNode }: RenderContextMenuOptions): ContextMenuAccess {
+        const contextMenu = this.menuFactory.createContextMenu(menuPath, args, context, contextKeyService, skipSingleRootNode);
         const { x, y } = coordinateFromAnchor(anchor);
         if (onHide) {
             contextMenu.aboutToClose.connect(() => onHide!());

package/src/browser/menu/browser-menu-plugin.ts

@@ -108,8 +108,8 @@ export class BrowserMainMenuFactory implements MenuWidgetFactory {
         }
     }
 
-    createContextMenu(path: MenuPath, args?: unknown[], context?: HTMLElement, contextKeyService?: ContextMatcher): MenuWidget {
-        const menuModel = this.menuProvider.getMenu(path);
+    createContextMenu(path: MenuPath, args?: unknown[], context?: HTMLElement, contextKeyService?: ContextMatcher, skipSingleRootNode?: boolean): MenuWidget {
+        const menuModel = skipSingleRootNode ? this.menuProvider.removeSingleRootNode(this.menuProvider.getMenu(path), path) : this.menuProvider.getMenu(path);
         const menuCommandRegistry = this.createMenuCommandRegistry(menuModel, args).snapshot(path);
         const contextMenu = this.createMenuWidget(menuModel, { commands: menuCommandRegistry, context, rootMenuPath: path, contextKeyService });
         return contextMenu;

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

@@ -40,6 +40,7 @@ export class FrontendStopwatch extends Stopwatch {
             performance.mark(endMarker);
 
             let duration: number;
+            let startTime: number;
 
             try {
                 performance.measure(name, startMarker, endMarker);
@@ -47,16 +48,18 @@ export class FrontendStopwatch extends Stopwatch {
                 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;
+                duration = entries[0].duration ?? Number.NaN;
+                startTime = entries[0].startTime ?? Number.NaN;
             } catch (e) {
                 console.warn(e);
                 duration = Number.NaN;
+                startTime = Number.NaN;
             }
 
             performance.clearMeasures(name);
             performance.clearMarks(startMarker);
             performance.clearMarks(endMarker);
-            return duration;
+            return { startTime, duration };
         }, options);
     }
 };

package/src/browser/preferences/preference-contribution.ts

@@ -34,6 +34,8 @@ import { JSONValue } from '@phosphor/coreutils';
 
 export const PreferenceContribution = Symbol('PreferenceContribution');
 
+export const DefaultOverridesPreferenceSchemaId = 'defaultOverrides';
+
 /**
  * A {@link PreferenceContribution} allows adding additional custom preferences.
  * For this, the {@link PreferenceContribution} has to provide a valid JSON Schema specifying which preferences
@@ -202,34 +204,44 @@ export class PreferenceSchemaProvider extends PreferenceProvider {
         const defaultScope = PreferenceSchema.getDefaultScope(schema);
         const overridable = schema.overridable || false;
         for (const [preferenceName, rawSchemaProps] of Object.entries(schema.properties)) {
-            if (this.combinedSchema.properties[preferenceName]) {
+            if (this.combinedSchema.properties[preferenceName] && DefaultOverridesPreferenceSchemaId !== schema.id) {
                 console.error('Preference name collision detected in the schema for property: ' + preferenceName);
-            } else if (!rawSchemaProps.hasOwnProperty('included') || rawSchemaProps.included) {
-                const schemaProps = PreferenceDataProperty.fromPreferenceSchemaProperty(rawSchemaProps, defaultScope);
-                if (typeof schemaProps.overridable !== 'boolean' && overridable) {
-                    schemaProps.overridable = true;
-                }
-                if (schemaProps.overridable) {
-                    this.overridePatternProperties.properties[preferenceName] = schemaProps;
+            } else {
+                let schemaProps;
+                if (this.combinedSchema.properties[preferenceName] && DefaultOverridesPreferenceSchemaId === schema.id) {
+                    // update existing default value in schema
+                    schemaProps = PreferenceDataProperty.fromPreferenceSchemaProperty(rawSchemaProps, defaultScope);
+                    this.updateSchemaPropsDefault(preferenceName, schemaProps);
+                } else if (!rawSchemaProps.hasOwnProperty('included') || rawSchemaProps.included) {
+                    // add overrides for languages
+                    schemaProps = PreferenceDataProperty.fromPreferenceSchemaProperty(rawSchemaProps, defaultScope);
+                    if (typeof schemaProps.overridable !== 'boolean' && overridable) {
+                        schemaProps.overridable = true;
+                    }
+                    if (schemaProps.overridable) {
+                        this.overridePatternProperties.properties[preferenceName] = schemaProps;
+                    }
+                    this.updateSchemaProps(preferenceName, schemaProps);
                 }
-                this.updateSchemaProps(preferenceName, schemaProps);
-
-                const schemaDefault = this.getDefaultValue(schemaProps);
-                const configuredDefault = this.getConfiguredDefault(preferenceName);
-                if (this.preferenceOverrideService.testOverrideValue(preferenceName, schemaDefault)) {
-                    schemaProps.defaultValue = PreferenceSchemaProperties.is(configuredDefault)
-                        ? PreferenceProvider.merge(schemaDefault, configuredDefault)
-                        : schemaDefault;
-                    if (schemaProps.defaultValue && PreferenceSchemaProperties.is(schemaProps.defaultValue)) {
-                        for (const overriddenPreferenceName in schemaProps.defaultValue) {
-                            const overrideValue = schemaDefault[overriddenPreferenceName];
-                            const overridePreferenceName = `${preferenceName}.${overriddenPreferenceName}`;
-                            changes.push(this.doSetPreferenceValue(overridePreferenceName, overrideValue, { scope, domain }));
+
+                if (schemaProps !== undefined) {
+                    const schemaDefault = this.getDefaultValue(schemaProps);
+                    const configuredDefault = this.getConfiguredDefault(preferenceName);
+                    if (this.preferenceOverrideService.testOverrideValue(preferenceName, schemaDefault)) {
+                        schemaProps.defaultValue = PreferenceSchemaProperties.is(configuredDefault)
+                            ? PreferenceProvider.merge(schemaDefault, configuredDefault)
+                            : schemaDefault;
+                        if (schemaProps.defaultValue && PreferenceSchemaProperties.is(schemaProps.defaultValue)) {
+                            for (const overriddenPreferenceName in schemaProps.defaultValue) {
+                                const overrideValue = schemaDefault[overriddenPreferenceName];
+                                const overridePreferenceName = `${preferenceName}.${overriddenPreferenceName}`;
+                                changes.push(this.doSetPreferenceValue(overridePreferenceName, overrideValue, { scope, domain }));
+                            }
                         }
+                    } else {
+                        schemaProps.defaultValue = configuredDefault === undefined ? schemaDefault : configuredDefault;
+                        changes.push(this.doSetPreferenceValue(preferenceName, schemaProps.defaultValue, { scope, domain }));
                     }
-                } else {
-                    schemaProps.defaultValue = configuredDefault === undefined ? schemaDefault : configuredDefault;
-                    changes.push(this.doSetPreferenceValue(preferenceName, schemaProps.defaultValue, { scope, domain }));
                 }
             }
         }
@@ -383,6 +395,19 @@ export class PreferenceSchemaProvider extends PreferenceProvider {
         }
     }
 
+    protected updateSchemaPropsDefault(key: string, property: PreferenceDataProperty): void {
+        this.combinedSchema.properties[key].default = property.default;
+        this.combinedSchema.properties[key].defaultValue = property.defaultValue;
+        if (this.workspaceSchema.properties[key]) {
+            this.workspaceSchema.properties[key].default = property.default;
+            this.workspaceSchema.properties[key].defaultValue = property.defaultValue;
+        }
+        if (this.folderSchema.properties[key]) {
+            this.folderSchema.properties[key].default = property.default;
+            this.folderSchema.properties[key].defaultValue = property.defaultValue;
+        }
+    }
+
     protected removePropFromSchemas(key: string): void {
         // If we remove a key from combined, it should also be removed from all narrower scopes.
         delete this.combinedSchema.properties[key];

package/src/browser/saveable.ts

@@ -16,13 +16,13 @@
 
 import { Widget } from '@phosphor/widgets';
 import { Message } from '@phosphor/messaging';
-import { Event } from '../common/event';
+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 { isObject } from '../common';
+import { Disposable, isObject } from '../common';
 
 export interface Saveable {
     readonly dirty: boolean;
@@ -50,6 +50,45 @@ export interface SaveableSource {
     readonly saveable: Saveable;
 }
 
+export class SaveableDelegate implements Saveable {
+    dirty = false;
+    protected readonly onDirtyChangedEmitter = new Emitter<void>();
+
+    get onDirtyChanged(): Event<void> {
+        return this.onDirtyChangedEmitter.event;
+    }
+    autoSave: 'off' | 'afterDelay' | 'onFocusChange' | 'onWindowChange' = 'off';
+
+    async save(options?: SaveOptions): Promise<void> {
+        await this.delegate?.save(options);
+    }
+
+    revert?(options?: Saveable.RevertOptions): Promise<void>;
+    createSnapshot?(): Saveable.Snapshot;
+    applySnapshot?(snapshot: object): void;
+
+    protected delegate?: Saveable;
+    protected toDispose?: Disposable;
+
+    set(delegate: Saveable): void {
+        this.toDispose?.dispose();
+        this.delegate = delegate;
+        this.toDispose = this.delegate.onDirtyChanged(() => {
+            this.dirty = delegate.dirty;
+            this.onDirtyChangedEmitter.fire();
+        });
+        this.autoSave = delegate.autoSave;
+        if (this.dirty !== delegate.dirty) {
+            this.dirty = delegate.dirty;
+            this.onDirtyChangedEmitter.fire();
+        }
+        this.revert = delegate.revert?.bind(delegate);
+        this.createSnapshot = delegate.createSnapshot?.bind(delegate);
+        this.applySnapshot = delegate.applySnapshot?.bind(delegate);
+    }
+
+}
+
 export namespace Saveable {
     export interface RevertOptions {
         /**