@dhtmlx/grid 9.3.8 → 9.3.9

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

@@ -5,7 +5,20 @@ export declare class Loader {
     private _changes;
     constructor(parent: IDataCollection, changes: any);
     load(url: IDataProxy, driver?: IDataDriver | DataDriver): Promise<any>;
-    parse(data: any | any[], driver?: IDataDriver | DataDriver): any;
+    /**
+     * Converts the raw input with a driver and hands it over to the collection.
+     * A partial response of a lazy-loading source is handled differently: into an empty collection
+     * it is expanded to the full length reported by the source, with the items outside the received
+     * range put in as `$empty` placeholders; into a collection that already holds those placeholders
+     * it is merged over them, and the collection is not refilled at all.
+     * @param data - Items or a serialized string.
+     * @param driver - Data driver used to parse the input. Defaults to the JSON driver.
+     * @param resetRules - Whether the collection should drop its sorting and non-permanent
+     * filtering rules before taking the data. Set when the whole dataset is replaced. Defaults to `false`.
+     * @returns The parsed items.
+     * @internal
+     */
+    parse(data: any | any[], driver?: IDataDriver | DataDriver, resetRules?: boolean): any;
     save(url: IDataProxy): void;
     updateChanges(changes: IDataChangeStack): void;
     private _setPromise;

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

@@ -44,24 +44,118 @@ export declare class DataCollection<T extends IDataItem = IDataItem> implements
     getId(index: number): Id;
     getLength(): number;
     isDataLoaded(from?: number, to?: number): boolean;
+    /**
+     * Filters the collection.
+     * Replaces the currently applied filters unless `config.add` is set; permanent filters always
+     * survive and are combined with the new rule - they are applied first and the new rule narrows
+     * the result further, so the two act as AND. Calling the method without a rule drops all
+     * non-permanent filters and restores the unfiltered order.
+     * @param rule - A single rule, a set of rules combined with AND, or a predicate. Omit to reset filtering.
+     * @param config - Options that control how the rule is applied and stored.
+     * @param silent - Whether to suppress the `filter` event. Defaults to `false`.
+     * @returns The id the filter is stored under, or `undefined` if no rule was passed or the call
+     * only reapplied the already stored filters.
+     * @example
+     * ```ts
+     * // keep items whose "age" is 30 or more
+     * collection.filter({ by: "age", match: "30", compare: (value, match) => Number(value) >= Number(match) });
+     *
+     * // narrow the current result further instead of replacing it
+     * collection.filter({ by: "country", match: "France" }, { add: true });
+     *
+     * // a filter that survives resetFilter() and data reloading
+     * collection.filter({ by: "archived", match: false }, { permanent: true });
+     *
+     * collection.filter();
+     * ```
+     */
     filter(rule?: IFilterMode | IFilterComplexMode | IFilterCallback, config?: IFilterConfig, silent?: boolean): string;
+    /**
+     * Removes the applied filters and restores the unfiltered order. Whatever is left after the
+     * removal is reapplied to the restored order.
+     * Permanent filters are kept and reapplied unless `config.permanent` is set.
+     * @param config - Restricts the reset to a single filter or extends it to permanent ones. Omit to
+     * drop all non-permanent filters. `permanent` wins over `id`: passing both removes every filter,
+     * not just the one with that id.
+     * @param silent - Whether to suppress the `filter` event. Defaults to `false`.
+     * @returns `true` if no user-facing filters are left applied. Filters applied internally by a
+     * widget are not counted, so the result can be `true` while such a filter is still in effect.
+     * @example
+     * ```ts
+     * collection.resetFilter();                        // all non-permanent filters
+     * collection.resetFilter({ id: filterId });        // one filter
+     * collection.resetFilter({ permanent: true });     // everything, permanent included
+     * ```
+     */
     resetFilter(config?: IResetFilterConfig, silent?: boolean): boolean;
+    /**
+     * Returns the currently applied filters, keyed by filter id.
+     * Filters applied internally by a widget are omitted; use {@link DataCollection.getRawFilters} to get them as well.
+     * @param config - Set `permanent` to return only permanent filters.
+     * @returns The applied filters, or `null` if there are none.
+     */
     getFilters(config?: {
         permanent?: boolean;
     }): IFilter;
+    /**
+     * Returns the currently applied filters including the ones applied internally by a widget.
+     * @param config - Set `permanent` to return only permanent filters.
+     * @returns The applied filters, or `null` if there are none.
+     */
     getRawFilters(config?: {
         permanent?: boolean;
     }): IFilter;
     find(conf: IFilterMode | DataCallback<T>): any;
     findAll(conf: IFilterMode | DataCallback<T>): any[];
+    /**
+     * Sorts the collection.
+     * A rule applied on its own replaces whatever was applied before. Multi-level sorting is built
+     * by applying the base level with `smartSorting: true`: while that base is in place every next
+     * rule is appended as another level instead of replacing it, whether it comes with
+     * `smartSorting: false` or with no config at all. A rule for a field that is already a level
+     * only changes that level's direction. Calling the method without a rule resets the sorting
+     * and restores the original order.
+     * Does not work while data is being lazy-loaded.
+     * @param rule - The sorting rule. Omit to reset the sorting.
+     * @param config - Options that control how the rule is combined with the already applied ones.
+     * @param ignore - Internal. Reorders the data without recording the rule in the sorting state
+     * and without firing the `change` event. A call that resets the sorting still clears the state.
+     * Defaults to `false`.
+     * @example
+     * ```ts
+     * collection.sort({ by: "country", dir: "asc" });
+     *
+     * // two-level sorting: by country, then by population
+     * collection.sort({ by: "country", dir: "asc" }, { smartSorting: true });
+     * collection.sort({ by: "population", dir: "desc" }, { smartSorting: false });
+     *
+     * // sorting anew while a base is in place - reset first
+     * collection.sort();
+     * collection.sort({ by: "population", dir: "desc" });
+     * ```
+     */
     sort(rule?: ISortMode, config?: ISortConfig, ignore?: boolean): void;
-    getSortingStates(): ISortMode[];
+    /**
+     * Returns the currently applied sorting rules, from the base level to the last one added.
+     * The array is the one the collection sorts by, not a copy: do not modify it.
+     * @returns The applied rules, or an empty array if the collection is not sorted.
+     */
+    getSortingStates(): ISortingState[];
     copy(id: Id | Id[], index: number, target?: IDataCollection | ITreeCollection, targetId?: Id): Id | Id[];
     move(id: Id | Id[], index: number, target?: IDataCollection | ITreeCollection, targetId?: Id, newId?: Id): Id | Id[];
     forEach(callback: DataCallback<T>): void;
     load(url: IDataProxy | string, driver?: IDataDriver | DataDriver): Promise<any>;
     parse(data: T[] | string, driver?: DataDriver | IDataDriver): any;
-    $parse(data: any[]): void;
+    /**
+     * Puts already normalized data into the collection and notifies the subscribers.
+     * Called by the loader once a driver has converted the raw input into an array of items.
+     * @param data - Normalized items.
+     * @param resetRules - Whether to drop the sorting and non-permanent filtering rules before
+     * putting the data in. Set for `parse()` and `load()`, which replace the whole dataset, and
+     * not set for grouping, which only rebuilds the order. Defaults to `false`.
+     * @internal
+     */
+    $parse(data: any[], resetRules?: boolean): void;
     save(url: IDataProxy | string): void;
     changeId(id: Id, newId?: Id, silent?: boolean): void;
     isSaved(): boolean;
@@ -90,12 +184,81 @@ export declare class DataCollection<T extends IDataItem = IDataItem> implements
     protected _approximate(data: any[], values: string[], maxNum: number): any[];
     protected _onChange(status: Statuses, id: Id, obj: any): void;
     protected _addToOrder(array: any[], obj: any, index?: number): void;
+    /**
+     * Reorders the data by all currently stored sorting rules.
+     * @internal
+     */
     protected _applySorters(): void;
+    /**
+     * Narrows the data by a single rule, remembering the unfiltered order on first use.
+     * @param rule - The rule to apply. A missing rule is a no-op.
+     * @throws If the rule is neither a predicate nor a valid field/value pair.
+     * @internal
+     */
     protected _applyFilters(rule?: IFilterMode | IFilterCallback): void;
-    protected _reapplyFilters(): void;
+    /**
+     * Drops the sorting rules and restores the order the data had before sorting.
+     * If filtering was applied on top of the sorting, it is reapplied to the restored order.
+     * @internal
+     */
+    protected _resetSorting(): void;
+    /**
+     * Forgets the filters that do not outlive a data change, keeping the permanent ones.
+     * @internal
+     */
+    protected _dropNonPermanentFilters(): void;
+    /**
+     * Drops the rules that must not outlive a full data replacement: the sorting and
+     * the non-permanent filters. The counterpart of {@link DataCollection._reapplyRules},
+     * which restores everything that does outlive it.
+     * Called before the new data is put in, so the surviving permanent filters are only forgotten
+     * here, not reapplied: applying them to an empty collection would memorize an empty
+     * pre-filter state and lose the data that comes next.
+     * @internal
+     */
+    protected _resetRules(): void;
+    /**
+     * Restores the rules that outlive a data change: the permanent filters and,
+     * while smart sorting is on, the sorting order. Called after items are added, updated or parsed,
+     * and after a tree is sorted.
+     * @internal
+     */
+    protected _reapplyRules(): void;
+    /**
+     * Turns a field/value rule into a predicate.
+     * @param rule - The rule to convert.
+     * @returns The predicate, or `undefined` if the rule has no field or no value to match.
+     * @internal
+     */
     protected _getRuleCallback(rule: IFilterMode): IFilterCallback;
+    /**
+     * Strips the filters applied by a widget, leaving only those the user set.
+     * @param filters - The filters to strip.
+     * @returns The user-facing filters.
+     * @internal
+     */
     protected _getPureFilters(filters: IFilter): IFilter;
+    /**
+     * Flattens stored filters into a set of predicates that can be reapplied at once.
+     * @param filters - The stored filters.
+     * @returns A set of predicates keyed by index.
+     * @internal
+     */
     protected _normalizeFilters(filters: any): any;
+    /**
+     * Checks that a rule can be applied: it is either a predicate or has both a field and a value.
+     * @param rule - The rule to check.
+     * @returns Whether the rule is valid.
+     * @internal
+     */
     protected _checkFilterRule(rule: IFilterMode | IFilterCallback): boolean;
+    /**
+     * Clears the collection and hands the data over to the loader.
+     * @param data - Items or a serialized string.
+     * @param driver - Data driver used to parse the input. Defaults to the JSON driver.
+     * @param grouping - Whether the call rebuilds the order for grouping rather than replaces the
+     * dataset. Grouping keeps the sorting and filtering rules, a replacement drops them. Defaults to `false`.
+     * @internal
+     */
     private _parse;
 }

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

