@dhtmlx/chart 9.3.4 → 9.3.5

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

@@ -34,3 +34,4 @@ export declare function getReverseScrollState(grid: any): {
     x: number;
     y: number;
 };
+export declare function getColumnHeaderText(col: ICol): string;

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

@@ -1,27 +1,49 @@
+/**
+ * Creates keyboard event handlers for grid navigation, editing, and zone transitions.
+ * Initializes focus sentinels and returns a map of key handlers used by KeyManager.
+ * Each handler routes to zone-specific logic (header/footer) or body cell navigation
+ * depending on the current focus position.
+ * @param grid - the grid instance (IProGrid or IExtendedGrid)
+ * @returns an object mapping key names to their handler functions
+ */
 export declare function getKeysHandlers(grid: any): {
-    enter: () => void;
+    enter: (e: any) => void;
+    f2: () => void;
     space: (e: any) => void;
-    escape: () => void;
+    escape: (e: any) => void;
     tab: (e: any) => void;
     delete: () => void;
     "shift+tab": (e: any) => void;
-    arrowUp: (event: any) => void;
+    arrowUp: (e: any) => void;
+    "shift+enter": (e: any) => void;
     "ctrl+z": () => void;
     "ctrl+shift+z": () => void;
     "ctrl+enter": () => void;
-    "ctrl+arrowUp": (event: any) => void;
-    "shift+arrowUp": (event: any) => void;
-    "ctrl+shift+arrowUp": (event: any) => void;
-    arrowDown: (event: any) => void;
-    "ctrl+arrowDown": (event: any) => void;
-    "shift+arrowDown": (event: any) => void;
-    "ctrl+shift+arrowDown": (event: any) => void;
-    arrowRight: (event: any) => void;
-    "ctrl+arrowRight": (event: any) => void;
-    "shift+arrowRight": (event: any) => void;
-    "ctrl+shift+arrowRight": (event: any) => void;
-    arrowLeft: (event: any) => void;
-    "ctrl+arrowLeft": (event: any) => void;
-    "shift+arrowLeft": (event: any) => void;
-    "ctrl+shift+arrowLeft": (event: any) => void;
+    "ctrl+arrowUp": (e: any) => void;
+    "shift+arrowUp": (e: any) => void;
+    "ctrl+shift+arrowUp": (e: any) => void;
+    arrowDown: (e: any) => void;
+    "ctrl+arrowDown": (e: any) => void;
+    "shift+arrowDown": (e: any) => void;
+    "ctrl+shift+arrowDown": (e: any) => void;
+    arrowRight: (e: any) => void;
+    "ctrl+arrowRight": (e: any) => void;
+    "shift+arrowRight": (e: any) => void;
+    "ctrl+shift+arrowRight": (e: any) => void;
+    arrowLeft: (e: any) => void;
+    "ctrl+arrowLeft": (e: any) => void;
+    "shift+arrowLeft": (e: any) => void;
+    "ctrl+shift+arrowLeft": (e: any) => void;
+    pageDown: (e: any) => void;
+    pageUp: (e: any) => void;
+    "shift+pageDown": (e: any) => void;
+    "shift+pageUp": (e: any) => void;
+    home: (e: any) => void;
+    end: (e: any) => void;
+    "shift+home": (e: any) => void;
+    "shift+end": (e: any) => void;
+    "ctrl+home": (e: any) => void;
+    "ctrl+end": (e: any) => void;
+    "ctrl+shift+home": (e: any) => void;
+    "ctrl+shift+end": (e: any) => void;
 };

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

@@ -0,0 +1,9 @@
+import { IGrid, ICol, IRow } from "../types";
+export declare function isColumnEditable(column: ICol, config: {
+    editable?: boolean;
+}): boolean;
+export declare function toggleBooleanCell(grid: IGrid, row: IRow, column: ICol): void;
+export declare function startCellEdit(grid: IGrid, selected: {
+    row: IRow;
+    column: ICol;
+}): void;

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

