@codingame/monaco-vscode-api 1.78.4 → 1.78.5

package/dist/vscode/vs/workbench/browser/parts/editor/editorStatus.js

@@ -0,0 +1,460 @@
+import { __decorate, __param } from '../../../../../../node_modules/tslib/tslib.es6.js';
+import "../../../../../../assets/editorstatus.css";
+import { localize } from 'monaco-editor/esm/vs/nls.js';
+import { extname, basename } from 'monaco-editor/esm/vs/base/common/resources.js';
+import { withNullAsUndefined, withUndefinedAsNull, areFunctions } from 'monaco-editor/esm/vs/base/common/types.js';
+import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
+import { Action } from 'monaco-editor/esm/vs/base/common/actions.js';
+import { Language } from 'monaco-editor/esm/vs/base/common/platform.js';
+import { UntitledTextEditorInput } from '../../../services/untitled/common/untitledTextEditorInput.js';
+import { EditorResourceAccessor, SideBySideEditor } from '../../../common/editor.js';
+import { IEditorService } from '../../../services/editor/common/editorService.js';
+import { FILES_ASSOCIATIONS_CONFIG, IFileService } from 'monaco-editor/esm/vs/platform/files/common/files.js';
+import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { ILanguageService } from 'monaco-editor/esm/vs/editor/common/languages/language.js';
+import { ICommandService } from 'monaco-editor/esm/vs/platform/commands/common/commands.js';
+import { IExtensionGalleryService } from '../../../../platform/extensionManagement/common/extensionManagement.js';
+import { ITextFileService } from '../../../services/textfile/common/textfiles.js';
+import { SUPPORTED_ENCODINGS } from '../../../services/textfile/common/encoding.js';
+import { ITextResourceConfigurationService } from 'monaco-editor/esm/vs/editor/common/services/textResourceConfiguration.js';
+import { IConfigurationService } from 'monaco-editor/esm/vs/platform/configuration/common/configuration.js';
+import { deepClone } from 'monaco-editor/esm/vs/base/common/objects.js';
+import { getCodeEditor } from 'monaco-editor/esm/vs/editor/browser/editorBrowser.js';
+import { Schemas } from 'monaco-editor/esm/vs/base/common/network.js';
+import { IPreferencesService } from '../../../services/preferences/common/preferences.js';
+import { IQuickInputService } from 'monaco-editor/esm/vs/platform/quickinput/common/quickInput.js';
+import { getIconClassesForLanguageId } from 'monaco-editor/esm/vs/editor/common/services/getIconClasses.js';
+import { timeout, Promises } from 'monaco-editor/esm/vs/base/common/async.js';
+import { ITelemetryService } from 'monaco-editor/esm/vs/platform/telemetry/common/telemetry.js';
+import { SideBySideEditorInput } from '../../../common/editor/sideBySideEditorInput.js';
+import { ILanguageDetectionService, AutomaticLanguageDetectionLikelyWrongId } from '../../../services/languageDetection/common/languageDetectionWorkerService.js';
+import { ContextKeyExpr } from 'monaco-editor/esm/vs/platform/contextkey/common/contextkey.js';
+import { Action2 } from 'monaco-editor/esm/vs/platform/actions/common/actions.js';
+import { KeyChord } from 'monaco-editor/esm/vs/base/common/keyCodes.js';
+class SideBySideEditorEncodingSupport {
+    constructor(primary, secondary) {
+        this.primary = primary;
+        this.secondary = secondary;
+    }
+    getEncoding() {
+        return this.primary.getEncoding();
+    }
+    async setEncoding(encoding, mode) {
+        await Promises.settled(( [this.primary, this.secondary].map(editor => editor.setEncoding(encoding, mode))));
+    }
+}
+class SideBySideEditorLanguageSupport {
+    constructor(primary, secondary) {
+        this.primary = primary;
+        this.secondary = secondary;
+    }
+    setLanguageId(languageId, source) {
+        [this.primary, this.secondary].forEach(editor => editor.setLanguageId(languageId, source));
+    }
+}
+function toEditorWithEncodingSupport(input) {
+    if (input instanceof UntitledTextEditorInput) {
+        return input;
+    }
+    if (input instanceof SideBySideEditorInput) {
+        const primaryEncodingSupport = toEditorWithEncodingSupport(input.primary);
+        const secondaryEncodingSupport = toEditorWithEncodingSupport(input.secondary);
+        if (primaryEncodingSupport && secondaryEncodingSupport) {
+            return ( new SideBySideEditorEncodingSupport(primaryEncodingSupport, secondaryEncodingSupport));
+        }
+        return primaryEncodingSupport;
+    }
+    const encodingSupport = input;
+    if (areFunctions(encodingSupport.setEncoding, encodingSupport.getEncoding)) {
+        return encodingSupport;
+    }
+    return null;
+}
+function toEditorWithLanguageSupport(input) {
+    if (input instanceof UntitledTextEditorInput) {
+        return input;
+    }
+    if (input instanceof SideBySideEditorInput) {
+        const primaryLanguageSupport = toEditorWithLanguageSupport(input.primary);
+        const secondaryLanguageSupport = toEditorWithLanguageSupport(input.secondary);
+        if (primaryLanguageSupport && secondaryLanguageSupport) {
+            return ( new SideBySideEditorLanguageSupport(primaryLanguageSupport, secondaryLanguageSupport));
+        }
+        return primaryLanguageSupport;
+    }
+    const languageSupport = input;
+    if (typeof languageSupport.setLanguageId === 'function') {
+        return languageSupport;
+    }
+    return null;
+}
+const nlsEOLLF = ( localize('endOfLineLineFeed', "LF"));
+const nlsEOLCRLF = ( localize('endOfLineCarriageReturnLineFeed', "CRLF"));
+let ShowLanguageExtensionsAction = class ShowLanguageExtensionsAction extends Action {
+    constructor(fileExtension, commandService, galleryService) {
+        super(ShowLanguageExtensionsAction.ID, ( localize(
+            'showLanguageExtensions',
+            "Search Marketplace Extensions for '{0}'...",
+            fileExtension
+        )));
+        this.fileExtension = fileExtension;
+        this.commandService = commandService;
+        this.enabled = galleryService.isEnabled();
+    }
+    async run() {
+        await this.commandService.executeCommand('workbench.extensions.action.showExtensionsForLanguage', this.fileExtension);
+    }
+};
+ShowLanguageExtensionsAction.ID = 'workbench.action.showLanguageExtensions';
+ShowLanguageExtensionsAction = ( __decorate([
+    ( __param(1, ICommandService)),
+    ( __param(2, IExtensionGalleryService))
+], ShowLanguageExtensionsAction));
+class ChangeLanguageAction extends Action2 {
+    constructor() {
+        super({
+            id: ChangeLanguageAction.ID,
+            title: { value: ( localize('changeMode', "Change Language Mode")), original: 'Change Language Mode' },
+            f1: true,
+            keybinding: {
+                weight: 200 ,
+                primary: KeyChord(2048  | 41 , 43 )
+            },
+            precondition: ContextKeyExpr.not('notebookEditorFocused')
+        });
+    }
+    async run(accessor) {
+        const quickInputService = accessor.get(IQuickInputService);
+        const editorService = accessor.get(IEditorService);
+        const languageService = accessor.get(ILanguageService);
+        const languageDetectionService = accessor.get(ILanguageDetectionService);
+        const textFileService = accessor.get(ITextFileService);
+        const preferencesService = accessor.get(IPreferencesService);
+        const instantiationService = accessor.get(IInstantiationService);
+        const configurationService = accessor.get(IConfigurationService);
+        const telemetryService = accessor.get(ITelemetryService);
+        const activeTextEditorControl = getCodeEditor(editorService.activeTextEditorControl);
+        if (!activeTextEditorControl) {
+            await quickInputService.pick([{ label: ( localize('noEditor', "No text editor active at this time")) }]);
+            return;
+        }
+        const textModel = activeTextEditorControl.getModel();
+        const resource = EditorResourceAccessor.getOriginalUri(editorService.activeEditor, { supportSideBySide: SideBySideEditor.PRIMARY });
+        let currentLanguageName;
+        let currentLanguageId;
+        if (textModel) {
+            currentLanguageId = textModel.getLanguageId();
+            currentLanguageName = withNullAsUndefined(languageService.getLanguageName(currentLanguageId));
+        }
+        let hasLanguageSupport = !!resource;
+        if (resource?.scheme === Schemas.untitled && !textFileService.untitled.get(resource)?.hasAssociatedFilePath) {
+            hasLanguageSupport = false;
+        }
+        const languages = languageService.getSortedRegisteredLanguageNames();
+        const picks = ( languages
+            .map(({ languageName, languageId }) => {
+            const extensions = languageService.getExtensions(languageId).join(' ');
+            let description;
+            if (currentLanguageName === languageName) {
+                description = ( localize('languageDescription', "({0}) - Configured Language", languageId));
+            }
+            else {
+                description = ( localize('languageDescriptionConfigured', "({0})", languageId));
+            }
+            return {
+                label: languageName,
+                meta: extensions,
+                iconClasses: getIconClassesForLanguageId(languageId),
+                description
+            };
+        }));
+        picks.unshift({ type: 'separator', label: ( localize('languagesPicks', "languages (identifier)")) });
+        let configureLanguageAssociations;
+        let configureLanguageSettings;
+        let galleryAction;
+        if (hasLanguageSupport && resource) {
+            const ext = extname(resource) || basename(resource);
+            galleryAction = instantiationService.createInstance(ShowLanguageExtensionsAction, ext);
+            if (galleryAction.enabled) {
+                picks.unshift(galleryAction);
+            }
+            configureLanguageSettings = { label: ( localize(
+                'configureModeSettings',
+                "Configure '{0}' language based settings...",
+                currentLanguageName
+            )) };
+            picks.unshift(configureLanguageSettings);
+            configureLanguageAssociations = { label: ( localize('configureAssociationsExt', "Configure File Association for '{0}'...", ext)) };
+            picks.unshift(configureLanguageAssociations);
+        }
+        const autoDetectLanguage = {
+            label: ( localize('autoDetect', "Auto Detect"))
+        };
+        picks.unshift(autoDetectLanguage);
+        const pick = await quickInputService.pick(picks, { placeHolder: ( localize('pickLanguage', "Select Language Mode")), matchOnDescription: true });
+        if (!pick) {
+            return;
+        }
+        if (pick === galleryAction) {
+            galleryAction.run();
+            return;
+        }
+        if (pick === configureLanguageAssociations) {
+            if (resource) {
+                this.configureFileAssociation(resource, languageService, quickInputService, configurationService);
+            }
+            return;
+        }
+        if (pick === configureLanguageSettings) {
+            preferencesService.openUserSettings({ jsonEditor: true, revealSetting: { key: `[${withUndefinedAsNull(currentLanguageId)}]`, edit: true } });
+            return;
+        }
+        const activeEditor = editorService.activeEditor;
+        if (activeEditor) {
+            const languageSupport = toEditorWithLanguageSupport(activeEditor);
+            if (languageSupport) {
+                let languageSelection;
+                let detectedLanguage;
+                if (pick === autoDetectLanguage) {
+                    if (textModel) {
+                        const resource = EditorResourceAccessor.getOriginalUri(activeEditor, { supportSideBySide: SideBySideEditor.PRIMARY });
+                        if (resource) {
+                            let languageId = withNullAsUndefined(languageService.guessLanguageIdByFilepathOrFirstLine(resource, textModel.getLineContent(1)));
+                            if (!languageId || languageId === 'unknown') {
+                                detectedLanguage = await languageDetectionService.detectLanguage(resource);
+                                languageId = detectedLanguage;
+                            }
+                            if (languageId) {
+                                languageSelection = languageService.createById(languageId);
+                            }
+                        }
+                    }
+                }
+                else {
+                    const languageId = languageService.getLanguageIdByLanguageName(pick.label);
+                    languageSelection = languageService.createById(languageId);
+                    if (resource) {
+                        languageDetectionService.detectLanguage(resource).then(detectedLanguageId => {
+                            const chosenLanguageId = languageService.getLanguageIdByLanguageName(pick.label) || 'unknown';
+                            if (detectedLanguageId === currentLanguageId && currentLanguageId !== chosenLanguageId) {
+                                const modelPreference = configurationService.getValue('workbench.editor.preferHistoryBasedLanguageDetection') ? 'history' : 'classic';
+                                telemetryService.publicLog2(AutomaticLanguageDetectionLikelyWrongId, {
+                                    currentLanguageId: currentLanguageName ?? 'unknown',
+                                    nextLanguageId: pick.label,
+                                    lineCount: textModel?.getLineCount() ?? -1,
+                                    modelPreference,
+                                });
+                            }
+                        });
+                    }
+                }
+                if (typeof languageSelection !== 'undefined') {
+                    languageSupport.setLanguageId(languageSelection.languageId, ChangeLanguageAction.ID);
+                    if (resource?.scheme === Schemas.untitled) {
+                        const modelPreference = configurationService.getValue('workbench.editor.preferHistoryBasedLanguageDetection') ? 'history' : 'classic';
+                        telemetryService.publicLog2('setUntitledDocumentLanguage', {
+                            to: languageSelection.languageId,
+                            from: currentLanguageId ?? 'none',
+                            modelPreference,
+                        });
+                    }
+                }
+            }
+            activeTextEditorControl.focus();
+        }
+    }
+    configureFileAssociation(resource, languageService, quickInputService, configurationService) {
+        const extension = extname(resource);
+        const base = basename(resource);
+        const currentAssociation = languageService.guessLanguageIdByFilepathOrFirstLine(URI.file(base));
+        const languages = languageService.getSortedRegisteredLanguageNames();
+        const picks = ( languages.map(({ languageName, languageId }) => {
+            return {
+                id: languageId,
+                label: languageName,
+                iconClasses: getIconClassesForLanguageId(languageId),
+                description: (languageId === currentAssociation) ? ( localize('currentAssociation', "Current Association")) : undefined
+            };
+        }));
+        setTimeout(async () => {
+            const language = await quickInputService.pick(picks, { placeHolder: ( localize(
+                'pickLanguageToConfigure',
+                "Select Language Mode to Associate with '{0}'",
+                extension || base
+            )) });
+            if (language) {
+                const fileAssociationsConfig = configurationService.inspect(FILES_ASSOCIATIONS_CONFIG);
+                let associationKey;
+                if (extension && base[0] !== '.') {
+                    associationKey = `*${extension}`;
+                }
+                else {
+                    associationKey = base;
+                }
+                let target = 2 ;
+                if (fileAssociationsConfig.workspaceValue && !!fileAssociationsConfig.workspaceValue[associationKey]) {
+                    target = 5 ;
+                }
+                const currentAssociations = deepClone(((target === 5) ) ? fileAssociationsConfig.workspaceValue : fileAssociationsConfig.userValue) || Object.create(null);
+                currentAssociations[associationKey] = language.id;
+                configurationService.updateValue(FILES_ASSOCIATIONS_CONFIG, currentAssociations, target);
+            }
+        }, 50 );
+    }
+}
+ChangeLanguageAction.ID = 'workbench.action.editor.changeLanguageMode';
+class ChangeEOLAction extends Action2 {
+    constructor() {
+        super({
+            id: 'workbench.action.editor.changeEOL',
+            title: { value: ( localize('changeEndOfLine', "Change End of Line Sequence")), original: 'Change End of Line Sequence' },
+            f1: true
+        });
+    }
+    async run(accessor) {
+        const editorService = accessor.get(IEditorService);
+        const quickInputService = accessor.get(IQuickInputService);
+        const activeTextEditorControl = getCodeEditor(editorService.activeTextEditorControl);
+        if (!activeTextEditorControl) {
+            await quickInputService.pick([{ label: ( localize('noEditor', "No text editor active at this time")) }]);
+            return;
+        }
+        if (editorService.activeEditor?.hasCapability(2 )) {
+            await quickInputService.pick([{ label: ( localize('noWritableCodeEditor', "The active code editor is read-only.")) }]);
+            return;
+        }
+        let textModel = activeTextEditorControl.getModel();
+        const EOLOptions = [
+            { label: nlsEOLLF, eol: 0  },
+            { label: nlsEOLCRLF, eol: 1  },
+        ];
+        const selectedIndex = (textModel?.getEOL() === '\n') ? 0 : 1;
+        const eol = await quickInputService.pick(EOLOptions, { placeHolder: ( localize('pickEndOfLine', "Select End of Line Sequence")), activeItem: EOLOptions[selectedIndex] });
+        if (eol) {
+            const activeCodeEditor = getCodeEditor(editorService.activeTextEditorControl);
+            if (activeCodeEditor?.hasModel() && !editorService.activeEditor?.hasCapability(2 )) {
+                textModel = activeCodeEditor.getModel();
+                textModel.pushStackElement();
+                textModel.pushEOL(eol.eol);
+                textModel.pushStackElement();
+            }
+        }
+        activeTextEditorControl.focus();
+    }
+}
+class ChangeEncodingAction extends Action2 {
+    constructor() {
+        super({
+            id: 'workbench.action.editor.changeEncoding',
+            title: { value: ( localize('changeEncoding', "Change File Encoding")), original: 'Change File Encoding' },
+            f1: true
+        });
+    }
+    async run(accessor) {
+        const editorService = accessor.get(IEditorService);
+        const quickInputService = accessor.get(IQuickInputService);
+        const fileService = accessor.get(IFileService);
+        const textFileService = accessor.get(ITextFileService);
+        const textResourceConfigurationService = accessor.get(ITextResourceConfigurationService);
+        const activeTextEditorControl = getCodeEditor(editorService.activeTextEditorControl);
+        if (!activeTextEditorControl) {
+            await quickInputService.pick([{ label: ( localize('noEditor', "No text editor active at this time")) }]);
+            return;
+        }
+        const activeEditorPane = editorService.activeEditorPane;
+        if (!activeEditorPane) {
+            await quickInputService.pick([{ label: ( localize('noEditor', "No text editor active at this time")) }]);
+            return;
+        }
+        const encodingSupport = toEditorWithEncodingSupport(activeEditorPane.input);
+        if (!encodingSupport) {
+            await quickInputService.pick([{ label: ( localize('noFileEditor', "No file active at this time")) }]);
+            return;
+        }
+        const saveWithEncodingPick = { label: ( localize('saveWithEncoding', "Save with Encoding")) };
+        const reopenWithEncodingPick = { label: ( localize('reopenWithEncoding', "Reopen with Encoding")) };
+        if (!Language.isDefaultVariant()) {
+            const saveWithEncodingAlias = 'Save with Encoding';
+            if (saveWithEncodingAlias !== saveWithEncodingPick.label) {
+                saveWithEncodingPick.detail = saveWithEncodingAlias;
+            }
+            const reopenWithEncodingAlias = 'Reopen with Encoding';
+            if (reopenWithEncodingAlias !== reopenWithEncodingPick.label) {
+                reopenWithEncodingPick.detail = reopenWithEncodingAlias;
+            }
+        }
+        let action;
+        if (encodingSupport instanceof UntitledTextEditorInput) {
+            action = saveWithEncodingPick;
+        }
+        else if (activeEditorPane.input.hasCapability(2 )) {
+            action = reopenWithEncodingPick;
+        }
+        else {
+            action = await quickInputService.pick([reopenWithEncodingPick, saveWithEncodingPick], { placeHolder: ( localize('pickAction', "Select Action")), matchOnDetail: true });
+        }
+        if (!action) {
+            return;
+        }
+        await timeout(50);
+        const resource = EditorResourceAccessor.getOriginalUri(activeEditorPane.input, { supportSideBySide: SideBySideEditor.PRIMARY });
+        if (!resource || (!fileService.hasProvider(resource) && resource.scheme !== Schemas.untitled)) {
+            return;
+        }
+        let guessedEncoding = undefined;
+        if (fileService.hasProvider(resource)) {
+            const content = await textFileService.readStream(resource, { autoGuessEncoding: true });
+            guessedEncoding = content.encoding;
+        }
+        const isReopenWithEncoding = (action === reopenWithEncodingPick);
+        const configuredEncoding = textResourceConfigurationService.getValue(withNullAsUndefined(resource), 'files.encoding');
+        let directMatchIndex;
+        let aliasMatchIndex;
+        const picks = ( ( Object.keys(SUPPORTED_ENCODINGS))
+            .sort((k1, k2) => {
+            if (k1 === configuredEncoding) {
+                return -1;
+            }
+            else if (k2 === configuredEncoding) {
+                return 1;
+            }
+            return SUPPORTED_ENCODINGS[k1].order - SUPPORTED_ENCODINGS[k2].order;
+        })
+            .filter(k => {
+            if (k === guessedEncoding && guessedEncoding !== configuredEncoding) {
+                return false;
+            }
+            return !isReopenWithEncoding || !SUPPORTED_ENCODINGS[k].encodeOnly;
+        })
+            .map((key, index) => {
+            if (key === encodingSupport.getEncoding()) {
+                directMatchIndex = index;
+            }
+            else if (SUPPORTED_ENCODINGS[key].alias === encodingSupport.getEncoding()) {
+                aliasMatchIndex = index;
+            }
+            return { id: key, label: SUPPORTED_ENCODINGS[key].labelLong, description: key };
+        }));
+        const items = picks.slice();
+        if (guessedEncoding && configuredEncoding !== guessedEncoding && SUPPORTED_ENCODINGS[guessedEncoding]) {
+            picks.unshift({ type: 'separator' });
+            picks.unshift({ id: guessedEncoding, label: SUPPORTED_ENCODINGS[guessedEncoding].labelLong, description: ( localize('guessedEncoding', "Guessed from content")) });
+        }
+        const encoding = await quickInputService.pick(picks, {
+            placeHolder: isReopenWithEncoding ? ( localize('pickEncodingForReopen', "Select File Encoding to Reopen File")) : ( localize('pickEncodingForSave', "Select File Encoding to Save with")),
+            activeItem: items[typeof directMatchIndex === 'number' ? directMatchIndex : typeof aliasMatchIndex === 'number' ? aliasMatchIndex : -1]
+        });
+        if (!encoding) {
+            return;
+        }
+        if (!editorService.activeEditorPane) {
+            return;
+        }
+        const activeEncodingSupport = toEditorWithEncodingSupport(editorService.activeEditorPane.input);
+        if (typeof encoding.id !== 'undefined' && activeEncodingSupport) {
+            await activeEncodingSupport.setEncoding(encoding.id, isReopenWithEncoding ? 1  : 0 );
+        }
+        activeTextEditorControl.focus();
+    }
+}
+export { ChangeEOLAction, ChangeEncodingAction, ChangeLanguageAction, ShowLanguageExtensionsAction };

