Tree

Module Extensions

`ColumnRegular` (Extended from `@revolist/revogrid`)

1
interface ColumnRegular {
2
  /**
3
       * Enables tree template on cells
4
       */
5
      tree?: boolean
6
}

`HTMLRevoGridElement` (Extended from `global`)

1
interface HTMLRevoGridElement {
2
  tree?: TreeConfig
3
}

`AdditionalData` (Extended from `@revolist/revogrid`)

1
interface AdditionalData {
2
  /**
3
       * Additional data property tree
4
       * @deprecated Use `grid.tree` instead.
5
       *
6
       * @example
7
       * ```typescript
8
       * const grid = document.createElement('revo-grid');
9
       * grid.additionalData = {
10
       *   tree: {
11
       *     idField: 'id',
12
       *     parentIdField: 'parentId',
13
       *     rootParentId: null,
14
       *     expandAll: true,
15
       *     expandedRowIds: new Set(),
16
       *   },
17
       * };
18
       * ```
19
       */
20
      tree?: TreeConfig
21
}

`HTMLRevoGridElementEventMap` (Extended from `global`)

1
interface HTMLRevoGridElementEventMap {
2
  [TREE_ROW_SELECT_EVENT]: TreeRowSelectEvent;
3
  [TREE_TOGGLE_EVENT]: { rowId: any };
4
  [TREE_EXPAND_ALL_EVENT]: undefined;
5
  [TREE_COLLAPSE_ALL_EVENT]: undefined;
6
  [TREE_STATE_CHANGED_EVENT]: { expandedRowIds: Set<any> }
7
}

Plugin API

`TreeDataPlugin`

The TreeDataPlugin now uses Revogrid’s row trimming mechanism without modifying the original data.

All tree metadata (level, expanded, hasChildren, visible) is computed separately and stored in a Map. The plugin builds a parent→children mapping from the original flat data and then recursively computes, for each row, its tree level and whether it should be visible based on the expanded/collapsed state of its ancestors.

The cell template uses a supplied “getMeta” function to look up computed tree metadata for rendering (indentation and expand/collapse icons) without changing the underlying row.

Usage Example:

1
import { TreeDataPlugin } from './tree/index';
2

3
const grid = document.createElement('revo-grid');
4
grid.plugins = [TreeDataPlugin];
5

6
grid.columns = [
7
  {
8
    prop: 'treeColumn',
9
    name: 'Hierarchy',
10
    tree: true,
11
    cellTemplate: TreeCellTemplate, // or you can let the plugin override it
12
  },
13
];

Dependencies

Event integration row-order: Integrates with RowOrderPlugin row order events to reparent tree rows after drag and drop.
Event integration row-select: Integrates with RowSelectPlugin row selection events for parent and descendant selection.
Event integration DimensionAnimationPlugin: Auto-installs DimensionAnimationPlugin when tree.animation is enabled to animate tree collapse and expand trim changes.

