@codingame/monaco-vscode-views-service-override 2.0.3 → 2.1.0

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

@@ -1,152 +0,0 @@
-import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
-import { Dimension } from 'vscode/vscode/vs/base/browser/dom';
-import { IInstantiationService } from 'vscode/vscode/vs/platform/instantiation/common/instantiation';
-import { MultiEditorTabsControl } from './multiEditorTabsControl.js';
-import { Disposable } from 'vscode/vscode/vs/base/common/lifecycle';
-import { StickyEditorGroupModel, UnstickyEditorGroupModel } from '../../../common/editor/filteredEditorGroupModel.js';
-
-let MultiRowEditorControl = class MultiRowEditorControl extends Disposable {
-    constructor(parent, editorPartsView, groupsView, groupView, model, instantiationService) {
-        super();
-        this.parent = parent;
-        this.groupsView = groupsView;
-        this.groupView = groupView;
-        this.model = model;
-        this.instantiationService = instantiationService;
-        const stickyModel = this._register(( new StickyEditorGroupModel(this.model)));
-        const unstickyModel = this._register(( new UnstickyEditorGroupModel(this.model)));
-        this.stickyEditorTabsControl = this._register(this.instantiationService.createInstance(MultiEditorTabsControl, this.parent, editorPartsView, this.groupsView, this.groupView, stickyModel));
-        this.unstickyEditorTabsControl = this._register(this.instantiationService.createInstance(MultiEditorTabsControl, this.parent, editorPartsView, this.groupsView, this.groupView, unstickyModel));
-        this.handlePinnedTabsSeparateRowToolbars();
-    }
-    handlePinnedTabsSeparateRowToolbars() {
-        if (this.groupView.count === 0) {
-            return;
-        }
-        if (this.groupView.count === this.groupView.stickyCount) {
-            this.parent.classList.toggle('two-tab-bars', false);
-        }
-        else {
-            this.parent.classList.toggle('two-tab-bars', true);
-        }
-    }
-    getEditorTabsController(editor) {
-        return this.model.isSticky(editor) ? this.stickyEditorTabsControl : this.unstickyEditorTabsControl;
-    }
-    openEditor(editor, options) {
-        const [editorTabController, otherTabController] = this.model.isSticky(editor) ? [this.stickyEditorTabsControl, this.unstickyEditorTabsControl] : [this.unstickyEditorTabsControl, this.stickyEditorTabsControl];
-        const didChange = editorTabController.openEditor(editor, options);
-        if (didChange) {
-            otherTabController.openEditors([]);
-            this.handleOpenedEditors();
-        }
-        return didChange;
-    }
-    openEditors(editors) {
-        const stickyEditors = editors.filter(e => this.model.isSticky(e));
-        const unstickyEditors = editors.filter(e => !this.model.isSticky(e));
-        const didChangeOpenEditorsSticky = this.stickyEditorTabsControl.openEditors(stickyEditors);
-        const didChangeOpenEditorsUnSticky = this.unstickyEditorTabsControl.openEditors(unstickyEditors);
-        const didChange = didChangeOpenEditorsSticky || didChangeOpenEditorsUnSticky;
-        if (didChange) {
-            this.handleOpenedEditors();
-        }
-        return didChange;
-    }
-    handleOpenedEditors() {
-        this.handlePinnedTabsSeparateRowToolbars();
-    }
-    beforeCloseEditor(editor) {
-        this.getEditorTabsController(editor).beforeCloseEditor(editor);
-    }
-    closeEditor(editor) {
-        this.stickyEditorTabsControl.closeEditor(editor);
-        this.unstickyEditorTabsControl.closeEditor(editor);
-        this.handleClosedEditors();
-    }
-    closeEditors(editors) {
-        const stickyEditors = editors.filter(e => this.model.isSticky(e));
-        const unstickyEditors = editors.filter(e => !this.model.isSticky(e));
-        this.stickyEditorTabsControl.closeEditors(stickyEditors);
-        this.unstickyEditorTabsControl.closeEditors(unstickyEditors);
-        this.handleClosedEditors();
-    }
-    handleClosedEditors() {
-        this.handlePinnedTabsSeparateRowToolbars();
-    }
-    moveEditor(editor, fromIndex, targetIndex, stickyStateChange) {
-        if (stickyStateChange) {
-            if (this.model.isSticky(editor)) {
-                this.stickyEditorTabsControl.openEditor(editor);
-                this.unstickyEditorTabsControl.closeEditor(editor);
-            }
-            else {
-                this.stickyEditorTabsControl.closeEditor(editor);
-                this.unstickyEditorTabsControl.openEditor(editor);
-            }
-            this.handlePinnedTabsSeparateRowToolbars();
-        }
-        else {
-            if (this.model.isSticky(editor)) {
-                this.stickyEditorTabsControl.moveEditor(editor, fromIndex, targetIndex, stickyStateChange);
-            }
-            else {
-                this.unstickyEditorTabsControl.moveEditor(editor, fromIndex - this.model.stickyCount, targetIndex - this.model.stickyCount, stickyStateChange);
-            }
-        }
-    }
-    pinEditor(editor) {
-        this.getEditorTabsController(editor).pinEditor(editor);
-    }
-    stickEditor(editor) {
-        this.unstickyEditorTabsControl.closeEditor(editor);
-        this.stickyEditorTabsControl.openEditor(editor);
-        this.handlePinnedTabsSeparateRowToolbars();
-    }
-    unstickEditor(editor) {
-        this.stickyEditorTabsControl.closeEditor(editor);
-        this.unstickyEditorTabsControl.openEditor(editor);
-        this.handlePinnedTabsSeparateRowToolbars();
-    }
-    setActive(isActive) {
-        this.stickyEditorTabsControl.setActive(isActive);
-        this.unstickyEditorTabsControl.setActive(isActive);
-    }
-    updateEditorLabel(editor) {
-        this.getEditorTabsController(editor).updateEditorLabel(editor);
-    }
-    updateEditorDirty(editor) {
-        this.getEditorTabsController(editor).updateEditorDirty(editor);
-    }
-    updateOptions(oldOptions, newOptions) {
-        this.stickyEditorTabsControl.updateOptions(oldOptions, newOptions);
-        this.unstickyEditorTabsControl.updateOptions(oldOptions, newOptions);
-    }
-    layout(dimensions) {
-        const stickyDimensions = this.stickyEditorTabsControl.layout(dimensions);
-        const unstickyAvailableDimensions = {
-            container: dimensions.container,
-            available: ( new Dimension(
-                dimensions.available.width,
-                dimensions.available.height - stickyDimensions.height
-            ))
-        };
-        const unstickyDimensions = this.unstickyEditorTabsControl.layout(unstickyAvailableDimensions);
-        return ( new Dimension(
-            dimensions.container.width,
-            stickyDimensions.height + unstickyDimensions.height
-        ));
-    }
-    getHeight() {
-        return this.stickyEditorTabsControl.getHeight() + this.unstickyEditorTabsControl.getHeight();
-    }
-    dispose() {
-        this.parent.classList.toggle('two-tab-bars', false);
-        super.dispose();
-    }
-};
-MultiRowEditorControl = ( __decorate([
-    ( __param(5, IInstantiationService))
-], MultiRowEditorControl));
-
-export { MultiRowEditorControl };

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

