@revolist/revogrid 4.0.2-next → 4.0.2

package/dist/types/index.d.ts

@@ -1 +1,15 @@
+export * from './types/dimension';
+export * from './types/interfaces';
+export * from './types/selection';
+export * from './types/theme';
+export * from './types/viewport.interfaces';
+export * from './types/plugin';
+export * from './types/plugin.types';
+export * from './plugins/base.plugin';
+export * from './plugins/dispatcher';
+export * from './store/dataSource';
+export * from './store/dimension';
+export * from './store/selection';
+export * from './store/storeTypes';
+export * from './store/viewport';
 export * from './components';

package/dist/types/plugins/base.plugin.d.ts

@@ -0,0 +1,49 @@
+import { PluginProviders, PluginBaseComponent } from '..';
+type WatchConfig = {
+    immediate: boolean;
+};
+/**
+ * Base layer for plugins
+ * Provide minimal starting core for plugins to work
+ * Extend this class to create plugin
+ */
+export declare class BasePlugin implements PluginBaseComponent {
+    protected revogrid: HTMLRevoGridElement;
+    protected providers: PluginProviders;
+    protected readonly subscriptions: Record<string, (...args: any[]) => void>;
+    constructor(revogrid: HTMLRevoGridElement, providers: PluginProviders);
+    /**
+     *
+     * @param eventName - event name to subscribe to in revo-grid component (e.g. 'beforeheaderclick')
+     * @param callback - callback function for event
+     */
+    protected addEventListener(eventName: string, callback: (e: CustomEvent) => void): void;
+    /**
+     * Subscribe to property change in revo-grid component
+     * You can return false in callback to prevent default value set
+     *
+     * @param prop - property name
+     * @param callback - callback function
+     * @param immediate - trigger callback immediately with current value
+     */
+    protected watch<T extends any>(prop: string, callback: (arg: T) => boolean | void, { immediate }?: Partial<WatchConfig>): void;
+    /**
+     * Remove event listener
+     * @param eventName
+     */
+    protected removeEventListener(eventName: string): void;
+    /**
+     * Emit event from revo-grid component
+     * Event can be cancelled by calling event.preventDefault() in callback
+     */
+    protected emit(eventName: string, detail?: any): CustomEvent<any>;
+    /**
+     * Clear all subscriptions
+     */
+    protected clearSubscriptions(): void;
+    /**
+     * Destroy plugin and clear all subscriptions
+     */
+    destroy(): void;
+}
+export {};

package/dist/types/plugins/column.auto-size.plugin.d.ts

@@ -0,0 +1,47 @@
+import { BasePlugin } from './base.plugin';
+import { PluginProviders } from '../';
+export type AutoSizeColumnConfig = {
+    mode?: ColumnAutoSizeMode;
+    /**
+     * autoSize for all columns
+     * if allColumnes true all columns treated as autoSize, worse for performance
+     * false by default
+     */
+    allColumns?: boolean;
+    /**
+     * assumption per characted size
+     * by default defined as 8, can be changed in this config
+     */
+    letterBlockSize?: number;
+    /** make size calculation exact
+     * by default it based on assumption each character takes some space defined in letterBlockSize */
+    preciseSize?: boolean;
+};
+declare enum ColumnAutoSizeMode {
+    headerClickAutosize = "headerClickAutoSize",
+    autoSizeOnTextOverlap = "autoSizeOnTextOverlap",
+    autoSizeAll = "autoSizeAll"
+}
+export default class AutoSizeColumnPlugin extends BasePlugin {
+    protected providers: PluginProviders;
+    private config?;
+    private autoSizeColumns;
+    private readonly letterBlockSize;
+    /** for config option when @preciseSize enabled */
+    private readonly precsizeCalculationArea;
+    /** for edge case when no columns defined before data */
+    private dataResolve;
+    private dataReject;
+    constructor(revogrid: HTMLRevoGridElement, providers: PluginProviders, config?: AutoSizeColumnConfig);
+    private setSource;
+    private getLength;
+    private afteredit;
+    private afterEditAll;
+    private getColumnSize;
+    private columnSet;
+    private clearPromise;
+    private isRangeEdit;
+    private initiatePresizeElement;
+    destroy(): void;
+}
+export {};

package/dist/types/plugins/column.stretch.plugin.d.ts

