lsp-grid 1.0.0

package/dist/types/global/global.d.ts

@@ -0,0 +1 @@
+export default function (): void;

package/dist/types/index.d.ts

@@ -0,0 +1,9 @@
+export * from './types';
+export * from './store';
+export * from './plugins';
+export * from './components';
+export * from './utils';
+export * from './components/data/cell-renderer';
+export { TextEditor } from './components/editors/text-editor';
+export * from './components/editors/edit.utils';
+export { h, type FunctionalComponent } from './stencil-public-runtime';

package/dist/types/plugins/add-rows-on-paste.plugin.d.ts

@@ -0,0 +1,14 @@
+import type { PluginProviders } from '../types/plugin.types';
+import { BasePlugin } from './base.plugin';
+/**
+ * Automatically adds new rows when pasted data is larger than current rows
+ * @event newRows - is triggered when new rows are added. Data of new rows can be filled with default values. If the event is prevented, no rows will be added
+ */
+export declare class AutoAddRowsPlugin extends BasePlugin {
+    constructor(revogrid: HTMLRevoGridElement, providers: PluginProviders);
+    handleBeforePasteApply(event: CustomEvent<{
+        raw: string;
+        parsed: string[][];
+        event: ClipboardEvent;
+    }>): void;
+}

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

@@ -0,0 +1,51 @@
+import { h } from '../stencil-public-runtime';
+import type { PluginProviders, PluginBaseComponent } from '../types';
+export 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 {
+    revogrid: HTMLRevoGridElement;
+    providers: PluginProviders;
+    readonly h: typeof h;
+    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
+     */
+    addEventListener<K extends keyof HTMLRevoGridElementEventMap>(eventName: K, callback: (this: BasePlugin, e: CustomEvent<HTMLRevoGridElementEventMap[K]>) => 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
+     */
+    watch<T extends any>(prop: string, callback: (arg: T) => boolean | void, { immediate }?: Partial<WatchConfig>): void;
+    /**
+     * Remove event listener
+     * @param eventName
+     */
+    removeEventListener(eventName: string): void;
+    /**
+     * Emit event from revo-grid component
+     * Event can be cancelled by calling event.preventDefault() in callback
+     */
+    emit<T = any>(eventName: string, detail?: T): CustomEvent<T>;
+    /**
+     * Clear all subscriptions
+     */
+    clearSubscriptions(): void;
+    /**
+     * Destroy plugin and clear all subscriptions
+     */
+    destroy(): void;
+}
+export type GridPlugin = (typeof BasePlugin);

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

@@ -0,0 +1,55 @@
+import { BasePlugin } from './base.plugin';
+import type { DimensionCols, ColumnRegular, DataType, BeforeSaveDataDetails, BeforeRangeSaveDataDetails, PluginProviders } from "../types/index";
+interface Column extends ColumnRegular {
+    index: number;
+}
+type AutoSizeColumns = Record<DimensionCols, ColumnRecords>;
+type ColumnRecords = Record<any, Column>;
+type EditEvent = BeforeSaveDataDetails | BeforeRangeSaveDataDetails;
+type Resolve = (cols: Partial<AutoSizeColumns>) => void;
+type Reject = () => void;
+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;
+};
+export declare const enum ColumnAutoSizeMode {
+    headerClickAutosize = "headerClickAutoSize",
+    autoSizeOnTextOverlap = "autoSizeOnTextOverlap",
+    autoSizeAll = "autoSizeAll"
+}
+export declare class AutoSizeColumnPlugin extends BasePlugin {
+    providers: PluginProviders;
+    config?: AutoSizeColumnConfig | undefined;
+    autoSizeColumns: Partial<AutoSizeColumns> | null;
+    readonly letterBlockSize: number;
+    /** for config option when preciseSize enabled */
+    readonly precsizeCalculationArea: HTMLElement;
+    /** for edge case when no columns defined before data */
+    dataResolve: Resolve | null;
+    dataReject: Reject | null;
+    constructor(revogrid: HTMLRevoGridElement, providers: PluginProviders, config?: AutoSizeColumnConfig | undefined);
+    setSource(source: DataType[]): Promise<void>;
+    getLength(len?: any): number;
+    afteredit(e: EditEvent): void;
+    afterEditAll(e: EditEvent): void;
+    getColumnSize(index: number, type: DimensionCols): number;
+    columnSet(columns: Record<DimensionCols, ColumnRegular[]>): void;
+    clearPromise(): void;
+    isRangeEdit(e: EditEvent): e is BeforeRangeSaveDataDetails;
+    initiatePresizeElement(): HTMLElement;
+    destroy(): void;
+}
+export {};

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