@@ -21,8 +21,42 @@ 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;
+    /**
+     * 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
+     * method has no lazy-loading guard and reorders whatever is currently in the tree.
+     * @param rule - The sorting rule. Omit to reset the sorting.
+     * @param config - Options that control how the rule is combined with the already applied ones.
+     * @param ignore - Internal. Reorders the data without recording the rule in the sorting state
+     * and without firing the `change` event. A call that resets the sorting still clears the state.
+     * Defaults to `false`.
+     */
     sort(rule?: ISortMode, config?: ISortConfig, ignore?: boolean): void;
+    /**
+     * Filters the tree, keeping the matched items together with their parent chain.
+     * By default every item at every nesting level is matched; `config.type` narrows that
+     * to a single level or to leaf items only. Rules are stored and combined the same way as in
+     * {@link DataCollection.filter}, but a rule without `compare` is matched differently: the field
+     * value has to contain `match` ignoring case, rather than be loosely equal to it, and a rule
+     * with an empty `match` is skipped instead of filtering everything out.
+     * @param rule - A single rule, a set of rules combined with AND, or a predicate. Omit to reset filtering.
+     * @param config - Options that control which items the rule is matched against and how it is stored.
+     * @param silent - Whether to suppress the `filter` event. Defaults to `false`.
+     * @returns The id the filter is stored under, or `undefined` if no rule was passed.
+     * @example
+     * ```ts
+     * // match every item at any level
+     * collection.filter({ by: "status", match: "done" });
+     *
+     * // match leaf items only
+     * collection.filter({ by: "status", match: "done" }, { type: "leafs" });
+     * ```
+     */
     filter(rule?: IFilterMode | IFilterComplexMode | IFilterCallback, config?: ITreeFilterConfig, silent?: boolean): string;
