@theia/core 1.49.1 → 1.50.0

package/lib/node/ws-request-validators.js

@@ -41,13 +41,13 @@ let WsRequestValidator = class WsRequestValidator {
         });
     }
 };
-(0, tslib_1.__decorate)([
+exports.WsRequestValidator = WsRequestValidator;
+tslib_1.__decorate([
     (0, inversify_1.inject)(common_1.ContributionProvider),
     (0, inversify_1.named)(exports.WsRequestValidatorContribution),
-    (0, tslib_1.__metadata)("design:type", Object)
+    tslib_1.__metadata("design:type", Object)
 ], WsRequestValidator.prototype, "requestValidators", void 0);
-WsRequestValidator = (0, tslib_1.__decorate)([
+exports.WsRequestValidator = WsRequestValidator = tslib_1.__decorate([
     (0, inversify_1.injectable)()
 ], WsRequestValidator);
-exports.WsRequestValidator = WsRequestValidator;
 //# sourceMappingURL=ws-request-validators.js.map

package/lib/node/ws-request-validators.js.map

@@ -1 +1 @@
-{"version":3,"file":"ws-request-validators.js","sourceRoot":"","sources":["../../src/node/ws-request-validators.ts"],"names":[],"mappings":";AAAA,gFAAgF;AAChF,0CAA0C;AAC1C,EAAE;AACF,2EAA2E;AAC3E,mEAAmE;AACnE,wCAAwC;AACxC,EAAE;AACF,4EAA4E;AAC5E,8EAA8E;AAC9E,6EAA6E;AAC7E,yDAAyD;AACzD,uDAAuD;AACvD,EAAE;AACF,gFAAgF;AAChF,gFAAgF;;;;AAEhF,yCAAsD;AAEtD,sCAA+D;AAE/D;;GAEG;AACU,QAAA,8BAA8B,GAAG,MAAM,CAAC,8BAA8B,CAAC,CAAC;AAUrF;;GAEG;AAEH,IAAa,kBAAkB,GAA/B,MAAa,kBAAkB;IAK3B;;OAEG;IACH,KAAK,CAAC,cAAc,CAAC,OAA6B;QAC9C,OAAO,IAAI,OAAO,CAAC,KAAK,EAAC,OAAO,EAAC,EAAE;YAC/B,MAAM,OAAO,CAAC,GAAG,CAAC,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,iBAAiB,CAAC,gBAAgB,EAAE,EAAE,KAAK,EAAC,SAAS,EAAC,EAAE;gBACtF,IAAI,CAAC,MAAM,SAAS,CAAC,cAAc,CAAC,OAAO,CAAC,EAAE;oBAC1C,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,wBAAwB;iBAC3C;YACL,CAAC,CAAC,CAAC,CAAC;YACJ,OAAO,CAAC,IAAI,CAAC,CAAC;QAClB,CAAC,CAAC,CAAC;IACP,CAAC;CACJ,CAAA;AAfG;IADC,IAAA,kBAAM,EAAC,6BAAoB,CAAC;IAAE,IAAA,iBAAK,EAAC,sCAA8B,CAAC;;6DACuB;AAHlF,kBAAkB;IAD9B,IAAA,sBAAU,GAAE;GACA,kBAAkB,CAkB9B;AAlBY,gDAAkB"}
+{"version":3,"file":"ws-request-validators.js","sourceRoot":"","sources":["../../src/node/ws-request-validators.ts"],"names":[],"mappings":";AAAA,gFAAgF;AAChF,0CAA0C;AAC1C,EAAE;AACF,2EAA2E;AAC3E,mEAAmE;AACnE,wCAAwC;AACxC,EAAE;AACF,4EAA4E;AAC5E,8EAA8E;AAC9E,6EAA6E;AAC7E,yDAAyD;AACzD,uDAAuD;AACvD,EAAE;AACF,gFAAgF;AAChF,gFAAgF;;;;AAEhF,yCAAsD;AAEtD,sCAA+D;AAE/D;;GAEG;AACU,QAAA,8BAA8B,GAAG,MAAM,CAAC,8BAA8B,CAAC,CAAC;AAUrF;;GAEG;AAEI,IAAM,kBAAkB,GAAxB,MAAM,kBAAkB;IAK3B;;OAEG;IACH,KAAK,CAAC,cAAc,CAAC,OAA6B;QAC9C,OAAO,IAAI,OAAO,CAAC,KAAK,EAAC,OAAO,EAAC,EAAE;YAC/B,MAAM,OAAO,CAAC,GAAG,CAAC,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,iBAAiB,CAAC,gBAAgB,EAAE,EAAE,KAAK,EAAC,SAAS,EAAC,EAAE;gBACtF,IAAI,CAAC,MAAM,SAAS,CAAC,cAAc,CAAC,OAAO,CAAC,EAAE,CAAC;oBAC3C,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,wBAAwB;gBAC5C,CAAC;YACL,CAAC,CAAC,CAAC,CAAC;YACJ,OAAO,CAAC,IAAI,CAAC,CAAC;QAClB,CAAC,CAAC,CAAC;IACP,CAAC;CACJ,CAAA;AAlBY,gDAAkB;AAGR;IADlB,IAAA,kBAAM,EAAC,6BAAoB,CAAC;IAAE,IAAA,iBAAK,EAAC,sCAA8B,CAAC;;6DACuB;6BAHlF,kBAAkB;IAD9B,IAAA,sBAAU,GAAE;GACA,kBAAkB,CAkB9B"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@theia/core",
-  "version": "1.49.1",
+  "version": "1.50.0",
   "description": "Theia is a cloud & desktop IDE framework implemented in TypeScript.",
   "main": "lib/common/index.js",
   "typings": "lib/common/index.d.ts",
@@ -16,8 +16,8 @@
     "@phosphor/signaling": "1",
     "@phosphor/virtualdom": "1",
     "@phosphor/widgets": "1",
-    "@theia/application-package": "1.49.1",
-    "@theia/request": "1.49.1",
+    "@theia/application-package": "1.50.0",
+    "@theia/request": "1.50.0",
     "@types/body-parser": "^1.16.4",
     "@types/cookie": "^0.3.3",
     "@types/dompurify": "^2.2.2",
@@ -56,7 +56,7 @@
     "lodash.debounce": "^4.0.8",
     "lodash.throttle": "^4.1.1",
     "markdown-it": "^12.3.2",
-    "msgpackr": "^1.10.1",
+    "msgpackr": "^1.10.2",
     "nsfw": "^2.2.4",
     "p-debounce": "^2.1.0",
     "perfect-scrollbar": "^1.3.0",
@@ -152,6 +152,9 @@
       "frontend": "lib/browser/window/browser-window-module",
       "frontendElectron": "lib/electron-browser/window/electron-window-module"
     },
+    {
+      "backendElectron": "lib/electron-node/cli/electron-backend-cli-module"
+    },
     {
       "frontend": "lib/browser/keyboard/browser-keyboard-module",
       "frontendElectron": "lib/electron-browser/keyboard/electron-keyboard-module",
@@ -206,12 +209,12 @@
     "watch": "theiaext watch"
   },
   "devDependencies": {
-    "@theia/ext-scripts": "1.49.1",
-    "@theia/re-exports": "1.49.1",
+    "@theia/ext-scripts": "1.50.0",
+    "@theia/re-exports": "1.50.0",
     "minimist": "^1.2.0"
   },
   "nyc": {
     "extends": "../../configs/nyc.json"
   },
-  "gitHead": "5bab04a50e95f7515a4d276fce963bef0e89db28"
+  "gitHead": "63585530b2e32af0ed4bac4edb5ff443bfc248b7"
 }

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

@@ -62,7 +62,7 @@ import { WindowService } from './window/window-service';
 import { FrontendApplicationConfigProvider } from './frontend-application-config-provider';
 import { DecorationStyle } from './decoration-style';
 import { isPinned, Title, togglePinned, Widget } from './widgets';
-import { SaveResourceService } from './save-resource-service';
+import { SaveableService } from './saveable-service';
 import { UserWorkingDirectoryProvider } from './user-working-directory-provider';
 import { UNTITLED_SCHEME, UntitledResourceResolver } from '../common';
 import { LanguageQuickPickService } from './i18n/language-quick-pick-service';
@@ -385,7 +385,7 @@ export class CommonFrontendContribution implements FrontendApplicationContributi
         @inject(OpenerService) protected readonly openerService: OpenerService,
         @inject(AboutDialog) protected readonly aboutDialog: AboutDialog,
         @inject(AsyncLocalizationProvider) protected readonly localizationProvider: AsyncLocalizationProvider,
-        @inject(SaveResourceService) protected readonly saveResourceService: SaveResourceService,
+        @inject(SaveableService) protected readonly saveResourceService: SaveableService,
     ) { }
 
     @inject(ContextKeyService)
@@ -1408,7 +1408,7 @@ export class CommonFrontendContribution implements FrontendApplicationContributi
         const items = [...itemsByTheme.light, ...itemsByTheme.dark, ...itemsByTheme.hc, ...itemsByTheme.hcLight];
         this.quickInputService?.showQuickPick(items,
             {
-                placeholder: nls.localizeByDefault('Select Color Theme (Up/Down Keys to Preview)'),
+                placeholder: nls.localizeByDefault('Select Color Theme'),
                 activeItem: items.find(item => item.id === resetTo),
                 onDidChangeSelection: (_, selectedItems) => {
                     resetTo = undefined;

package/src/browser/core-preferences.ts

@@ -216,7 +216,7 @@ export const corePreferenceSchema: PreferenceSchema = {
             enum: ['dark', 'light', 'hc-theia'],
             enumItemLabels: ['Dark (Theia)', 'Light (Theia)', 'High Contrast (Theia)'],
             default: DefaultTheme.defaultForOSTheme(FrontendApplicationConfigProvider.get().defaultTheme),
-            description: nls.localizeByDefault('Specifies the color theme used in the workbench.')
+            description: nls.localizeByDefault('Specifies the color theme used in the workbench when {0} is not enabled.', '`#window.autoDetectColorScheme#`')
         },
         'workbench.iconTheme': {
             type: ['string'],

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

@@ -126,7 +126,7 @@ import { DockPanel, RendererHost } from './widgets';
 import { TooltipService, TooltipServiceImpl } from './tooltip-service';
 import { BackendRequestService, RequestService, REQUEST_SERVICE_PATH } from '@theia/request';
 import { bindFrontendStopwatch, bindBackendStopwatch } from './performance';
-import { SaveResourceService } from './save-resource-service';
+import { SaveableService } from './saveable-service';
 import { SecondaryWindowHandler } from './secondary-window-handler';
 import { UserWorkingDirectoryProvider } from './user-working-directory-provider';
 import { WindowTitleService } from './window/window-title-service';
@@ -141,6 +141,7 @@ import { AdditionalViewsMenuWidget, AdditionalViewsMenuWidgetFactory } from './s
 import { LanguageIconLabelProvider } from './language-icon-provider';
 import { bindTreePreferences } from './tree';
 import { OpenWithService } from './open-with-service';
+import { ViewColumnService } from './shell/view-column-service';
 
 export { bindResourceProvider, bindMessageService, bindPreferenceService };
 
@@ -449,7 +450,9 @@ export const frontendApplicationModule = new ContainerModule((bind, _unbind, _is
     bindFrontendStopwatch(bind);
     bindBackendStopwatch(bind);
 
-    bind(SaveResourceService).toSelf().inSingletonScope();
+    bind(SaveableService).toSelf().inSingletonScope();
+    bind(FrontendApplicationContribution).toService(SaveableService);
+
     bind(UserWorkingDirectoryProvider).toSelf().inSingletonScope();
     bind(FrontendApplicationContribution).toService(UserWorkingDirectoryProvider);
 
@@ -460,4 +463,6 @@ export const frontendApplicationModule = new ContainerModule((bind, _unbind, _is
     bind(FrontendApplicationContribution).toService(StylingService);
 
     bind(SecondaryWindowHandler).toSelf().inSingletonScope();
+
+    bind(ViewColumnService).toSelf().inSingletonScope();
 });

package/src/browser/index.ts

@@ -46,3 +46,4 @@ export * from './tooltip-service';
 export * from './decoration-style';
 export * from './styling-service';
 export * from './hover-service';
+export * from './saveable-service';

package/src/browser/keybinding.spec.ts

@@ -90,7 +90,8 @@ before(async () => {
         bind(StatusBar).toConstantValue({} as StatusBar);
         bind(MarkdownRendererImpl).toSelf().inSingletonScope();
         bind(MarkdownRenderer).toService(MarkdownRendererImpl);
-        bind(MarkdownRendererFactory).toFactory(({ container }) => container.get(MarkdownRenderer));
+        bind(MarkdownRendererFactory).toFactory(({ container }) => () => container.get(MarkdownRenderer));
+
         bind(CommandService).toService(CommandRegistry);
         bind(LabelParser).toSelf().inSingletonScope();
         bind(ContextKeyService).to(ContextKeyServiceDummyImpl).inSingletonScope();

package/src/browser/messaging/index.ts

@@ -15,3 +15,4 @@
 // *****************************************************************************
 
 export * from './ws-connection-provider';
+export * from './service-connection-provider';

package/src/browser/messaging/ws-connection-provider.ts

@@ -22,7 +22,8 @@ decorate(injectable(), RpcProxyFactory);
 decorate(unmanaged(), RpcProxyFactory, 0);
 
 /**
- * @deprecated This class serves to keep API compatibility for a while. Use {@linkcode ServiceConnectionProvider} instead.
+ * @deprecated This class serves to keep API compatibility for a while.
+ * Use the {@linkcode RemoteConnectionProvider} as the injection symbol and {@linkcode ServiceConnectionProvider} as the type instead.
  */
 @injectable()
 export class WebSocketConnectionProvider {

package/src/browser/saveable-service.ts

@@ -0,0 +1,328 @@
+/********************************************************************************
+ * Copyright (C) 2022 Arm and others.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the Eclipse
+ * Public License v. 2.0 are satisfied: GNU General Public License, version 2
+ * with the GNU Classpath Exception which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
+ ********************************************************************************/
+
+import type { ApplicationShell } from './shell';
+import { injectable } from 'inversify';
+import { UNTITLED_SCHEME, URI, Disposable, DisposableCollection, Emitter, Event } from '../common';
+import { Navigatable, NavigatableWidget } from './navigatable-types';
+import { AutoSaveMode, Saveable, SaveableSource, SaveableWidget, SaveOptions, SaveReason, setDirty, close, PostCreationSaveableWidget, ShouldSaveDialog } from './saveable';
+import { waitForClosed, Widget } from './widgets';
+import { FrontendApplicationContribution } from './frontend-application-contribution';
+import { FrontendApplication } from './frontend-application';
+import throttle = require('lodash.throttle');
+
+@injectable()
+export class SaveableService implements FrontendApplicationContribution {
+
+    protected saveThrottles = new Map<Widget, AutoSaveThrottle>();
+    protected saveMode: AutoSaveMode = 'off';
+    protected saveDelay = 1000;
+    protected shell: ApplicationShell;
+
+    protected readonly onDidAutoSaveChangeEmitter = new Emitter<AutoSaveMode>();
+    protected readonly onDidAutoSaveDelayChangeEmitter = new Emitter<number>();
+
+    get onDidAutoSaveChange(): Event<AutoSaveMode> {
+        return this.onDidAutoSaveChangeEmitter.event;
+    }
+
+    get onDidAutoSaveDelayChange(): Event<number> {
+        return this.onDidAutoSaveDelayChangeEmitter.event;
+    }
+
+    get autoSave(): AutoSaveMode {
+        return this.saveMode;
+    }
+
+    set autoSave(value: AutoSaveMode) {
+        this.updateAutoSaveMode(value);
+    }
+
+    get autoSaveDelay(): number {
+        return this.saveDelay;
+    }
+
+    set autoSaveDelay(value: number) {
+        this.updateAutoSaveDelay(value);
+    }
+
+    onDidInitializeLayout(app: FrontendApplication): void {
+        this.shell = app.shell;
+        // Register restored editors first
+        for (const widget of this.shell.widgets) {
+            const saveable = Saveable.get(widget);
+            if (saveable) {
+                this.registerSaveable(widget, saveable);
+            }
+        }
+        this.shell.onDidAddWidget(e => {
+            const saveable = Saveable.get(e);
+            if (saveable) {
+                this.registerSaveable(e, saveable);
+            }
+        });
+        this.shell.onDidChangeCurrentWidget(e => {
+            if (this.saveMode === 'onFocusChange') {
+                const widget = e.oldValue;
+                const saveable = Saveable.get(widget);
+                if (saveable && widget && this.shouldAutoSave(widget, saveable)) {
+                    saveable.save({
+                        saveReason: SaveReason.FocusChange
+                    });
+                }
+            }
+        });
+        this.shell.onDidRemoveWidget(e => {
+            this.saveThrottles.get(e)?.dispose();
+            this.saveThrottles.delete(e);
+        });
+    }
+
+    protected updateAutoSaveMode(mode: AutoSaveMode): void {
+        this.saveMode = mode;
+        this.onDidAutoSaveChangeEmitter.fire(mode);
+        if (mode === 'onFocusChange') {
+            // If the new mode is onFocusChange, we need to save all dirty documents that are not focused
+            const widgets = this.shell.widgets;
+            for (const widget of widgets) {
+                const saveable = Saveable.get(widget);
+                if (saveable && widget !== this.shell.currentWidget && this.shouldAutoSave(widget, saveable)) {
+                    saveable.save({
+                        saveReason: SaveReason.FocusChange
+                    });
+                }
+            }
+        }
+    }
+
+    protected updateAutoSaveDelay(delay: number): void {
+        this.saveDelay = delay;
+        this.onDidAutoSaveDelayChangeEmitter.fire(delay);
+    }
+
+    registerSaveable(widget: Widget, saveable: Saveable): Disposable {
+        const saveThrottle = new AutoSaveThrottle(
+            saveable,
+            this,
+            () => {
+                if (this.saveMode === 'afterDelay' && this.shouldAutoSave(widget, saveable)) {
+                    saveable.save({
+                        saveReason: SaveReason.AfterDelay
+                    });
+                }
+            },
+            this.addBlurListener(widget, saveable)
+        );
+        this.saveThrottles.set(widget, saveThrottle);
+        this.applySaveableWidget(widget, saveable);
+        return saveThrottle;
+    }
+
+    protected addBlurListener(widget: Widget, saveable: Saveable): Disposable {
+        const document = widget.node.ownerDocument;
+        const listener = (() => {
+            if (this.saveMode === 'onWindowChange' && !this.windowHasFocus(document) && this.shouldAutoSave(widget, saveable)) {
+                saveable.save({
+                    saveReason: SaveReason.FocusChange
+                });
+            }
+        }).bind(this);
+        document.addEventListener('blur', listener);
+        return Disposable.create(() => {
+            document.removeEventListener('blur', listener);
+        });
+    }
+
+    protected windowHasFocus(document: Document): boolean {
+        if (document.visibilityState === 'hidden') {
+            return false;
+        } else if (document.hasFocus()) {
+            return true;
+        }
+        // TODO: Add support for iframes
+        return false;
+    }
+
+    protected shouldAutoSave(widget: Widget, saveable: Saveable): boolean {
+        const uri = NavigatableWidget.getUri(widget);
+        if (uri?.scheme === UNTITLED_SCHEME) {
+            // Never auto-save untitled documents
+            return false;
+        } else {
+            return saveable.dirty;
+        }
+    }
+
+    protected applySaveableWidget(widget: Widget, saveable: Saveable): void {
+        if (SaveableWidget.is(widget)) {
+            return;
+        }
+        const saveableWidget = widget as PostCreationSaveableWidget;
+        setDirty(saveableWidget, saveable.dirty);
+        saveable.onDirtyChanged(() => setDirty(saveableWidget, saveable.dirty));
+        const closeWithSaving = this.createCloseWithSaving();
+        const closeWithoutSaving = () => this.closeWithoutSaving(saveableWidget, false);
+        Object.assign(saveableWidget, {
+            closeWithoutSaving,
+            closeWithSaving,
+            close: closeWithSaving,
+            [close]: saveableWidget.close,
+        });
+    }
+
+    protected createCloseWithSaving(): (this: SaveableWidget, options?: SaveableWidget.CloseOptions) => Promise<void> {
+        let closing = false;
+        const doSave = this.closeWithSaving.bind(this);
+        return async function (this: SaveableWidget, options?: SaveableWidget.CloseOptions): Promise<void> {
+            if (closing) {
+                return;
+            }
+            closing = true;
+            try {
+                await doSave(this, options);
+            } finally {
+                closing = false;
+            }
+        };
+    }
+
+    protected async closeWithSaving(widget: PostCreationSaveableWidget, options?: SaveableWidget.CloseOptions): Promise<void> {
+        const result = await this.shouldSaveWidget(widget, options);
+        if (typeof result === 'boolean') {
+            if (result) {
+                await this.save(widget, {
+                    saveReason: SaveReason.AfterDelay
+                });
+                if (!Saveable.isDirty(widget)) {
+                    await widget.closeWithoutSaving();
+                }
+            } else {
+                await widget.closeWithoutSaving();
+            }
+        }
+    }
+
+    protected async shouldSaveWidget(widget: PostCreationSaveableWidget, options?: SaveableWidget.CloseOptions): Promise<boolean | undefined> {
+        if (!Saveable.isDirty(widget)) {
+            return false;
+        }
+        if (this.autoSave !== 'off') {
+            return true;
+        }
+        const notLastWithDocument = !Saveable.closingWidgetWouldLoseSaveable(widget, Array.from(this.saveThrottles.keys()));
+        if (notLastWithDocument) {
+            return widget.closeWithoutSaving(false).then(() => undefined);
+        }
+        if (options && options.shouldSave) {
+            return options.shouldSave();
+        }
+        return new ShouldSaveDialog(widget).open();
+    }
+
+    protected async closeWithoutSaving(widget: PostCreationSaveableWidget, doRevert: boolean = true): Promise<void> {
+        const saveable = Saveable.get(widget);
+        if (saveable && doRevert && saveable.dirty && saveable.revert) {
+            await saveable.revert();
+        }
+        widget[close]();
+        return waitForClosed(widget);
+    }
+
+    /**
+     * Indicate if the document can be saved ('Save' command should be disable if not).
+     */
+    canSave(widget?: Widget): widget is Widget & (Saveable | SaveableSource) {
+        return Saveable.isDirty(widget) && (this.canSaveNotSaveAs(widget) || this.canSaveAs(widget));
+    }
+
+    canSaveNotSaveAs(widget?: Widget): widget is Widget & (Saveable | SaveableSource) {
+        // By default, we never allow a document to be saved if it is untitled.
+        return Boolean(widget && NavigatableWidget.getUri(widget)?.scheme !== UNTITLED_SCHEME);
+    }
+
+    /**
+     * Saves the document
+     *
+     * No op if the widget is not saveable.
+     */
+    async save(widget: Widget | undefined, options?: SaveOptions): Promise<URI | undefined> {
+        if (this.canSaveNotSaveAs(widget)) {
+            await Saveable.save(widget, options);
+            return NavigatableWidget.getUri(widget);
+        } else if (this.canSaveAs(widget)) {
+            return this.saveAs(widget, options);
+        }
+    }
+
+    canSaveAs(saveable?: Widget): saveable is Widget & SaveableSource & Navigatable {
+        return false;
+    }
+
+    saveAs(sourceWidget: Widget & SaveableSource & Navigatable, options?: SaveOptions): Promise<URI | undefined> {
+        return Promise.reject('Unsupported: The base SaveResourceService does not support saveAs action.');
+    }
+}
+
+export class AutoSaveThrottle implements Disposable {
+
+    private _saveable: Saveable;
+    private _callback: () => void;
+    private _saveService: SaveableService;
+    private _disposable: DisposableCollection;
+    private _throttle?: ReturnType<typeof throttle>;
+
+    constructor(saveable: Saveable, saveService: SaveableService, callback: () => void, ...disposables: Disposable[]) {
+        this._callback = callback;
+        this._saveable = saveable;
+        this._saveService = saveService;
+        this._disposable = new DisposableCollection(
+            ...disposables,
+            saveable.onContentChanged(() => {
+                this.throttledSave();
+            }),
+            saveable.onDirtyChanged(() => {
+                this.throttledSave();
+            }),
+            saveService.onDidAutoSaveChange(() => {
+                this.throttledSave();
+            }),
+            saveService.onDidAutoSaveDelayChange(() => {
+                this.throttledSave(true);
+            })
+        );
+    }
+
+    protected throttledSave(reset = false): void {
+        this._throttle?.cancel();
+        if (reset) {
+            this._throttle = undefined;
+        }
+        if (this._saveService.autoSave === 'afterDelay' && this._saveable.dirty) {
+            if (!this._throttle) {
+                this._throttle = throttle(() => this._callback(), this._saveService.autoSaveDelay, {
+                    leading: false,
+                    trailing: true
+                });
+            }
+            this._throttle();
+        }
+    }
+
+    dispose(): void {
+        this._disposable.dispose();
+    }
+
+}