rowvia 0.2.4 → 0.3.1

package/dist/types/core/gridHost.d.ts

@@ -0,0 +1,365 @@
+import type { SelectionService } from '../features/selectionService';
+import type { HeaderView } from '../render/headerView';
+import type { RowRenderer } from '../render/rowRenderer';
+import type { observeInteractions } from '../shared/interaction';
+import type { Column, ColumnApi, ExportParams, FilterModelItem, GridApi, GridOptions, RowDataTransaction, RowNode, RowNodeTransactionResult, SortDirection, SortModelItem } from '../types';
+import type { RowModel } from './clientSideRowModel';
+import type { ColumnModel } from './columnModel';
+import type { EventService } from './eventService';
+import type { InfiniteRowModel, ServerSideRowModel, ViewportRowModel } from './remoteRowModels';
+/** Ports used by features; implementations are assembled by Grid. */
+export interface GridHost {
+    onInteraction: ReturnType<typeof observeInteractions>['onInteraction'];
+    getOptions(): GridOptions;
+    t(key: string): string;
+    translate(key: string, fallback: string): string;
+    getContext(): any;
+    getEventService(): EventService;
+    getColumnModel(): ColumnModel;
+    getRowModel(): RowModel;
+    getRowRenderer(): RowRenderer;
+    getHeaderView(): HeaderView;
+    getSelectionService(): SelectionService;
+    getEditService(): EditService;
+    getFilterService(): FilterService;
+    getSortService(): SortService;
+    getFilterGui(): FilterGui;
+    getPaginationService(): PaginationService | null;
+    getSideBarService(): SideBarService;
+    getChartService(): ChartService;
+    getFindService(): FindService;
+    getRangeSelectionService(): RangeSelectionService;
+    getExportService(): ExportService;
+    getPopupService(): PopupService;
+    getOverlayService(): OverlayService;
+    getRowGroupPanel(): RowGroupPanel | null;
+    getUndoRedoService(): UndoRedoService;
+    getFormulaEditorService(): FormulaEditorService;
+    getNotesService(): NotesService;
+    getRowDragService(): RowDragService;
+    getServerSideRowModel(): ServerSideRowModel | null;
+    getInfiniteRowModel(): InfiniteRowModel | null;
+    getViewportRowModel(): ViewportRowModel | null;
+    refreshPivotColumns(): void;
+    isRemoteLoading(): boolean;
+    getApi(): GridApi;
+    getColumnApi(): ColumnApi;
+    getRootElement(): HTMLElement;
+    getMainElement(): HTMLElement;
+    getHeaderElement(): HTMLElement;
+    getGridDiv(): HTMLElement;
+    getColumns(): {
+        left: Column[];
+        center: Column[];
+        right: Column[];
+    };
+    getAllColumns(): Column[];
+    getColumn(key: string | Column): Column | undefined;
+    getDisplayedRowCount(): number;
+    getDisplayedRowAtIndex(index: number): RowNode | undefined;
+    getRowNode(id: string): RowNode | undefined;
+    getRowHeight(node: RowNode): number;
+    getRowClass(node: RowNode): string;
+    getRowStyle(node: RowNode): Record<string, any>;
+    isNodeSelectable(node: RowNode): boolean;
+    isCellEditable(column: Column, node: RowNode): boolean;
+    setRowData(rowData: any[], initial?: boolean): void;
+    applyTransaction(transaction: RowDataTransaction): RowNodeTransactionResult | null;
+    setCellValue(column: Column, node: RowNode, value: any, source?: string, oldValueOverride?: any): void;
+    refreshModel(step?: string): void;
+    refreshCells(params?: {
+        rowNodes?: RowNode[];
+        columns?: Array<string | Column>;
+        force?: boolean;
+        flash?: boolean;
+    }): void;
+    setQuickFilter(text: string): void;
+    getQuickFilter(): string;
+    setRowNodePinned(node: RowNode, pinned: 'top' | 'bottom' | null): void;
+    openFind(): void;
+    closeFind(): void;
+    setHorizontalScrollLeft(left: number): void;
+    onGridSizeChanged(): void;
+    updateGridOptions(options: Partial<GridOptions>): void;
+    destroy(): void;
+}
+export type ChartType = 'line' | 'area' | 'column' | 'bar' | 'pie' | 'scatter';
+export interface ChartSeries {
+    title: string;
+    data: number[];
+}
+export interface ChartData {
+    categories: string[];
+    series: ChartSeries[];
+}
+export interface ChartService {
+    isEnabled(): boolean;
+    getChartData(params?: {
+        categoryColumn?: Column;
+        valueColumns?: Column[];
+    }): ChartData;
+    buildChartPanel(): HTMLElement;
+    createChart(params?: {
+        type?: ChartType;
+        categoryColumn?: Column;
+        valueColumns?: Column[];
+        title?: string;
+    }): string;
+    destroyChart(id: string): void;
+    getChartModels(): any[];
+    refreshCharts(): void;
+    saveCharts(): void;
+    loadCharts(): void;
+}
+export interface ColumnMenuService {
+    openColumnMenu(column: Column, anchor: HTMLElement): void;
+}
+export interface MenuItem {
+    name: string;
+    label?: string;
+    icon?: string;
+    disabled?: boolean;
+    checked?: boolean;
+    subMenu?: MenuItem[];
+    action?: () => void;
+    separator?: boolean;
+    cssClasses?: string[];
+    shortcut?: string;
+}
+export interface ContextMenuService {
+    openContextMenu(anchor: HTMLElement, params: {
+        column?: any;
+        node?: any;
+    }): void;
+}
+export interface FocusedCell {
+    rowIndex: number;
+    column: Column;
+    rowNode: RowNode;
+}
+export interface EditService {
+    getFocusedCell(): FocusedCell | null;
+    setFocusedCell(rowIndex: number, column: Column): void;
+    clearFocusedCell(): void;
+    isEditing(): boolean;
+    getEditingCells(): Array<{
+        rowIndex: number;
+        colId: string;
+    }>;
+    startEditingCell(params: {
+        rowIndex: number;
+        colKey: string | Column;
+        charPress?: string;
+    }): void;
+    stopEditing(cancel?: boolean): boolean;
+    onGridKeyDown(event: KeyboardEvent): void;
+    moveFocus(rowDelta: number, colDelta: number): void;
+    tabToNextCell(): void;
+    tabToPreviousCell(): void;
+    onCellClicked(params: {
+        node: RowNode;
+        column: Column;
+        event: MouseEvent;
+        rowIndex: number;
+    }): void;
+    onCellDoubleClicked(params: {
+        node: RowNode;
+        column: Column;
+        event: MouseEvent;
+        rowIndex: number;
+    }): void;
+    destroy(): void;
+}
+export interface ExportService {
+    getDataAsCsv(params?: ExportParams): string;
+    getDataAsExcel(params?: ExportParams): Blob;
+    exportToCsv(params?: ExportParams): void;
+    exportToExcel(params?: ExportParams): void;
+    getDataAsPdf(params?: ExportParams & {
+        pageSize?: string;
+        title?: string;
+    }): Blob;
+    exportToPdf(params?: ExportParams & {
+        pageSize?: string;
+        title?: string;
+    }): void;
+    importExcel(file: Blob | ArrayBuffer, params?: {
+        sheetIndex?: number;
+        onSuccess?: (rows: any[]) => void;
+    }): Promise<any[]>;
+    copyToClipboard(params?: any): void;
+    cutToClipboard(params?: any): void;
+    pasteFromClipboard(): void;
+    pasteText(text: string): void;
+}
+export interface FilterGui {
+    openFilter(column: Column, anchor: HTMLElement): void;
+    openMultiFilter(column: Column, anchor: HTMLElement): void;
+    openAdvancedFilter(anchor: HTMLElement): void;
+}
+export interface AdvancedFilterCondition {
+    colId: string;
+    type: string;
+    filter?: any;
+    filterTo?: any;
+    dateFrom?: string;
+    dateTo?: string;
+}
+export interface AdvancedFilterModel {
+    filterType: 'advanced';
+    operator: 'AND' | 'OR';
+    conditions: AdvancedFilterCondition[];
+}
+export interface FilterService {
+    getAdvancedFilterModel(): AdvancedFilterModel | null;
+    setAdvancedFilterModel(model: AdvancedFilterModel | null): void;
+    isAdvancedFilterEnabled(): boolean;
+    doesNodePassAdvancedFilter(node: any): boolean;
+    getFilterModel(): Record<string, FilterModelItem>;
+    getFilterInstance(colId: string): FilterModelItem | undefined;
+    setFilterModel(model: Record<string, FilterModelItem> | null): void;
+    setColumnFilterModel(colKey: string | Column, model: FilterModelItem | null): void;
+    isFilterActive(column: Column): boolean;
+    handleFloatingFilterChange(column: Column, value: string): void;
+    resetFilters(): void;
+    onFilterChanged(source: string): void;
+}
+export interface FindService {
+    isOpen(): boolean;
+    open(): void;
+    close(): void;
+    setFindText(text: string): void;
+    getFindText(): string;
+    getNumMatches(): number;
+    getActiveMatch(): number;
+    find(text: string): void;
+    findNext(): boolean;
+    findPrevious(): boolean;
+    applyHighlight(): void;
+}
+export interface FormulaEditorService {
+    isFormulaColumn(column: Column): boolean;
+    openFormulaEditor(column: Column, anchor: HTMLElement): void;
+}
+export interface NoteKey {
+    rowNodeId: string;
+    colId: string;
+}
+export interface NotesService {
+    getNote(rowNodeId: string, colId: string, colDefNote?: any, params?: any): string | undefined;
+    setNote(rowNodeId: string, colId: string, note: string | undefined): void;
+    openNoteEditor(rowNodeId: string, colId: string, anchor: HTMLElement): void;
+}
+export interface OverlayService {
+    showLoadingOverlay(): void;
+    showNoRowsOverlay(): void;
+    hideOverlay(): void;
+    updateAuto(): void;
+    getCurrent(): 'loading' | 'noRows' | null;
+}
+export interface PaginationService {
+    isEnabled(): boolean;
+    setEnabled(enabled: boolean): void;
+    getPageSize(): number;
+    setPageSize(size: number): void;
+    getCurrentPage(): number;
+    getTotalPages(): number;
+    goToPage(page: number): void;
+    goToNextPage(): void;
+    goToPreviousPage(): void;
+    goToFirstPage(): void;
+    goToLastPage(): void;
+    update(): void;
+    getPanel(): HTMLElement;
+    isLastPageFound(): boolean;
+}
+export interface PopupService {
+    getParent(): HTMLElement;
+    createPopup(width?: number, className?: string): {
+        ePopup: HTMLElement;
+        close: () => void;
+        onClose: (cb: () => void) => void;
+    };
+    positionAt(ePopup: HTMLElement, anchor: HTMLElement, offsetX?: number): void;
+    closeAll(): void;
+}
+export interface RangeState {
+    rowStartIndex: number;
+    rowEndIndex: number;
+    colStartId: string;
+    colEndId: string;
+}
+export interface RangeSelectionService {
+    isEnabled(): boolean;
+    getRanges(): RangeState[];
+    clearRanges(): void;
+    onCellMouseDown(params: {
+        event: MouseEvent;
+        column: Column;
+        rowIndex: number;
+    }): void;
+    onHandleMouseDown(event: MouseEvent): void;
+    updateOverlay(): void;
+    applyHighlight(): void;
+    getRangeCells(range: RangeState): Array<{
+        node: any;
+        column: Column;
+    }>;
+    getCurrentRange(): RangeState | null;
+    onGridKeyDown(event: KeyboardEvent): void;
+}
+export interface RowDragService {
+    isEnabled(): boolean;
+    startDrag(rowNode: RowNode, event: MouseEvent): void;
+}
+export interface RowGroupPanel {
+    refresh(): void;
+}
+export interface ToolPanelDef {
+    id: string;
+    label: string;
+}
+export interface SideBarService {
+    getElement(): HTMLElement;
+    setPosition(position: 'left' | 'right'): void;
+    setVisible(visible: boolean): void;
+    isVisible(): boolean;
+    openPanel(id: string): void;
+    getActivePanel(): string | null;
+    refresh(): void;
+}
+export interface SortService {
+    getSortingOrder(): SortDirection[];
+    onSortRequested(column: Column, event: MouseEvent, multiSort: boolean): void;
+    getSortModel(): SortModelItem[];
+    setSortModel(model: SortModelItem[]): void;
+    onSortChanged(source: string): void;
+}
+export interface StatusBarService {
+    getElement(): HTMLElement;
+    isVisible(): boolean;
+    setVisible(visible: boolean): void;
+    update(): void;
+}
+export interface UndoRedoAction {
+    rowNodeId: string;
+    colId: string;
+    oldValue: any;
+    newValue: any;
+    /** batch id — edits committed in one batch share an id and undo together */
+    batchId: number;
+}
+export interface UndoRedoService {
+    isEnabled(): boolean;
+    pushAction(action: UndoRedoAction): void;
+    canUndo(): boolean;
+    canRedo(): boolean;
+    getUndoStackSize(): number;
+    getRedoStackSize(): number;
+    undo(): number;
+    redo(): number;
+    startBatchEdit(): void;
+    endBatchEdit(cancel?: boolean): void;
+    isBatchEditing(): boolean;
+    clear(): void;
+}