+    /**
+     * Restores the original order of the tree, dropping the sorting and every filter,
+     * permanent ones included.
+     */
     restoreOrder(): void;
     copy(id: Id, index: number, target?: IDataCollection | ITreeCollection, targetId?: Id): Id;
     copy(id: Id[], index: number, target?: IDataCollection | ITreeCollection, targetId?: Id): Id[];
@@ -65,8 +99,35 @@ export declare class TreeCollection<T extends IDataItem = IDataItem> extends Dat
     protected _parseItem(item: any): void;
     private _recursiveFilter;
     private _serialize;
+    /**
+     * Narrows the tree by a single rule, keeping the parent chain of every matched item
+     * and remembering the unfiltered tree on first use.
+     * @param rule - The rule to apply. A missing or empty rule is a no-op.
+     * @param config - Options that control which items the rule is matched against.
+     * @throws If the rule is neither a predicate nor a valid field/value pair.
+     * @internal
+     */
     private _applyFilter;
+    /**
+     * 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:
+     * {@link TreeCollection._applyFilter} needs the original rule to walk the tree, and it needs the
+     * id to look the matching config up.
+     * @param filters - The stored filters.
+     * @returns The bare rules, keyed by filter id.
+     * @internal
+     */
     protected _normalizeFilters(filters: any): any;
     protected _checkFilterRule(rule: IFilterMode | IFilterComplexMode | IFilterCallback): boolean;