@@ -0,0 +1,20 @@
+import { BasePlugin } from './base.plugin';
+import { DimensionCols, PluginBaseComponent, PluginProviders, ColumnRegular } from "../types/index";
+export declare class StretchColumn extends BasePlugin {
+    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: Record<DimensionCols, ColumnRegular[]>): 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,20 @@
+/**
+ * Dispatches a custom event to a specified target element.
+ *
+ * @param target - The target element to dispatch the event to.
+ * @param eventName - The name of the custom event.
+ * @param detail - Optional. The detail of the custom event.
+ * @returns The custom event that was dispatched.
+ */
+export declare function dispatch<DispatchDetail = any>(target: MouseEvent['target'], eventName: string, detail?: DispatchDetail): CustomEvent<DispatchDetail>;
+/**
+ * Dispatches a custom event based on an existing event object and prevents the default behavior of the original event.
+ *
+ * @param e - The original event object containing the target and preventDefault method.
+ * @param eventName - The name of the custom event.
+ * @param detail - Optional. The detail of the custom event.
+ * @returns The custom event that was dispatched.
+ */
+export declare function dispatchByEvent<DispatchDetail = any>(e: Pick<MouseEvent, 'target' | 'preventDefault'>, // The original event object containing the target and preventDefault method.
+eventName: string, // The name of the custom event.
+detail?: DispatchDetail): CustomEvent;

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

@@ -0,0 +1,9 @@
+import { CSVFormat, DataInput, Formatter } from './types';
+export type CSVFormatter = (options: Partial<CSVFormat>, data: DataInput) => string;
+export declare class ExportCsv implements Formatter {
+    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

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

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

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

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

@@ -0,0 +1,4 @@
+import { LogicFunction } from '../filter.types';
+declare const eq: LogicFunction;
+export declare const notEq: LogicFunction;
+export default eq;

package/dist/types/plugins/filter/conditions/number/greaterThan.d.ts

@@ -0,0 +1,3 @@
+import { LogicFunction } from '../../filter.types';
+declare const gtThan: LogicFunction;
+export default gtThan;

package/dist/types/plugins/filter/conditions/number/greaterThanOrEqual.d.ts

@@ -0,0 +1,3 @@
+import { LogicFunction } from '../../filter.types';
+declare const gtThanEq: LogicFunction;
+export default gtThanEq;

package/dist/types/plugins/filter/conditions/number/lessThan.d.ts

@@ -0,0 +1,3 @@
+import { LogicFunction } from '../../filter.types';
+declare const lt: LogicFunction;
+export default lt;

package/dist/types/plugins/filter/conditions/number/lessThanOrEqual.d.ts

@@ -0,0 +1,3 @@
+import { LogicFunction } from '../../filter.types';
+declare const lsEq: LogicFunction;
+export default lsEq;

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

@@ -0,0 +1,4 @@
+import { LogicFunction } from '../filter.types';
+declare const set: LogicFunction;
+export declare const notSet: LogicFunction;
+export default set;

package/dist/types/plugins/filter/conditions/string/beginswith.d.ts

@@ -0,0 +1,3 @@
+import { LogicFunction } from '../../filter.types';
+declare const beginsWith: LogicFunction;
+export default beginsWith;

package/dist/types/plugins/filter/conditions/string/contains.d.ts

@@ -0,0 +1,4 @@
+import { LogicFunction } from '../../filter.types';
+declare const contains: LogicFunction;
+export declare const notContains: LogicFunction;
+export default contains;

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

@@ -0,0 +1,14 @@
+import { ColumnRegular } from "../../types/index";
+export declare const FILTER_BUTTON_CLASS = "rv-filter";
+export declare const FILTER_BUTTON_ACTIVE = "active";
+export declare const FILTER_PROP = "hasFilter";
+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: ({ text }: any) => any;
+export declare function isFilterBtn(e: HTMLElement): true | Element | null;
+export {};

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

@@ -0,0 +1,20 @@
+import { LogicFunction } from './filter.types';
+export declare const filterCoreFunctionsIndexedByType: Record<FilterType, LogicFunction>;
+export declare const filterTypes: Record<string, FilterType[]>;
+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;
+};
+export type FilterType = keyof typeof filterNames;

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

