@highcharts/grid-pro 2.0.0

package/es-modules/Data/ColumnUtils.d.ts

@@ -0,0 +1,87 @@
+import type DataTable from './DataTable';
+import type Types from '../Shared/Types';
+/**
+ * Utility functions for columns that can be either arrays or typed arrays.
+ * @private
+ */
+declare namespace ColumnUtils {
+    /**
+     * Result of the `shift` function.
+     */
+    interface ShiftResult {
+        value: DataTable.CellType;
+        array: DataTable.Column;
+    }
+    /**
+     * Result of the `splice` function.
+     */
+    interface SpliceResult<T extends DataTable.Column> {
+        removed: T;
+        array: T;
+    }
+    /**
+     * Sets the length of the column array.
+     *
+     * @param {DataTable.Column} column
+     * Column to be modified.
+     *
+     * @param {number} length
+     * New length of the column.
+     *
+     * @param {boolean} asSubarray
+     * If column is a typed array, return a subarray instead of a new array. It
+     * is faster `O(1)`, but the entire buffer will be kept in memory until all
+     * views of it are destroyed. Default is `false`.
+     *
+     * @return {DataTable.Column}
+     * Modified column.
+     *
+     * @private
+     */
+    function setLength(column: DataTable.Column, length: number, asSubarray?: boolean): DataTable.Column;
+    /**
+     * Splices a column array.
+     *
+     * @param {DataTable.Column} column
+     * Column to be modified.
+     *
+     * @param {number} start
+     * Index at which to start changing the array.
+     *
+     * @param {number} deleteCount
+     * An integer indicating the number of old array elements to remove.
+     *
+     * @param {boolean} removedAsSubarray
+     * If column is a typed array, return a subarray instead of a new array. It
+     * is faster `O(1)`, but the entire buffer will be kept in memory until all
+     * views to it are destroyed. Default is `true`.
+     *
+     * @param {Array<number>|TypedArray} items
+     * The elements to add to the array, beginning at the start index. If you
+     * don't specify any elements, `splice()` will only remove elements from the
+     * array.
+     *
+     * @return {SpliceResult}
+     * Object containing removed elements and the modified column.
+     *
+     * @private
+     */
+    function splice(column: DataTable.Column, start: number, deleteCount: number, removedAsSubarray?: boolean, items?: DataTable.CellType[] | Types.TypedArray): SpliceResult<DataTable.Column>;
+    /**
+     * Converts a cell value to a number.
+     *
+     * @param {DataTable.CellType} value
+     * Cell value to convert to a number.
+     *
+     * @param {boolean} useNaN
+     * If `true`, returns `NaN` for non-numeric values; if `false`,
+     * returns `null` instead.
+     *
+     * @return {number | null}
+     * Number or `null` if the value is not a number.
+     *
+     * @private
+     */
+    function convertToNumber(value?: DataTable.CellType, useNaN?: boolean): number | null;
+}
+export default ColumnUtils;

package/es-modules/Data/ColumnUtils.js