@@ -0,0 +1,22 @@
+import { ColumnItems } from '../services/dimension.provider';
+import { BasePlugin } from './base.plugin';
+import { PluginBaseComponent } from '../';
+import { PluginProviders } from '../';
+export default class StretchColumn extends BasePlugin {
+    protected providers: PluginProviders;
+    private stretchedColumn;
+    private readonly scrollSize;
+    constructor(revogrid: HTMLRevoGridElement, providers: PluginProviders);
+    private setScroll;
+    private activateChanges;
+    private dropChanges;
+    private apply;
+    /**
+     * Apply stretch changes
+     */
+    applyStretch(columns: ColumnItems): void;
+}
+/**
+ * Check plugin type is Stretch
+ */
+export declare function isStretchPlugin(plugin: PluginBaseComponent | StretchColumn): plugin is StretchColumn;

package/dist/types/plugins/dispatcher.d.ts

@@ -0,0 +1,16 @@
+export type Target = HTMLElement | Element | null;
+export type DispatchDetail = any;
+type Event = {
+    target: HTMLElement | null;
+    preventDefault(): void;
+};
+/**
+ * Dispatch custom event to element
+ */
+export declare function dispatch(target: Target, eventName: string, detail?: DispatchDetail): CustomEvent;
+export declare function dispatchByEvent(e: Event, eventName: string, detail: DispatchDetail): CustomEvent;
+/**
+ * Dispatch event by other event target
+ */
+export declare function dispatchOnEvent(e: MouseEvent | CustomEvent, eventName: string, detail?: any): CustomEvent;
+export {};

package/dist/types/plugins/export/csv.d.ts

@@ -1,9 +1,9 @@
 import { CSVFormat, DataInput, Formatter } from './types';
-export declare type CSVFormatter = (options: Partial<CSVFormat>, data: DataInput) => string;
+export type CSVFormatter = (options: Partial<CSVFormat>, data: DataInput) => string;
 export default class ExportCsv implements Formatter {
-  readonly options: Readonly<CSVFormat>;
-  constructor(options?: Partial<CSVFormat>);
-  doExport({ data, headers, props }: DataInput): string;
-  private prepareHeader;
-  private parseCell;
+    readonly options: Readonly<CSVFormat>;
+    constructor(options?: Partial<CSVFormat>);
+    doExport({ data, headers, props }: DataInput): string;
+    private prepareHeader;
+    private parseCell;
 }

package/dist/types/plugins/export/export.plugin.d.ts

@@ -1,24 +1,24 @@
 import { CSVFormat, Formatter } from './types';
-import BasePlugin from '../basePlugin';
+import { BasePlugin } from '../base.plugin';
 declare enum ExportTypes {
-  csv = "csv"
+    csv = "csv"
 }
-export declare type ExportFormat = Partial<CSVFormat>;
+export type ExportFormat = Partial<CSVFormat>;
 export default class ExportFilePlugin extends BasePlugin {
-  /** Exports string */
-  exportString(options?: ExportFormat, t?: ExportTypes): Promise<string>;
-  /** Exports Blob */
-  exportBlob(options?: ExportFormat, t?: ExportTypes): Promise<Blob>;
-  /** Export file */
-  exportFile(options?: ExportFormat, t?: ExportTypes): Promise<void>;
-  /** Blob object */
-  getBlob(formatter: Formatter): Promise<Blob>;
-  private beforeexport;
-  private getData;
-  private getColPerSource;
-  private getGroupHeaders;
-  private findGroupStartIndex;
-  private getSource;
-  private formatter;
+    /** Exports string */
+    exportString(options?: ExportFormat, t?: ExportTypes): Promise<string>;
+    /** Exports Blob */
+    exportBlob(options?: ExportFormat, t?: ExportTypes): Promise<Blob>;
+    /** Export file */
+    exportFile(options?: ExportFormat, t?: ExportTypes): Promise<void>;
+    /** Blob object */
+    getBlob(formatter: Formatter): Promise<Blob>;
+    private beforeexport;
+    private getData;
+    private getColPerSource;
+    private getGroupHeaders;
+    private findGroupStartIndex;
+    private getSource;
+    private formatter;
 }
 export {};

package/dist/types/plugins/export/types.d.ts