@@ -1,54 +0,0 @@
-import './media/singleeditortabscontrol.css.js';
-import { EditorTabsControl } from 'vscode/vscode/vs/workbench/browser/parts/editor/editorTabsControl';
-import { Dimension } from 'vscode/vscode/vs/base/browser/dom';
-
-class NoEditorTabsControl extends EditorTabsControl {
-    constructor() {
-        super(...arguments);
-        this.activeEditor = null;
-    }
-    prepareEditorActions(editorActions) {
-        return {
-            primary: [],
-            secondary: []
-        };
-    }
-    openEditor(editor) {
-        return this.handleOpenedEditors();
-    }
-    openEditors(editors) {
-        return this.handleOpenedEditors();
-    }
-    handleOpenedEditors() {
-        const didChange = this.activeEditorChanged();
-        this.activeEditor = this.tabsModel.activeEditor;
-        return didChange;
-    }
-    activeEditorChanged() {
-        if (!this.activeEditor && this.tabsModel.activeEditor ||
-            this.activeEditor && !this.tabsModel.activeEditor ||
-            (!this.activeEditor || !this.tabsModel.isActive(this.activeEditor))
-        ) {
-            return true;
-        }
-        return false;
-    }
-    beforeCloseEditor(editor) { }
-    closeEditor(editor) { }
-    closeEditors(editors) { }
-    moveEditor(editor, fromIndex, targetIndex) { }
-    pinEditor(editor) { }
-    stickEditor(editor) { }
-    unstickEditor(editor) { }
-    setActive(isActive) { }
-    updateEditorLabel(editor) { }
-    updateEditorDirty(editor) { }
-    getHeight() {
-        return 0;
-    }
-    layout(dimensions) {
-        return ( new Dimension(dimensions.container.width, this.getHeight()));
-    }
-}
-
-export { NoEditorTabsControl };

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

