@codingame/monaco-vscode-api 1.78.8 → 1.79.0

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

@@ -1,242 +0,0 @@
-import { Composite } from '../../composite.js';
-import { isEditorInput } from '../../../common/editor.js';
-import { LRUCache } from 'monaco-editor/esm/vs/base/common/map.js';
-import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
-import { Event, Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
-import { isEmptyObject } from 'monaco-editor/esm/vs/base/common/types.js';
-import { DEFAULT_EDITOR_MIN_DIMENSIONS, DEFAULT_EDITOR_MAX_DIMENSIONS } from './editor.js';
-import { isEqual, joinPath } from 'monaco-editor/esm/vs/base/common/resources.js';
-import { indexOfPath } from 'monaco-editor/esm/vs/base/common/extpath.js';
-import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
-class EditorPane extends Composite {
-    get minimumWidth() { return DEFAULT_EDITOR_MIN_DIMENSIONS.width; }
-    get maximumWidth() { return DEFAULT_EDITOR_MAX_DIMENSIONS.width; }
-    get minimumHeight() { return DEFAULT_EDITOR_MIN_DIMENSIONS.height; }
-    get maximumHeight() { return DEFAULT_EDITOR_MAX_DIMENSIONS.height; }
-    get input() { return this._input; }
-    get options() { return this._options; }
-    get group() { return this._group; }
-    get scopedContextKeyService() { return undefined; }
-    constructor(id, telemetryService, themeService, storageService) {
-        super(id, telemetryService, themeService, storageService);
-        this.onDidChangeSizeConstraints = Event.None;
-        this._onDidChangeControl = this._register(( new Emitter()));
-        this.onDidChangeControl = this._onDidChangeControl.event;
-    }
-    create(parent) {
-        super.create(parent);
-        this.createEditor(parent);
-    }
-    async setInput(input, options, context, token) {
-        this._input = input;
-        this._options = options;
-    }
-    clearInput() {
-        this._input = undefined;
-        this._options = undefined;
-    }
-    setOptions(options) {
-        this._options = options;
-    }
-    setVisible(visible, group) {
-        super.setVisible(visible);
-        this.setEditorVisible(visible, group);
-    }
-    setEditorVisible(visible, group) {
-        this._group = group;
-    }
-    setBoundarySashes(_sashes) {
-    }
-    getEditorMemento(editorGroupService, configurationService, key, limit = 10) {
-        const mementoKey = `${this.getId()}${key}`;
-        let editorMemento = EditorPane.EDITOR_MEMENTOS.get(mementoKey);
-        if (!editorMemento) {
-            editorMemento = this._register(( new EditorMemento(
-                this.getId(),
-                key,
-                this.getMemento(1 , 1 ),
-                limit,
-                editorGroupService,
-                configurationService
-            )));
-            EditorPane.EDITOR_MEMENTOS.set(mementoKey, editorMemento);
-        }
-        return editorMemento;
-    }
-    getViewState() {
-        return undefined;
-    }
-    saveState() {
-        for (const [, editorMemento] of EditorPane.EDITOR_MEMENTOS) {
-            if (editorMemento.id === this.getId()) {
-                editorMemento.saveState();
-            }
-        }
-        super.saveState();
-    }
-    dispose() {
-        this._input = undefined;
-        this._options = undefined;
-        super.dispose();
-    }
-}
-EditorPane.EDITOR_MEMENTOS = ( new Map());
-class EditorMemento extends Disposable {
-    constructor(id, key, memento, limit, editorGroupService, configurationService) {
-        super();
-        this.id = id;
-        this.key = key;
-        this.memento = memento;
-        this.limit = limit;
-        this.editorGroupService = editorGroupService;
-        this.configurationService = configurationService;
-        this.cleanedUp = false;
-        this.shareEditorState = false;
-        this.updateConfiguration(undefined);
-        this.registerListeners();
-    }
-    registerListeners() {
-        this._register(this.configurationService.onDidChangeConfiguration(e => this.updateConfiguration(e)));
-    }
-    updateConfiguration(e) {
-        if (!e || e.affectsConfiguration(undefined, 'workbench.editor.sharedViewState')) {
-            this.shareEditorState = this.configurationService.getValue(undefined, 'workbench.editor.sharedViewState') === true;
-        }
-    }
-    saveEditorState(group, resourceOrEditor, state) {
-        const resource = this.doGetResource(resourceOrEditor);
-        if (!resource || !group) {
-            return;
-        }
-        const cache = this.doLoad();
-        let mementosForResource = cache.get(( resource.toString()));
-        if (!mementosForResource) {
-            mementosForResource = Object.create(null);
-            cache.set(( resource.toString()), mementosForResource);
-        }
-        mementosForResource[group.id] = state;
-        if (this.shareEditorState) {
-            mementosForResource[EditorMemento.SHARED_EDITOR_STATE] = state;
-        }
-        if (isEditorInput(resourceOrEditor)) {
-            this.clearEditorStateOnDispose(resource, resourceOrEditor);
-        }
-    }
-    loadEditorState(group, resourceOrEditor) {
-        const resource = this.doGetResource(resourceOrEditor);
-        if (!resource || !group) {
-            return;
-        }
-        const cache = this.doLoad();
-        const mementosForResource = cache.get(( resource.toString()));
-        if (mementosForResource) {
-            const mementoForResourceAndGroup = mementosForResource[group.id];
-            if (mementoForResourceAndGroup) {
-                return mementoForResourceAndGroup;
-            }
-            if (this.shareEditorState) {
-                return mementosForResource[EditorMemento.SHARED_EDITOR_STATE];
-            }
-        }
-        return undefined;
-    }
-    clearEditorState(resourceOrEditor, group) {
-        if (isEditorInput(resourceOrEditor)) {
-            this.editorDisposables?.delete(resourceOrEditor);
-        }
-        const resource = this.doGetResource(resourceOrEditor);
-        if (resource) {
-            const cache = this.doLoad();
-            if (group) {
-                const mementosForResource = cache.get(( resource.toString()));
-                if (mementosForResource) {
-                    delete mementosForResource[group.id];
-                    if (isEmptyObject(mementosForResource)) {
-                        cache.delete(( resource.toString()));
-                    }
-                }
-            }
-            else {
-                cache.delete(( resource.toString()));
-            }
-        }
-    }
-    clearEditorStateOnDispose(resource, editor) {
-        if (!this.editorDisposables) {
-            this.editorDisposables = ( new Map());
-        }
-        if (!( this.editorDisposables.has(editor))) {
-            this.editorDisposables.set(editor, Event.once(editor.onWillDispose)(() => {
-                this.clearEditorState(resource);
-                this.editorDisposables?.delete(editor);
-            }));
-        }
-    }
-    moveEditorState(source, target, comparer) {
-        const cache = this.doLoad();
-        const cacheKeys = [...( cache.keys())];
-        for (const cacheKey of cacheKeys) {
-            const resource = ( URI.parse(cacheKey));
-            if (!comparer.isEqualOrParent(resource, source)) {
-                continue;
-            }
-            let targetResource;
-            if (isEqual(source, resource)) {
-                targetResource = target;
-            }
-            else {
-                const index = indexOfPath(resource.path, source.path);
-                targetResource = joinPath(target, resource.path.substr(index + source.path.length + 1));
-            }
-            const value = cache.get(cacheKey, 0 );
-            if (value) {
-                cache.delete(cacheKey);
-                cache.set(( targetResource.toString()), value);
-            }
-        }
-    }
-    doGetResource(resourceOrEditor) {
-        if (isEditorInput(resourceOrEditor)) {
-            return resourceOrEditor.resource;
-        }
-        return resourceOrEditor;
-    }
-    doLoad() {
-        if (!this.cache) {
-            this.cache = ( new LRUCache(this.limit));
-            const rawEditorMemento = this.memento[this.key];
-            if (Array.isArray(rawEditorMemento)) {
-                this.cache.fromJSON(rawEditorMemento);
-            }
-        }
-        return this.cache;
-    }
-    saveState() {
-        const cache = this.doLoad();
-        if (!this.cleanedUp) {
-            this.cleanUp();
-            this.cleanedUp = true;
-        }
-        this.memento[this.key] = cache.toJSON();
-    }
-    cleanUp() {
-        const cache = this.doLoad();
-        const entries = [...cache.entries()];
-        for (const [resource, mapGroupToMementos] of entries) {
-            for (const group of ( Object.keys(mapGroupToMementos))) {
-                const groupId = Number(group);
-                if (groupId === EditorMemento.SHARED_EDITOR_STATE && this.shareEditorState) {
-                    continue;
-                }
-                if (!this.editorGroupService.getGroup(groupId)) {
-                    delete mapGroupToMementos[groupId];
-                    if (isEmptyObject(mapGroupToMementos)) {
-                        cache.delete(resource);
-                    }
-                }
-            }
-        }
-    }
-}
-EditorMemento.SHARED_EDITOR_STATE = -1;
-export { EditorMemento, EditorPane };

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

@@ -1,139 +0,0 @@
-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 };