@@ -1,23 +1,23 @@
-import { RevoGrid } from '../../interfaces';
-export declare type ColSource = {
-  headers: string[][];
-  props: any[];
+import { DataType } from '../..';
+export type ColSource = {
+    headers: string[][];
+    props: any[];
 };
-export declare type DataInput = {
-  data: RevoGrid.DataType[];
+export type DataInput = {
+    data: DataType[];
 } & ColSource;
 export interface FormatterOptions {
-  mime: string;
-  encoding: string;
+    mime: string;
+    encoding: string;
 }
 export interface Formatter {
-  options: FormatterOptions;
-  doExport(data: DataInput): string;
+    options: FormatterOptions;
+    doExport(data: DataInput): string;
 }
 export interface CSVFormat extends FormatterOptions {
-  fileKind: 'csv';
-  bom: boolean;
-  columnDelimiter: string;
-  rowDelimiter: string;
-  filename?: string;
+    fileKind: 'csv';
+    bom: boolean;
+    columnDelimiter: string;
+    rowDelimiter: string;
+    filename?: string;
 }

package/dist/types/plugins/filter/filter.button.d.ts

@@ -1,10 +1,14 @@
-import { RevoGrid } from '../../interfaces';
+import { ColumnRegular } from '../../types/interfaces';
 export declare const FILTER_BUTTON_CLASS = "rv-filter";
 export declare const FILTER_BUTTON_ACTIVE = "active";
 export declare const FILTER_PROP = "hasFilter";
-declare type Props = {
-  column: RevoGrid.ColumnRegular;
+export declare const AND_OR_BUTTON = "and-or-button";
+export declare const TRASH_BUTTON = "trash-button";
+type Props = {
+    column: ColumnRegular;
 };
 export declare const FilterButton: ({ column }: Props) => any;
+export declare const TrashButton: () => any;
+export declare const AndOrButton: ({ isAnd }: any) => any;
 export declare function isFilterBtn(e: HTMLElement): true | Element;
 export {};

package/dist/types/plugins/filter/filter.plugin.d.ts

@@ -1,12 +1,23 @@
-import BasePlugin from '../basePlugin';
-import { RevoGrid } from '../../interfaces';
-import { FilterItem } from './filter.pop';
+import { BasePlugin } from '../base.plugin';
+import { MultiFilterItem } from './filter.pop';
 import { FilterType } from './filter.service';
 import { LogicFunction } from './filter.types';
-declare type CustomFilter = {
-  columnFilterType: string;
-  name: string;
-  func: LogicFunction;
+import { ColumnProp, ColumnRegular, DataType } from '../../types/interfaces';
+import { PluginProviders } from '../..';
+type CustomFilter = {
+    columnFilterType: string;
+    name: string;
+    func: LogicFunction;
+};
+export type FilterCaptions = {
+    title: string;
+    save: string;
+    reset: string;
+    cancel: string;
+};
+export type FilterLocalization = {
+    captions: FilterCaptions;
+    filterNames: Record<FilterType, string>;
 };
 /**
  * @typedef ColumnFilterConfig
@@ -14,46 +25,53 @@ declare type CustomFilter = {
  * @property {FilterCollection|undefined} collection - preserved filter data
  * @property {string[]|undefined} include - filters to be included, if defined everything else out of scope will be ignored
  * @property {Record<string, CustomFilter>|undefined} customFilters - hash map of {FilterType:CustomFilter}.
+ * @property {FilterLocalization|undefined} localization - translation for filter popup captions.
+ * @property {MultiFilterItem|undefined} multiFilterItems - data for multi filtering.
+ * @property {boolean|undefined} disableDynamicFiltering - disables dynamic filtering.
  * A way to define your own filter types per column
  */
-export declare type ColumnFilterConfig = {
-  collection?: FilterCollection;
-  include?: string[];
-  customFilters?: Record<string, CustomFilter>;
+/**
+ * @internal
+ */
+export type ColumnFilterConfig = {
+    collection?: FilterCollection;
+    include?: string[];
+    customFilters?: Record<string, CustomFilter>;
+    filterProp?: string;
+    localization?: FilterLocalization;
+    multiFilterItems?: MultiFilterItem;
+    disableDynamicFiltering?: boolean;
 };
-declare type FilterCollectionItem = {
-  filter: LogicFunction;
-  type: FilterType;
-  value?: any;
+type FilterCollectionItem = {
+    filter: LogicFunction;
+    type: FilterType;
+    value?: any;
 };
-export declare type FilterCollection = Record<RevoGrid.ColumnProp, FilterCollectionItem>;
+export type FilterCollection = Record<ColumnProp, FilterCollectionItem>;
 export declare const FILTER_TRIMMED_TYPE = "filter";
-export default class FilterPlugin extends BasePlugin {
-  protected revogrid: HTMLRevoGridElement;
-  private pop;
-  private filterCollection;
-  private possibleFilters;
-  private possibleFilterNames;
-  private possibleFilterEntities;
-  constructor(revogrid: HTMLRevoGridElement, uiid: string, config?: ColumnFilterConfig);
-  private initConfig;
-  private headerclick;
-  private getColumnFilter;
-  private isValidType;
-  private onFilterChange;
-  /**
-   * Apply filters collection to extend existing one or override
-   * @method
-   * @param conditions - list of filters to apply
-   */
-  filterByProps(conditions: Record<RevoGrid.ColumnProp, FilterItem>, override?: boolean): Promise<void>;
-  /**
-   * Triggers grid filtering
-   */
-  doFiltering(collection: FilterCollection, items: RevoGrid.DataType[], columns: RevoGrid.ColumnRegular[]): Promise<void>;
-  clearFiltering(): Promise<void>;
-  private runFiltering;
-  private getData;
-  private getRowFilter;
+export declare const FILTER_CONFIG_CHANGED_EVENT = "filterconfigchanged";
+export declare class FilterPlugin extends BasePlugin {
+    protected revogrid: HTMLRevoGridElement;
+    private pop;
+    private filterCollection;
+    private multiFilterItems;
+    private possibleFilters;
+    private possibleFilterNames;
+    private possibleFilterEntities;
+    private filterProp;
+    constructor(revogrid: HTMLRevoGridElement, providers: PluginProviders, uiid: string, config?: ColumnFilterConfig);
+    private initConfig;
+    private headerclick;
+    private getColumnFilter;
+    private isValidType;
+    private onFilterChange;
+    /**
+     * Triggers grid filtering
+     */
+    doFiltering(collection: FilterCollection, items: DataType[], columns: ColumnRegular[], filterItems: MultiFilterItem): Promise<void>;
+    clearFiltering(): Promise<void>;
+    private runFiltering;
+    private getData;
+    private getRowFilter;
 }
 export {};

package/dist/types/plugins/filter/filter.pop.d.ts

@@ -1,42 +1,67 @@
 import { EventEmitter, VNode } from '../../stencil-public-runtime';
 import { FilterType } from './filter.service';
-import { RevoGrid } from '../../interfaces';
-import '../../utils/closestPolifill';
+import '../../utils/closest.polifill';
 import { LogicFunction } from './filter.types';
-/**
- * @typedef FilterItem
- * @type {object}
- * @property {ColumnProp} prop - column id
- * @property {FilterType} type - filter type definition
- * @property {any} value - value for additional filtering, text value or some id
- */
-export declare type FilterItem = {
-  prop?: RevoGrid.ColumnProp;
-  type?: FilterType;
-  value?: any;
+import { FilterCaptions } from './filter.plugin';
+import { ColumnProp } from '../../types/interfaces';
+export type FilterItem = {
+    prop?: ColumnProp;
+    type?: FilterType;
+    value?: any;
+};
+export type FilterData = {
+    id: number;
+    type: FilterType;
+    value?: any;
+    relation: 'and' | 'or';
+};
+export type MultiFilterItem = {
+    [prop: string]: FilterData[];
 };
-export declare type ShowData = {
-  x: number;
-  y: number;
+export type ShowData = {
+    x: number;
+    y: number;
 } & FilterItem;
+/**
+ * Filter panel for editing filters
+ */
+/**
+ * @internal
+ */
 export declare class FilterPanel {
-  private extraElement;
-  changes: ShowData | undefined;
-  uuid: string;
-  filterTypes: Record<string, string[]>;
-  filterNames: Record<string, string>;
-  filterEntities: Record<string, LogicFunction>;
-  filterChange: EventEmitter<FilterItem>;
-  onMouseDown(e: MouseEvent): void;
-  show(newEntity?: ShowData): Promise<void>;
-  getChanges(): Promise<ShowData>;
-  renderConditions(type: FilterType): VNode[];
-  renderExtra(extra?: string, value?: any): any;
-  render(): any;
-  private onFilterChange;
-  private onInput;
-  private onKeyDown;
-  private onCancel;
-  private onSave;
-  private isOutside;
+    private filterCaptionsInternal;
+    isFilterIdSet: boolean;
+    filterId: number;
+    currentFilterId: number;
+    currentFilterType: FilterType;
+    changes: ShowData | undefined;
+    uuid: string;
+    filterItems: MultiFilterItem;
+    filterTypes: Record<string, string[]>;
+    filterNames: Record<string, string>;
+    filterEntities: Record<string, LogicFunction>;
+    filterCaptions: FilterCaptions | undefined;
+    disableDynamicFiltering: boolean;
+    filterChange: EventEmitter<MultiFilterItem>;
+    onMouseDown(e: MouseEvent): void;
+    show(newEntity?: ShowData): Promise<void>;
+    getChanges(): Promise<ShowData>;
+    componentWillRender(): void;
+    renderSelectOptions(type: FilterType, isDefaultTypeRemoved?: boolean): VNode[];
+    renderExtra(prop: ColumnProp, index: number): any;
+    getFilterItemsList(): any;
+    render(): any;
+    private onFilterTypeChange;
+    private debouncedApplyFilter;
+    private onAddNewFilter;
+    private addNewFilterToProp;
+    private onUserInput;
+    private onKeyDown;
+    private onSave;
+    private onCancel;
+    private onReset;
+    private onRemoveFilter;
+    private toggleFilterAndOr;
+    private assertChanges;
+    private isOutside;
 }

package/dist/types/plugins/filter/filter.service.d.ts

@@ -1,20 +1,20 @@
 import { LogicFunction } from './filter.types';
 export declare const filterNames: {
-  none: string;
-  empty: string;
-  notEmpty: string;
-  eq: string;
-  notEq: string;
-  begins: string;
-  contains: string;
-  notContains: string;
-  eqN: string;
-  neqN: string;
-  gt: string;
-  gte: string;
-  lt: string;
-  lte: string;
+    none: string;
+    empty: string;
+    notEmpty: string;
+    eq: string;
+    notEq: string;
+    begins: string;
+    contains: string;
+    notContains: string;
+    eqN: string;
+    neqN: string;
+    gt: string;
+    gte: string;
+    lt: string;
+    lte: string;
 };
-export declare type FilterType = keyof typeof filterNames;
+export type FilterType = keyof typeof filterNames;
 export declare const filterEntities: Record<FilterType, LogicFunction>;
 export declare const filterTypes: Record<string, FilterType[]>;

package/dist/types/plugins/filter/filter.types.d.ts

@@ -1,8 +1,8 @@
-export declare type DateEnum = 'today' | 'yesterday' | 'tomorrow' | 'thisweek' | 'lastweek' | 'nextweek' | 'thismonth' | 'lastmonth' | 'nextmonth' | 'thisyear' | 'lastyear' | 'nextyear';
-export declare type ExtraField = 'input' | 'select' | 'multi' | 'datepicker';
-export declare type LogicFunctionParam = any;
-export declare type LogicFunctionExtraParam = 'select' | 'input' | 'multi' | 'datepicker' | undefined | string | number | Date | DateEnum | null | undefined | string[] | number[];
-export declare type LogicFunction = {
-  (value: LogicFunctionParam, extra?: LogicFunctionExtraParam): boolean;
-  extra?: ExtraField;
+export type DateEnum = 'today' | 'yesterday' | 'tomorrow' | 'thisweek' | 'lastweek' | 'nextweek' | 'thismonth' | 'lastmonth' | 'nextmonth' | 'thisyear' | 'lastyear' | 'nextyear';
+export type ExtraField = 'input' | 'select' | 'multi' | 'datepicker';
+export type LogicFunctionParam = any;
+export type LogicFunctionExtraParam = 'select' | 'input' | 'multi' | 'datepicker' | undefined | string | number | Date | DateEnum | null | undefined | string[] | number[];
+export type LogicFunction = {
+    (value: LogicFunctionParam, extra?: LogicFunctionExtraParam): boolean;
+    extra?: ExtraField;
 };

package/dist/types/plugins/groupingColumn/columnGroupsRenderer.d.ts

@@ -1,16 +1,19 @@
 import { VNode } from '../../stencil-public-runtime';
-import { RevoGrid } from '../../interfaces';
 import { Group } from '../../store/dataSource/data.store';
-declare type Props = {
-  visibleProps: {
-    [prop: string]: number;
-  };
-  groups: Record<number, Group[]>;
-  dimensionCol: Pick<RevoGrid.DimensionSettingsState, 'indexes' | 'originItemSize' | 'indexToItem'>;
-  depth: number;
-  canResize: boolean;
-  providers: RevoGrid.Providers;
-  onResize(changedX: number, startIndex: number, endIndex: number): void;
-};
-declare const ColumnGroupsRenderer: ({ providers, depth, groups, visibleProps, dimensionCol, canResize, onResize }: Props) => VNode[];
+import { DimensionSettingsState, Providers } from '../../types/interfaces';
+import { ResizeProps } from '../..';
+import { DimensionCols } from '../../components';
+type Props<T> = {
+    visibleProps: {
+        [prop: string]: number;
+    };
+    groups: Record<number, Group[]>;
+    dimensionCol: Pick<DimensionSettingsState, 'indexes' | 'originItemSize' | 'indexToItem'>;
+    depth: number;
+    canResize: boolean;
+    providers: Providers<T>;
+    additionalData: any;
+    onResize(changedX: number, startIndex: number, endIndex: number): void;
+} & Partial<Pick<ResizeProps, 'active'>>;
+declare const ColumnGroupsRenderer: ({ additionalData, providers, depth, groups, visibleProps, dimensionCol, canResize, active, onResize }: Props<DimensionCols | 'rowHeaders'>) => VNode[];
 export default ColumnGroupsRenderer;

package/dist/types/plugins/groupingColumn/grouping.col.plugin.d.ts

@@ -1,13 +1,17 @@
-import { RevoGrid } from '../../interfaces';
 import { ColumnCollection } from '../../services/column.data.provider';
 import { Group as StoreGroup } from '../../store/dataSource/data.store';
-import BasePlugin from '../basePlugin';
+import { BasePlugin } from '../base.plugin';
+import { DimensionCols } from '../..';
+import { ColumnGrouping, ColumnRegular } from '../..';
 interface Group extends StoreGroup {
-  level: number;
+    level: number;
 }
-export declare type ColumnGrouping = Record<RevoGrid.DimensionCols, Group[]>;
+export type ColumnGroupingCollection = Record<DimensionCols, Group[]>;
 export default class GroupingColumnPlugin extends BasePlugin {
-  static gatherGroup<T extends ColumnCollection>(res: T, colData: RevoGrid.ColumnGrouping, collection: T, level?: number): T;
-  static isColGrouping(colData: RevoGrid.ColumnGrouping | RevoGrid.ColumnRegular): colData is RevoGrid.ColumnGrouping;
+    static gatherGroup<T extends ColumnCollection>(res: T, colData: ColumnGrouping, collection: T, level?: number): T;
 }
+/**
+ * Check if column is grouping column
+ */
+export declare function isColGrouping(colData: ColumnGrouping | ColumnRegular): colData is ColumnGrouping;
 export {};

package/dist/types/plugins/groupingColumn/headerGroupRenderer.d.ts

@@ -1,14 +1,16 @@
 import { VNode } from '../../stencil-public-runtime';
-import { ResizeEvent } from '../../services/resizable.directive';
+import { ResizeEvent, ResizeProps } from '../../services/resizable.directive';
 import { Group } from '../../store/dataSource/data.store';
-import { RevoGrid } from '../../interfaces';
-declare type Props = {
-  start: number;
-  end: number;
-  group: Group;
-  providers: RevoGrid.Providers;
-  canResize?: boolean;
-  onResize?(e: ResizeEvent): void;
-};
+import { DimensionCols } from '../../components';
+import { Providers } from '../../types/interfaces';
+type Props = {
+    start: number;
+    end: number;
+    group: Group;
+    providers: Providers<DimensionCols | 'rowHeaders'>;
+    additionalData: any;
+    canResize?: boolean;
+    onResize?(e: ResizeEvent): void;
+} & Partial<Pick<ResizeProps, 'active'>>;
 declare const GroupHeaderRenderer: (p: Props) => VNode[];
 export default GroupHeaderRenderer;