@@ -0,0 +1,23 @@
+import { IGrid, IDirection, IProGrid, ICol, IRow } from "../types";
+import { IRangeSelection } from "../modules/Range";
+interface IMoveConf {
+    grid: IGrid | IProGrid;
+    dir: IDirection;
+    rangedIndex: number;
+    columns?: ICol[];
+    event?: KeyboardEvent;
+    toEnd?: boolean;
+    shiftUp?: boolean;
+}
+export declare function move(config: IMoveConf): void;
+export declare function applyRangeMove(proGrid: IProGrid, target: ICol | IRow, rangedCell: IRangeSelection, dir: IDirection, shiftUp: boolean): void;
+export declare function getRangedIndex(grid: IGrid | IProGrid, direction: "up" | "down" | "left" | "right"): number;
+export declare function getActiveCell(grid: IGrid | IProGrid, cellSelection: boolean): {
+    row: IRow;
+    column: ICol;
+} | null;
+export declare function walkVisibleRows(grid: IGrid | IProGrid, fromRowId: any, steps: number): any;
+export declare function getNextVisibleRowId(grid: IGrid | IProGrid, currentRowId: any, direction: 1 | -1): import("../../../ts-common/types").Id;
+export declare function isTreeColumn(grid: IGrid | IProGrid, colId: any): boolean;
+export declare function navigateToCell(grid: any, cellSelection: boolean, rowId: any, colId: any): void;
+export {};

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

