@dhtmlx/grid 9.3.12 → 9.4.1

package/codebase/types/ts-calendar/sources/Calendar.d.ts

@@ -20,10 +20,12 @@ export declare class Calendar extends View implements ICalendar {
     showDate(date?: Date, mode?: ViewMode): void;
     destructor(): void;
     clear(): void;
+    private _clear;
     link(targetCalendar: Calendar): void;
     private _unlink;
     private _setSelected;
     private _getSelected;
+    private _normalizeControls;
     private _draw;
     private _initHandlers;
     private _getData;
@@ -31,7 +33,11 @@ export declare class Calendar extends View implements ICalendar {
     private _drawMonthSelector;
     private _drawYearSelector;
     private _drawHeader;
+    private _drawControls;
+    private _drawControlButton;
+    private _drawTimepickerControl;
     private _drawTimepicker;
     private _selectDate;
+    private _selectToday;
     private _moveBrowseFocus;
 }

package/codebase/types/ts-calendar/sources/helper.d.ts

@@ -1 +1,2 @@
 export declare const linkButtonClasses = ".dhx_button.dhx_button--view_link.dhx_button--icon.dhx_button--size_medium.dhx_button--color_secondary";
+export declare const getControlButtonClass: (control: "clear" | "today" | "timepicker", fullWidth?: boolean) => string;

package/codebase/types/ts-calendar/sources/types.d.ts

@@ -14,6 +14,7 @@ export interface ICalendarConfig {
     width?: string | number;
     range?: boolean;
     $rangeMark?: (a: Date) => string;
+    controls?: boolean | TCalendarControlsInput[];
     /** @deprecated See a documentation: https://docs.dhtmlx.com/ */
     block?: (a: Date) => boolean;
     /** @deprecated See a documentation: https://docs.dhtmlx.com/ */
@@ -30,6 +31,8 @@ export interface ICalendar {
     link(calendar: ICalendar): void;
 }
 export type ViewMode = "calendar" | "year" | "month" | "timepicker";
+export type TCalendarControls = "clear" | "today" | "timepicker" | "spacer";
+export type TCalendarControlsInput = TCalendarControls | Uppercase<TCalendarControls> | Capitalize<TCalendarControls>;
 export interface ICalendarDay {
     css: string;
     date: Date;

package/codebase/types/ts-common/date.d.ts

@@ -4,6 +4,8 @@ export declare const locale: {
     daysShort: string[];
     days: string[];
     cancel: string;
+    today: string;
+    clear: string;
 };
 export declare function getFormattedDate(format: string, date: Date): string;
 export declare function getExcelDate(date: Date): number;

package/codebase/types/ts-data/sources/datacollection/group.d.ts

@@ -1,3 +1,4 @@
+import { IAnyObj, Id } from "../../../ts-common/types";
 import { IDataItem } from "../types";
 export type TGroupOrderFunc = (i: IDataItem) => string;
 export type TAggregate = "sum" | "count" | "min" | "max" | "avg" | string;
@@ -16,6 +17,11 @@ export type TDisplayMode = "original" | "column" | "row";
 export interface IGroupConfig {
     displayMode?: TDisplayMode;
     showMissed?: boolean | string;
+    /**
+     * Whether a group whose items are all filtered out stays in the data with a zero count.
+     * Defaults to `false`, i.e. such a group is dropped.
+     */
+    showEmptyGroups?: boolean;
     field?: string;
 }
 export interface IGroup {
@@ -24,18 +30,23 @@ export interface IGroup {
     isGrouped(): boolean;
     getGroupedFields(): string[];
     getGroupConfig(config?: IGroupConfig): IGroupConfig;
+    recalculate(node: IDataItem, items: IDataItem[], count?: number, total?: number): IAnyObj;
+    hasMap(id: Id): boolean;
 }
 export declare class Group implements IGroup {
     private _init;
     private _config;
     private _groupSet;
     private _groupOrderFields;
+    private _nodes;
     constructor();
     group(order: TGroupOrder[], arr: IDataItem[], config?: IGroupConfig): IDataItem[];
     ungroup(modifiedData?: IDataItem[]): IDataItem[];
     isGrouped(): boolean;
     getGroupedFields(): string[];
     getGroupConfig(config?: IGroupConfig): IGroupConfig;
+    recalculate(node: IDataItem, items: IDataItem[], count?: number, total?: number): IAnyObj;
+    hasMap(id: Id): boolean;
     private _group;
     private _addSummaryRow;
     private _toAggregate;

package/codebase/types/ts-data/sources/datacollection.d.ts

@@ -1,7 +1,7 @@
 import { IEventSystem } from "../../ts-common/events";
 import { Id } from "../../ts-common/types";
 import { Sort } from "./datacollection/sort";
-import { DataCallback, DataEvents, IDataCollection, IDataItem, IDataProxy, IFilterCallback, IFilterConfig, IFilterMode, ISortMode, ITreeCollection, IUpdateObject, ReduceCallBack, Statuses, IDataEventsHandlersMap, DataDriver, IDataConfig, ISortConfig, IDataDriver, IFilterComplexMode, IFilter, IResetFilterConfig, IGroupDataConfig, ISortingState } from "./types";
+import { DataCallback, DataEvents, IDataChangeService, IDataCollection, IDataItem, IDataProxy, IFilterCallback, IFilterConfig, IFilterMode, ISortMode, ITreeCollection, IUpdateObject, ReduceCallBack, Statuses, IDataEventsHandlersMap, DataDriver, IDataConfig, ISortConfig, IDataDriver, IFilterComplexMode, IFilter, IResetFilterConfig, IGroupDataConfig, ISortingState } from "./types";
 import { TGroupOrder, IGroup } from "./datacollection/group";
 export declare class DataCollection<T extends IDataItem = IDataItem> implements IDataCollection<T> {
     loadData: Promise<any>;
@@ -41,6 +41,22 @@ export declare class DataCollection<T extends IDataItem = IDataItem> implements
     getItem(id: Id): T;
     update(id: Id, newItem: IUpdateObject, silent?: boolean): void;
     getIndex(id: Id): number;
+    /**
+     * Returns the index of an item among the visible ones, i.e. in the order the items are
+     * rendered in. Unlike {@link DataCollection.getIndex} the hidden items are not counted, and
+     * a range set by {@link DataCollection.setRange} narrows the counting down to that range.
+     * @param id - The id of the item.
+     * @returns The zero-based index of the item, or `-1` if the item doesn't exist, is hidden,
+     * or is out of the currently set range.
+     * @example
+     * ```ts
+     * collection.update("2", { hidden: true });
+     * collection.getIndex("3"); // 2
+     * collection.getVisibleIndex("3"); // 1
+     * collection.getVisibleIndex("2"); // -1
+     * ```
+     */
+    getVisibleIndex(id: Id): number;
     getId(index: number): Id;
     getLength(): number;
     isDataLoaded(from?: number, to?: number): boolean;
@@ -157,7 +173,14 @@ export declare class DataCollection<T extends IDataItem = IDataItem> implements
      */
     $parse(data: any[], resetRules?: boolean): void;
     save(url: IDataProxy | string): void;
-    changeId(id: Id, newId?: Id, silent?: boolean): void;
+    /**
+     * Changes the id of a data item.
+     * @param id - The current id of the item.
+     * @param newId - The new id for the item. If omitted, a unique id is generated automatically.
+     * @param silent - If true, the change event is not fired.
+     * @returns The new id of the item, or the original id if the change was rejected.
+     */
+    changeId(id: Id, newId?: Id, silent?: boolean): Id;
     isSaved(): boolean;
     map(callback: DataCallback<T>): any[];
     mapRange(from: number, to: number, callback: DataCallback<T>): any[];
@@ -182,7 +205,20 @@ export declare class DataCollection<T extends IDataItem = IDataItem> implements
     protected _removeCore(id: Id): void;
     protected _parse_data(data: any[]): void;
     protected _approximate(data: any[], values: string[], maxNum: number): any[];
-    protected _onChange(status: Statuses, id: Id, obj: any): void;
+    /**
+     * Remaps the item to the new id inside all the internal structures.
+     * `_order`, `_initFilterOrder` and `_initSortOrder` keep the references to the same
+     * objects as `_pull`, so changing `item.id` is enough for them.
+     * @internal
+     */
+    protected _changeIdCore(id: Id, newId: Id): void;
+    /**
+     * Retargets the pending save operations of the item to its new id,
+     * so that a rename between `add` and `save` doesn't produce a second request.
+     * @internal
+     */
+    private _remapChanges;
+    protected _onChange(status: Statuses, id: Id, obj: any, service?: IDataChangeService): void;
     protected _addToOrder(array: any[], obj: any, index?: number): void;
     /**
      * Reorders the data by all currently stored sorting rules.
@@ -224,6 +260,44 @@ export declare class DataCollection<T extends IDataItem = IDataItem> implements
      * @internal
      */
     protected _reapplyRules(): void;
+    /**
+     * Brings the group headers in line with the items the collection holds now: the counts and the
+     * aggregates next to the group names are computed while the tree is built, so every change of
+     * what is in the collection leaves them stale. Headers left with nothing under them are dropped
+     * unless `showEmptyGroups` is set — see {@link DataCollection._dropGroups} for what dropping a
+     * header costs it.
+     * @internal
+     */
+    protected _recalculateGroups(): void;
+    /**
+     * Collects a group header together with everything below it: the nested headers, their summary
+     * rows and the items. Removing the header alone would leave the items with a parent that is not
+     * there any more, and the counts of the groups above it short.
+     * A `TreeCollection` needs none of this, its {@link TreeCollection._removeCore} already takes
+     * the subtree of an item with it.
+     * @param id - The id of the header.
+     * @returns The ids to remove, the header itself last.
+     * @internal
+     */
+    protected _getGroupSubtree(id: Id): Id[];
+    /**
+     * Takes the group headers left with nothing in them out of the data, their summary rows and
+     * their nested groups included: a group is empty only when everything under it is.
+     * While a filter is applied the headers only leave `_order`, because `_initFilterOrder` keeps
+     * the whole grouped order and resetting the filter has to bring them back. Without a filter
+     * there is nothing to restore them from, so they leave the collection for good.
+     * @param ids - Ids of the headers to drop.
+     * @internal
+     */
+    protected _dropGroups(ids: Set<string>): void;
+    /**
+     * Counts the items every group header holds in a given order, its whole subtree and not just
+     * the items directly under it. Summary rows are not items.
+     * @param order - The order to count over.
+     * @returns The counts, keyed by header id.
+     * @internal
+     */
+    protected _countGroupItems(order: T[]): Map<Id, number>;
     /**
      * Turns a field/value rule into a predicate.
      * @param rule - The rule to convert.
@@ -261,4 +335,11 @@ export declare class DataCollection<T extends IDataItem = IDataItem> implements
      * @internal
      */
     private _parse;
+    /**
+     * Fires the change event. The service payload is appended only when it is set,
+     * so that the arguments of the event stay exactly the same as before for every
+     * operation that doesn't provide it.
+     * @internal
+     */
+    private _fireChange;
 }

package/codebase/types/ts-data/sources/methods.d.ts

@@ -1,11 +1,16 @@
 type Item = {
     [key: string]: any;
 };
+/**
+ * Aggregation functions shared by the group aggregates and the widget summaries.
+ * `sum` and `count` return `0` for an empty set, the rest return `null`: there is no
+ * meaningful average, minimum or maximum of nothing.
+ */
 export declare const methods: {
     sum: (items: Item[], field: string) => number;
-    avg: (items: Item[], field: string) => number;
+    avg: (items: Item[], field: string) => number | null;
     count: (items: Item[], field: string) => number;
-    min: (items: Item[], field: string) => number;
-    max: (items: Item[], field: string) => number;
+    min: (items: Item[], field: string) => number | null;
+    max: (items: Item[], field: string) => number | null;
 };
 export {};

package/codebase/types/ts-data/sources/treecollection.d.ts

@@ -21,6 +21,31 @@ export declare class TreeCollection<T extends IDataItem = IDataItem> extends Dat
     removeAll(id?: Id): void;
     update(id: Id, newItem: IUpdateObject, silent?: boolean): void;
     getIndex(id: Id): number;
+    /**
+     * Returns the index of an item among the visible ones, i.e. in the order the items are
+     * rendered in. Unlike {@link TreeCollection.getIndex} the hidden items are not counted, and an
+     * item that is not rendered at all gets `-1`. A range set by {@link DataCollection.setRange}
+     * leaves the top level items of the current page only.
+     * @param id - The id of the item.
+     * @param flat - Whether the index is counted in the flat list of all the visible items, i.e.
+     * the items of the expanded branches above the item are counted as well. By default the index
+     * is counted within the parent branch of the item only. Defaults to `false`.
+     * @returns The zero-based index of the item, or `-1` if the item doesn't exist, is hidden, is
+     * placed under a hidden or a collapsed parent, or is out of the currently set range.
+     * @example
+     * ```ts
+     * // "1", "2", "3" are top level items, "3" is expanded and holds "3.1" and "3.2"
+     * collection.update("3.1", { hidden: true });
+     * collection.getIndex("3.2"); // 1 - the second child of "3"
+     * collection.getVisibleIndex("3.2"); // 0 - the first rendered child of "3"
+     * collection.getVisibleIndex("3.2", true); // 3 - the fourth rendered item
+     *
+     * collection.update("3", { $opened: false });
+     * collection.getVisibleIndex("3.2"); // -1
+     * collection.getVisibleIndex("3.2", true); // -1
+     * ```
+     */
+    getVisibleIndex(id: Id, flat?: boolean): number;
     /**
      * Sorts the tree, reordering the items within each parent independently.
      * The rules are combined the same way as in {@link DataCollection.sort}, but unlike it this
@@ -74,6 +99,47 @@ export declare class TreeCollection<T extends IDataItem = IDataItem> extends Dat
     getId(index: number, parent?: Id): Id;
     map(callback: DataCallback<T>, parent?: Id, direct?: boolean): any[];
     getRawData(from: number, to: number, order?: T[], mode?: number, parent?: Id): T[];
+    /**
+     * Tells whether the children of an item are rendered. Both flags in use are checked:
+     * `$opened`, set by TreeGrid, and `opened`, set by Tree.
+     * @param item - The item to check.
+     * @returns `true` if the item is expanded.
+     * @internal
+     */
+    protected _isOpened(item: T): boolean;
+    /**
+     * Gives the range of the top level items to count, narrowed by {@link DataCollection.setRange}.
+     * @returns The index to count from and the one to stop before.
+     * @internal
+     */
+    private _getRootBounds;
+    /**
+     * Counts the visible items placed before an item within its parent branch.
+     * @param item - The item to locate.
+     * @param start - The index the top level items are counted from, set by a range.
+     * @param end - The index the top level items are counted up to, set by a range.
+     * @returns The index of the item within its branch, or `-1` if the branch doesn't hold it.
+     * @internal
+     */
+    private _getBranchVisibleIndex;
+    /**
+     * Counts the visible items placed before an item in the flat list of the visible items: at
+     * every level the branches of the preceding siblings are counted together with the parent
+     * item itself.
+     * @param item - The item to locate.
+     * @param start - The index the top level items are counted from, set by a range.
+     * @returns The index of the item in the flat list, or `-1` if the tree doesn't hold it.
+     * @internal
+     */
+    private _getFlatVisibleIndex;
+    /**
+     * Counts the rows an item takes in the flat list of the visible items: the item itself plus
+     * the visible items of its branch while it is expanded.
+     * @param item - The item to measure.
+     * @returns The number of the visible rows, `0` for a hidden item.
+     * @internal
+     */
+    private _getVisibleCount;
     protected flatten(input: T[]): T[];
     protected _add({ newItem, index, parent, order, batch, }: {
         newItem: IDataItem;
@@ -85,6 +151,15 @@ export declare class TreeCollection<T extends IDataItem = IDataItem> extends Dat
     protected _setParent(item: IDataItem, parent: Id): void;
     protected _copy(id: Id, index: number, target?: IDataCollection | ITreeCollection, targetId?: Id, key?: number): Id;
     protected _move(id: Id, index: number, target?: ITreeCollection | IDataCollection, targetId?: Id, key?: number): Id;
+    /**
+     * Changes the id of a data item. The root id can't be changed.
+     * @param id - The current id of the item.
+     * @param newId - The new id for the item. If omitted, a unique id is generated automatically.
+     * @param silent - If true, the change event is not fired.
+     * @returns The new id of the item, or the original id if the change was rejected.
+     */
+    changeId(id: Id, newId?: Id, silent?: boolean): Id;
+    protected _changeIdCore(id: Id, newId: Id): void;
     protected _moveItem(id: any, targetId: any, index: any): void;
     protected _reset(config: {
         id?: Id;
@@ -108,6 +183,30 @@ export declare class TreeCollection<T extends IDataItem = IDataItem> extends Dat
      * @internal
      */
     private _applyFilter;
+    /**
+     * Recomputes every group header from the items the tree holds now, and drops the groups that
+     * ended up with nothing in them unless `showEmptyGroups` is set. See
+     * {@link TreeCollection._dropGroups} for what dropping a header costs it.
+     * @internal
+     */
+    protected _recalculateGroups(): void;
+    /**
+     * Counts the items every group header holds in a given tree, its whole subtree and not just
+     * the direct children. Summary rows are not items.
+     * @param store - The parent to children map to count over.
+     * @returns The counts, keyed by header id.
+     * @internal
+     */
+    private _countTreeGroups;
+    /**
+     * Takes group headers out of the tree together with everything below them, their summary rows
+     * included. While a filter is applied the headers only leave `_children`, because `_initChildren`
+     * keeps the whole grouped tree and resetting the filter has to bring them back. Without a filter
+     * there is nothing to restore them from, so they leave the tree for good.
+     * @param ids - Ids of the headers to drop.
+     * @internal
+     */
+    protected _dropGroups(ids: Set<string>): void;
     /**
      * Unwraps the stored filters into their bare rules, keeping them keyed by filter id.
      * Unlike {@link DataCollection._normalizeFilters} it does not turn the rules into predicates:

package/codebase/types/ts-data/sources/types.d.ts

@@ -184,6 +184,7 @@ export interface IDataCollection<T extends IDataItem = IDataItem> {
     getInitialData(): T[];
     getItem(id: Id): T;
     getIndex(id: Id): number;
+    getVisibleIndex(id: Id): number;
     getLength(): number;
     isDataLoaded(from?: number, to?: number): boolean;
     getId(index: number): Id;
@@ -205,7 +206,7 @@ export interface IDataCollection<T extends IDataItem = IDataItem> {
     serialize(driver?: DataDriver): T[];
     copy(id: Id | Id[], index: number, target?: IDataCollection | ITreeCollection, targetId?: Id): Id | Id[];
     move(id: Id | Id[], index: number, target?: IDataCollection | ITreeCollection, targetId?: Id): Id | Id[];
-    changeId(id: Id, newId?: Id, silent?: boolean): void;
+    changeId(id: Id, newId?: Id, silent?: boolean): Id;
     forEach(callback: DataCallback<T>): void;
     save(url: IDataProxy | string): void;
     isSaved(): boolean;
@@ -215,6 +216,14 @@ export interface IDataChangeStack {
     order: IDataChange[];
 }
 export type Statuses = "add" | "update" | "remove" | string;
+/**
+ * Service payload of the {@link DataEvents.change} event.
+ * @internal Not a part of the public API, may be extended or changed without notice.
+ */
+export interface IDataChangeService {
+    /** the previous id of the item, set by changeId */
+    oldId?: Id;
+}
 export interface IDataChange {
     id: Id;
     status: Statuses;
@@ -265,6 +274,7 @@ export interface ITreeCollection<T extends IDataItem = IDataItem> extends IDataC
     removeAll(id?: Id): void;
     getLength(id?: Id): number;
     getIndex(id: Id): number;
+    getVisibleIndex(id: Id, flat?: boolean): number;
     getItems(id: Id): T[];
     sort(rule?: ISortMode, config?: ISortConfig, ignore?: boolean): void;
     map(callback: DataCallback<T>, parent?: Id, direct?: boolean): any;
@@ -348,7 +358,7 @@ export declare enum DataEvents {
 }
 export interface IDataEventsHandlersMap {
     [key: string]: (...args: any[]) => any;
-    [DataEvents.change]: (id?: Id, status?: Statuses, updatedItem?: IDataItem) => void;
+    [DataEvents.change]: (id?: Id, status?: Statuses, updatedItem?: IDataItem, service?: IDataChangeService) => void;
     [DataEvents.filter]: (filter?: IFilter) => void;
     [DataEvents.beforeAdd]: (newItem: IDataItem, batch: IDataItem[], index: number) => boolean | void;
     [DataEvents.afterAdd]: (newItem: IDataItem, batch: IDataItem[], index: number) => void;

package/codebase/types/ts-grid/sources/ExtendedGrid.d.ts

@@ -1,4 +1,4 @@
-import { IGridConfig, ICol, IRow, IFooter, IHeader, IGroupOrderItem, IExtendedGrid, IExtendedGridConfig, ISubViewCell } from "./types";
+import { IGridConfig, ICol, IRow, IFooter, IHeader, IGroupOrderItem, IExtendedGrid, IExtendedGridConfig, ISubViewCell, IFixedRowLevel, TFixedRowsName } from "./types";
 import { IDataCollection, IDataItem } from "../../ts-data";
 import { ScrollView } from "../../ts-common/ScrollView";
 import { Id } from "../../ts-common/types";
@@ -30,11 +30,13 @@ export declare class ExtendedGrid extends Grid implements IExtendedGrid {
     protected _setEventHandlers(): void;
     protected _afterEditEndProcess(value: any, editableRow: any, editableColumn: any): void;
     protected _setSort(): void;
+    protected _resolveFixedRowLevel(name: TFixedRowsName, index: number, config: IExtendedGridConfig): IFixedRowLevel;
     protected getNormalizeContentHeight(row: IFooter | IHeader, col: ICol, config: IGridConfig): number;
     protected _prepareData(data: IDataItem[] | IDataCollection): IRow[];
     protected _prepareDataFromTo(data: IDataCollection, from: number, to: number): IRow[];
     protected _dragStart(event: any): void;
     protected _group(order: IGroupOrderItem[]): void;
+    protected _getGroupCounter(row: IRow): string;
     protected _expand(row: IRow): boolean;
     protected _collapse(row: IRow): boolean;
     private _lazyLoad;

package/codebase/types/ts-grid/sources/Grid.d.ts

@@ -6,7 +6,7 @@ import { DataEvents, DragEvents, IDataCollection, IDataEventsHandlersMap, IDataI
 import { Exporter } from "./modules/Exporter";
 import { PrefixSums } from "./helpers/PrefixSums";
 import { ISelection } from "./modules/Selection";
-import { EditorType, GridEvents, IAdjustBy, ICellRect, ICol, ICoords, IEventHandlersMap, IGrid, IGridConfig, IRow, IScrollState, ISpan, GridSystemEvents, ISystemEventHandlersMap, IColumnsWidth, SortFunction, IAdjustColumns, IDirection, IFooter, IHeader, INormalizeColumnsParams, ISummaryList, ISortingStates } from "./types";
+import { EditorType, GridEvents, IAdjustBy, ICellRect, ICol, ICoords, IEventHandlersMap, IGrid, IGridConfig, IRow, IScrollState, ISpan, GridSystemEvents, ISystemEventHandlersMap, IColumnsWidth, SortFunction, IAdjustColumns, IDirection, IFooter, IHeader, INormalizeColumnsParams, ISummaryList, ISortingStates, IFixedRowLevel, TFixedRowsName } from "./types";
 import { IContentList, IHeaderFilter } from "./ui/content";
 import { IActiveCell } from "./modules/ActiveCell";
 import { IProContentList } from "./ui/proContent";
@@ -92,10 +92,11 @@ export declare class Grid extends View implements IGrid {
     protected _dragInit(): void;
     protected _parseColumns(configChanged?: boolean): void;
     protected normalizeColumns({ config, columns, configChanged }: INormalizeColumnsParams): void;
+    protected _buildFixedRowsHeightMap(config: IGridConfig, columns: ICol[], name: TFixedRowsName): void;
+    protected _resolveFixedRowLevel(name: TFixedRowsName, index: number, config: IGridConfig): IFixedRowLevel;
     protected getNormalizeContentHeight(row: IFooter | IHeader, col: ICol, config: IGridConfig): number;
     protected _parseData(): void;
     protected _createCollection(): void;
-    protected _getRowIndex(rowId: Id): number;
     protected _setHTMLEventHandlers(): void;
     protected _setEventHandlers(): void;
     protected _afterEditEndProcess(value: any, editableRow: any, editableColumn: any): void;
@@ -121,6 +122,13 @@ export declare class Grid extends View implements IGrid {
     protected _normalizeDataType(): void;
     protected _applyLocalFilter(beforePrepareData?: boolean): void;
     protected _normalizeSpans(): void;
+    /**
+     * Retargets the caches that store a row id by value to the new id.
+     * The row objects themselves are shared with the data collection, so everything that
+     * keeps a reference to them (the selected cells, the rendered rows) is already up to date.
+     * @internal
+     */
+    protected _remapRowId(oldId: Id, newId: Id): void;
     protected _hideColumn(column: ICol): void;
     protected _showColumn(column: ICol): void;
     protected _setSummary(): void;

package/codebase/types/ts-grid/sources/helpers/data.d.ts

@@ -1,10 +1,22 @@
 import { IContainerConfig } from "../../../ts-common/core";
-import { ICol, IColumnsWidth, IGridConfig, IRow, AdjustTargetType, TOption, IScrollState, IVisibleRange, ISizes } from "./../types";
+import { ICol, IColumnsWidth, IGridConfig, IRow, AdjustTargetType, TOption, IOption, IScrollState, IVisibleRange, ISizes, TContentFilter, TFilterOptions, TFixedRowHeight } from "./../types";
 import { Id } from "../../../ts-common/types";
 export declare function getTotalRowHeight(row: IRow): number;
 export declare function rowsHeight(config: IGridConfig, rows: IRow[], from: number, to: number): number;
 export declare function colsWidth(config: IGridConfig, cols: ICol[], from: number, to: number): number;
 export declare function normalizeArray(obj: any, name: string): void;
+/**
+ * Resolves the height of a single header/footer level from the headerRowHeight/footerRowHeight value.
+ * An array form describes the levels individually, a plain number applies to every level.
+ * @param value - the headerRowHeight/footerRowHeight config value
+ * @param index - the zero-based header/footer level index
+ * @returns the level height and its auto-height state, where `auto: null` means
+ * "the legacy mode, the headerAutoHeight/footerAutoHeight flag decides"
+ */
+export declare function resolveFixedRowHeight(value: TFixedRowHeight | undefined, index: number): {
+    height: number;
+    auto: boolean | null;
+};
 export declare function measureTextHeight({ text, width, lineHeight, font, htmlEnable, }: {
     text?: string;
     width?: number;
@@ -28,6 +40,9 @@ export declare const getTreeCellWidthOffset: (row: IRow, toArrow?: boolean) => n
 export declare const getMaxColsWidth: (rows: IRow[], cols: ICol[], config: IContainerConfig, target: AdjustTargetType) => IColumnsWidth;
 export declare function applyPattern(value: string | number | boolean, col: ICol): string | number | boolean;
 export declare function getEditorOptions(col: ICol, row?: IRow): TOption[];
+export declare function normalizeOptions(options: any[]): IOption[];
+export declare function getFilterOptions(col: ICol, content: TContentFilter): TFilterOptions;
+export declare function resolveFilterOptions(col: ICol, content: TContentFilter, uniqueData?: any[]): IOption[];
 export declare function getOptionValue(value: string, column: ICol): string;
 export declare function getValueForNumberColumn(col: ICol, value: any): any;
 export declare function getComboEditorValue(value: any, col: ICol, row: IRow): any;

package/codebase/types/ts-grid/sources/helpers/default.d.ts

@@ -1,5 +1,6 @@
 import { IHistoryConfig } from "../modules/History";
 import { IDragPanelConfig, IGroup, ISubRowConfig } from "../types";
+export declare const DEFAULT_ROW_HEIGHT = 40;
 export declare const getGroupDefaultConfig: (config?: IGroup | boolean) => IGroup;
 export declare const defaultSubRowConfig: Omit<ISubRowConfig, "view">;
 export declare const defaultDragPanelConfig: IDragPanelConfig;

package/codebase/types/ts-grid/sources/helpers/dom.d.ts

@@ -1,3 +1,6 @@
 import { Id } from "../../../ts-common/types";
+import { ISpan } from "../types";
 export declare function getRowNode(id: Id, root: HTMLElement, split?: "left" | "right"): HTMLElement;
+/** Returns a data cell, or the span that covers it, from any part of the grid, frozen columns included. */
+export declare function getCellNode(root: HTMLElement, rowId: Id, colId: Id, span?: ISpan): HTMLElement;
 export declare function getVisibleRowNode(row: HTMLElement, width: number, offset: number): HTMLElement;

package/codebase/types/ts-grid/sources/helpers/zoneFocus.d.ts

@@ -49,8 +49,9 @@ export declare function findZoneCell(grid: any, zone: FocusZone, colId: string,
  * the scroll offset if the column is outside the visible range.
  * @param grid - the grid instance
  * @param colId - the column ID to make visible
+ * @returns true if the grid was scrolled
  */
-export declare function ensureZoneCellVisible(grid: any, colId: string): void;
+export declare function ensureZoneCellVisible(grid: any, colId: string): boolean;
 /**
  * Resolves the actual owning cell for a position that may be covered by a colspan or rowspan.
  * Scans all rows (0..rowIndex) and columns (0..colIndex) to find any cell whose
@@ -93,8 +94,9 @@ export declare function moveZoneFocusVertical(grid: any, event: KeyboardEvent, z
  * Moves focus via Tab/Shift+Tab within a header/footer zone.
  * Advances column-by-column with row wrapping: when reaching the last column,
  * moves to the first column of the next row (and vice versa for backward).
- * Skips cells that resolve back to the current cell (due to spans) and retries
- * if a cell is not found in the DOM (virtualized columns).
+ * Skips cells that resolve back to the current cell (due to spans) and cells that are
+ * not in the DOM although their column is in view. A cell scrolled into view is focused
+ * after the redraw, not skipped (see setZoneCellFocus).
  * Does NOT call preventDefault for exit cases — the caller decides.
  * @param grid - the grid instance
  * @param event - the keyboard event (preventDefault'd only on successful move)
@@ -153,9 +155,18 @@ export declare function triggerHeaderSort(grid: any, event: KeyboardEvent, isMod
  * @param rowIndex - the row index of the cell to focus
  * @param prevCell - the previously focused cell (will get tabindex="-1")
  * @param navRowIndex - the logical navigation row to store (defaults to rowIndex)
- * @returns true if focus was set successfully, false if the cell was not found
+ * @returns true if focus was set, or will be set after the redraw; false if the cell was not found
  */
 export declare function setZoneCellFocus(grid: any, zone: FocusZone, colId: string, rowIndex: number, prevCell?: HTMLElement, navRowIndex?: number): boolean;
+/**
+ * Checks if focus is still in the body data area, or was dropped to the page.
+ * Focus is dropped to the page when the focused editor is removed. Focus that has moved on,
+ * out of the widget or into the header or the footer, is not in the body.
+ * Used after an edit ends, so that focus is returned to the active cell only when nothing moved it away.
+ * @param grid - the grid instance
+ * @returns true if focus is in the body or on the page body element
+ */
+export declare function isFocusInBody(grid: any): boolean;
 /**
  * Transitions focus from a header/footer zone to the body data area.
  * Selects the first or last row in the specified column, using either

package/codebase/types/ts-grid/sources/locales/en.d.ts

@@ -21,8 +21,6 @@ declare const locale: {
     aria_collapseRow: string;
     aria_editContent: string;
     aria_subRow: string;
-    aria_enterGrid: string;
-    aria_exitGrid: string;
     aria_dragPanel: string;
     aria_panelHeader: string;
     aria_panelFooter: string;

package/codebase/types/ts-grid/sources/modules/History.d.ts

@@ -1,5 +1,6 @@
 import { IEventSystem } from "../../../ts-common/events";
 import { IExtendedGrid, IProGrid, IRow } from "../types";
+import { Id } from "../../../ts-common/types";
 export type ActionType = "add" | "remove" | "removeAll" | "change";
 export interface IAction {
     type: ActionType;
@@ -45,6 +46,8 @@ export interface IHistory {
     enable(): void;
     isDisabled(): boolean;
     destructor(): void;
+    /** @internal Retarget the stored actions after a row id has been changed */
+    remapId(oldId: Id, newId: Id): void;
 }
 export declare class History implements IHistory {
     config: IHistoryConfig;
@@ -66,6 +69,7 @@ export declare class History implements IHistory {
     enable(): void;
     isDisabled(): boolean;
     destructor(): void;
+    remapId(oldId: Id, newId: Id): void;
     private _initConfig;
     private _initHandlers;
     private _fireError;

package/codebase/types/ts-grid/sources/modules/Selection.d.ts

@@ -15,6 +15,8 @@ export interface ISelection extends ICellSource {
     enable(): void;
     isSelectedCell(row: IRow | Id, column?: ICol | Id): boolean;
     toHTML(): VNode | VNode[];
+    /** @internal Rebuild the id-based cache after a row id has been changed */
+    remapRows(): void;
 }
 export declare enum GridSelectionEvents {
     beforeUnSelect = "beforeUnSelect",
@@ -46,6 +48,7 @@ export declare class Selection implements ISelection {
     enable(): void;
     isSelectedCell(row: IRow | Id, column?: ICol | Id): boolean;
     restoreFocus(): void;
+    remapRows(): void;
     toHTML(): VNode | VNode[];
     private _setCell;
     private _removeCell;