@highcharts/grid-pro 2.0.0

package/es-modules/Grid/Core/Querying/QueryingController.d.ts

@@ -0,0 +1,58 @@
+import type DataModifier from '../../../Data/Modifiers/DataModifier.js';
+import type Grid from '../Grid.js';
+import SortingController from './SortingController.js';
+import FilteringController from './FilteringController.js';
+import PaginationController from './PaginationController.js';
+/**
+ * Class that manage data modification of the visible data in the data grid.
+ * It manages the modifiers that are applied to the data table.
+ */
+declare class QueryingController {
+    /**
+     * The data grid instance.
+     */
+    grid: Grid;
+    /**
+     * Sorting controller instance.
+     */
+    sorting: SortingController;
+    /**
+     * Filtering controller instance.
+     */
+    filtering: FilteringController;
+    /**
+     * Pagination controller instance
+     */
+    pagination: PaginationController;
+    /**
+     * This flag should be set to `true` if the modifiers should reapply to the
+     * data table due to some data change or other important reason.
+     */
+    shouldBeUpdated: boolean;
+    constructor(grid: Grid);
+    /**
+     * Proceeds with the data modification if needed.
+     *
+     * @param force
+     * If the data should be modified even if the significant options are not
+     * changed.
+     */
+    proceed(force?: boolean): Promise<void>;
+    /**
+     * Load all options needed to generate the modifiers.
+     */
+    loadOptions(): void;
+    /**
+     * Creates a list of modifiers that should be applied to the data table.
+     */
+    willNotModify(): boolean;
+    /**
+     * Returns a list of modifiers that should be applied to the data table.
+     */
+    getGroupedModifiers(): DataModifier[];
+    /**
+     * Apply all modifiers to the data table.
+     */
+    private modifyData;
+}
+export default QueryingController;

package/es-modules/Grid/Core/Querying/QueryingController.js

@@ -0,0 +1,127 @@
+/* *
+ *
+ *  Grid Querying Controller class
+ *
+ *  (c) 2020-2025 Highsoft AS
+ *
+ *  License: www.highcharts.com/license
+ *
+ *  !!!!!!! SOURCE GETS TRANSPILED BY TYPESCRIPT. EDIT TS FILE ONLY. !!!!!!!
+ *
+ *  Authors:
+ *  - Dawid Dragula
+ *
+ * */
+'use strict';
+import ChainModifier from '../../../Data/Modifiers/ChainModifier.js';
+import SortingController from './SortingController.js';
+import FilteringController from './FilteringController.js';
+import PaginationController from './PaginationController.js';
+/* *
+ *
+ *  Class
+ *
+ * */
+/**
+ * Class that manage data modification of the visible data in the data grid.
+ * It manages the modifiers that are applied to the data table.
+ */
+class QueryingController {
+    /* *
+    *
+    *  Constructor
+    *
+    * */
+    constructor(grid) {
+        /**
+         * This flag should be set to `true` if the modifiers should reapply to the
+         * data table due to some data change or other important reason.
+         */
+        this.shouldBeUpdated = false;
+        this.grid = grid;
+        this.filtering = new FilteringController(this);
+        this.sorting = new SortingController(this);
+        this.pagination = new PaginationController(this);
+    }
+    /* *
+    *
+    *  Functions
+    *
+    * */
+    /**
+     * Proceeds with the data modification if needed.
+     *
+     * @param force
+     * If the data should be modified even if the significant options are not
+     * changed.
+     */
+    async proceed(force = false) {
+        if (force || this.shouldBeUpdated) {
+            await this.modifyData();
+        }
+    }
+    /**
+     * Load all options needed to generate the modifiers.
+     */
+    loadOptions() {
+        this.filtering.loadOptions();
+        this.sorting.loadOptions();
+        this.pagination.loadOptions();
+    }
+    /**
+     * Creates a list of modifiers that should be applied to the data table.
+     */
+    willNotModify() {
+        return (!this.sorting.modifier &&
+            !this.filtering.modifier);
+    }
+    /**
+     * Returns a list of modifiers that should be applied to the data table.
+     */
+    getGroupedModifiers() {
+        const modifiers = [];
+        if (this.sorting.modifier) {
+            modifiers.push(this.sorting.modifier);
+        }
+        if (this.filtering.modifier) {
+            modifiers.push(this.filtering.modifier);
+        }
+        return modifiers;
+    }
+    /**
+     * Apply all modifiers to the data table.
+     */
+    async modifyData() {
+        const originalDataTable = this.grid.dataTable;
+        if (!originalDataTable) {
+            return;
+        }
+        const groupedModifiers = this.getGroupedModifiers();
+        let interTable;
+        // Grouped modifiers
+        if (groupedModifiers.length > 0) {
+            const chainModifier = new ChainModifier({}, ...groupedModifiers);
+            const dataTableCopy = originalDataTable.clone();
+            await chainModifier.modify(dataTableCopy.getModified());
+            interTable = dataTableCopy.getModified();
+        }
+        else {
+            interTable = originalDataTable.getModified();
+        }
+        // Pagination modifier
+        const paginationModifier = this.pagination.createModifier(interTable.rowCount);
+        if (paginationModifier) {
+            interTable = interTable.clone();
+            await paginationModifier.modify(interTable);
+            interTable = interTable.getModified();
+        }
+        this.grid.presentationTable = interTable;
+        this.shouldBeUpdated = false;
+    }
+}
+/* *
+ *
+ *  Default Export
+ *
+ * */
+export default QueryingController;