@@ -0,0 +1,53 @@
+import { EventEmitter, type VNode } from '../../stencil-public-runtime';
+import '../../utils/closest.polifill';
+import { FilterCaptions, LogicFunction, MultiFilterItem, ShowData } from './filter.types';
+import type { ColumnProp } from "../../types/index";
+import { FilterType } from './filter.indexed';
+/**
+ * Filter panel for editing filters
+ */
+/**
+ * @internal
+ */
+export declare class FilterPanel {
+    private filterCaptionsInternal;
+    element: HTMLElement;
+    isFilterIdSet: boolean;
+    filterId: number;
+    currentFilterId: number;
+    currentFilterType: FilterType;
+    changes: ShowData | undefined;
+    filterItems: MultiFilterItem;
+    filterNames: Record<string, string>;
+    filterEntities: Record<string, LogicFunction>;
+    filterCaptions: Partial<FilterCaptions> | undefined;
+    /**
+     * Disables dynamic filtering. A way to apply filters on Save only
+     */
+    disableDynamicFiltering: boolean;
+    /**
+     * If true, closes the filter panel when clicking outside
+     */
+    closeOnOutsideClick: boolean;
+    filterChange: EventEmitter<MultiFilterItem>;
+    resetChange: EventEmitter<ColumnProp>;
+    onMouseDown(e: MouseEvent): void;
+    show(newEntity?: ShowData): Promise<void>;
+    getChanges(): Promise<ShowData | undefined>;
+    componentWillRender(): void;
+    getFilterItemsList(): any;
+    private autoCorrect;
+    private onFilterTypeChange;
+    private debouncedApplyFilter;
+    private onAddNewFilter;
+    private addNewFilterToProp;
+    private onSave;
+    private onCancel;
+    private onReset;
+    private onRemoveFilter;
+    private toggleFilterAndOr;
+    private assertChanges;
+    renderSelectOptions(type: FilterType, isDefaultTypeRemoved?: boolean): VNode[] | undefined;
+    renderExtra(prop: ColumnProp, index: number): any;
+    render(): any;
+}

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

@@ -0,0 +1,73 @@
+import { type VNode } from '../../stencil-public-runtime';
+import type { ColumnProp, ColumnRegular, DataType, PluginProviders } from "../../types/index";
+import { BasePlugin } from '../base.plugin';
+import type { ColumnFilterConfig, FilterCollectionItem, LogicFunction, MultiFilterItem, ShowData } from './filter.types';
+import { TrimmedEntity } from "../../store/index";
+export * from './filter.types';
+export * from './filter.indexed';
+export * from './filter.button';
+export declare const FILTER_TRIMMED_TYPE = "filter";
+export declare const FILTER_CONFIG_CHANGED_EVENT = "filterconfigchanged";
+export declare const FILTE_PANEL = "revogr-filter-panel";
+/**
+ * @typedef ColumnFilterConfig
+ * @type {object}
+ *
+ * @property {MultiFilterItem|undefined} multiFilterItems - data for multi filtering with relation
+ *
+ * @property {Record<ColumnProp, FilterCollectionItem>|undefined} collection - preserved filter data, relation for filters will be applied as 'and'
+ *
+ * @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 {boolean|undefined} disableDynamicFiltering - disables dynamic filtering. A way to apply filters on Save only.
+ */
+/**
+ * @internal
+ */
+export declare class FilterPlugin extends BasePlugin {
+    revogrid: HTMLRevoGridElement;
+    config?: ColumnFilterConfig | undefined;
+    pop?: HTMLRevogrFilterPanelElement;
+    filterCollection: Record<ColumnProp, FilterCollectionItem>;
+    multiFilterItems: MultiFilterItem;
+    /**
+     * Filter types
+     * @example
+     * {
+     *    string: ['contains', 'beginswith'],
+     *    number: ['eqN', 'neqN', 'gt']
+     *  }
+     */
+    filterByType: Record<string, string[]>;
+    filterNameIndexByType: Record<string, string>;
+    filterFunctionsIndexedByType: Record<string, LogicFunction>;
+    filterProp: string;
+    extraHyperContent?: (data: ShowData) => VNode | VNode[];
+    constructor(revogrid: HTMLRevoGridElement, providers: PluginProviders, config?: ColumnFilterConfig | undefined);
+    beforeshow(_: ShowData): void;
+    extraContent(): any;
+    initConfig(config: ColumnFilterConfig): void;
+    headerclick(e: CustomEvent<ColumnRegular>): Promise<void>;
+    getColumnFilter(type?: boolean | string | string[]): Record<string, string[]>;
+    isValidType(type: any): type is string;
+    /**
+     * Called on internal component change
+     */
+    onFilterChange(filterItems: MultiFilterItem): Promise<void>;
+    onFilterReset(prop?: ColumnProp): void;
+    /**
+     * Triggers grid filtering
+     */
+    doFiltering(collection: Record<ColumnProp, FilterCollectionItem>, source: DataType[], columns: ColumnRegular[], filterItems: MultiFilterItem): Promise<void>;
+    clearFiltering(): Promise<void>;
+    runFiltering(multiFilterItems: MultiFilterItem): Promise<void>;
+    /**
+     * Get trimmed rows based on filter
+     */
+    getRowFilter(rows: DataType[], filterItems: MultiFilterItem, columnByProp: Record<string, ColumnRegular>): TrimmedEntity;
+    private shouldTrimRow;
+}

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