+    /**
+     * Drops the sorting rules and rebuilds the tree in the order it had before sorting.
+     * If filtering was applied on top of the sorting, it is reapplied to the restored tree.
+     * @internal
+     */
+    protected _resetSorting(): void;
+    /**
+     * Reorders the children of every parent by all currently stored sorting rules.
+     * @internal
+     */
     protected _applySorters(): void;
 }

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

@@ -18,48 +18,130 @@ export interface ILazyConfig {
     delay?: number;
     prepare?: number;
 }
+/** Sorting direction: ascending or descending. */
 export type TSortDir = "asc" | "desc";
+/**
+ * A single sorting rule. Set either `by` or `rule`; with neither of them the rule has no effect.
+ *
+ * @example
+ * ```ts
+ * // sort by a field
+ * collection.sort({ by: "country", dir: "asc" });
+ *
+ * // sort by a computed value
+ * collection.sort({ by: "date", dir: "desc", as: value => new Date(value).getTime() });
+ *
+ * // sort by a custom comparator
+ * collection.sort({ rule: (a, b) => a.price - b.price });
+ * ```
+ */
 export interface ISortMode {
+    /** Name of the field to sort by. */
     by?: string | number;
+    /** Sorting direction. Defaults to `"asc"`. */
     dir?: TSortDir;
+    /** Maps a field value to the value actually compared (e.g. a date string to a timestamp). Ignored if `rule` is set. */
     as?: (a: any) => any;
+    /** Custom comparator applied to whole items. Takes precedence over `by` and `as`. */
     rule?: (a: any, b: any) => number;
 }
+/** An applied sorting rule together with the config it was applied with. */
 export type ISortingState = ISortMode & ISortConfig;
+/** Predicate that decides whether an item passes the filter. */
 export type IFilterCallback = (obj: any) => boolean;
+/**
+ * A single filtering rule.
+ *
+ * @example
+ * ```ts
+ * // keep items whose "country" equals "France"
+ * collection.filter({ by: "country", match: "France" });
+ *
+ * // keep items whose "age" is 30 or more
+ * collection.filter({ by: "age", match: "30", compare: (value, match) => Number(value) >= Number(match) });
+ * ```
+ */
 export interface IFilterMode {
+    /** Name of the field to filter by. */
     by?: Id;
-    match?: string | number | boolean;
+    /**
+     * Value the field is matched against. A multiselect filter passes an array of values,
+     * which `compare` is expected to treat as "any of these" — see `multi`.
+     */
+    match?: string | number | boolean | Array<string | number | boolean>;
+    /**
+     * Custom comparison. Without it the field value is compared to `match` loosely by a flat
+     * collection, while a tree one checks that the value contains `match` ignoring case.
+     */
     compare?: (value: any, match: any, obj: any, multi?: boolean) => boolean;
-    multi?: any;
-}
+    /**
+     * Marks the field as holding several values at once (a multiselect column stores them
+     * as a comma-separated string). Passed to `compare` as its last argument, both by a flat
+     * collection and by a tree one.
+     */
+    multi?: boolean;
+}
+/** A set of filtering rules combined with AND, keyed by an arbitrary name. */
 export interface IFilterComplexMode {
     [key: string]: IFilterMode;
 }
+/** Applied filters, keyed by filter id. */
 export interface IFilter {
     [key: string]: IFilterParams;
 }
+/** An applied filtering rule together with the config it was applied with. */
 export interface IFilterParams {
     rule: IFilterMode | IFilterComplexMode | IFilterCallback;
     config: IFilterConfig | ITreeFilterConfig;
 }