package/es-modules/Grid/Core/Querying/SortingController.d.ts

@@ -0,0 +1,67 @@
+import type { ColumnSortingOrder } from '../Options.js';
+import QueryingController from './QueryingController.js';
+import SortModifier from '../../../Data/Modifiers/SortModifier.js';
+/**
+ * Class that manages one of the data grid querying types - sorting.
+ */
+declare class SortingController {
+    /**
+     * The data grid instance.
+     */
+    private querying;
+    /**
+     * The current sorting options: column ID and sorting order.
+     */
+    currentSorting?: SortingController.SortingState;
+    /**
+     * The initial sorting options: column ID and sorting order.
+     * This is the sorting that is applied when the data grid is created or
+     * after the whole viewport is reloaded with changed sorting options.
+     */
+    private initialSorting?;
+    /**
+     * The modifier that is applied to the data table.
+     */
+    modifier?: SortModifier;
+    /**
+     * Constructs the SortingController instance.
+     *
+     * @param querying
+     * The querying controller instance.
+     */
+    constructor(querying: QueryingController);
+    /**
+     * Sets the sorting state. If the new sorting state is different than the
+     * current one, the `shouldBeUpdated` flag is set to `true`. If the
+     * same, the flag is set to `false`.
+     *
+     * @param order
+     * The sorting order.
+     *
+     * @param columnId
+     * The column ID to sort by.
+     */
+    setSorting(order: ColumnSortingOrder, columnId?: string): void;
+    /**
+     * Returns the sorting options from the data grid options.
+     */
+    private getSortingOptions;
+    /**
+     * Loads sorting options from the data grid options.
+     */
+    loadOptions(): void;
+    /**
+     * Returns the sorting modifier based on the loaded sorting options.
+     */
+    private createModifier;
+}
+declare namespace SortingController {
+    /**
+     * The sorting state interface.
+     */
+    interface SortingState {
+        columnId?: string;
+        order: ColumnSortingOrder;
+    }
+}
+export default SortingController;

package/es-modules/Grid/Core/Querying/SortingController.js

@@ -0,0 +1,136 @@
+/* *
+ *
+ *  Grid Sorting Controller class
+ *
+ *  (c) 2020-2025 Highsoft AS
+ *
+ *  License: www.highcharts.com/license
+ *
+ *  !!!!!!! SOURCE GETS TRANSPILED BY TYPESCRIPT. EDIT TS FILE ONLY. !!!!!!!
+ *
+ *  Authors:
+ *  - Dawid Dragula
+ *
+ * */
+'use strict';
+import SortModifier from '../../../Data/Modifiers/SortModifier.js';
+/* *
+ *
+ *  Class
+ *
+ * */
+/**
+ * Class that manages one of the data grid querying types - sorting.
+ */
+class SortingController {
+    /* *
+    *
+    *  Constructor
+    *
+    * */
+    /**
+     * Constructs the SortingController instance.
+     *
+     * @param querying
+     * The querying controller instance.
+     */
+    constructor(querying) {
+        this.querying = querying;
+    }
+    /* *
+    *
+    *  Functions
+    *
+    * */
+    /**
+     * Sets the sorting state. If the new sorting state is different than the
+     * current one, the `shouldBeUpdated` flag is set to `true`. If the
+     * same, the flag is set to `false`.
+     *
+     * @param order
+     * The sorting order.
+     *
+     * @param columnId
+     * The column ID to sort by.
+     */
+    setSorting(order, columnId) {
+        if (this.currentSorting?.columnId !== columnId ||
+            this.currentSorting?.order !== order) {
+            this.querying.shouldBeUpdated = true;
+            this.currentSorting = {
+                columnId,
+                order
+            };
+        }
+        this.modifier = this.createModifier();
+    }
+    /**
+     * Returns the sorting options from the data grid options.
+     */
+    getSortingOptions() {
+        const grid = this.querying.grid, { columnOptionsMap } = grid;
+        if (!columnOptionsMap) {
+            return { order: null };
+        }
+        const columnIDs = Object.keys(columnOptionsMap);
+        let foundOrder = null;
+        let foundColumnId;
+        for (let i = columnIDs.length - 1; i > -1; --i) {
+            const columnId = columnIDs[i];
+            const columnOptions = columnOptionsMap[columnId]?.options || {};
+            const order = columnOptions.sorting?.order;
+            if (order) {
+                if (foundColumnId) {
+                    // eslint-disable-next-line no-console
+                    console.warn('Grid: Only one column can be sorted at a time. ' +
+                        'Data will be sorted only by the last found column ' +
+                        `with the sorting order defined in the options: "${foundColumnId}".`);
+                    break;
+                }
+                foundOrder = order;
+                foundColumnId = columnId;
+            }
+        }
+        return {
+            columnId: foundColumnId,
+            order: foundOrder
+        };
+    }
+    /**
+     * Loads sorting options from the data grid options.
+     */
+    loadOptions() {
+        const stateFromOptions = this.getSortingOptions();
+        if (stateFromOptions.columnId !== this.initialSorting?.columnId ||
+            stateFromOptions.order !== this.initialSorting?.order) {
+            this.initialSorting = stateFromOptions;
+            this.setSorting(stateFromOptions.order, stateFromOptions.columnId);
+        }
+    }
+    /**
+     * Returns the sorting modifier based on the loaded sorting options.
+     */
+    createModifier() {
+        if (!this.currentSorting) {
+            return;
+        }
+        const { columnId, order } = this.currentSorting;
+        if (!order || !columnId) {
+            return;
+        }
+        const grid = this.querying.grid;
+        return new SortModifier({
+            orderByColumn: columnId,
+            direction: order,
+            compare: grid.columnOptionsMap?.[columnId]?.options
+                ?.sorting?.compare ||
+                grid.options?.columnDefaults?.sorting?.compare
+        });
+    }
+}
+/* *
+ *
+ *  Default Export
+ *
+ * */
+export default SortingController;