1
class TreeDataPlugin {
2
  /** Whether tree configuration or tree-enabled columns currently activate this plugin. */
3
  isActive(): boolean;
4

5
  /** Active structural properties used by tree-safe editing integrations. */
6
  getStructuralProps(): ReadonlySet<string>;
7

8
  /** Resolve stable node identity and computed hierarchy state for a source row. */
9
  getNodeContext<T extends DataType = DataType>(
10
    model: T,
11
    type: DimensionRows = 'rgRow',
12
  ): TreeNodeContext<T> | undefined;
13

14
  /** Resolve whether a hierarchy mutation is valid without changing source state. */
15
  getMutationState<T extends DataType = DataType>(
16
    request: TreeMutationRequest<T>,
17
  ): TreeMutationState<T>;
18

19
  /**
20
     * Validate and commit one tree hierarchy mutation. Existing moved rows retain
21
     * object identity; row creation is completed and validated before any write.
22
     */
23
  async mutate<T extends DataType = DataType>(
24
    request: TreeMutationRequest<T>,
25
  ): Promise<TreeMutationResult<T>>;
26

27
  /** Capture stable ID-based hierarchy state for HistoryPlugin replay. */
28
  getStructureSnapshot(type: DimensionRows = 'rgRow'): TreeStructureSnapshot;
29

30
  /** Restore a stable ID-based hierarchy snapshot without replacing row objects. */
31
  applyStructureSnapshot(snapshot: TreeStructureSnapshot): boolean;
32

33
  /**
34
     * Recomputes the tree metadata for every row in the original data and builds a trimmed map.
35
     * Call this method after the original data/order/visibility/set changes
36
     *
37
     * This method builds a parent→children mapping (without modifying the original data) and then
38
     * recursively computes for each row:
39
     *  - its level (indentation),
40
     *  - whether it is expanded (based on the expandedRowIds set),
41
     *  - whether it has children,
42
     *  - and whether it should be visible (i.e. none of its ancestors are collapsed).
43
     *
44
     * The trimmed map is then applied via providers.data.setTrimmed().
45
     */
46
  async updateTree(type?: DimensionRows, animate = true);
47

48
  /**
49
     * Toggle the expanded state for a row and then re-calculate tree metadata.
50
     */
51
  toggleRowExpanded(row: DataType);
52

53
  getExpandedRowIds();
54

55
  toggleRowExpandedById(rowId: any);
56

57
  expandAll();
58

59
  collapseAll();
60

61
  /**
62
     * Gets all descendant row IDs (children, grandchildren, etc.) for a given row
63
     * @param rowId - The ID of the row to get descendants for
64
     * @returns Array of physical indices of all descendant rows
65
     */
66
  public getAllDescendantPhysicalIndices(rowId: any, type: DimensionRows = 'rgRow'): number[];
67
}

`TreeMeta`

This is the shape of computed tree metadata. Notice that nothing is stored on the row itself.

1
interface TreeMeta {
2
  level: number;
3
  expanded: boolean;
4
  hasChildren: boolean;
5
  visible: boolean;
6
  parentId: any
7
}

`TreeConfig`

1
interface TreeConfig {
2
  idField?: string;
3
  parentIdField?: string;
4
  rootParentId?: any;
5
  expandAll?: boolean;
6
  expandedRowIds?: Set<any>;
7
  /**
8
     * Mark tree parent rows as sticky through StickyCellsPlugin.
9
     *
10
     * Parent detection uses the row model fields configured by `idField` and
11
     * `parentIdField`, plus tree metadata computed by TreeDataPlugin. It does not
12
     * depend on virtual row indexes.
13
     *
14
     * This option only adds sticky behavior to tree-enabled columns. Register
15
     * StickyCellsPlugin separately to render those parent rows in pinned top rows.
16
     *
17
     * @default false
18
     */
19
    stickyParents?: boolean;
20
  /**
21
     * Animate tree collapse and expand through DimensionAnimationPlugin.
22
     *
23
     * TreeDataPlugin auto-registers DimensionAnimationPlugin when this option is
24
     * enabled and the dimension animation plugin is not already registered.
25
     *
26
     * @default false
27
     */
28
    animation?: boolean
29
}

`TreeRowSelectEvent`

Event emitted when a tree row with children is selected. This event allows for custom handling of parent-child selection relationships.

1
interface TreeRowSelectEvent {
2
  /** The row type (e.g., 'rgRow') */
3
    type: DimensionRows;
4
  /** The physical index of the parent row in the source data */
5
    parentIndex: number;
6
  /** Array of physical indices of all descendant rows */
7
    childrenIndices: number[];
8
  /** The original row selection event that triggered this tree selection */
9
    originalEvent?: any
10
}

`TreeSelectionProvider`

Runtime contract exposed by TreeDataPlugin for plugins that need tree descendant lookup without depending on the TreeDataPlugin class.

1
interface TreeSelectionProvider {
2
  getAllDescendantPhysicalIndices(rowId: unknown, type: DimensionRows): number[]
3
}

`TreeMutationAction`

1
export type TreeMutationAction =
2
  | 'moveUp'
3
  | 'moveDown'
4
  | 'indent'
5
  | 'outdent'
6
  | 'insertSiblingAbove'
7
  | 'insertSiblingBelow'
8
  | 'insertChild'
9
  | 'duplicate'
10
  | 'delete';

`TreeMutationUnavailableReason`

1
export type TreeMutationUnavailableReason =
2
  | 'inactive'
3
  | 'invalid-tree'
4
  | 'invalid-selection'
5
  | 'mixed-parent'
6
  | 'missing-factory'
7
  | 'first-sibling'
8
  | 'last-sibling'