@@ -1,259 +0,0 @@
-import './media/singleeditortabscontrol.css.js';
-import { preventEditorClose, EditorCloseMethod, EditorResourceAccessor, SideBySideEditor } from 'vscode/vscode/vs/workbench/common/editor';
-import { EditorTabsControl } from 'vscode/vscode/vs/workbench/browser/parts/editor/editorTabsControl';
-import { ResourceLabel } from 'vscode/vscode/vs/workbench/browser/labels';
-import { TAB_ACTIVE_FOREGROUND, TAB_UNFOCUSED_ACTIVE_FOREGROUND } from 'vscode/vscode/vs/workbench/common/theme';
-import { Gesture, EventType as EventType$1 } from 'vscode/vscode/vs/base/browser/touch';
-import { addDisposableListener, EventType, DragAndDropObserver, EventHelper, isAncestor, Dimension } from 'vscode/vscode/vs/base/browser/dom';
-import { CLOSE_EDITOR_COMMAND_ID, UNLOCK_GROUP_COMMAND_ID } from 'vscode/vscode/vs/workbench/browser/parts/editor/editorCommands';
-import { Color } from 'vscode/vscode/vs/base/common/color';
-import { assertIsDefined, assertAllDefined } from 'vscode/vscode/vs/base/common/types';
-import { equals } from 'vscode/vscode/vs/base/common/objects';
-import { toDisposable } from 'vscode/vscode/vs/base/common/lifecycle';
-import { defaultBreadcrumbsWidgetStyles } from 'vscode/vscode/vs/platform/theme/browser/defaultStyles';
-import { BreadcrumbsControlFactory } from './breadcrumbsControl.js';
-
-class SingleEditorTabsControl extends EditorTabsControl {
-    constructor() {
-        super(...arguments);
-        this.activeLabel = Object.create(null);
-    }
-    get breadcrumbsControl() { return this.breadcrumbsControlFactory?.control; }
-    create(parent) {
-        super.create(parent);
-        const titleContainer = this.titleContainer = parent;
-        titleContainer.draggable = true;
-        this.registerContainerListeners(titleContainer);
-        this._register(Gesture.addTarget(titleContainer));
-        const labelContainer = document.createElement('div');
-        labelContainer.classList.add('label-container');
-        titleContainer.appendChild(labelContainer);
-        this.editorLabel = this._register(this.instantiationService.createInstance(ResourceLabel, labelContainer, undefined)).element;
-        this._register(addDisposableListener(this.editorLabel.element, EventType.CLICK, e => this.onTitleLabelClick(e)));
-        this.breadcrumbsControlFactory = this._register(this.instantiationService.createInstance(BreadcrumbsControlFactory, labelContainer, this.groupView, {
-            showFileIcons: false,
-            showSymbolIcons: true,
-            showDecorationColors: false,
-            widgetStyles: { ...defaultBreadcrumbsWidgetStyles, breadcrumbsBackground: ( Color.transparent.toString()) },
-            showPlaceholder: false
-        }));
-        this._register(this.breadcrumbsControlFactory.onDidEnablementChange(() => this.handleBreadcrumbsEnablementChange()));
-        titleContainer.classList.toggle('breadcrumbs', Boolean(this.breadcrumbsControl));
-        this._register(toDisposable(() => titleContainer.classList.remove('breadcrumbs')));
-        this.createEditorActionsToolBar(titleContainer, ['title-actions']);
-    }
-    registerContainerListeners(titleContainer) {
-        let lastDragEvent = undefined;
-        this._register(( new DragAndDropObserver(titleContainer, {
-            onDragStart: e => this.onGroupDragStart(e, titleContainer),
-            onDrag: e => { lastDragEvent = e; },
-            onDragEnd: e => { this.onGroupDragEnd(e, lastDragEvent, titleContainer); },
-        })));
-        this._register(addDisposableListener(titleContainer, EventType.DBLCLICK, e => this.onTitleDoubleClick(e)));
-        this._register(addDisposableListener(titleContainer, EventType.AUXCLICK, e => this.onTitleAuxClick(e)));
-        this._register(addDisposableListener(titleContainer, EventType$1.Tap, (e) => this.onTitleTap(e)));
-        for (const event of [EventType.CONTEXT_MENU, EventType$1.Contextmenu]) {
-            this._register(addDisposableListener(titleContainer, event, e => {
-                if (this.tabsModel.activeEditor) {
-                    this.onTabContextMenu(this.tabsModel.activeEditor, e, titleContainer);
-                }
-            }));
-        }
-    }
-    onTitleLabelClick(e) {
-        EventHelper.stop(e, false);
-        setTimeout(() => this.quickInputService.quickAccess.show());
-    }
-    onTitleDoubleClick(e) {
-        EventHelper.stop(e);
-        this.groupView.pinEditor();
-    }
-    onTitleAuxClick(e) {
-        if (e.button === 1  && this.tabsModel.activeEditor) {
-            EventHelper.stop(e, true );
-            if (!preventEditorClose(this.tabsModel, this.tabsModel.activeEditor, EditorCloseMethod.MOUSE, this.groupsView.partOptions)) {
-                this.groupView.closeEditor(this.tabsModel.activeEditor);
-            }
-        }
-    }
-    onTitleTap(e) {
-        const target = e.initialTarget;
-        if (!(target instanceof HTMLElement) || !this.editorLabel || !isAncestor(target, this.editorLabel.element)) {
-            return;
-        }
-        setTimeout(() => this.quickInputService.quickAccess.show(), 50);
-    }
-    openEditor(editor) {
-        return this.doHandleOpenEditor();
-    }
-    openEditors(editors) {
-        return this.doHandleOpenEditor();
-    }
-    doHandleOpenEditor() {
-        const activeEditorChanged = this.ifActiveEditorChanged(() => this.redraw());
-        if (!activeEditorChanged) {
-            this.ifActiveEditorPropertiesChanged(() => this.redraw());
-        }
-        return activeEditorChanged;
-    }
-    beforeCloseEditor(editor) {
-    }
-    closeEditor(editor) {
-        this.ifActiveEditorChanged(() => this.redraw());
-    }
-    closeEditors(editors) {
-        this.ifActiveEditorChanged(() => this.redraw());
-    }
-    moveEditor(editor, fromIndex, targetIndex) {
-        this.ifActiveEditorChanged(() => this.redraw());
-    }
-    pinEditor(editor) {
-        this.ifEditorIsActive(editor, () => this.redraw());
-    }
-    stickEditor(editor) {
-    }
-    unstickEditor(editor) {
-    }
-    setActive(isActive) {
-        this.redraw();
-    }
-    updateEditorLabel(editor) {
-        this.ifEditorIsActive(editor, () => this.redraw());
-    }
-    updateEditorDirty(editor) {
-        this.ifEditorIsActive(editor, () => {
-            const titleContainer = assertIsDefined(this.titleContainer);
-            if (editor.isDirty() && !editor.isSaving()) {
-                titleContainer.classList.add('dirty');
-            }
-            else {
-                titleContainer.classList.remove('dirty');
-            }
-        });
-    }
-    updateOptions(oldOptions, newOptions) {
-        super.updateOptions(oldOptions, newOptions);
-        if (oldOptions.labelFormat !== newOptions.labelFormat || !equals(oldOptions.decorations, newOptions.decorations)) {
-            this.redraw();
-        }
-    }
-    updateStyles() {
-        this.redraw();
-    }
-    handleBreadcrumbsEnablementChange() {
-        const titleContainer = assertIsDefined(this.titleContainer);
-        titleContainer.classList.toggle('breadcrumbs', Boolean(this.breadcrumbsControl));
-        this.redraw();
-    }
-    ifActiveEditorChanged(fn) {
-        if (!this.activeLabel.editor && this.tabsModel.activeEditor ||
-            this.activeLabel.editor && !this.tabsModel.activeEditor ||
-            (!this.activeLabel.editor || !this.tabsModel.isActive(this.activeLabel.editor))
-        ) {
-            fn();
-            return true;
-        }
-        return false;
-    }
-    ifActiveEditorPropertiesChanged(fn) {
-        if (!this.activeLabel.editor || !this.tabsModel.activeEditor) {
-            return;
-        }
-        if (this.activeLabel.pinned !== this.tabsModel.isPinned(this.tabsModel.activeEditor)) {
-            fn();
-        }
-    }
-    ifEditorIsActive(editor, fn) {
-        if (this.tabsModel.isActive(editor)) {
-            fn();
-        }
-    }
-    redraw() {
-        const editor = this.tabsModel.activeEditor ?? undefined;
-        const options = this.groupsView.partOptions;
-        const isEditorPinned = editor ? this.tabsModel.isPinned(editor) : false;
-        const isGroupActive = this.groupsView.activeGroup === this.groupView;
-        this.activeLabel = { editor, pinned: isEditorPinned };
-        if (this.breadcrumbsControl) {
-            if (isGroupActive) {
-                this.breadcrumbsControl.update();
-                this.breadcrumbsControl.domNode.classList.toggle('preview', !isEditorPinned);
-            }
-            else {
-                this.breadcrumbsControl.hide();
-            }
-        }
-        const [titleContainer, editorLabel] = assertAllDefined(this.titleContainer, this.editorLabel);
-        if (!editor) {
-            titleContainer.classList.remove('dirty');
-            editorLabel.clear();
-            this.clearEditorActionsToolbar();
-        }
-        else {
-            this.updateEditorDirty(editor);
-            const { labelFormat } = this.groupsView.partOptions;
-            let description;
-            if (this.breadcrumbsControl && !this.breadcrumbsControl.isHidden()) {
-                description = '';
-            }
-            else if (labelFormat === 'default' && !isGroupActive) {
-                description = '';
-            }
-            else {
-                description = editor.getDescription(this.getVerbosity(labelFormat)) || '';
-            }
-            let title = editor.getTitle(2 );
-            if (description === title) {
-                title = '';
-            }
-            editorLabel.setResource({
-                resource: EditorResourceAccessor.getOriginalUri(editor, { supportSideBySide: SideBySideEditor.BOTH }),
-                name: editor.getName(),
-                description
-            }, {
-                title,
-                italic: !isEditorPinned,
-                extraClasses: ['single-tab', 'title-label'].concat(editor.getLabelExtraClasses()),
-                fileDecorations: {
-                    colors: Boolean(options.decorations?.colors),
-                    badges: Boolean(options.decorations?.badges)
-                },
-            });
-            if (isGroupActive) {
-                titleContainer.style.color = this.getColor(TAB_ACTIVE_FOREGROUND) || '';
-            }
-            else {
-                titleContainer.style.color = this.getColor(TAB_UNFOCUSED_ACTIVE_FOREGROUND) || '';
-            }
-            this.updateEditorActionsToolbar();
-        }
-    }
-    getVerbosity(style) {
-        switch (style) {
-            case 'short': return 0 ;
-            case 'long': return 2 ;
-            default: return 1 ;
-        }
-    }
-    prepareEditorActions(editorActions) {
-        const isGroupActive = this.groupsView.activeGroup === this.groupView;
-        if (isGroupActive) {
-            return editorActions;
-        }
-        else {
-            return {
-                primary: editorActions.primary.filter(action => action.id === CLOSE_EDITOR_COMMAND_ID || action.id === UNLOCK_GROUP_COMMAND_ID),
-                secondary: editorActions.secondary
-            };
-        }
-    }
-    getHeight() {
-        return this.tabHeight;
-    }
-    layout(dimensions) {
-        this.breadcrumbsControl?.layout(undefined);
-        return ( new Dimension(dimensions.container.width, this.getHeight()));
-    }
-}
-
-export { SingleEditorTabsControl };