@@ -0,0 +1,129 @@
+import type { ColumnProp, ColumnRegular, HyperFunc } from "../../types/index";
+import type { FilterType } from './filter.indexed';
+import type { VNode } from '../../stencil-public-runtime';
+export type DateEnum = 'today' | 'yesterday' | 'tomorrow' | 'thisweek' | 'lastweek' | 'nextweek' | 'thismonth' | 'lastmonth' | 'nextmonth' | 'thisyear' | 'lastyear' | 'nextyear';
+export type ExtraField = 'input' | 'datepicker' | ((h: HyperFunc<VNode>, config: {
+    value: any;
+    filter: FilterItem;
+    prop: ColumnProp;
+    index: number;
+    placeholder: string;
+    onInput: (value: any) => void;
+    onFocus: () => void;
+}) => VNode | VNode[]);
+export type LogicFunctionParam = any;
+export type LogicFunctionExtraParam = 'select' | 'input' | 'multi' | 'datepicker' | number | Date | DateEnum | null | undefined | string | string[] | number[];
+export interface LogicFunction<T1 = LogicFunctionParam, T2 = LogicFunctionExtraParam> {
+    (value: T1, extra?: T2): boolean;
+    extra?: ExtraField;
+}
+export interface CustomFilter<T1 = LogicFunctionParam, T2 = LogicFunctionExtraParam> {
+    /**
+     * Property defined in column { filter: string/number/abstract/enum...etc }
+     */
+    columnFilterType: string;
+    /**
+     * Filter name
+     */
+    name: string;
+    /**
+     * Function to apply the filter
+     */
+    func: LogicFunction<T1, T2>;
+}
+export interface FilterCaptions {
+    title: string;
+    save: string;
+    reset: string;
+    ok: string;
+    cancel: string;
+    add: string;
+    placeholder: string;
+    and: string;
+    or: string;
+}
+export interface FilterLocalization {
+    captions: Partial<FilterCaptions>;
+    filterNames: Record<FilterType, string>;
+}
+/**
+ * Filter configuration for a column. This is the type of the `filter` property on a column.
+ */
+export interface ColumnFilterConfig {
+    /**
+     * The collection of filters to be applied to the column.
+     */
+    collection?: Record<ColumnProp, FilterCollectionItem>;
+    /**
+     * The names of the filters to be included in the filter dropdown.
+     */
+    include?: string[];
+    /**
+     * A mapping of custom filter names to custom filter functions.
+     */
+    customFilters?: Record<string, CustomFilter>;
+    /**
+     * The property on the column idintifying which has the filter is applied.
+     */
+    filterProp?: string;
+    /**
+     * The localization for the filter dropdown.
+     */
+    localization?: FilterLocalization;
+    /**
+     * Information about the multi-filter items.
+     */
+    multiFilterItems?: MultiFilterItem;
+    /**
+     * Whether or not to disable dynamic filtering. If set to true, the filter will only be applied
+     * when the user clicks on the filter button.
+     */
+    disableDynamicFiltering?: boolean;
+    /**
+     * Whether or not to close the filter panel when clicking outside
+     */
+    closeFilterPanelOnOutsideClick?: boolean;
+}
+export type FilterCollectionItem = {
+    type: FilterType;
+    value?: any;
+};
+export interface FilterItem {
+    prop?: ColumnProp;
+    type?: FilterType;
+    value?: any;
+}
+export interface FilterData {
+    id: number;
+    /**
+     * Filter type
+     */
+    type: FilterType;
+    /**
+     * Filter value
+     */
+    value?: any;
+    /**
+     * Filter invisible in filter panel
+     */
+    hidden?: boolean;
+    /**
+     * Filter relation
+     */
+    relation?: 'and' | 'or';
+}
+export interface MultiFilterItem {
+    [prop: string]: FilterData[];
+}
+export interface ShowData extends FilterItem, Omit<ColumnRegular, 'filter'> {
+    x: number;
+    y: number;
+    /**
+     * Auto correct position if it is out of document bounds
+     */
+    autoCorrect?: boolean;
+    filterTypes?: Record<string, string[]>;
+    filterItems?: MultiFilterItem;
+    hideDefaultFilters?: boolean;
+    extraContent?: (data: ShowData) => any;
+}