9
  | 'no-previous-sibling'
10
  | 'root-level'
11
  | 'cancelled';

`TreeNodeContext` (Extended from `index.ts`)

1
interface TreeNodeContext {
2
  readonly type: DimensionRows;
3
  readonly model: T;
4
  readonly physicalIndex: number;
5
  readonly id: unknown
6
}

`TreeMutationCreateContext`

1
interface TreeMutationCreateContext {
2
  readonly action: Extract<
3
      TreeMutationAction,
4
      'insertSiblingAbove' | 'insertSiblingBelow' | 'insertChild' | 'duplicate'
5
    >;
6
  readonly anchorRow: T;
7
  readonly sourceRow?: T;
8
  readonly parentRow?: T;
9
  readonly depth: number
10
}

`TreeMutationRowFactory`

1
export type TreeMutationRowFactory<T extends DataType = DataType> = (
2
  context: TreeMutationCreateContext<T>,
3
) => T | null | undefined | Promise<T | null | undefined>;

`TreeMutationRequest`

1
interface TreeMutationRequest {
2
  readonly action: TreeMutationAction;
3
  readonly type: DimensionRows;
4
  readonly models: readonly T[];
5
  readonly createRow?: TreeMutationRowFactory<T>
6
}

`TreeMutationState`

1
interface TreeMutationState {
2
  readonly available: boolean;
3
  readonly reason?: TreeMutationUnavailableReason;
4
  readonly roots: readonly T[]
5
}

`TreeMutationResult` (Extended from `index.ts`)

1
interface TreeMutationResult {
2
  readonly applied: boolean;
3
  readonly createdRows?: readonly T[];
4
  readonly deletedRows?: readonly T[]
5
}

`TreeStructureSnapshot`

1
interface TreeStructureSnapshot {
2
  readonly type: DimensionRows;
3
  readonly orderedRowIds: readonly unknown[];
4
  readonly parentByRowId: readonly (readonly [unknown, unknown])[];
5
  readonly expandedRowIds: readonly unknown[]
6
}

`composeTreeCellTemplate`

Compose the structural tree affordance with a replaceable value renderer. Other plugins may replace the value renderer without removing indentation or the expand/collapse control.

1
export function composeTreeCellTemplate(
2
  treeTemplate: CellTemplate,
3
  valueTemplate: CellTemplate,
4
): CellTemplate;

`getTreeCellValueTemplate`

Return the application/value renderer wrapped by a tree template.

1
export function getTreeCellValueTemplate(
2
  template: CellTemplate | undefined,
3
): CellTemplate | undefined;

`replaceTreeCellValueTemplate`

Replace only the value renderer when the supplied template is tree-composed.

1
export function replaceTreeCellValueTemplate(
2
  template: CellTemplate | undefined,
3
  valueTemplate: CellTemplate,
4
): CellTemplate;

`TREE_CELL_TEMPLATE`

1
TREE_CELL_TEMPLATE: typeof TREE_CELL_TEMPLATE;

`TreeCellTemplate`

The TreeCellTemplate now receives an extra “getMeta” callback that provides the computed tree metadata for the given row. It does not assume that any tree information has been stored on the row itself.

1
TreeCellTemplate: (toggleRowExpanded: (data: DataType) => void, getMeta: (row: DataType) => TreeMeta) => CellTemplate<DataType<any, ColumnProp>>;

`analyzeTreeMutation`

1
export function analyzeTreeMutation<T extends DataType>(
2
  options: TreeMutationOptions<T>,
3
): TreeMutationState<T>;

`planTreeMutation`

1
export async function planTreeMutation<T extends DataType>(
2
  options: TreeMutationOptions<T>,
3
): Promise<TreeMutationPlan<T>>;

`TreeMutationPlan` (Extended from `index.ts`)

1
interface TreeMutationPlan {
2
  readonly source: readonly T[];
3
  readonly parentChanges: readonly {
4
      readonly model: T;
5
      readonly previousParentId: unknown;
6
      readonly parentId: unknown;
7
    }[];
8
  readonly expandedRowIds: readonly unknown[]
9
}

`TreeAnimationUpdate`

1
export type TreeAnimationUpdate = {
2
  cancelledIndexes: number[];
3
  reused: boolean;
4
  version: number;
5
};

`TreeAnimationCoordinator`