+/** Options that control how a filtering rule is applied and stored. */
 export interface IFilterConfig {
+    /** Id to store the filter under. Reapplying with the same id replaces the previous rule. Generated automatically if omitted. */
     id?: string;
+    /** Applies the rule on top of the already filtered data instead of replacing the active filters. */
     add?: boolean;
-    smartFilter?: boolean;
+    /**
+     * Marks the filter as permanent. Permanent filters are not dropped by `resetFilter()`
+     * and are reapplied to newly loaded data after `parse()` / `load()`.
+     */
     permanent?: boolean;
+    /**
+     * Reapplies the stored filters instead of registering a new one.
+     * @internal
+     */
     $restore?: boolean;
+    /**
+     * Hides the filter from `getFilters()` and from the `filter` event.
+     * @internal
+     */
     $local?: boolean;
+    /** @deprecated Not used. Kept for backward compatibility. */
+    smartFilter?: boolean;
 }
+/** Options that control which filters `resetFilter()` removes. */
 export interface IResetFilterConfig {
+    /** Removes only the filter with this id. */
     id?: string;
+    /** Removes permanent filters as well. Without it they survive the reset. */
     permanent?: boolean;
 }
+/** Options that control how a sorting rule is applied and stored. */
 export interface ISortConfig {
+    /**
+     * Makes the rule the base level of a multi-level sorting: the previously applied
+     * levels are discarded and the order is maintained when items are added or updated.
+     * While such a base is in place every next rule is appended as another level instead of
+     * replacing it - both with `smartSorting: false` and with no config at all. Without a base
+     * every rule replaces whatever is applied.
+     * To sort anew while a base is in place, reset the sorting first: `sort()`, then `sort(rule)`.
+     */
     smartSorting?: boolean;
 }