@@ -0,0 +1,140 @@
+/* *
+ *
+ *  (c) 2020-2025 Highsoft AS
+ *
+ *  License: www.highcharts.com/license
+ *
+ *  !!!!!!! SOURCE GETS TRANSPILED BY TYPESCRIPT. EDIT TS FILE ONLY. !!!!!!!
+ *
+ *  Authors:
+ *  - Dawid Dragula
+ *
+ * */
+/**
+ * Utility functions for columns that can be either arrays or typed arrays.
+ * @private
+ */
+var ColumnUtils;
+(function (ColumnUtils) {
+    /* *
+    *
+    *  Declarations
+    *
+    * */
+    /* *
+    *
+    * Functions
+    *
+    * */
+    /**
+     * Sets the length of the column array.
+     *
+     * @param {DataTable.Column} column
+     * Column to be modified.
+     *
+     * @param {number} length
+     * New length of the column.
+     *
+     * @param {boolean} asSubarray
+     * If column is a typed array, return a subarray instead of a new array. It
+     * is faster `O(1)`, but the entire buffer will be kept in memory until all
+     * views of it are destroyed. Default is `false`.
+     *
+     * @return {DataTable.Column}
+     * Modified column.
+     *
+     * @private
+     */
+    function setLength(column, length, asSubarray) {
+        if (Array.isArray(column)) {
+            column.length = length;
+            return column;
+        }
+        return column[asSubarray ? 'subarray' : 'slice'](0, length);
+    }
+    ColumnUtils.setLength = setLength;
+    /**
+     * Splices a column array.
+     *
+     * @param {DataTable.Column} column
+     * Column to be modified.
+     *
+     * @param {number} start
+     * Index at which to start changing the array.
+     *
+     * @param {number} deleteCount
+     * An integer indicating the number of old array elements to remove.
+     *
+     * @param {boolean} removedAsSubarray
+     * If column is a typed array, return a subarray instead of a new array. It
+     * is faster `O(1)`, but the entire buffer will be kept in memory until all
+     * views to it are destroyed. Default is `true`.
+     *
+     * @param {Array<number>|TypedArray} items
+     * The elements to add to the array, beginning at the start index. If you
+     * don't specify any elements, `splice()` will only remove elements from the
+     * array.
+     *
+     * @return {SpliceResult}
+     * Object containing removed elements and the modified column.
+     *
+     * @private
+     */
+    function splice(column, start, deleteCount, removedAsSubarray, items = []) {
+        if (Array.isArray(column)) {
+            if (!Array.isArray(items)) {
+                items = Array.from(items);
+            }
+            return {
+                removed: column.splice(start, deleteCount, ...items),
+                array: column
+            };
+        }
+        const Constructor = Object.getPrototypeOf(column)
+            .constructor;
+        const removed = column[removedAsSubarray ? 'subarray' : 'slice'](start, start + deleteCount);
+        const newLength = column.length - deleteCount + items.length;
+        const result = new Constructor(newLength);
+        result.set(column.subarray(0, start), 0);
+        result.set(items, start);
+        result.set(column.subarray(start + deleteCount), start + items.length);
+        return {
+            removed: removed,
+            array: result
+        };
+    }
+    ColumnUtils.splice = splice;
+    /**
+     * Converts a cell value to a number.
+     *
+     * @param {DataTable.CellType} value
+     * Cell value to convert to a number.
+     *
+     * @param {boolean} useNaN
+     * If `true`, returns `NaN` for non-numeric values; if `false`,
+     * returns `null` instead.
+     *
+     * @return {number | null}
+     * Number or `null` if the value is not a number.
+     *
+     * @private
+     */
+    function convertToNumber(value, useNaN) {
+        switch (typeof value) {
+            case 'boolean':
+                return (value ? 1 : 0);
+            case 'number':
+                return (isNaN(value) && !useNaN ? null : value);
+            default:
+                value = parseFloat(`${value ?? ''}`);
+                return (isNaN(value) && !useNaN ? null : value);
+        }
+    }
+    ColumnUtils.convertToNumber = convertToNumber;
+})(ColumnUtils || (ColumnUtils = {}));
+/* *
+ *
+ *  Default Export
+ *
+ * */
+export default ColumnUtils;

package/es-modules/Data/Connectors/CSVConnector.d.ts

@@ -0,0 +1,63 @@
+import type DataEvent from '../DataEvent';
+import type CSVConnectorOptions from './CSVConnectorOptions';
+import CSVConverter from '../Converters/CSVConverter.js';
+import DataConnector from './DataConnector.js';
+/**
+ * Class that handles creating a DataConnector from CSV
+ *
+ * @private
+ */
+declare class CSVConnector extends DataConnector {
+    protected static readonly defaultOptions: CSVConnectorOptions;
+    /**
+     * Constructs an instance of CSVConnector.
+     *
+     * @param {Partial<CSVConnectorOptions>} [options]
+     * Options for the connector and converter.
+     */
+    constructor(options?: Partial<CSVConnectorOptions>);
+    /**
+     * Options related to the handling of the CSV DataConnector,
+     * i.e. source, fetching, polling
+     */
+    readonly options: CSVConnectorOptions;
+    /**
+     * The attached parser, which can be replaced in the constructor
+     */
+    converter?: CSVConverter;
+    /**
+     * Overrides the DataConnector method. Emits an event on the connector to
+     * all registered callbacks of this event.
+     *
+     * @param {CSVConnector.Event} e
+     * Event object containing additional event information.
+     */
+    emit(e: CSVConnector.Event): void;
+    /**
+     * Initiates the loading of the CSV source to the connector
+     *
+     * @param {DataEvent.Detail} [eventDetail]
+     * Custom information for pending events.
+     *
+     * @emits CSVConnector#load
+     * @emits CSVConnector#afterLoad
+     */
+    load(eventDetail?: DataEvent.Detail): Promise<this>;
+}
+/**
+ * Types for class-specific options and events.
+ */
+declare namespace CSVConnector {
+    /**
+     * Event objects fired from CSVConnector events.
+     */
+    interface Event extends DataConnector.Event {
+        readonly csv?: string;
+    }
+}
+declare module './DataConnectorType' {
+    interface DataConnectorTypes {
+        CSV: typeof CSVConnector;
+    }
+}
+export default CSVConnector;

