@highcharts/grid-pro 2.0.0

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

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

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

@@ -0,0 +1,156 @@
+/* *
+ *
+ *  (c) 2009-2025 Highsoft AS
+ *
+ *  License: www.highcharts.com/license
+ *
+ *  !!!!!!! SOURCE GETS TRANSPILED BY TYPESCRIPT. EDIT TS FILE ONLY. !!!!!!!
+ *
+ *  Authors:
+ *  - Pawel Lysy
+ *  - Kamil Kubik
+ *
+ * */
+'use strict';
+import DataConnector from './DataConnector.js';
+import JSONConverter from '../Converters/JSONConverter.js';
+import U from '../../Core/Utilities.js';
+const { merge, fireEvent } = U;
+/* *
+ *
+ *  Class
+ *
+ * */
+/**
+ * Class that handles creating a DataConnector from JSON structure
+ *
+ * @private
+ */
+class JSONConnector extends DataConnector {
+    /* *
+     *
+     *  Constructor
+     *
+     * */
+    /**
+     * Constructs an instance of JSONConnector.
+     *
+     * @param {Partial<JSONConnectorOptions>} [options]
+     * Options for the connector and converter.
+     */
+    constructor(options) {
+        const mergedOptions = merge(JSONConnector.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 {JSONConnector.Event} e
+     * Event object containing additional event information.
+     */
+    emit(e) {
+        fireEvent(this, e.type, e);
+    }
+    /**
+     * Initiates the loading of the JSON source to the connector
+     *
+     * @param {DataEvent.Detail} [eventDetail]
+     * Custom information for pending events.
+     *
+     * @emits JSONConnector#load
+     * @emits JSONConnector#afterLoad
+     */
+    load(eventDetail) {
+        const connector = this;
+        const options = connector.options;
+        const { data, dataUrl, dataTables } = options;
+        connector.emit({
+            type: 'load',
+            detail: eventDetail,
+            data
+        });
+        return Promise
+            .resolve(dataUrl ?
+            fetch(dataUrl, {
+                signal: connector?.pollingController?.signal
+            }).then((response) => response.json())['catch']((error) => {
+                connector.emit({
+                    type: 'loadError',
+                    detail: eventDetail,
+                    error
+                });
+                console.warn(`Unable to fetch data from ${dataUrl}.`); // eslint-disable-line no-console
+            }) :
+            data || [])
+            .then(async (data) => {
+            if (data) {
+                this.initConverters(data, (key) => {
+                    const tableOptions = dataTables?.find((dataTable) => dataTable.key === key);
+                    // The data table options takes precedence over the
+                    // connector options.
+                    const { columnIds = options.columnIds, firstRowAsNames = options.firstRowAsNames, orientation = options.orientation, beforeParse = options.beforeParse } = tableOptions || {};
+                    const converterOptions = {
+                        data,
+                        columnIds,
+                        firstRowAsNames,
+                        orientation,
+                        beforeParse
+                    };
+                    return new JSONConverter(converterOptions);
+                }, (converter, data) => converter.parse({ data }));
+            }
+            return connector.applyTableModifiers().then(() => data ?? []);
+        })
+            .then((data) => {
+            connector.emit({
+                type: 'afterLoad',
+                detail: eventDetail,
+                data
+            });
+            return connector;
+        })['catch']((error) => {
+            connector.emit({
+                type: 'loadError',
+                detail: eventDetail,
+                error
+            });
+            throw error;
+        });
+    }
+}
+/* *
+ *
+ *  Static Properties
+ *
+ * */
+JSONConnector.defaultOptions = {
+    type: 'JSON',
+    id: 'json-connector',
+    data: [],
+    enablePolling: false,
+    dataRefreshRate: 0,
+    firstRowAsNames: true,
+    orientation: 'rows'
+};
+/* *
+ *
+ *  Registry
+ *
+ * */
+DataConnector.registerType('JSON', JSONConnector);
+/* *
+ *
+ *  Default Export
+ *
+ * */
+export default JSONConnector;

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

@@ -0,0 +1,185 @@
+/* *
+ *
+ *  (c) 2009-2025 Highsoft AS
+ *
+ *  License: www.highcharts.com/license
+ *
+ *  !!!!!!! SOURCE GETS TRANSPILED BY TYPESCRIPT. EDIT TS FILE ONLY. !!!!!!!
+ *
+ *  Authors:
+ *  - Pawel Lysy
+ *  - Kamil Kubik
+ *
+ * */
+
+/* *
+ *
+ *  Imports
+ *
+ * */
+
+import type DataConnectorOptions from './DataConnectorOptions';
+import type { DataTableConnectorOptions } from './DataConnectorOptions';
+import type { JSONData } from '../Converters/JSONConverterOptions';
+
+/* *
+ *
+ *  Declarations
+ *
+ * */
+
+/**
+ * Options of the JSONConnector.
+ */
+export interface JSONConnectorOptions extends DataConnectorOptions {
+    /**
+     * The corresponding connector type.
+     */
+    type: 'JSON';
+    /**
+     * If JSON data is row oriented, these options define keys for the columns.
+     * In column oriented case this is handled automatically unless the
+     * `firstRowAsNames` set to false, then the `columnIds` can be used.
+     *
+     * In case of complex JSON structure, use the `ColumnIdsOptions` to define
+     * the key and path to the data.
+     *
+     * If you have more complex data, you can adjust it by  the `beforeParse`
+     * callback function to manually parse the rows into valid JSON. However,
+     * the resulting JSON will still be converted into a proper table structure.
+     */
+    columnIds?: string[] | ColumnIdsOptions;
+
+    /**
+     * Data in JSON format.
+     */
+    data?: JSONData;
+
+    /**
+     * Data refresh rate in seconds.
+     */
+    dataRefreshRate?: number;
+
+    /**
+     * URL to the JSON data. try it {@link https://jsfiddle.net/gh/get/library/pure/highcharts/highcharts/tree/master/samples/highcharts/data-tools/datapool-json-connector-dataurl/ | data fetched from url }
+     */
+    dataUrl?: string;
+
+    /**
+     * Whether polling should be enabled.
+     */
+    enablePolling?: boolean;
+
+    /**
+     * Should first row be treated as names of columns.
+     * @default true
+     */
+    firstRowAsNames?: boolean;
+
+    /**
+     * Whether data is in columns or rows.
+     *
+     * Try it:
+     *
+     * {@link https://jsfiddle.net/gh/get/library/pure/highcharts/highcharts/tree/master/samples/highcharts/data-tools/datapool-json-connector-orientation/ | JSON Connector orientation }
+     *
+     * @default 'rows'
+     */
+    orientation?: 'columns' | 'rows';
+
+    /**
+     * 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?: JSONDataTableConnectorOptions[];
+
+    /**
+     * A custom callback function that parses the data before it's being parsed
+     * to the data table format inside the converter.
+     */
+    beforeParse?: JSONBeforeParseCallbackFunction;
+}
+
+/**
+ * Options used for parsing JSON data with multiple levels.
+ * The key is the column name (later used as a reference), and the value is
+ * an array of keys that are used to access the data.
+ *
+ * @example
+ * columnIds: {
+ *     InstanceType: ['InstanceType'],
+ *     DiskSpace: ['DiskSpace', 'RootDisk', 'SizeGB'],
+ *     ReadOps: ['DiskOperations', 0, 'ReadOps']
+ * },
+ */
+export interface ColumnIdsOptions {
+    [key: string]: (string|number)[]
+}
+
+/**
+ * Options of the JSONConnector dataTable.
+ */
+export interface JSONDataTableConnectorOptions extends DataTableConnectorOptions {
+    columnIds?: string[] | ColumnIdsOptions;
+    orientation?: 'columns' | 'rows';
+    beforeParse?: JSONBeforeParseCallbackFunction;
+}
+
+/**
+ * Callback function allowing modification of the data before parsing it.
+ * Must return a valid JSON structure.
+ *
+ * {@link https://jsfiddle.net/gh/get/library/pure/highcharts/highcharts/tree/master/samples/highcharts/data-tools/datapool-json-connector-enable-polling/ | JSON Connector with beforeParse and enablePolling }
+ */
+export interface JSONBeforeParseCallbackFunction {
+    (data: JSONData): JSONData;
+}
+
+/* *
+ *
+ *  Default Export
+ *
+ * */
+
+export default JSONConnectorOptions;

package/es-modules/Data/Converters/CSVConverter.d.ts

@@ -0,0 +1,64 @@
+import type DataEvent from '../DataEvent';
+import type CSVConverterOptions from './CSVConverterOptions';
+import DataConverter from './DataConverter.js';
+import DataTable from '../DataTable.js';
+/**
+ * Handles parsing and transforming CSV to a table.
+ *
+ * @private
+ */
+declare class CSVConverter extends DataConverter {
+    /**
+     * Default options
+     */
+    protected static readonly defaultOptions: CSVConverterOptions;
+    /**
+     * Constructs an instance of the CSV parser.
+     *
+     * @param {Partial<CSVConverterOptions>} [options]
+     * Options for the CSV parser.
+     */
+    constructor(options?: Partial<CSVConverterOptions>);
+    private headers;
+    private dataTypes;
+    private guessedItemDelimiter?;
+    private guessedDecimalPoint?;
+    /**
+     * Options for the DataConverter.
+     */
+    readonly options: CSVConverterOptions;
+    /**
+     * Parses the CSV string into a DataTable column collection.
+     * Handles line and item delimiters, optional header row, and
+     * applies pre-processing if a beforeParse callback is provided.
+     *
+     * @param {Partial<CSVConverterOptions>} [options]
+     * Options for the parser.
+     * @param {DataEvent.Detail} [eventDetail]
+     * Custom information for pending events.
+     * @return {DataTable.ColumnCollection}
+     * The parsed column collection.
+     *
+     * @emits CSVDataParser#parse
+     * @emits CSVDataParser#afterParse
+     */
+    parse(options: Partial<CSVConverterOptions>, eventDetail?: DataEvent.Detail): DataTable.ColumnCollection;
+    /**
+     * Parses a single CSV row string into columns, handling delimiters,
+     * quoted values, data type inference, and column range selection.
+     */
+    private parseCSVRow;
+    /**
+     * Internal method that guesses the delimiter from the first
+     * 13 lines of the CSV
+     * @param {string[]} lines
+     * The CSV, split into lines
+     */
+    private guessDelimiter;
+}
+declare module './DataConverterType' {
+    interface DataConverterTypes {
+        CSV: typeof CSVConverter;
+    }
+}
+export default CSVConverter;