package/es-modules/Grid/Core/Table/Actions/ColumnFiltering/ColumnFiltering.d.ts

@@ -0,0 +1,114 @@
+import type Column from '../../Column';
+import type { Condition } from './FilteringTypes';
+import type FilterCell from './FilterCell.js';
+/**
+ * Class that manages filtering for a dedicated column.
+ */
+declare class ColumnFiltering {
+    /**
+     * Parses a camel case string to a readable string and capitalizes the first
+     * letter.
+     *
+     * @param value
+     * The camel case string to parse.
+     *
+     * @returns
+     * The readable string with the first letter capitalized.
+     */
+    static parseCamelCaseToReadable(value: string): string;
+    /**
+     * The filtered column of the table.
+     */
+    column: Column;
+    /**
+     * The filter cell of the column if the filtering is inline.
+     */
+    inlineCell?: FilterCell;
+    /**
+     * The input element for the filtering. Can be of type `text`, `number`
+     * or `date`.
+     */
+    filterInput?: HTMLInputElement;
+    /**
+     * The select element setting the condition for the filtering.
+     */
+    filterSelect?: HTMLSelectElement;
+    /**
+     * The button to clear the filtering.
+     */
+    clearButton?: HTMLButtonElement;
+    /**
+     * Constructs filtering controller for a dedicated column.
+     *
+     * @param column
+     * The filtered column.
+     */
+    constructor(column: Column);
+    /**
+     * Sets the value and condition for the filtering.
+     *
+     * @param value
+     * The value to set.
+     *
+     * @param condition
+     * The condition to set.
+     */
+    set(value?: string, condition?: Condition): Promise<void>;
+    /**
+     * Render the filtering content in the container.
+     *
+     * @param container
+     * The container element.
+     */
+    renderFilteringContent(container: HTMLElement): void;
+    /**
+     * Handles the keydown event for the filtering content. Used externally,
+     * not in the class itself.
+     *
+     * @param e
+     * The keyboard event.
+     */
+    onKeyDown: (e: KeyboardEvent) => void;
+    /**
+     * Takes the filtering value and condition from the inputs and applies it
+     * to the column.
+     */
+    private applyFilterFromForm;
+    /**
+     * Applies the filtering to the column.
+     *
+     * @param condition
+     * The filtering condition.
+     */
+    private applyFilter;
+    /**
+     * Render the filtering input element, based on the column type.
+     *
+     * @param inputWrapper
+     * Reference to the input wrapper.
+     *
+     * @param columnType
+     * Reference to the column type.
+     */
+    private renderFilteringInput;
+    /**
+     * Render the condition select element.
+     *
+     * @param inputWrapper
+     * Reference to the input wrapper.
+     */
+    private renderConditionSelect;
+    private renderClearButton;
+    /**
+     * Checks if filtering is applied to the column.
+     *
+     * @returns
+     * `true` if filtering is applied to the column, `false` otherwise.
+     */
+    private isFilteringApplied;
+    /**
+     * Disables the input element if the condition is `empty` or `notEmpty`.
+     */
+    private disableInputIfNeeded;
+}
+export default ColumnFiltering;