1
class TreeAnimationCoordinator {
2
  beginUpdate({
3
    type,
4
    nextTrimmed,
5
    source,
6
    proxyItems,
7
  }: BeginTreeAnimationUpdateOptions): TreeAnimationUpdate;
8

9
  reset(type: DimensionRows): number[];
10

11
  isCurrent(type: DimensionRows, version: number): boolean;
12

13
  canAnimate(type: DimensionRows, dimensionAnimation?: DimensionAnimationPlugin): dimensionAnimation is DimensionAnimationPlugin;
14

15
  markInitialized(type: DimensionRows, sourceLength: number);
16

17
  hasTrimChanges(
18
    currentTrimmed: Record<number, boolean>,
19
    nextTrimmed: Record<number, boolean>,
20
  ): boolean;
21

22
  async applyAnimatedTrim({
23
    applyTrim,
24
    currentTrimmed,
25
    dimensionAnimation,
26
    nextTrimmed,
27
    proxyItems,
28
    source,
29
    type,
30
    version,
31
  }: {
32
    applyTrim: (trimmed: Record<number, boolean>) => void;
33
    currentTrimmed: Record<number, boolean>;
34
    dimensionAnimation: DimensionAnimationPlugin;
35
    nextTrimmed: Record<number, boolean>;
36
    proxyItems: number[];
37
    source: DataType[];
38
    type: DimensionRows;
39
    version: number;
40
  }): Promise<boolean>;
41
}

`resolveTreeFilterTypes`

1
export function resolveTreeFilterTypes(detail: TreeFilterEventDetail): string[];

`resolveTreeFilterTrim`

Keeps complete hierarchy context around rows that match an active filter.

The filter plugin marks non-matching physical row indexes as trimmed. Positive filtering closes the matching set in both directions: ancestors remain as the path to a deep match, and descendants remain as the branch owned by a matching parent. Exclusion-only filters instead prune complete subtrees rooted at excluded rows. Unrelated branches keep the filter plugin’s trim decisions.

1
export function resolveTreeFilterTrim({
2
  filterTrimmed,
3
  filterTypes,
4
  idField,
5
  parentIdField,
6
  rootParentId,
7
  source,
8
}: TreeFilterTrimOptions): TrimmedEntity;

`TreeFilterTrimOptions`

1
export type TreeFilterTrimOptions = {
2
  filterTrimmed: TrimmedEntity;
3
  filterTypes?: readonly string[];
4
  idField: string;
5
  parentIdField: string;
6
  rootParentId: any;
7
  source: DataType[];
8
};

`TreeFilterEventDetail`

1
interface TreeFilterEventDetail {
2
  collection?: Record<string, { type?: string }>;
3
  filterItems?: Record<string, Array<{ type?: string }>>
4
}

`TreeRowOrderController`

1
class TreeRowOrderController {
2
  isParentUpdatePending(type: DimensionRows): boolean;
3

4
  handleDragEnd();
5

6
  handleDropValidation(context: RowOrderDropValidationContext): TreeDropValidation;
7

8
  handleRowDrop(e: CustomEvent<RowOrderChange>);
9

10
  highlightDropTarget(context: RowOrderDropStateChange);
11

12
  clearDropTarget();
13
}

`isTreeRowType`

1
export function isTreeRowType(type: unknown): type is DimensionRows;

`buildTreeChildIndex`

1
export function buildTreeChildIndex({
2
  idField,
3
  parentIdField,
4
  rootParentId,
5
  source,
6
}: {
7
  idField: string;
8
  parentIdField: string;
9
  rootParentId: any;
10
  source: DataType[];
11
}): TreeChildIndex;

`collectDescendantPhysicalIndices`

1
export function collectDescendantPhysicalIndices(
2
  childrenByParent: TreeChildIndex,
3
  rowId: any,
4
): number[];

`resolveTreeTrimState`

1
export function resolveTreeTrimState(
2
  allTrimmed: Record<string, Record<number, boolean>> = {},
3
): TreeTrimState;

`computeTreeState`

1
export function computeTreeState({
2
  expandedRowIds,
3
  idField,
4
  items,
5
  outsideTrimmed,
6
  parentIdField,
7
  rootParentId,
8
  source,
9
}: {
10
  expandedRowIds: Set<any>;
11
  idField: string;
12
  items: number[];
13
  outsideTrimmed: TrimmedEntity;
14
  parentIdField: string;
15
  rootParentId: any;
16
  source: DataType[];
17
}): TreeState;