package/es-modules/Data/Connectors/CSVConnector.js

@@ -0,0 +1,149 @@
+/* *
+ *
+ *  (c) 2009-2025 Highsoft AS
+ *
+ *  License: www.highcharts.com/license
+ *
+ *  !!!!!!! SOURCE GETS TRANSPILED BY TYPESCRIPT. EDIT TS FILE ONLY. !!!!!!!
+ *
+ *  Authors:
+ *  - Torstein Hønsi
+ *  - Christer Vasseng
+ *  - Gøran Slettemark
+ *  - Sophie Bremer
+ *  - Kamil Kubik
+ *
+ * */
+'use strict';
+import CSVConverter from '../Converters/CSVConverter.js';
+import DataConnector from './DataConnector.js';
+import U from '../../Core/Utilities.js';
+const { merge, fireEvent } = U;
+/* *
+ *
+ *  Class
+ *
+ * */
+/**
+ * Class that handles creating a DataConnector from CSV
+ *
+ * @private
+ */
+class CSVConnector extends DataConnector {
+    /* *
+     *
+     *  Constructor
+     *
+     * */
+    /**
+     * Constructs an instance of CSVConnector.
+     *
+     * @param {Partial<CSVConnectorOptions>} [options]
+     * Options for the connector and converter.
+     */
+    constructor(options) {
+        const mergedOptions = merge(CSVConnector.defaultOptions, options);
+        super(mergedOptions);
+        this.options = mergedOptions;
+        if (mergedOptions.enablePolling) {
+            this.startPolling(Math.max(mergedOptions.dataRefreshRate || 0, 1) * 1000);
+        }
+    }
+    /* *
+     *
+     *  Functions
+     *
+     * */
+    /**
+     * Overrides the DataConnector method. Emits an event on the connector to
+     * all registered callbacks of this event.
+     *
+     * @param {CSVConnector.Event} e
+     * Event object containing additional event information.
+     */
+    emit(e) {
+        fireEvent(this, e.type, e);
+    }
+    /**
+     * Initiates the loading of the CSV source to the connector
+     *
+     * @param {DataEvent.Detail} [eventDetail]
+     * Custom information for pending events.
+     *
+     * @emits CSVConnector#load
+     * @emits CSVConnector#afterLoad
+     */
+    load(eventDetail) {
+        const connector = this;
+        const options = connector.options;
+        const { csv, csvURL, dataTables, decimalPoint } = options;
+        connector.emit({
+            type: 'load',
+            csv
+        });
+        return Promise
+            .resolve(csvURL ?
+            fetch(csvURL, {
+                signal: connector?.pollingController?.signal
+            }).then((response) => response.text()) :
+            csv || '')
+            .then((csv) => {
+            if (csv) {
+                this.initConverters(csv, (key) => {
+                    const tableOptions = dataTables?.find((dataTable) => dataTable.key === key);
+                    // The data table options takes precedence over the
+                    // connector options.
+                    const { firstRowAsNames = options.firstRowAsNames, beforeParse = options.beforeParse } = tableOptions || {};
+                    const converterOptions = {
+                        decimalPoint,
+                        firstRowAsNames,
+                        beforeParse
+                    };
+                    return new CSVConverter(merge(options, converterOptions));
+                }, (converter, data) => converter.parse({ csv: data }));
+            }
+            return connector.applyTableModifiers().then(() => csv);
+        })
+            .then((csv) => {
+            connector.emit({
+                type: 'afterLoad',
+                detail: eventDetail,
+                csv
+            });
+            return connector;
+        })['catch']((error) => {
+            connector.emit({
+                type: 'loadError',
+                detail: eventDetail,
+                error
+            });
+            throw error;
+        });
+    }
+}
+/* *
+ *
+ *  Static Properties
+ *
+ * */
+CSVConnector.defaultOptions = {
+    id: 'csv-connector',
+    type: 'CSV',
+    csv: '',
+    csvURL: '',
+    enablePolling: false,
+    dataRefreshRate: 1,
+    firstRowAsNames: true
+};
+/* *
+ *
+ *  Registry
+ *
+ * */
+DataConnector.registerType('CSV', CSVConnector);
+/* *
+ *
+ *  Default Export
+ *
+ * */
+export default CSVConnector;