@@ -0,0 +1,239 @@
+import { ICol } from "../types";
+export type FocusZone = "header" | "body" | "footer" | "groupPanel";
+/**
+ * Detects which focus zone the event target belongs to.
+ * Walks up the DOM tree to determine if the target is in the header, footer, body, or group panel.
+ * Span cells require special disambiguation since they exist across multiple zones.
+ * @param event - the DOM event whose target will be inspected
+ * @returns the zone containing the event target
+ */
+export declare function detectFocusZone(event: Event): FocusZone;
+/**
+ * Returns all visible (non-hidden) columns in their configured order.
+ * @param grid - the grid instance
+ * @returns an array of visible column configs
+ */
+export declare function getVisibleColumns(grid: any): ICol[];
+/**
+ * Determines which split section a column belongs to based on its index
+ * relative to leftSplit and rightSplit boundaries.
+ * @param grid - the grid instance
+ * @param colId - the column ID to look up
+ * @returns "left" for left-fixed, "right" for right-fixed, or "center" for scrollable columns
+ */
+export declare function getColumnSplitSection(grid: any, colId: string): "left" | "center" | "right";
+/**
+ * Returns the number of rows in a header or footer zone.
+ * Uses the internal $headerHeightMap / $footerHeightMap arrays.
+ * @param grid - the grid instance
+ * @param zone - the focus zone to query
+ * @returns the row count for the zone, or 0 if zone is not header/footer
+ */
+export declare function getZoneRowCount(grid: any, zone: FocusZone): number;
+/**
+ * Finds a zone cell element in the DOM by column ID and row index.
+ * Checks span cells first since they overlay regular cells, then falls back
+ * to regular header/footer cells. Searches section-specific containers first
+ * for performance, falling back to the entire grid root.
+ * @param grid - the grid instance
+ * @param zone - the focus zone to search in
+ * @param colId - the column ID attribute to match
+ * @param rowIndex - the row index attribute to match
+ * @returns the matching DOM element, or null if not found
+ */
+export declare function findZoneCell(grid: any, zone: FocusZone, colId: string, rowIndex: number): HTMLElement | null;
+/**
+ * Scrolls the grid horizontally to ensure a column is visible in the viewport.
+ * Skips fixed (left/right split) columns since they are always visible.
+ * Calculates the column position relative to the scrollable area and adjusts
+ * the scroll offset if the column is outside the visible range.
+ * @param grid - the grid instance
+ * @param colId - the column ID to make visible
+ */
+export declare function ensureZoneCellVisible(grid: any, colId: string): void;
+/**
+ * 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
+ * colspan+rowspan coverage includes the target position. Handles colspan-only,
+ * rowspan-only, and combined span cases uniformly.
+ * @param zone - the focus zone (determines whether to use "header" or "footer" config)
+ * @param colId - the target column ID
+ * @param rowIndex - the target row index
+ * @param columns - the visible columns array
+ * @returns the owning cell's colId and rowIndex (unchanged if no span covers the position)
+ */
+export declare function resolveSpanTarget(zone: FocusZone, colId: string, rowIndex: number, columns: ICol[]): {
+    colId: string;
+    rowIndex: number;
+};
+/**
+ * Moves focus horizontally within a header/footer zone (ArrowLeft/ArrowRight).
+ * Preserves the logical navigation row (navRowIndex) across rowspan cells so that
+ * horizontal movement stays on the same logical level. Handles colspan skip when
+ * moving right past a multi-column cell.
+ * @param grid - the grid instance
+ * @param event - the keyboard event (will be preventDefault'd)
+ * @param zone - the current focus zone
+ * @param direction - horizontal direction to move
+ */
+export declare function moveZoneFocus(grid: any, event: KeyboardEvent, zone: FocusZone, direction: "left" | "right"): void;
+/**
+ * Moves focus vertically within a header/footer zone (ArrowUp/ArrowDown).
+ * When moving down past a rowspan cell, starts from the span's last row.
+ * Returns false when reaching the zone boundary, signaling the caller
+ * to handle the transition to body or adjacent zone.
+ * @param grid - the grid instance
+ * @param event - the keyboard event (will be preventDefault'd)
+ * @param zone - the current focus zone
+ * @param direction - vertical direction to move
+ * @returns true if focus moved within the zone, false if at the boundary
+ */
+export declare function moveZoneFocusVertical(grid: any, event: KeyboardEvent, zone: FocusZone, direction: "up" | "down"): boolean;
+/**
+ * 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).
+ * 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)
+ * @param zone - the current focus zone
+ * @param direction - tab direction: "forward" for Tab, "backward" for Shift+Tab
+ * @returns "moved" on success, "exit-end" if past the last cell, "exit-start" if before the first
+ */
+export declare function moveZoneFocusTab(grid: any, event: KeyboardEvent, zone: FocusZone, direction: "forward" | "backward"): "moved" | "exit-start" | "exit-end";
+/**
+ * Checks if the active body cell is in the first visible column.
+ * Works with both cell selection and block (range) selection modes.
+ * @param grid - the grid instance
+ * @returns true if the selection is on the first column or no selection exists
+ */
+export declare function isAtFirstColumn(grid: any): boolean;
+/**
+ * Checks if a header/footer cell is a content cell (contains a filter widget).
+ * Content cells have the dhx_grid-custom-content-cell class.
+ * @param target - the DOM element to check
+ * @returns true if the element is a content cell
+ */
+export declare function isContentCell(target: HTMLElement): boolean;
+/**
+ * Activates the inner widget of a content cell (Enter on a filter cell).
+ * Sets tabindex="0" on the inner input/select and focuses it.
+ * Attaches an Escape keydown listener directly on the inner element to handle
+ * widgets that call stopPropagation (e.g., ComboFilter closing its popup).
+ * @param target - the content cell DOM element
+ */
+export declare function activateContentCell(target: HTMLElement): void;
+/**
+ * Deactivates the inner widget of a content cell (Escape from an active filter).
+ * Restores tabindex="-1" on the inner element, removes the Escape listener,
+ * and returns focus to the outer cell.
+ * @param cell - the content cell DOM element to deactivate
+ */
+export declare function deactivateContentCell(cell: HTMLElement): void;
+/**
+ * Triggers column sorting on a header cell via keyboard (Enter/Space/Shift+Enter).
+ * Matches the click-based sort logic from ExtendedGrid.
+ * Skips content cells (filters) and colspan cells.
+ * After the sort triggers a re-render, restores focus to the same cell.
+ * @param grid - the grid instance
+ * @param event - the keyboard event
+ * @param isModifierKey - if true, toggles multi-sort behavior (Shift+Enter)
+ */
+export declare function triggerHeaderSort(grid: any, event: KeyboardEvent, isModifierKey?: boolean): void;
+/**
+ * Sets focus on a zone cell using the roving tabindex pattern.
+ * Scrolls the column into view first (the cell may not exist in the DOM due to
+ * virtualized rendering), then sets tabindex="0" and focuses the target cell.
+ * Updates the sentinel state to track the last active position and logical navigation row.
+ * @param grid - the grid instance
+ * @param zone - the focus zone containing the cell
+ * @param colId - the column ID of the cell to focus
+ * @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
+ */
+export declare function setZoneCellFocus(grid: any, zone: FocusZone, colId: string, rowIndex: number, prevCell?: HTMLElement, navRowIndex?: number): 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
+ * cell selection or block (range) selection depending on the grid config.
+ * Falls back to manual focus if restoreFocus() doesn't reach the cell
+ * (e.g., fixed columns outside .dhx_grid_data).
+ * @param grid - the grid instance
+ * @param colId - the column to focus in the body
+ * @param position - "first" to select the first row, "last" to select the last row
+ */
+export declare function transitionToBody(grid: any, colId: string, position: "first" | "last"): void;
+/**
+ * Transitions focus from the body data area to a header/footer zone.
+ * Resolves span targets and sets focus on the appropriate zone cell.
+ * @param grid - the grid instance
+ * @param zone - the target zone to transition to
+ * @param colId - the column to focus in the zone
+ * @param rowIndex - the row index in the zone (defaults to the last row)
+ */
+export declare function transitionFromBodyToZone(grid: any, zone: FocusZone, colId: string, rowIndex?: number): void;
+/**
+ * Checks if the active body cell is on the first data row.
+ * Works with both cell selection and block (range) selection modes.
+ * @param grid - the grid instance
+ * @returns true if the selection is on the first row or no selection exists
+ */
+export declare function isAtFirstRow(grid: any): boolean;
+/**
+ * Checks if the active body cell is on the last data row.
+ * For tree grids, considers the deepest last child as the last row.
+ * Works with both cell selection and block (range) selection modes.
+ * @param grid - the grid instance
+ * @returns true if the selection is on the last row or no selection exists
+ */
+export declare function isAtLastRow(grid: any): boolean;
+/**
+ * Checks if the grid has a footer zone with at least one row.
+ * @param grid - the grid instance
+ * @returns true if footer row count is greater than 0
+ */
+export declare function hasFooter(grid: any): boolean;
+/**
+ * Returns the column ID of the currently active body cell.
+ * Reads from range selection (xStart) or cell selection depending on config.
+ * @param grid - the grid instance
+ * @returns the active column ID, or null if no cell is selected
+ */
+export declare function getActiveColumnId(grid: any): string | null;
+/**
+ * Extracts the column ID from a DOM element's data-dhx-id attribute.
+ * @param target - the DOM element to read from
+ * @returns the column ID string, or null if the attribute is missing
+ */
+export declare function getColIdFromTarget(target: HTMLElement): string | null;
+/**
+ * Resets all zone cells and their inner elements to tabindex="-1".
+ * Called when leaving a zone to ensure the sentinel remains the sole Tab entry point.
+ * Also resets inner filter inputs/selects (including ComboFilter inputs
+ * that don't get tabindex via VDOM).
+ * @param grid - the grid instance
+ * @param zone - the zone whose cells should be reset
+ */
+export declare function restoreZoneTabindex(grid: any, zone: FocusZone): void;
+/**
+ * Initializes the start focus sentinel for the grid.
+ * Attaches a focus listener on the .dhx_grid-focus-sentinel element that redirects
+ * focus to the stored header cell position (or the first cell on initial entry).
+ * Validates the stored column and row index before focusing.
+ * Only runs once per grid instance (tracked via sentinelStateMap).
+ * @param grid - the grid instance
+ */
+export declare function initFocusSentinel(grid: any): void;
+/**
+ * Initializes the end focus sentinel for backward Tab entry.
+ * When Shift+Tab from outside the grid lands on the end sentinel,
+ * redirects focus to the footer's last cell, or to the header's first cell
+ * if the grid has no footer.
+ * Only runs once per sentinel element (tracked via data-dhx-initialized attribute).
+ * @param grid - the grid instance
+ */
+export declare function initEndSentinel(grid: any): void;

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