`collectExpandableRowIds`

1
export function collectExpandableRowIds({
2
  idField,
3
  parentIdField,
4
  rootParentId,
5
  source,
6
}: {
7
  idField: string;
8
  parentIdField: string;
9
  rootParentId: any;
10
  source: DataType[];
11
}): Set<any>;

`TRIMMED_COLLAPSED`

1
TRIMMED_COLLAPSED: string;

`TREE_ROW_TYPES`

1
TREE_ROW_TYPES: DimensionRows[];

`TreeState`

1
export type TreeState = {
2
  itemParentOrder: number[];
3
  metaData: Map<any, TreeMeta>;
4
  rowMetaEntries: Array<[DataType, TreeMeta]>;
5
  trimmed: Record<number, boolean>;
6
};

`TreeChildIndex`

1
export type TreeChildIndex = Map<any, Array<{
2
  id: any;
3
  physicalIndex: number;
4
}>>;

`TreeTrimState`

1
export type TreeTrimState = {
2
  currentTreeTrimmed: Record<number, boolean>;
3
  outsideTrimmed: TrimmedEntity;
4
};

`TreeRuntimeState`

1
class TreeRuntimeState {
2
  setConfig(options: TreeConfig = {});
3

4
  snapshotExpandedRowIds(): Set<any>;
5

6
  toggleExpanded(rowId: any);
7

8
  setExpandedRowIds(expandedRowIds: Set<any>);
9

10
  clearExpandedRowIds();
11

12
  setExpandAllPending(pending: boolean);
13
}

`isNoopTreeDrop`

1
export function isNoopTreeDrop({
2
  dropPosition,
3
  from,
4
  itemCount,
5
  targetIndex,
6
  targetRow,
7
  visibleRowIndexes,
8
}: {
9
  dropPosition?: RowOrderDropValidationContext['dropPosition'];
10
  from: number;
11
  itemCount: number;
12
  targetIndex: number;
13
  targetRow?: number;
14
  visibleRowIndexes?: number[];
15
}): boolean;

`resolveTreeDropParentId`

1
export function resolveTreeDropParentId({
2
  dropPosition,
3
  expandedRowIds,
4
  from,
5
  idField,
6
  itemCount,
7
  parentIdField,
8
  rootParentId,
9
  store,
10
  targetIndex,
11
  targetRow,
12
  visibleRowIndexes,
13
}: {
14
  dropPosition?: RowOrderDropValidationContext['dropPosition'];
15
  expandedRowIds: Set<unknown>;
16
  from: number;
17
  idField: string;
18
  itemCount?: number;
19
  parentIdField: string;
20
  rootParentId: unknown;
21
  store: DataStore<DataType, DimensionRows>['store'];
22
  targetIndex: number;
23
  targetRow?: number;
24
  visibleRowIndexes?: number[];
25
}): unknown;

`validateTreeRowDrop`

1
export function validateTreeRowDrop({
2
  context,
3
  idField,
4
  metaData,
5
  newParentId,
6
  rootParentId,
7
}: {
8
  context: RowOrderDropValidationContext;
9
  idField: string;
10
  metaData: Map<unknown, { parentId?: unknown }>;
11
  newParentId: unknown;
12
  rootParentId: unknown;
13
}): RowOrderDropValidationResult;

`resolveTreeDropValidation`

1
export function resolveTreeDropValidation({
2
  context,
3
  expandedRowIds,
4
  idField,
5
  metaData,
6
  parentIdField,
7
  rootParentId,
8
  store,
9
}: {
10
  context: RowOrderDropValidationContext;
11
  expandedRowIds: Set<unknown>;
12
  idField: string;
13
  metaData: Map<unknown, { parentId?: unknown }>;
14
  parentIdField: string;
15
  rootParentId: unknown;
16
  store: DataStore<DataType, DimensionRows>['store'];
17
}): {
18
  newParentId: unknown;
19
  result: RowOrderDropValidationResult;
20
} | null;

`moveProxySubtreesAfterTarget`