package/es-modules/Data/Connectors/CSVConnectorOptions.d.ts

@@ -0,0 +1,149 @@
+/* *
+ *
+ *  (c) 2009-2025 Highsoft AS
+ *
+ *  License: www.highcharts.com/license
+ *
+ *  !!!!!!! SOURCE GETS TRANSPILED BY TYPESCRIPT. EDIT TS FILE ONLY. !!!!!!!
+ *
+ *  Authors:
+ *  - Karol Kolodziej
+ *  - Kamil Kubik
+ *
+ * */
+
+/* *
+ *
+ *  Imports
+ *
+ * */
+
+import type DataConnectorOptions from './DataConnectorOptions';
+import type { DataTableConnectorOptions } from './DataConnectorOptions';
+
+
+/* *
+ *
+ *  Declarations
+ *
+ * */
+
+/**
+ * Options of the CSVConnector.
+ */
+export interface CSVConnectorOptions extends DataConnectorOptions {
+    /**
+     * The corresponding connector type.
+     */
+    type: 'CSV';
+    /**
+     * Data in CSV format passed directly to connector as a string.
+     */
+    csv?: string;
+    /**
+     * The URL to a remote CSV dataset
+     */
+    csvURL?: string;
+    /**
+     * The decimal point used for parsing numbers in the CSV.
+     *
+     * @default '.'
+     */
+    decimalPoint?: string;
+    /**
+     * The rate in seconds for polling for live data.
+     * Note that polling requires the option `enablePolling` to be true.
+     */
+    dataRefreshRate?: number;
+    /**
+     * Whether to enable polling for live data.
+     */
+    enablePolling?: boolean;
+    /**
+     * Whether to treat the first row of the data set as series names.
+     * @default true
+     */
+    firstRowAsNames?: boolean;
+    /**
+     * Item or cell delimiter for parsing CSV.
+     *
+     * @default ','
+     */
+    itemDelimiter?: string;
+
+    /**
+     * Allows defining multiple data tables within a single connector to adjust
+     * options or data parsing in various ways based on the same data source.
+     *
+     * @example
+     * dataPool: {
+     *     connectors: [{
+     *         id: 'data-connector',
+     *         type: 'JSON',
+     *         data: {
+     *             kpis: { a: 1, b: 2 },
+     *             more: {
+     *                 alpha: [1, 2, 3, 4, 5],
+     *                 beta: [10, 20, 30, 40, 50]
+     *             }
+     *         },
+     *         dataTables: [{
+     *             key: 'more',
+     *             beforeParse: function ({ more }) {
+     *                 const keys = Object.keys(more);
+     *                 return [
+     *                     keys,
+     *                     ...more[keys[0]].map((_, index) =>
+     *                         keys.map(key => more[key][index])
+     *                     )
+     *                 ];
+     *             }
+     *         }, {
+     *             key: 'kpis',
+     *             firstRowAsNames: false,
+     *             columnIds: ['a', 'b'],
+     *             beforeParse: function ({ kpis }) {
+     *                 return [[kpis.a, kpis.b]];
+     *             },
+     *             dataModifier: {
+     *                 type: 'Math',
+     *                 columnFormulas: [{
+     *                     column: 'c',
+     *                     formula: 'A1+B1'
+     *                 }]
+     *             }
+     *         }]
+     *     }]
+     * }
+     **/
+    dataTables?: CSVDataTableConnectorOptions[];
+
+    /**
+     * A custom callback function that parses the data before it's being parsed
+     * to the data table format inside the converter.
+     */
+    beforeParse?: CSVBeforeParseCallbackFunction;
+}
+
+/**
+ * Options of the CSVConnector dataTable.
+ */
+export interface CSVDataTableConnectorOptions extends DataTableConnectorOptions {
+    beforeParse?: CSVBeforeParseCallbackFunction;
+}
+
+/**
+ * Callback function allowing modification of the data before parsing it.
+ * Must return a valid CSV structure.
+ */
+export interface CSVBeforeParseCallbackFunction {
+    (csv: string): string;
+}
+
+/* *
+ *
+ *  Default Export
+ *
+ * */
+
+export default CSVConnectorOptions;