@codingame/monaco-vscode-api 1.78.4 → 1.78.5

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

@@ -0,0 +1,242 @@
+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/editorQuickAccess.js

@@ -0,0 +1,213 @@
+import { __decorate, __param } from '../../../../../../node_modules/tslib/tslib.es6.js';
+import "../../../../../../assets/editorquickaccess.css";
+import { localize } from 'monaco-editor/esm/vs/nls.js';
+import { quickPickItemScorerAccessor } from 'monaco-editor/esm/vs/platform/quickinput/common/quickInput.js';
+import { PickerQuickAccessProvider, TriggerAction } from 'monaco-editor/esm/vs/platform/quickinput/browser/pickerQuickAccess.js';
+import { IEditorGroupsService } from '../../../services/editor/common/editorGroupsService.js';
+import { EditorResourceAccessor, SideBySideEditor } from '../../../common/editor.js';
+import { IEditorService } from '../../../services/editor/common/editorService.js';
+import { IModelService } from 'monaco-editor/esm/vs/editor/common/services/model.js';
+import { ILanguageService } from 'monaco-editor/esm/vs/editor/common/languages/language.js';
+import { getIconClasses } from 'monaco-editor/esm/vs/editor/common/services/getIconClasses.js';
+import { prepareQuery, scoreItemFuzzy, compareItemsByFuzzyScore } from 'monaco-editor/esm/vs/base/common/fuzzyScorer.js';
+import { Codicon } from 'monaco-editor/esm/vs/base/common/codicons.js';
+import { ThemeIcon } from 'monaco-editor/esm/vs/base/common/themables.js';
+let BaseEditorQuickAccessProvider = class BaseEditorQuickAccessProvider extends PickerQuickAccessProvider {
+    constructor(prefix, editorGroupService, editorService, modelService, languageService) {
+        super(prefix, {
+            canAcceptInBackground: true,
+            noResultsPick: {
+                label: ( localize('noViewResults', "No matching editors")),
+                groupId: -1
+            }
+        });
+        this.editorGroupService = editorGroupService;
+        this.editorService = editorService;
+        this.modelService = modelService;
+        this.languageService = languageService;
+        this.pickState = new (class {
+            constructor() {
+                this.scorerCache = Object.create(null);
+                this.isQuickNavigating = undefined;
+            }
+            reset(isQuickNavigating) {
+                if (!isQuickNavigating) {
+                    this.scorerCache = Object.create(null);
+                }
+                this.isQuickNavigating = isQuickNavigating;
+            }
+        });
+    }
+    provide(picker, token) {
+        this.pickState.reset(!!picker.quickNavigate);
+        return super.provide(picker, token);
+    }
+    _getPicks(filter) {
+        const query = prepareQuery(filter);
+        const filteredEditorEntries = this.doGetEditorPickItems().filter(entry => {
+            if (!query.normalized) {
+                return true;
+            }
+            const itemScore = scoreItemFuzzy(entry, query, true, quickPickItemScorerAccessor, this.pickState.scorerCache);
+            if (!itemScore.score) {
+                return false;
+            }
+            entry.highlights = { label: itemScore.labelMatch, description: itemScore.descriptionMatch };
+            return true;
+        });
+        if (query.normalized) {
+            const groups = ( this.editorGroupService.getGroups(2 ).map(group => group.id));
+            filteredEditorEntries.sort((entryA, entryB) => {
+                if (entryA.groupId !== entryB.groupId) {
+                    return groups.indexOf(entryA.groupId) - groups.indexOf(entryB.groupId);
+                }
+                return compareItemsByFuzzyScore(entryA, entryB, query, true, quickPickItemScorerAccessor, this.pickState.scorerCache);
+            });
+        }
+        const filteredEditorEntriesWithSeparators = [];
+        if (this.editorGroupService.count > 1) {
+            let lastGroupId = undefined;
+            for (const entry of filteredEditorEntries) {
+                if (typeof lastGroupId !== 'number' || lastGroupId !== entry.groupId) {
+                    const group = this.editorGroupService.getGroup(entry.groupId);
+                    if (group) {
+                        filteredEditorEntriesWithSeparators.push({ type: 'separator', label: group.label });
+                    }
+                    lastGroupId = entry.groupId;
+                }
+                filteredEditorEntriesWithSeparators.push(entry);
+            }
+        }
+        else {
+            filteredEditorEntriesWithSeparators.push(...filteredEditorEntries);
+        }
+        return filteredEditorEntriesWithSeparators;
+    }
+    doGetEditorPickItems() {
+        const editors = this.doGetEditors();
+        const mapGroupIdToGroupAriaLabel = ( new Map());
+        for (const { groupId } of editors) {
+            if (!mapGroupIdToGroupAriaLabel.has(groupId)) {
+                const group = this.editorGroupService.getGroup(groupId);
+                if (group) {
+                    mapGroupIdToGroupAriaLabel.set(groupId, group.ariaLabel);
+                }
+            }
+        }
+        return ( this.doGetEditors().map(({ editor, groupId }) => {
+            const resource = EditorResourceAccessor.getOriginalUri(editor, { supportSideBySide: SideBySideEditor.PRIMARY });
+            const isDirty = editor.isDirty() && !editor.isSaving();
+            const description = editor.getDescription();
+            const nameAndDescription = description ? `${editor.getName()} ${description}` : editor.getName();
+            return {
+                groupId,
+                resource,
+                label: editor.getName(),
+                ariaLabel: (() => {
+                    if (mapGroupIdToGroupAriaLabel.size > 1) {
+                        return isDirty ?
+                            ( localize(
+                                'entryAriaLabelWithGroupDirty',
+                                "{0}, unsaved changes, {1}",
+                                nameAndDescription,
+                                mapGroupIdToGroupAriaLabel.get(groupId)
+                            )) :
+                            ( localize(
+                                'entryAriaLabelWithGroup',
+                                "{0}, {1}",
+                                nameAndDescription,
+                                mapGroupIdToGroupAriaLabel.get(groupId)
+                            ));
+                    }
+                    return isDirty ? ( localize('entryAriaLabelDirty', "{0}, unsaved changes", nameAndDescription)) : nameAndDescription;
+                })(),
+                description,
+                iconClasses: getIconClasses(this.modelService, this.languageService, resource).concat(editor.getLabelExtraClasses()),
+                italic: !this.editorGroupService.getGroup(groupId)?.isPinned(editor),
+                buttons: (() => {
+                    return [
+                        {
+                            iconClass: isDirty ? ('dirty-editor ' + ThemeIcon.asClassName(Codicon.closeDirty)) : ThemeIcon.asClassName(Codicon.close),
+                            tooltip: ( localize('closeEditor', "Close Editor")),
+                            alwaysVisible: isDirty
+                        }
+                    ];
+                })(),
+                trigger: async () => {
+                    const group = this.editorGroupService.getGroup(groupId);
+                    if (group) {
+                        await group.closeEditor(editor, { preserveFocus: true });
+                        if (!group.contains(editor)) {
+                            return TriggerAction.REMOVE_ITEM;
+                        }
+                    }
+                    return TriggerAction.NO_ACTION;
+                },
+                accept: (keyMods, event) => this.editorGroupService.getGroup(groupId)?.openEditor(editor, { preserveFocus: event.inBackground }),
+            };
+        }));
+    }
+};
+BaseEditorQuickAccessProvider = ( __decorate([
+    ( __param(1, IEditorGroupsService)),
+    ( __param(2, IEditorService)),
+    ( __param(3, IModelService)),
+    ( __param(4, ILanguageService))
+], BaseEditorQuickAccessProvider));
+let ActiveGroupEditorsByMostRecentlyUsedQuickAccess = class ActiveGroupEditorsByMostRecentlyUsedQuickAccess extends BaseEditorQuickAccessProvider {
+    constructor(editorGroupService, editorService, modelService, languageService) {
+        super(ActiveGroupEditorsByMostRecentlyUsedQuickAccess.PREFIX, editorGroupService, editorService, modelService, languageService);
+    }
+    doGetEditors() {
+        const group = this.editorGroupService.activeGroup;
+        return ( group.getEditors(0 ).map(editor => ({ editor, groupId: group.id })));
+    }
+};
+ActiveGroupEditorsByMostRecentlyUsedQuickAccess.PREFIX = 'edt active ';
+ActiveGroupEditorsByMostRecentlyUsedQuickAccess = ( __decorate([
+    ( __param(0, IEditorGroupsService)),
+    ( __param(1, IEditorService)),
+    ( __param(2, IModelService)),
+    ( __param(3, ILanguageService))
+], ActiveGroupEditorsByMostRecentlyUsedQuickAccess));
+let AllEditorsByAppearanceQuickAccess = class AllEditorsByAppearanceQuickAccess extends BaseEditorQuickAccessProvider {
+    constructor(editorGroupService, editorService, modelService, languageService) {
+        super(AllEditorsByAppearanceQuickAccess.PREFIX, editorGroupService, editorService, modelService, languageService);
+    }
+    doGetEditors() {
+        const entries = [];
+        for (const group of this.editorGroupService.getGroups(2 )) {
+            for (const editor of group.getEditors(1 )) {
+                entries.push({ editor, groupId: group.id });
+            }
+        }
+        return entries;
+    }
+};
+AllEditorsByAppearanceQuickAccess.PREFIX = 'edt ';
+AllEditorsByAppearanceQuickAccess = ( __decorate([
+    ( __param(0, IEditorGroupsService)),
+    ( __param(1, IEditorService)),
+    ( __param(2, IModelService)),
+    ( __param(3, ILanguageService))
+], AllEditorsByAppearanceQuickAccess));
+let AllEditorsByMostRecentlyUsedQuickAccess = class AllEditorsByMostRecentlyUsedQuickAccess extends BaseEditorQuickAccessProvider {
+    constructor(editorGroupService, editorService, modelService, languageService) {
+        super(AllEditorsByMostRecentlyUsedQuickAccess.PREFIX, editorGroupService, editorService, modelService, languageService);
+    }
+    doGetEditors() {
+        const entries = [];
+        for (const editor of this.editorService.getEditors(0 )) {
+            entries.push(editor);
+        }
+        return entries;
+    }
+};
+AllEditorsByMostRecentlyUsedQuickAccess.PREFIX = 'edt mru ';
+AllEditorsByMostRecentlyUsedQuickAccess = ( __decorate([
+    ( __param(0, IEditorGroupsService)),
+    ( __param(1, IEditorService)),
+    ( __param(2, IModelService)),
+    ( __param(3, ILanguageService))
+], AllEditorsByMostRecentlyUsedQuickAccess));
+export { ActiveGroupEditorsByMostRecentlyUsedQuickAccess, AllEditorsByAppearanceQuickAccess, AllEditorsByMostRecentlyUsedQuickAccess, BaseEditorQuickAccessProvider };