package/dist/types/plugins/groupingRow/grouping.const.d.ts

@@ -0,0 +1,12 @@
+import { DimensionRows } from "../../types/index";
+export declare const GROUP_DEPTH = "__rvgr-depth";
+export declare const PSEUDO_GROUP_ITEM = "__rvgr-name";
+export declare const PSEUDO_GROUP_ITEM_ID = "__rvgr-id";
+export declare const PSEUDO_GROUP_ITEM_VALUE = "__rvgr-value";
+export declare const PSEUDO_GROUP_COLUMN = "__rvgr-column";
+export declare const GROUP_EXPANDED = "__rvgr-expanded";
+export declare const GROUP_COLUMN_PROP = "__rvgr-prop";
+export declare const GROUP_ORIGINAL_INDEX = "__rvgr-original-index";
+export declare const GROUP_EXPAND_BTN = "group-expand";
+export declare const GROUP_EXPAND_EVENT = "groupexpandclick";
+export declare const GROUPING_ROW_TYPE: DimensionRows;

package/dist/types/plugins/groupingRow/grouping.row.expand.service.d.ts

@@ -0,0 +1,15 @@
+import { DataType } from "../../types/index";
+export declare function doCollapse(pIndex: number, source: DataType[]): {
+    trimmed: Record<number, boolean>;
+};
+/**
+ *
+ * @param pIndex - physical index
+ * @param vIndex - virtual index, need to update item collection
+ * @param source - data source
+ * @param rowItemsIndexes - rgRow indexes
+ */
+export declare function doExpand(vIndex: number, source: DataType[], rowItemsIndexes: number[]): {
+    trimmed: Record<number, boolean>;
+    items?: number[];
+};

package/dist/types/plugins/groupingRow/grouping.row.plugin.d.ts

@@ -0,0 +1,39 @@
+import { type DSourceState } from "../../store/index";
+import type { DataType, DimensionRows, PluginProviders } from "../../types/index";
+import { BasePlugin } from '../base.plugin';
+import type { Observable } from '../../utils';
+import type { GroupingOptions } from './grouping.row.types';
+export * from './grouping.const';
+export * from './grouping.row.expand.service';
+export * from './grouping.row.types';
+export * from './grouping.service';
+export * from './grouping.row.renderer';
+export declare class GroupingRowPlugin extends BasePlugin {
+    private options;
+    getStore(type?: DimensionRows): Observable<DSourceState<DataType, DimensionRows>>;
+    constructor(revogrid: HTMLRevoGridElement, providers: PluginProviders);
+    private onFocus;
+    private onExpand;
+    private setColumnGrouping;
+    private setColumns;
+    private onDrag;
+    private beforeTrimmedApply;
+    private isSortingRunning;
+    /**
+     * Starts global source update with group clearing and applying new one
+     * Initiated when need to reapply grouping
+     */
+    private doSourceUpdate;
+    /**
+     * Apply grouping on data set
+     * Clear grouping from source
+     * If source came from other plugin
+     */
+    private onDataSet;
+    /**
+     * External call to apply grouping. Called by revogrid when prop changed.
+     */
+    setGrouping(options: GroupingOptions): void;
+    clearGrouping(): void;
+    private updateTrimmed;
+}

package/dist/types/plugins/groupingRow/grouping.row.renderer.d.ts

@@ -0,0 +1,6 @@
+import type { RowGroupingProps } from './grouping.row.types';
+import type { DataType } from "../../types/index";
+export declare function expandEvent(e: MouseEvent, model: DataType, virtualIndex: number): void;
+export declare const GroupingRowRenderer: (props: RowGroupingProps) => any;
+export declare const expandSvgIconVNode: (expanded?: boolean) => any;
+export default GroupingRowRenderer;