1
export function moveProxySubtreesAfterTarget({
2
  idField,
3
  movedPhysicalIndexes,
4
  parentIdField,
5
  proxyItems,
6
  source,
7
  targetPhysicalIndex,
8
}: {
9
  idField: string;
10
  movedPhysicalIndexes: number[];
11
  parentIdField: string;
12
  proxyItems: number[];
13
  source: DataType[];
14
  targetPhysicalIndex: number;
15
}): number[];

`moveProxySubtreesToTarget`

1
export function moveProxySubtreesToTarget({
2
  idField,
3
  insert,
4
  movedPhysicalIndexes,
5
  parentIdField,
6
  proxyItems,
7
  source,
8
  targetPhysicalIndex,
9
}: {
10
  idField: string;
11
  insert: 'before' | 'after' | 'after-subtree';
12
  movedPhysicalIndexes: number[];
13
  parentIdField: string;
14
  proxyItems: number[];
15
  source: DataType[];
16
  targetPhysicalIndex: number;
17
}): number[];

`applyTreeStickyParentColumns`

1
export function applyTreeStickyParentColumns(
2
  columnsByType: ColumnCollection['columns'],
3
  resolveStickyCell: (model: CellTemplateProp, stickyCell: StickyCellPredicate | undefined) => boolean,
4
);

`resolveTreeStickyCell`

1
export function resolveTreeStickyCell(
2
  model: CellTemplateProp,
3
  stickyCell: StickyCellPredicate | undefined,
4
  context: TreeStickyCellContext,
5
): boolean;

`getStickyTreeConfig`

1
export function getStickyTreeConfig(revogrid: HTMLRevoGridElement): TreeConfig | undefined;

`resolveActiveTreeStickyRows`

1
export function resolveActiveTreeStickyRows({
2
  rowIndex,
3
  maxRows,
4
  config,
5
  includeRow = true,
6
  rowStore,
7
  resolveStickyColumns,
8
}: ActiveTreeStickyRowsContext): number[];

`TreeStickyCellContext`

1
interface TreeStickyCellContext {
2
  config: TreeConfig | undefined;
3
  getMeta(row: DataType): TreeMeta
4
}

`ActiveTreeStickyRowsContext`

1
interface ActiveTreeStickyRowsContext {
2
  rowIndex: number;
3
  maxRows: number;
4
  config: TreeConfig;
5
  includeRow?: boolean;
6
  rowStore: {
7
      get(key: 'source'): DataType[];
8
      get(key: 'items'): number[];
9
    };
10
  resolveStickyColumns(rowIndex: number): boolean
11
}

Tree

Module Extensions

ColumnRegular (Extended from @revolist/revogrid)

HTMLRevoGridElement (Extended from global)

AdditionalData (Extended from @revolist/revogrid)

HTMLRevoGridElementEventMap (Extended from global)

Plugin API

TreeDataPlugin

Dependencies

TreeMeta

TreeConfig

TreeRowSelectEvent

TreeSelectionProvider

TreeMutationAction

TreeMutationUnavailableReason

TreeNodeContext (Extended from index.ts)

TreeMutationCreateContext

TreeMutationRowFactory

TreeMutationRequest

TreeMutationState

TreeMutationResult (Extended from index.ts)

TreeStructureSnapshot

composeTreeCellTemplate

getTreeCellValueTemplate

replaceTreeCellValueTemplate

TREE_CELL_TEMPLATE

TreeCellTemplate

analyzeTreeMutation

planTreeMutation

TreeMutationPlan (Extended from index.ts)

TreeAnimationUpdate

TreeAnimationCoordinator

resolveTreeFilterTypes

resolveTreeFilterTrim

TreeFilterTrimOptions

TreeFilterEventDetail

TreeRowOrderController

isTreeRowType

buildTreeChildIndex

collectDescendantPhysicalIndices

resolveTreeTrimState

computeTreeState

collectExpandableRowIds

TRIMMED_COLLAPSED

TREE_ROW_TYPES

TreeState

TreeChildIndex

TreeTrimState

TreeRuntimeState

isNoopTreeDrop

resolveTreeDropParentId

validateTreeRowDrop

resolveTreeDropValidation

moveProxySubtreesAfterTarget

moveProxySubtreesToTarget

applyTreeStickyParentColumns

resolveTreeStickyCell

getStickyTreeConfig

resolveActiveTreeStickyRows

TreeStickyCellContext

ActiveTreeStickyRowsContext