package/dist/types/core/remoteRowModels.d.ts

@@ -1,7 +1,7 @@
 import type { Column, GridOptions, RowDataTransaction, RowNode, RowNodeTransactionResult, SortModelItem } from '../types';
-import { type RowNodeServices } from './rowNode';
-import type { EventService } from './eventService';
 import type { RowModel } from './clientSideRowModel';
+import type { EventService } from './eventService';
+import { type RowNodeServices } from './rowNode';
 /** ag-grid compatible server-side request */
 export interface ServerSideGetRowsRequest {
     startRow: number;
@@ -41,19 +41,16 @@ export interface RemoteRowModelParams {
  * grouping. Stores rows per group path and lazily requests blocks.
  */
 export declare class ServerSideRowModel implements RowModel {
-    private options;
     private eventService;
     private columns;
     private getSortModel;
     private getFilterModel;
-    private rowHeightProvider;
     private rowNodeServices;
     private datasource;
     private stores;
     private rowNodeMap;
     private displayRows;
     private blockSize;
-    private pureLoad;
     constructor(params: RemoteRowModelParams);
     getType(): string;
     setDatasource(datasource: ServerSideDatasource | null): void;
@@ -96,7 +93,6 @@ export declare class ServerSideRowModel implements RowModel {
  * Infinite Row Model — lazy-loads pages as the user scrolls.
  */
 export declare class InfiniteRowModel implements RowModel {
-    private options;
     private eventService;
     private getSortModel;
     private getFilterModel;
@@ -105,7 +101,6 @@ export declare class InfiniteRowModel implements RowModel {
     private nodes;
     private rowNodeMap;
     private blockSize;
-    private lastRow;
     private loading;
     constructor(params: RemoteRowModelParams);
     getType(): string;
@@ -135,14 +130,11 @@ export declare class InfiniteRowModel implements RowModel {
  * requesting them from the datasource.
  */
 export declare class ViewportRowModel implements RowModel {
-    private options;
     private eventService;
     private rowNodeServices;
     private datasource;
     private nodes;
     private rowNodeMap;
-    private firstRow;
-    private lastRow;
     private loading;
     constructor(params: RemoteRowModelParams);
     getType(): string;

package/dist/types/core/rowNode.d.ts

@@ -1,4 +1,4 @@
-import type { RowNode, Column } from '../types';
+import type { Column, RowNode } from '../types';
 export interface RowNodeServices {
     selectNode: (node: RowNode, clearSelection: boolean) => void;
     deselectNode: (node: RowNode) => void;
@@ -30,7 +30,6 @@ export declare class RowNodeImpl implements RowNode {
     rowIndex: number | null;
     __displayIndex: number | undefined;
     private services;
-    private _id;
     constructor(data: any, services: RowNodeServices, id?: string);
     /** true when this is a group node (row grouping) */
     get isGroup(): boolean;

package/dist/types/core/valueService.d.ts

@@ -1,4 +1,4 @@
-import type { AggFunc, Column, RowNode, GridApi } from '../types';
+import type { AggFunc, Column, GridApi, RowNode } from '../types';
 export declare function getValueForColumn(column: Column, node: RowNode, api: GridApi): any;
 export declare function formatValue(column: Column, node: RowNode, api: GridApi): string | null;
 export declare function applyBuiltInFormatter(name: string, value: any, params?: {

package/dist/types/createGrid.d.ts

@@ -0,0 +1,10 @@
+import { Grid } from './grid';
+import type { ColumnApi, GridApi, GridOptions } from './types';
+/**
+ * Create a grid inside the given element. Mirrors ag-grid's createGrid().
+ */
+export declare function createGrid(eGridDiv: HTMLElement, gridOptions: GridOptions): {
+    api: GridApi;
+    columnApi: ColumnApi;
+    grid: Grid;
+};

package/dist/types/features/chartService.d.ts

@@ -1,15 +1,7 @@
+export type { ChartData, ChartType } from '../core/gridHost';
+import type { ChartData, ChartType, GridHost as Grid } from '../core/gridHost';
 import type { Column } from '../types';
-import type { Grid } from '../grid';
 import type { PopupService } from './popupService';
-export type ChartType = 'line' | 'area' | 'column' | 'bar' | 'pie' | 'scatter';
-interface ChartSeries {
-    title: string;
-    data: number[];
-}
-export interface ChartData {
-    categories: string[];
-    series: ChartSeries[];
-}
 export declare class ChartService {
     private grid;
     private popupService;
@@ -46,4 +38,3 @@ export declare class ChartService {
     private formatTick;
     private truncate;
 }
-export {};

package/dist/types/features/columnMenu.d.ts

@@ -1,5 +1,5 @@
+import type { GridHost as Grid } from '../core/gridHost';
 import type { Column } from '../types';
-import type { Grid } from '../grid';
 import type { PopupService } from './popupService';
 export declare class ColumnMenuService {
     private grid;

package/dist/types/features/contextMenu.d.ts

@@ -1,17 +1,6 @@
-import type { Grid } from '../grid';
+export type { MenuItem } from '../core/gridHost';
+import type { GridHost as Grid } from '../core/gridHost';
 import type { PopupService } from './popupService';
-export interface MenuItem {
-    name: string;
-    label?: string;
-    icon?: string;
-    disabled?: boolean;
-    checked?: boolean;
-    subMenu?: MenuItem[];
-    action?: () => void;
-    separator?: boolean;
-    cssClasses?: string[];
-    shortcut?: string;
-}
 export declare class ContextMenuService {
     private grid;
     private popupService;

package/dist/types/features/editService.d.ts

@@ -1,11 +1,7 @@
-import type { Column, RowNode } from '../types';
+export type { FocusedCell } from '../core/gridHost';
 import type { EventService } from '../core/eventService';
-import type { Grid } from '../grid';
-export interface FocusedCell {
-    rowIndex: number;
-    column: Column;
-    rowNode: RowNode;
-}
+import type { FocusedCell, GridHost as Grid } from '../core/gridHost';
+import type { Column, RowNode } from '../types';
 export declare class EditService {
     private grid;
     private eventService;
@@ -14,7 +10,6 @@ export declare class EditService {
     private fullRowEditors;
     private fullRowNode;
     private focusedCell;
-    private suppressClickEdit;
     constructor(grid: Grid, eventService: EventService);
     getFocusedCell(): FocusedCell | null;
     setFocusedCell(rowIndex: number, column: Column): void;

package/dist/types/features/exportService.d.ts

@@ -1,6 +1,6 @@
-import type { ExportParams } from '../types';
-import type { Grid } from '../grid';
+import type { GridHost as Grid } from '../core/gridHost';
 import { escapeHtml } from '../core/utils';
+import type { ExportParams } from '../types';
 export declare class ExportService {
     private grid;
     private lastCopied;
@@ -8,6 +8,7 @@ export declare class ExportService {
     private getExportColumns;
     private getExportRows;
     private getCellValueForExport;
+    private groupValue;
     getDataAsCsv(params?: ExportParams): string;
     private csvRow;
     getDataAsExcel(params?: ExportParams): Blob;

package/dist/types/features/filterGui.d.ts

@@ -1,5 +1,5 @@
+import type { GridHost as Grid } from '../core/gridHost';
 import type { Column } from '../types';
-import type { Grid } from '../grid';
 import { PopupService } from './popupService';
 export declare class FilterGui {
     private grid;

package/dist/types/features/filterService.d.ts

@@ -1,18 +1,6 @@
+export type { AdvancedFilterCondition, AdvancedFilterModel } from '../core/gridHost';
+import type { AdvancedFilterModel, GridHost as Grid } from '../core/gridHost';
 import type { Column, FilterModelItem } from '../types';
-import type { Grid } from '../grid';
-export interface AdvancedFilterCondition {
-    colId: string;
-    type: string;
-    filter?: any;
-    filterTo?: any;
-    dateFrom?: string;
-    dateTo?: string;
-}
-export interface AdvancedFilterModel {
-    filterType: 'advanced';
-    operator: 'AND' | 'OR';
-    conditions: AdvancedFilterCondition[];
-}
 export declare class FilterService {
     private grid;
     private filterModel;

package/dist/types/features/findService.d.ts

@@ -1,4 +1,4 @@
-import type { Grid } from '../grid';
+import type { GridHost as Grid } from '../core/gridHost';
 import type { PopupService } from './popupService';
 export declare class FindService {
     private grid;

package/dist/types/features/formulaEditor.d.ts

@@ -1,5 +1,5 @@
+import type { GridHost as Grid } from '../core/gridHost';
 import type { Column } from '../types';
-import type { Grid } from '../grid';
 import type { PopupService } from './popupService';
 /** Formula editor popup — edits a column's formula (calculated columns). */
 export declare class FormulaEditorService {

package/dist/types/features/notesService.d.ts

@@ -1,9 +1,5 @@
-import type { Grid } from '../grid';
+import type { GridHost as Grid, NoteKey } from '../core/gridHost';
 import type { PopupService } from './popupService';
-interface NoteKey {
-    rowNodeId: string;
-    colId: string;
-}
 /**
  * Cell Notes (ag-grid Notes) — note markers in cell corners with an editor popup.
  * Notes can be declared per column (colDef.note) or set at runtime via the API.

package/dist/types/features/overlays.d.ts

@@ -1,4 +1,4 @@
-import type { Grid } from '../grid';
+import type { GridHost as Grid } from '../core/gridHost';
 export declare class OverlayService {
     private grid;
     private eOverlayWrapper;

package/dist/types/features/paginationService.d.ts

@@ -1,5 +1,5 @@
-import type { Grid } from '../grid';
 import type { EventService } from '../core/eventService';
+import type { GridHost as Grid } from '../core/gridHost';
 export declare class PaginationService {
     private grid;
     private eventService;
@@ -10,7 +10,6 @@ export declare class PaginationService {
     private ePanel;
     private ePageInfo;
     private ePageInput;
-    private ePageSizeSelect;
     private ePageSizeContainer;
     private eFromToContainer;
     constructor(grid: Grid, eventService: EventService);

package/dist/types/features/popupService.d.ts

@@ -1,4 +1,4 @@
-import type { Grid } from '../grid';
+import type { GridHost as Grid } from '../core/gridHost';
 /** Generic popup used by filters, menus, find bar and chart panel. */
 export declare class PopupService {
     private grid;

package/dist/types/features/rangeSelection.d.ts

@@ -1,12 +1,6 @@
-import type { Grid } from '../grid';
 import type { EventService } from '../core/eventService';
+import type { GridHost as Grid, RangeState } from '../core/gridHost';
 import type { Column } from '../types';
-interface RangeState {
-    rowStartIndex: number;
-    rowEndIndex: number;
-    colStartId: string;
-    colEndId: string;
-}
 export declare class RangeSelectionService {
     private grid;
     private eventService;
@@ -40,4 +34,3 @@ export declare class RangeSelectionService {
     getCurrentRange(): RangeState | null;
     onGridKeyDown(event: KeyboardEvent): void;
 }
-export {};

package/dist/types/features/rowDragService.d.ts

@@ -1,5 +1,5 @@
-import type { Grid } from '../grid';
 import type { EventService } from '../core/eventService';
+import type { GridHost as Grid } from '../core/gridHost';
 import type { RowNode } from '../types';
 /**
  * Row Dragging — managed (grid reorders the data) and unmanaged (app receives

package/dist/types/features/rowGroupPanel.d.ts

@@ -1,4 +1,4 @@
-import type { Grid } from '../grid';
+import type { GridHost as Grid } from '../core/gridHost';
 /** The "Row Groups" drop strip shown above the header (rowGroupPanelShow). */
 export declare class RowGroupPanel {
     private grid;

package/dist/types/features/selectionService.d.ts

@@ -1,5 +1,5 @@
-import type { RowNode } from '../types';
 import type { EventService } from '../core/eventService';
+import type { RowNode } from '../types';
 export declare class SelectionService {
     private eventService;
     private getOptions;