@@ -67,6 +67,7 @@ export interface IBlockSelection {
      * This method is for internal use and should not be called directly
      */
     toHTML(): VNode | VNode[];
+    restoreFocus(): void;
 }
 export declare class BlockSelection implements IBlockSelection {
     config: IBlockSelectionConfig;
@@ -92,6 +93,7 @@ export declare class BlockSelection implements IBlockSelection {
     disable(): void;
     isDisabled(): boolean;
     destructor(): void;
+    restoreFocus(): void;
     toHTML(): VNode | null;
     private _calculateClippedGeometry;
     private _getAreaNode;

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

@@ -17,6 +17,8 @@ export interface ISelection {
     enable(): void;
     isSelectedCell(row: IRow | Id, column?: ICol | Id): boolean;
     toHTML(): VNode | VNode[];
+    /** @internal Restore browser focus */
+    restoreFocus(): void;
 }
 export declare enum GridSelectionEvents {
     beforeUnSelect = "beforeUnSelect",
@@ -38,6 +40,7 @@ export declare class Selection implements ISelection {
     private _gridId;
     private _selectedCell;
     private _selectedCells;
+    private _selectedSet;
     constructor(grid: IGrid | IProGrid, config?: ISelectionConfig, events?: IEventSystem<any>, gridId?: Id);
     setCell(row?: IRow | Id, col?: ICol | Id, ctrlUp?: boolean, shiftUp?: boolean): void;
     removeCell(rowId?: Id, colId?: Id): void;
@@ -45,8 +48,9 @@ export declare class Selection implements ISelection {
     getCells(): ICell[];
     disable(): void;
     enable(): void;
-    toHTML(): VNode | VNode[];
     isSelectedCell(row: IRow | Id, column?: ICol | Id): boolean;
+    restoreFocus(): void;
+    toHTML(): VNode | VNode[];
     private _setCell;
     private _removeCell;
     private _removeCells;
@@ -54,5 +58,6 @@ export declare class Selection implements ISelection {
     private _toHTML;
     private _isUnselected;
     private _findIndex;
+    private _cellKey;
     private _setBrowserFocus;
 }

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

@@ -416,6 +416,7 @@ export interface ICol {
     };
     $uniqueData?: any[];
     $activeFilterData?: any[];
+    $index?: number;
     $width?: number;
     $fixedWidth?: boolean;
     $customOptions?: any;

package/codebase/types/ts-grid/sources/ui/editors/CheckboxEditor.d.ts

@@ -11,6 +11,7 @@ export declare class CheckboxEditor implements IEditor {
     protected _checkbox: HTMLInputElement;
     protected _input: HTMLInputElement;
     protected _checked: boolean;
+    protected _parent: HTMLElement;
     constructor(row: IRow, col: ICol, config: IRendererConfig);
     endEdit(): void;
     toHTML(): any;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@dhtmlx/chart",
-  "version": "9.3.4",
-  "description": "DHTMLX Chart – JavaScript chart library with 11 chart types, mixed charts, real-time updates, and deep customization",
+  "version": "9.3.5",
+  "description": "DHTMLX Chart - JavaScript chart library. GPL v2 edition for GPL-compatible open-source projects; commercial licenses are available for proprietary and production use.",
   "keywords": ["dhtmlx","chart","charts","graph","visualization","javascript","typescript"],
   "homepage":"https://docs.dhtmlx.com/suite/chart/",
   "license": "GPL-2.0-only",

package/whatsnew.txt

@@ -1,3 +1,6 @@
+Version 9.3.5 (July 1, 2026)
+----------------------------
+
 Version 9.3.4 (June 2, 2026)
 ----------------------------