+/** Options that control how a filtering rule is applied to a tree collection. */
 export interface ITreeFilterConfig extends IFilterConfig {
+    /** Which items the rule is matched against: all of them, a single level, or leaf items only. */
     type?: TreeFilterType;
+    /** Nesting level the rule is applied to when `type` is `"level"`. */
     level?: number;
 }
 export interface IUpdateObject {
@@ -91,7 +173,7 @@ export interface IDataCollection<T extends IDataItem = IDataItem> {
     isGrouped(): boolean;
     load(url: IDataProxy | string, driver?: IDataDriver | DataDriver): Promise<any>;
     parse(data: T[] | string, driver?: DataDriver | IDataDriver): void;
-    $parse(data: any[]): void;
+    $parse(data: any[], resetRules?: boolean): void;
     add(newItem: IDataItem, index?: number): Id;
     add(newItem: IDataItem[], index?: number): Id[];
     add(newItem: IDataItem | IDataItem[], index?: number): Id | Id[];
@@ -105,7 +187,7 @@ export interface IDataCollection<T extends IDataItem = IDataItem> {
     getLength(): number;
     isDataLoaded(from?: number, to?: number): boolean;
     getId(index: number): Id;
-    filter(rule?: IFilterMode | IFilterCallback, config?: IFilterConfig, silent?: boolean): string;
+    filter(rule?: IFilterMode | IFilterComplexMode | IFilterCallback, config?: IFilterConfig, silent?: boolean): string;
     resetFilter(config?: IResetFilterConfig, silent?: boolean): boolean;
     getFilters(config?: {
         permanent?: boolean;
@@ -118,7 +200,7 @@ export interface IDataCollection<T extends IDataItem = IDataItem> {
     findAll(rule: IFilterMode): T[];
     map(callback: DataCallback<T>): T[];
     mapRange(from: number, to: number, callback: DataCallback<T>): T[];
-    sort(rule?: ISortMode, config?: ISortConfig): void;
+    sort(rule?: ISortMode, config?: ISortConfig, ignore?: boolean): void;
     getSortingStates(): ISortingState[];
     serialize(driver?: DataDriver): T[];
     copy(id: Id | Id[], index: number, target?: IDataCollection | ITreeCollection, targetId?: Id): Id | Id[];
@@ -163,9 +245,13 @@ export interface ICsvDriverConfig {
     rowDelimiter?: string;
     columnDelimiter?: string;
 }
+/** Scope a tree filtering rule is matched against. */
 export declare enum TreeFilterType {
+    /** Every item at any nesting level. */
     all = "all",
+    /** Only items at the level given by {@link ITreeFilterConfig.level}. */
     level = "level",
+    /** Only items without children. */
     leafs = "leafs"
 }
 export type DataCallback<T> = (item: T, index?: number, array?: T[]) => any;
@@ -180,9 +266,9 @@ export interface ITreeCollection<T extends IDataItem = IDataItem> extends IDataC
     getLength(id?: Id): number;
     getIndex(id: Id): number;
     getItems(id: Id): T[];
-    sort(rule?: ISortMode, config?: ISortConfig): void;
+    sort(rule?: ISortMode, config?: ISortConfig, ignore?: boolean): void;
     map(callback: DataCallback<T>, parent?: Id, direct?: boolean): any;
-    filter(rule?: IFilterMode | IFilterCallback, config?: ITreeFilterConfig, silent?: boolean): string;
+    filter(rule?: IFilterMode | IFilterComplexMode | IFilterCallback, config?: ITreeFilterConfig, silent?: boolean): string;
     restoreOrder(): void;
     copy(id: Id, index: number, target?: IDataCollection | ITreeCollection, targetId?: Id): Id;
     copy(id: Id[], index: number, target?: IDataCollection | ITreeCollection, targetId?: Id): Id[];

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

@@ -91,6 +91,7 @@ export declare class Grid extends View implements IGrid {
     protected _checkFilters(reset?: boolean): void;
     protected _setUniqueData(sync?: boolean): void;
     protected _checkSelectFilterValue(): void;
+    protected _resetFilterUI(): void;
     protected _clearFilterValue(allCols?: boolean): void;
     protected _adjustColumns(): void;
     protected _prepareData(data: IDataItem[] | IDataCollection): any[] | IDataItem[];

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

@@ -14,6 +14,7 @@ export declare function isContentTooltip(config: IGridConfig, col: ICol, cell: a
 export declare function getTooltipConfig(config: IGridConfig, col?: ICol, cell?: IHeader | IFooter | ISpan, type?: "footer" | "header"): IGridTooltipConfig;
 export declare function isTooltip(config: IGridConfig, element: ICol | ISpan): boolean | IGridTooltipConfig;
 export declare function isHtmlEnable(config: IGridConfig, col: ICol, content?: IHeader | IFooter): boolean;
+export declare function isInteractiveTarget(target: EventTarget): boolean;
 export declare function getTotalWidth(columns: ICol[]): number;
 export declare function getTotalHeight(rows: IRow[]): number;
 export declare function scrollFixedColsAndRows(e: WheelEvent): void;

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

@@ -56,6 +56,7 @@ export declare class Selection implements ISelection {
     private _removeCells;
     private _init;
     private _toHTML;
+    private _getSelectionLayout;
     private _isUnselected;
     private _findIndex;
     private _cellKey;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dhtmlx/grid",
-  "version": "9.3.8",
+  "version": "9.3.9",
   "description": "DHTMLX Grid - JavaScript data grid library. GPL v2 edition for GPL-compatible open-source projects; commercial licenses are available for proprietary and production use.",
   "keywords": ["dhtmlx","grid","datagrid","table","treegrid","data-table","javascript","typescript"],
   "homepage":"https://docs.dhtmlx.com/suite/grid/",

package/whatsnew.txt

@@ -1,3 +1,23 @@
+# Version 9.3.9 (August 13, 2026)
+
+### Updates
+
+- DataCollection/TreeCollection. The `parse()` and `load()` methods now reset existing sorting and filtering. Only filters with `permanent: true` are retained and reapplied to the new dataset
+- Grid. Visual sorting indicators and header filter values are now automatically reset when data is reloaded via `parse()` or `load()`
+
+### Fixes
+
+- DataCollection. Fixed inconsistent results in `forEach()` and `map()` when `update()` was called from within the callback while sorting was active
+- Grid. Fixed the duplication of selection overlays on spanned cells when using `selection: "complex"`
+- Grid. Fixed a checkbox click in a sortable column header triggering a sort action
+- Grid. Fixed a bug where an `undefined` CSS class was added to cells when using the `mark` property
+- Grid. Fixed removing a grouped column via its "close" icon starting a column drag action
+- Grid. Resolved an issue where `removeAll()` cleared header filter inputs but failed to reset the underlying filtering rules
+- Grid. Fixed multiselect filtering for columns with `editorType: "multiselect"`; cells are now correctly matched if any of their values satisfy the filter
+- TreeCollection. Fixed an issue where the tree could appear empty after `parse()` if a permanent filter was active
+- TreeCollection. Fixed a bug where items were added twice when inserted into a sorted tree
+- TreeCollection. Fixed the `multi` property of a filtering rule not being passed to the `compare` callback
+
 # Version 9.3.8 (August 3, 2026)
 
 ### Fixes