package/dist/vscode/vs/workbench/browser/parts/editor/editorWithViewState.js

@@ -0,0 +1,139 @@
+import { __decorate, __param } from '../../../../../../node_modules/tslib/tslib.es6.js';
+import { Event } from 'monaco-editor/esm/vs/base/common/event.js';
+import { EditorResourceAccessor, SideBySideEditor } from '../../../common/editor.js';
+import { EditorPane } from './editorPane.js';
+import { IStorageService } from 'monaco-editor/esm/vs/platform/storage/common/storage.js';
+import { IInstantiationService } from 'monaco-editor/esm/vs/platform/instantiation/common/instantiation.js';
+import { ITelemetryService } from 'monaco-editor/esm/vs/platform/telemetry/common/telemetry.js';
+import { IThemeService } from 'monaco-editor/esm/vs/platform/theme/common/themeService.js';
+import { ITextResourceConfigurationService } from 'monaco-editor/esm/vs/editor/common/services/textResourceConfiguration.js';
+import { IEditorGroupsService } from '../../../services/editor/common/editorGroupsService.js';
+import { IEditorService } from '../../../services/editor/common/editorService.js';
+import { MutableDisposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+let AbstractEditorWithViewState = class AbstractEditorWithViewState extends EditorPane {
+    constructor(id, viewStateStorageKey, telemetryService, instantiationService, storageService, textResourceConfigurationService, themeService, editorService, editorGroupService) {
+        super(id, telemetryService, themeService, storageService);
+        this.instantiationService = instantiationService;
+        this.textResourceConfigurationService = textResourceConfigurationService;
+        this.editorService = editorService;
+        this.editorGroupService = editorGroupService;
+        this.groupListener = this._register(( new MutableDisposable()));
+        this.viewState = this.getEditorMemento(editorGroupService, textResourceConfigurationService, viewStateStorageKey, 100);
+    }
+    setEditorVisible(visible, group) {
+        this.groupListener.value = group?.onWillCloseEditor(e => this.onWillCloseEditor(e));
+        super.setEditorVisible(visible, group);
+    }
+    onWillCloseEditor(e) {
+        const editor = e.editor;
+        if (editor === this.input) {
+            this.updateEditorViewState(editor);
+        }
+    }
+    clearInput() {
+        this.updateEditorViewState(this.input);
+        super.clearInput();
+    }
+    saveState() {
+        this.updateEditorViewState(this.input);
+        super.saveState();
+    }
+    updateEditorViewState(input) {
+        if (!input || !this.tracksEditorViewState(input)) {
+            return;
+        }
+        const resource = this.toEditorViewStateResource(input);
+        if (!resource) {
+            return;
+        }
+        if (!this.tracksDisposedEditorViewState()) {
+            if (!this.editorViewStateDisposables) {
+                this.editorViewStateDisposables = ( new Map());
+            }
+            if (!this.editorViewStateDisposables.has(input)) {
+                this.editorViewStateDisposables.set(input, Event.once(input.onWillDispose)(() => {
+                    this.clearEditorViewState(resource, this.group);
+                    this.editorViewStateDisposables?.delete(input);
+                }));
+            }
+        }
+        if ((input.isDisposed() && !this.tracksDisposedEditorViewState()) ||
+            (!this.shouldRestoreEditorViewState(input) && (!this.group || !this.group.contains(input)))) {
+            this.clearEditorViewState(resource, this.group);
+        }
+        else if (!input.isDisposed()) {
+            this.saveEditorViewState(resource);
+        }
+    }
+    shouldRestoreEditorViewState(input, context) {
+        if (context?.newInGroup) {
+            return this.textResourceConfigurationService.getValue(EditorResourceAccessor.getOriginalUri(input, { supportSideBySide: SideBySideEditor.PRIMARY }), 'workbench.editor.restoreViewState') === false ? false : true ;
+        }
+        return true;
+    }
+    getViewState() {
+        const input = this.input;
+        if (!input || !this.tracksEditorViewState(input)) {
+            return;
+        }
+        const resource = this.toEditorViewStateResource(input);
+        if (!resource) {
+            return;
+        }
+        return this.computeEditorViewState(resource);
+    }
+    saveEditorViewState(resource) {
+        if (!this.group) {
+            return;
+        }
+        const editorViewState = this.computeEditorViewState(resource);
+        if (!editorViewState) {
+            return;
+        }
+        this.viewState.saveEditorState(this.group, resource, editorViewState);
+    }
+    loadEditorViewState(input, context) {
+        if (!input || !this.group) {
+            return undefined;
+        }
+        if (!this.tracksEditorViewState(input)) {
+            return undefined;
+        }
+        if (!this.shouldRestoreEditorViewState(input, context)) {
+            return undefined;
+        }
+        const resource = this.toEditorViewStateResource(input);
+        if (!resource) {
+            return;
+        }
+        return this.viewState.loadEditorState(this.group, resource);
+    }
+    moveEditorViewState(source, target, comparer) {
+        return this.viewState.moveEditorState(source, target, comparer);
+    }
+    clearEditorViewState(resource, group) {
+        this.viewState.clearEditorState(resource, group);
+    }
+    dispose() {
+        super.dispose();
+        if (this.editorViewStateDisposables) {
+            for (const [, disposables] of this.editorViewStateDisposables) {
+                disposables.dispose();
+            }
+            this.editorViewStateDisposables = undefined;
+        }
+    }
+    tracksDisposedEditorViewState() {
+        return false;
+    }
+};
+AbstractEditorWithViewState = ( __decorate([
+    ( __param(2, ITelemetryService)),
+    ( __param(3, IInstantiationService)),
+    ( __param(4, IStorageService)),
+    ( __param(5, ITextResourceConfigurationService)),
+    ( __param(6, IThemeService)),
+    ( __param(7, IEditorService)),
+    ( __param(8, IEditorGroupsService))
+], AbstractEditorWithViewState));
+export { AbstractEditorWithViewState };