package/vscode/src/vs/workbench/common/editor/filteredEditorGroupModel.js

@@ -1,109 +0,0 @@
-import { Emitter } from 'vscode/vscode/vs/base/common/event';
-import { Disposable } from 'vscode/vscode/vs/base/common/lifecycle';
-
-class FilteredEditorGroupModel extends Disposable {
-    constructor(model) {
-        super();
-        this.model = model;
-        this._onDidModelChange = this._register(( new Emitter()));
-        this.onDidModelChange = this._onDidModelChange.event;
-        this._register(this.model.onDidModelChange(e => {
-            const candidateOrIndex = e.editorIndex ?? e.editor;
-            if (candidateOrIndex !== undefined) {
-                if (!this.filter(candidateOrIndex)) {
-                    return;
-                }
-            }
-            this._onDidModelChange.fire(e);
-        }));
-    }
-    get id() { return this.model.id; }
-    get isLocked() { return this.model.isLocked; }
-    get stickyCount() { return this.model.stickyCount; }
-    get activeEditor() { return this.model.activeEditor && this.filter(this.model.activeEditor) ? this.model.activeEditor : null; }
-    get previewEditor() { return this.model.previewEditor && this.filter(this.model.previewEditor) ? this.model.previewEditor : null; }
-    isPinned(editorOrIndex) { return this.model.isPinned(editorOrIndex); }
-    isSticky(editorOrIndex) { return this.model.isSticky(editorOrIndex); }
-    isActive(editor) { return this.model.isActive(editor); }
-    isFirst(editor) {
-        return this.model.isFirst(editor, this.getEditors(1 ));
-    }
-    isLast(editor) {
-        return this.model.isLast(editor, this.getEditors(1 ));
-    }
-    getEditors(order, options) {
-        const editors = this.model.getEditors(order, options);
-        return editors.filter(e => this.filter(e));
-    }
-    findEditor(candidate, options) {
-        const result = this.model.findEditor(candidate, options);
-        if (!result) {
-            return undefined;
-        }
-        return this.filter(result[1]) ? result : undefined;
-    }
-}
-class StickyEditorGroupModel extends FilteredEditorGroupModel {
-    get count() { return this.model.stickyCount; }
-    getEditors(order, options) {
-        if (options?.excludeSticky) {
-            return [];
-        }
-        if (order === 1 ) {
-            return this.model.getEditors(1 ).slice(0, this.model.stickyCount);
-        }
-        return super.getEditors(order, options);
-    }
-    isSticky(editorOrIndex) {
-        return true;
-    }
-    getEditorByIndex(index) {
-        return index < this.count ? this.model.getEditorByIndex(index) : undefined;
-    }
-    indexOf(editor, editors, options) {
-        const editorIndex = this.model.indexOf(editor, editors, options);
-        if (editorIndex < 0 || editorIndex >= this.model.stickyCount) {
-            return -1;
-        }
-        return editorIndex;
-    }
-    contains(candidate, options) {
-        const editorIndex = this.model.indexOf(candidate, undefined, options);
-        return editorIndex >= 0 && editorIndex < this.model.stickyCount;
-    }
-    filter(candidateOrIndex) {
-        return this.model.isSticky(candidateOrIndex);
-    }
-}
-class UnstickyEditorGroupModel extends FilteredEditorGroupModel {
-    get count() { return this.model.count - this.model.stickyCount; }
-    get stickyCount() { return 0; }
-    isSticky(editorOrIndex) {
-        return false;
-    }
-    getEditors(order, options) {
-        if (order === 1 ) {
-            return this.model.getEditors(1 ).slice(this.model.stickyCount);
-        }
-        return super.getEditors(order, options);
-    }
-    getEditorByIndex(index) {
-        return index >= 0 ? this.model.getEditorByIndex(index + this.model.stickyCount) : undefined;
-    }
-    indexOf(editor, editors, options) {
-        const editorIndex = this.model.indexOf(editor, editors, options);
-        if (editorIndex < this.model.stickyCount || editorIndex >= this.model.count) {
-            return -1;
-        }
-        return editorIndex - this.model.stickyCount;
-    }
-    contains(candidate, options) {
-        const editorIndex = this.model.indexOf(candidate, undefined, options);
-        return editorIndex >= this.model.stickyCount && editorIndex < this.model.count;
-    }
-    filter(candidateOrIndex) {
-        return !this.model.isSticky(candidateOrIndex);
-    }
-}
-
-export { StickyEditorGroupModel, UnstickyEditorGroupModel };