@codingame/monaco-vscode-a17e9d37-b6c1-5556-8402-5db73960fae3-common 20.0.0

package/vscode/src/vs/platform/quickinput/browser/pickerQuickAccess.js

@@ -0,0 +1,228 @@
+
+import { timeout } from '@codingame/monaco-vscode-api/vscode/vs/base/common/async';
+import { CancellationTokenSource } from '@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation';
+import { Disposable, DisposableStore, MutableDisposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { isFunction } from '@codingame/monaco-vscode-api/vscode/vs/base/common/types';
+
+var TriggerAction;
+(function (TriggerAction) {
+    TriggerAction[TriggerAction["NO_ACTION"] = 0] = "NO_ACTION";
+    TriggerAction[TriggerAction["CLOSE_PICKER"] = 1] = "CLOSE_PICKER";
+    TriggerAction[TriggerAction["REFRESH_PICKER"] = 2] = "REFRESH_PICKER";
+    TriggerAction[TriggerAction["REMOVE_ITEM"] = 3] = "REMOVE_ITEM";
+})(TriggerAction || (TriggerAction = {}));
+function isPicksWithActive(obj) {
+    const candidate = obj;
+    return Array.isArray(candidate.items);
+}
+function isFastAndSlowPicks(obj) {
+    const candidate = obj;
+    return !!candidate.picks && candidate.additionalPicks instanceof Promise;
+}
+class PickerQuickAccessProvider extends Disposable {
+    constructor(prefix, options) {
+        super();
+        this.prefix = prefix;
+        this.options = options;
+    }
+    provide(picker, token, runOptions) {
+        const disposables = ( new DisposableStore());
+        picker.canAcceptInBackground = !!this.options?.canAcceptInBackground;
+        picker.matchOnLabel = picker.matchOnDescription = picker.matchOnDetail = picker.sortByLabel = false;
+        let picksCts = undefined;
+        const picksDisposable = disposables.add(( new MutableDisposable()));
+        const updatePickerItems = async () => {
+            picksCts?.dispose(true);
+            picker.busy = false;
+            const picksDisposables = picksDisposable.value = ( new DisposableStore());
+            picksCts = picksDisposables.add(( new CancellationTokenSource(token)));
+            const picksToken = picksCts.token;
+            let picksFilter = picker.value.substring(this.prefix.length);
+            if (!this.options?.shouldSkipTrimPickFilter) {
+                picksFilter = picksFilter.trim();
+            }
+            const providedPicks = this._getPicks(picksFilter, picksDisposables, picksToken, runOptions);
+            const applyPicks = (picks, skipEmpty) => {
+                let items;
+                let activeItem = undefined;
+                if (isPicksWithActive(picks)) {
+                    items = picks.items;
+                    activeItem = picks.active;
+                }
+                else {
+                    items = picks;
+                }
+                if (items.length === 0) {
+                    if (skipEmpty) {
+                        return false;
+                    }
+                    if ((picksFilter.length > 0 || picker.hideInput) && this.options?.noResultsPick) {
+                        if (isFunction(this.options.noResultsPick)) {
+                            items = [this.options.noResultsPick(picksFilter)];
+                        }
+                        else {
+                            items = [this.options.noResultsPick];
+                        }
+                    }
+                }
+                picker.items = items;
+                if (activeItem) {
+                    picker.activeItems = [activeItem];
+                }
+                return true;
+            };
+            const applyFastAndSlowPicks = async (fastAndSlowPicks) => {
+                let fastPicksApplied = false;
+                let slowPicksApplied = false;
+                await Promise.all([
+                    (async () => {
+                        if (typeof fastAndSlowPicks.mergeDelay === 'number') {
+                            await timeout(fastAndSlowPicks.mergeDelay);
+                            if (picksToken.isCancellationRequested) {
+                                return;
+                            }
+                        }
+                        if (!slowPicksApplied) {
+                            fastPicksApplied = applyPicks(fastAndSlowPicks.picks, true );
+                        }
+                    })(),
+                    (async () => {
+                        picker.busy = true;
+                        try {
+                            const awaitedAdditionalPicks = await fastAndSlowPicks.additionalPicks;
+                            if (picksToken.isCancellationRequested) {
+                                return;
+                            }
+                            let picks;
+                            let activePick = undefined;
+                            if (isPicksWithActive(fastAndSlowPicks.picks)) {
+                                picks = fastAndSlowPicks.picks.items;
+                                activePick = fastAndSlowPicks.picks.active;
+                            }
+                            else {
+                                picks = fastAndSlowPicks.picks;
+                            }
+                            let additionalPicks;
+                            let additionalActivePick = undefined;
+                            if (isPicksWithActive(awaitedAdditionalPicks)) {
+                                additionalPicks = awaitedAdditionalPicks.items;
+                                additionalActivePick = awaitedAdditionalPicks.active;
+                            }
+                            else {
+                                additionalPicks = awaitedAdditionalPicks;
+                            }
+                            if (additionalPicks.length > 0 || !fastPicksApplied) {
+                                let fallbackActivePick = undefined;
+                                if (!activePick && !additionalActivePick) {
+                                    const fallbackActivePickCandidate = picker.activeItems[0];
+                                    if (fallbackActivePickCandidate && picks.indexOf(fallbackActivePickCandidate) !== -1) {
+                                        fallbackActivePick = fallbackActivePickCandidate;
+                                    }
+                                }
+                                applyPicks({
+                                    items: [...picks, ...additionalPicks],
+                                    active: activePick || additionalActivePick || fallbackActivePick
+                                });
+                            }
+                        }
+                        finally {
+                            if (!picksToken.isCancellationRequested) {
+                                picker.busy = false;
+                            }
+                            slowPicksApplied = true;
+                        }
+                    })()
+                ]);
+            };
+            if (providedPicks === null) ;
+            else if (isFastAndSlowPicks(providedPicks)) {
+                await applyFastAndSlowPicks(providedPicks);
+            }
+            else if (!(providedPicks instanceof Promise)) {
+                applyPicks(providedPicks);
+            }
+            else {
+                picker.busy = true;
+                try {
+                    const awaitedPicks = await providedPicks;
+                    if (picksToken.isCancellationRequested) {
+                        return;
+                    }
+                    if (isFastAndSlowPicks(awaitedPicks)) {
+                        await applyFastAndSlowPicks(awaitedPicks);
+                    }
+                    else {
+                        applyPicks(awaitedPicks);
+                    }
+                }
+                finally {
+                    if (!picksToken.isCancellationRequested) {
+                        picker.busy = false;
+                    }
+                }
+            }
+        };
+        disposables.add(picker.onDidChangeValue(() => updatePickerItems()));
+        updatePickerItems();
+        disposables.add(picker.onDidAccept(event => {
+            if (runOptions?.handleAccept) {
+                if (!event.inBackground) {
+                    picker.hide();
+                }
+                runOptions.handleAccept?.(picker.activeItems[0], event.inBackground);
+                return;
+            }
+            const [item] = picker.selectedItems;
+            if (typeof item?.accept === 'function') {
+                if (!event.inBackground) {
+                    picker.hide();
+                }
+                item.accept(picker.keyMods, event);
+            }
+        }));
+        const buttonTrigger = async (button, item) => {
+            if (typeof item.trigger !== 'function') {
+                return;
+            }
+            const buttonIndex = item.buttons?.indexOf(button) ?? -1;
+            if (buttonIndex >= 0) {
+                const result = item.trigger(buttonIndex, picker.keyMods);
+                const action = (typeof result === 'number') ? result : await result;
+                if (token.isCancellationRequested) {
+                    return;
+                }
+                switch (action) {
+                    case TriggerAction.NO_ACTION:
+                        break;
+                    case TriggerAction.CLOSE_PICKER:
+                        picker.hide();
+                        break;
+                    case TriggerAction.REFRESH_PICKER:
+                        updatePickerItems();
+                        break;
+                    case TriggerAction.REMOVE_ITEM: {
+                        const index = picker.items.indexOf(item);
+                        if (index !== -1) {
+                            const items = picker.items.slice();
+                            const removed = items.splice(index, 1);
+                            const activeItems = picker.activeItems.filter(activeItem => activeItem !== removed[0]);
+                            const keepScrollPositionBefore = picker.keepScrollPosition;
+                            picker.keepScrollPosition = true;
+                            picker.items = items;
+                            if (activeItems) {
+                                picker.activeItems = activeItems;
+                            }
+                            picker.keepScrollPosition = keepScrollPositionBefore;
+                        }
+                        break;
+                    }
+                }
+            }
+        };
+        disposables.add(picker.onDidTriggerItemButton(({ button, item }) => buttonTrigger(button, item)));
+        disposables.add(picker.onDidTriggerSeparatorButton(({ button, separator }) => buttonTrigger(button, separator)));
+        return disposables;
+    }
+}
+
+export { PickerQuickAccessProvider, TriggerAction };

package/vscode/src/vs/workbench/browser/parts/editor/editorCommandsContext.d.ts

@@ -0,0 +1,13 @@
+import { IListService } from "@codingame/monaco-vscode-api/vscode/vs/platform/list/browser/listService.service";
+import { EditorInput } from "@codingame/monaco-vscode-api/vscode/vs/workbench/common/editor/editorInput";
+import { IEditorGroup } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorGroupsService";
+import { IEditorGroupsService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorGroupsService.service";
+import { IEditorService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorService.service";
+export interface IResolvedEditorCommandsContext {
+    readonly groupedEditors: {
+        readonly group: IEditorGroup;
+        readonly editors: EditorInput[];
+    }[];
+    readonly preserveFocus: boolean;
+}
+export declare function resolveCommandsContext(commandArgs: unknown[], editorService: IEditorService, editorGroupsService: IEditorGroupsService, listService: IListService): IResolvedEditorCommandsContext;

package/vscode/src/vs/workbench/browser/parts/editor/editorCommandsContext.js

@@ -0,0 +1,137 @@
+
+import { getActiveElement } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/dom';
+import { List } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/ui/list/listWidget';
+import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
+import { isEditorCommandsContext, isEditorIdentifier } from '@codingame/monaco-vscode-api/vscode/vs/workbench/common/editor';
+import { isEditorGroup } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorGroupsService';
+
+function resolveCommandsContext(commandArgs, editorService, editorGroupsService, listService) {
+    const commandContext = getCommandsContext(commandArgs, editorService, editorGroupsService, listService);
+    const preserveFocus = commandContext.length ? commandContext[0].preserveFocus || false : false;
+    const resolvedContext = { groupedEditors: [], preserveFocus };
+    for (const editorContext of commandContext) {
+        const groupAndEditor = getEditorAndGroupFromContext(editorContext, editorGroupsService);
+        if (!groupAndEditor) {
+            continue;
+        }
+        const { group, editor } = groupAndEditor;
+        let groupContext = undefined;
+        for (const targetGroupContext of resolvedContext.groupedEditors) {
+            if (targetGroupContext.group.id === group.id) {
+                groupContext = targetGroupContext;
+                break;
+            }
+        }
+        if (!groupContext) {
+            groupContext = { group, editors: [] };
+            resolvedContext.groupedEditors.push(groupContext);
+        }
+        if (editor) {
+            groupContext.editors.push(editor);
+        }
+    }
+    return resolvedContext;
+}
+function getCommandsContext(commandArgs, editorService, editorGroupsService, listService) {
+    const list = listService.lastFocusedList;
+    let isListAction = list instanceof List && list.getHTMLElement() === getActiveElement();
+    let editorContext = getEditorContextFromCommandArgs(commandArgs, isListAction, editorService, editorGroupsService, listService);
+    if (!editorContext) {
+        const activeGroup = editorGroupsService.activeGroup;
+        const activeEditor = activeGroup.activeEditor;
+        editorContext = { groupId: activeGroup.id, editorIndex: activeEditor ? activeGroup.getIndexOfEditor(activeEditor) : undefined };
+        isListAction = false;
+    }
+    const multiEditorContext = getMultiSelectContext(editorContext, isListAction, editorService, editorGroupsService, listService);
+    return moveCurrentEditorContextToFront(editorContext, multiEditorContext);
+}
+function moveCurrentEditorContextToFront(editorContext, multiEditorContext) {
+    if (multiEditorContext.length <= 1) {
+        return multiEditorContext;
+    }
+    const editorContextIndex = multiEditorContext.findIndex(context => context.groupId === editorContext.groupId &&
+        context.editorIndex === editorContext.editorIndex);
+    if (editorContextIndex !== -1) {
+        multiEditorContext.splice(editorContextIndex, 1);
+        multiEditorContext.unshift(editorContext);
+    }
+    else if (editorContext.editorIndex === undefined) {
+        multiEditorContext.unshift(editorContext);
+    }
+    else {
+        throw ( new Error('Editor context not found in multi editor context'));
+    }
+    return multiEditorContext;
+}
+function getEditorContextFromCommandArgs(commandArgs, isListAction, editorService, editorGroupsService, listService) {
+    const filteredArgs = commandArgs.filter(arg => isEditorCommandsContext(arg) || URI.isUri(arg));
+    for (const arg of filteredArgs) {
+        if (isEditorCommandsContext(arg)) {
+            return arg;
+        }
+    }
+    for (const uri of filteredArgs) {
+        const editorIdentifiers = editorService.findEditors(uri);
+        if (editorIdentifiers.length) {
+            const editorIdentifier = editorIdentifiers[0];
+            const group = editorGroupsService.getGroup(editorIdentifier.groupId);
+            return { groupId: editorIdentifier.groupId, editorIndex: group?.getIndexOfEditor(editorIdentifier.editor) };
+        }
+    }
+    if (isListAction) {
+        const list = listService.lastFocusedList;
+        for (const focusedElement of list.getFocusedElements()) {
+            if (isGroupOrEditor(focusedElement)) {
+                return groupOrEditorToEditorContext(focusedElement, undefined, editorGroupsService);
+            }
+        }
+    }
+    return undefined;
+}
+function getMultiSelectContext(editorContext, isListAction, editorService, editorGroupsService, listService) {
+    if (isListAction) {
+        const list = listService.lastFocusedList;
+        const selection = list.getSelectedElements().filter(isGroupOrEditor);
+        if (selection.length > 1) {
+            return ( selection.map(
+                e => groupOrEditorToEditorContext(e, editorContext.preserveFocus, editorGroupsService)
+            ));
+        }
+        if (selection.length === 0) {
+            return getMultiSelectContext(editorContext, false, editorService, editorGroupsService, listService);
+        }
+    }
+    else {
+        const group = editorGroupsService.getGroup(editorContext.groupId);
+        const editor = editorContext.editorIndex !== undefined ? group?.getEditorByIndex(editorContext.editorIndex) : group?.activeEditor;
+        if (group && editor && group.isSelected(editor)) {
+            return ( group.selectedEditors.map(
+                editor => groupOrEditorToEditorContext({ editor, groupId: group.id }, editorContext.preserveFocus, editorGroupsService)
+            ));
+        }
+    }
+    return [editorContext];
+}
+function groupOrEditorToEditorContext(element, preserveFocus, editorGroupsService) {
+    if (isEditorGroup(element)) {
+        return { groupId: element.id, editorIndex: undefined, preserveFocus };
+    }
+    const group = editorGroupsService.getGroup(element.groupId);
+    return { groupId: element.groupId, editorIndex: group ? group.getIndexOfEditor(element.editor) : -1, preserveFocus };
+}
+function isGroupOrEditor(element) {
+    return isEditorGroup(element) || isEditorIdentifier(element);
+}
+function getEditorAndGroupFromContext(commandContext, editorGroupsService) {
+    const group = editorGroupsService.getGroup(commandContext.groupId);
+    if (!group) {
+        return undefined;
+    }
+    if (commandContext.editorIndex === undefined) {
+        return { group, editor: undefined };
+    }
+    const editor = group.getEditorByIndex(commandContext.editorIndex);
+    return { group, editor };
+}
+
+export { resolveCommandsContext };

package/vscode/src/vs/workbench/browser/parts/editor/editorWithViewState.d.ts

@@ -0,0 +1,39 @@
+import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
+import { IEditorOpenContext } from "@codingame/monaco-vscode-api/vscode/vs/workbench/common/editor";
+import { EditorPane } from "@codingame/monaco-vscode-60014c9d-b815-501d-83a9-4b08725c2ec2-common/vscode/vs/workbench/browser/parts/editor/editorPane";
+import { IStorageService } from "@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage.service";
+import { IInstantiationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation";
+import { ITelemetryService } from "@codingame/monaco-vscode-api/vscode/vs/platform/telemetry/common/telemetry.service";
+import { IThemeService } from "@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/themeService.service";
+import { ITextResourceConfigurationService } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/services/textResourceConfiguration.service";
+import { IEditorGroup } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorGroupsService";
+import { IEditorGroupsService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorGroupsService.service";
+import { IEditorService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorService.service";
+import { IExtUri } from "@codingame/monaco-vscode-api/vscode/vs/base/common/resources";
+import { EditorInput } from "@codingame/monaco-vscode-api/vscode/vs/workbench/common/editor/editorInput";
+export declare abstract class AbstractEditorWithViewState<T extends object> extends EditorPane {
+    protected readonly instantiationService: IInstantiationService;
+    protected readonly textResourceConfigurationService: ITextResourceConfigurationService;
+    protected readonly editorService: IEditorService;
+    protected readonly editorGroupService: IEditorGroupsService;
+    private viewState;
+    private readonly groupListener;
+    private editorViewStateDisposables;
+    constructor(id: string, group: IEditorGroup, viewStateStorageKey: string, telemetryService: ITelemetryService, instantiationService: IInstantiationService, storageService: IStorageService, textResourceConfigurationService: ITextResourceConfigurationService, themeService: IThemeService, editorService: IEditorService, editorGroupService: IEditorGroupsService);
+    protected setEditorVisible(visible: boolean): void;
+    private onWillCloseEditor;
+    clearInput(): void;
+    protected saveState(): void;
+    private updateEditorViewState;
+    private shouldRestoreEditorViewState;
+    getViewState(): T | undefined;
+    private saveEditorViewState;
+    protected loadEditorViewState(input: EditorInput | undefined, context?: IEditorOpenContext): T | undefined;
+    protected moveEditorViewState(source: URI, target: URI, comparer: IExtUri): void;
+    protected clearEditorViewState(resource: URI, group?: IEditorGroup): void;
+    dispose(): void;
+    protected abstract computeEditorViewState(resource: URI): T | undefined;
+    protected abstract tracksEditorViewState(input: EditorInput): boolean;
+    protected tracksDisposedEditorViewState(): boolean;
+    protected abstract toEditorViewStateResource(input: EditorInput): URI | undefined;
+}

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

@@ -0,0 +1,139 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { Event } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
+import { EditorResourceAccessor, SideBySideEditor } from '@codingame/monaco-vscode-api/vscode/vs/workbench/common/editor';
+import { EditorPane } from '@codingame/monaco-vscode-60014c9d-b815-501d-83a9-4b08725c2ec2-common/vscode/vs/workbench/browser/parts/editor/editorPane';
+import { IStorageService } from '@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage.service';
+import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+import { ITelemetryService } from '@codingame/monaco-vscode-api/vscode/vs/platform/telemetry/common/telemetry.service';
+import { IThemeService } from '@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/themeService.service';
+import { ITextResourceConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/services/textResourceConfiguration.service';
+import { IEditorGroupsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorGroupsService.service';
+import { IEditorService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorService.service';
+import { MutableDisposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+
+let AbstractEditorWithViewState = class AbstractEditorWithViewState extends EditorPane {
+    constructor(id, group, viewStateStorageKey, telemetryService, instantiationService, storageService, textResourceConfigurationService, themeService, editorService, editorGroupService) {
+        super(id, group, 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) {
+        this.groupListener.value = this.group.onWillCloseEditor(e => this.onWillCloseEditor(e));
+        super.setEditorVisible(visible);
+    }
+    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.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) {
+        const editorViewState = this.computeEditorViewState(resource);
+        if (!editorViewState) {
+            return;
+        }
+        this.viewState.saveEditorState(this.group, resource, editorViewState);
+    }
+    loadEditorViewState(input, context) {
+        if (!input) {
+            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(3, ITelemetryService)),
+    ( __param(4, IInstantiationService)),
+    ( __param(5, IStorageService)),
+    ( __param(6, ITextResourceConfigurationService)),
+    ( __param(7, IThemeService)),
+    ( __param(8, IEditorService)),
+    ( __param(9, IEditorGroupsService))
+], AbstractEditorWithViewState));
+
+export { AbstractEditorWithViewState };

package/vscode/src/vs/workbench/browser/parts/editor/textEditor.d.ts

@@ -0,0 +1,84 @@
+import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
+import { Emitter, Event } from "@codingame/monaco-vscode-api/vscode/vs/base/common/event";
+import { ICodeEditor } from "@codingame/monaco-vscode-api/vscode/vs/editor/browser/editorBrowser";
+import { IEditorOpenContext, IEditorPaneSelection, EditorPaneSelectionCompareResult, IEditorPaneWithSelection, IEditorPaneSelectionChangeEvent, IEditorPaneScrollPosition, IEditorPaneWithScrolling } from "@codingame/monaco-vscode-api/vscode/vs/workbench/common/editor";
+import { EditorInput } from "@codingame/monaco-vscode-api/vscode/vs/workbench/common/editor/editorInput";
+import { AbstractEditorWithViewState } from "./editorWithViewState.js";
+import { IEditorViewState } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/editorCommon";
+import { Selection } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/core/selection";
+import { IStorageService } from "@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage.service";
+import { IInstantiationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation";
+import { ITelemetryService } from "@codingame/monaco-vscode-api/vscode/vs/platform/telemetry/common/telemetry.service";
+import { IThemeService } from "@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/themeService.service";
+import { ITextResourceConfigurationChangeEvent } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/services/textResourceConfiguration";
+import { ITextResourceConfigurationService } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/services/textResourceConfiguration.service";
+import { IEditorOptions as ICodeEditorOptions } from "@codingame/monaco-vscode-api/vscode/vs/editor/common/config/editorOptions";
+import { IEditorGroup } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorGroupsService";
+import { IEditorGroupsService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorGroupsService.service";
+import { CancellationToken } from "@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation";
+import { IEditorService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/editor/common/editorService.service";
+import { IEditorOptions, ITextEditorOptions } from "@codingame/monaco-vscode-api/vscode/vs/platform/editor/common/editor";
+import { IFileService } from "@codingame/monaco-vscode-api/vscode/vs/platform/files/common/files.service";
+import { IMarkdownString } from "@codingame/monaco-vscode-api/vscode/vs/base/common/htmlContent";
+export interface IEditorConfiguration {
+    editor: object;
+    diffEditor: object;
+    accessibility?: {
+        verbosity?: {
+            diffEditor?: boolean;
+        };
+    };
+    problems?: {
+        visibility?: boolean;
+    };
+}
+export declare abstract class AbstractTextEditor<T extends IEditorViewState> extends AbstractEditorWithViewState<T> implements IEditorPaneWithSelection, IEditorPaneWithScrolling {
+    protected readonly fileService: IFileService;
+    private static readonly VIEW_STATE_PREFERENCE_KEY;
+    protected readonly _onDidChangeSelection: Emitter<IEditorPaneSelectionChangeEvent>;
+    readonly onDidChangeSelection: Event<IEditorPaneSelectionChangeEvent>;
+    protected readonly _onDidChangeScroll: Emitter<void>;
+    readonly onDidChangeScroll: Event<void>;
+    private editorContainer;
+    private hasPendingConfigurationChange;
+    private lastAppliedEditorOptions?;
+    private readonly inputListener;
+    constructor(id: string, group: IEditorGroup, telemetryService: ITelemetryService, instantiationService: IInstantiationService, storageService: IStorageService, textResourceConfigurationService: ITextResourceConfigurationService, themeService: IThemeService, editorService: IEditorService, editorGroupService: IEditorGroupsService, fileService: IFileService);
+    private handleConfigurationChangeEvent;
+    protected shouldHandleConfigurationChangeEvent(e: ITextResourceConfigurationChangeEvent, resource: URI | undefined): boolean;
+    private consumePendingConfigurationChangeEvent;
+    protected computeConfiguration(configuration: IEditorConfiguration): ICodeEditorOptions;
+    protected computeAriaLabel(): string;
+    private onDidChangeFileSystemProvider;
+    private onDidChangeInputCapabilities;
+    protected updateReadonly(input: EditorInput): void;
+    protected getReadonlyConfiguration(isReadonly: boolean | IMarkdownString | undefined): {
+        readOnly: boolean;
+        readOnlyMessage: IMarkdownString | undefined;
+    };
+    protected getConfigurationOverrides(configuration: IEditorConfiguration): ICodeEditorOptions;
+    protected createEditor(parent: HTMLElement): void;
+    private registerCodeEditorListeners;
+    private toEditorPaneSelectionChangeReason;
+    getSelection(): IEditorPaneSelection | undefined;
+    protected abstract createEditorControl(parent: HTMLElement, initialOptions: ICodeEditorOptions): void;
+    protected abstract updateEditorControlOptions(options: ICodeEditorOptions): void;
+    protected abstract getMainControl(): ICodeEditor | undefined;
+    setInput(input: EditorInput, options: ITextEditorOptions | undefined, context: IEditorOpenContext, token: CancellationToken): Promise<void>;
+    clearInput(): void;
+    getScrollPosition(): IEditorPaneScrollPosition;
+    setScrollPosition(scrollPosition: IEditorPaneScrollPosition): void;
+    protected setEditorVisible(visible: boolean): void;
+    protected toEditorViewStateResource(input: EditorInput): URI | undefined;
+    private updateEditorConfiguration;
+    private getActiveResource;
+    dispose(): void;
+}
+export declare class TextEditorPaneSelection implements IEditorPaneSelection {
+    private readonly textSelection;
+    private static readonly TEXT_EDITOR_SELECTION_THRESHOLD;
+    constructor(textSelection: Selection);
+    compare(other: IEditorPaneSelection): EditorPaneSelectionCompareResult;
+    restore(options: IEditorOptions): ITextEditorOptions;
+    log(): string;
+}