@highcharts/grid-pro 2.0.0

package/es-modules/Data/Converters/DataConverter.js

@@ -0,0 +1,387 @@
+/* *
+ *
+ *  (c) 2009-2025 Highsoft AS
+ *
+ *  License: www.highcharts.com/license
+ *
+ *  !!!!!!! SOURCE GETS TRANSPILED BY TYPESCRIPT. EDIT TS FILE ONLY. !!!!!!!
+ *
+ *  Authors:
+ *  - Sophie Bremer
+ *  - Sebastian Bochan
+ *  - Gøran Slettemark
+ *  - Torstein Hønsi
+ *  - Wojciech Chmiel
+ *  - Jomar Hønsi
+ *  - Kamil Kubik
+ *
+ * */
+'use strict';
+import DataConverterUtils from './DataConverterUtils.js';
+import U from '../../Core/Utilities.js';
+const { addEvent, fireEvent, merge } = U;
+/* *
+ *
+ *  Class
+ *
+ * */
+/**
+ * Base class providing an interface and basic methods for a DataConverter
+ *
+ * @private
+ */
+class DataConverter {
+    /* *
+     *
+     *  Constructor
+     *
+     * */
+    /**
+     * Constructs an instance of the DataConverter.
+     *
+     * @param {DataConverter.UserOptions} [options]
+     * Options for the DataConverter.
+     */
+    constructor(options) {
+        /* *
+         *
+         *  Properties
+         *
+         * */
+        /**
+         * A collection of available date formats.
+         */
+        this.dateFormats = {
+            'YYYY/mm/dd': {
+                regex: /^(\d{4})([\-\.\/])(\d{1,2})\2(\d{1,2})$/,
+                parser: function (match) {
+                    return (match ?
+                        Date.UTC(+match[1], +match[3] - 1, +match[4]) : NaN);
+                }
+            },
+            'dd/mm/YYYY': {
+                regex: /^(\d{1,2})([\-\.\/])(\d{1,2})\2(\d{4})$/,
+                parser: function (match) {
+                    return (match ?
+                        Date.UTC(+match[4], +match[3] - 1, +match[1]) : NaN);
+                },
+                alternative: 'mm/dd/YYYY' // Different format with the same regex
+            },
+            'mm/dd/YYYY': {
+                regex: /^(\d{1,2})([\-\.\/])(\d{1,2})\2(\d{4})$/,
+                parser: function (match) {
+                    return (match ?
+                        Date.UTC(+match[4], +match[1] - 1, +match[3]) : NaN);
+                }
+            },
+            'dd/mm/YY': {
+                regex: /^(\d{1,2})([\-\.\/])(\d{1,2})\2(\d{2})$/,
+                parser: function (match) {
+                    const d = new Date();
+                    if (!match) {
+                        return NaN;
+                    }
+                    let year = +match[4];
+                    if (year > (d.getFullYear() - 2000)) {
+                        year += 1900;
+                    }
+                    else {
+                        year += 2000;
+                    }
+                    return Date.UTC(year, +match[3] - 1, +match[1]);
+                },
+                alternative: 'mm/dd/YY' // Different format with the same regex
+            },
+            'mm/dd/YY': {
+                regex: /^(\d{1,2})([\-\.\/])(\d{1,2})\2(\d{2})$/,
+                parser: function (match) {
+                    return (match ?
+                        Date.UTC(+match[4] + 2000, +match[1] - 1, +match[3]) :
+                        NaN);
+                }
+            }
+        };
+        const mergedOptions = merge(DataConverter.defaultOptions, options);
+        let regExpPoint = mergedOptions.decimalPoint;
+        if (regExpPoint === '.' || regExpPoint === ',') {
+            regExpPoint = regExpPoint === '.' ? '\\.' : ',';
+            this.decimalRegExp =
+                new RegExp('^(-?[0-9]+)' + regExpPoint + '([0-9]+)$');
+        }
+        this.options = mergedOptions;
+    }
+    /* *
+     *
+     *  Functions
+     *
+     * */
+    /**
+     * Converts a string value based on its guessed type.
+     *
+     * @param {*} value
+     * The value to examine.
+     *
+     * @return {number | string | Date}
+     * The converted value.
+     */
+    convertByType(value) {
+        const converter = this, typeMap = {
+            'number': (value) => DataConverterUtils.asNumber(value, converter.decimalRegExp),
+            'Date': (value) => DataConverterUtils.asDate(value, converter),
+            'string': DataConverterUtils.asString
+        };
+        return typeMap[DataConverterUtils.guessType(value, converter)]
+            .call(converter, value);
+    }
+    /**
+     * Tries to guess the date format
+     *  - Check if either month candidate exceeds 12
+     *  - Check if year is missing (use current year)
+     *  - Check if a shortened year format is used (e.g. 1/1/99)
+     *  - If no guess can be made, the user must be prompted
+     * data is the data to deduce a format based on
+     * @private
+     *
+     * @param {string[]} data
+     * Data to check the format.
+     *
+     * @param {number} limit
+     * Max data to check the format.
+     *
+     * @param {boolean} save
+     * Whether to save the date format in the converter options.
+     */
+    deduceDateFormat(data, limit, save) {
+        const parser = this, stable = [], max = [];
+        let format = 'YYYY/mm/dd', thing, guessedFormat = [], i = 0, madeDeduction = false, elem, j;
+        if (!limit || limit > data.length) {
+            limit = data.length;
+        }
+        for (; i < limit; i++) {
+            if (typeof data[i] !== 'undefined' &&
+                data[i] && data[i].length) {
+                thing = data[i]
+                    .trim()
+                    .replace(/[\-\.\/]/g, ' ')
+                    .split(' ');
+                guessedFormat = [
+                    '',
+                    '',
+                    ''
+                ];
+                for (j = 0; j < thing.length; j++) {
+                    if (j < guessedFormat.length) {
+                        elem = parseInt(thing[j], 10);
+                        if (elem) {
+                            max[j] = (!max[j] || max[j] < elem) ? elem : max[j];
+                            if (typeof stable[j] !== 'undefined') {
+                                if (stable[j] !== elem) {
+                                    stable[j] = false;
+                                }
+                            }
+                            else {
+                                stable[j] = elem;
+                            }
+                            if (elem > 31) {
+                                if (elem < 100) {
+                                    guessedFormat[j] = 'YY';
+                                }
+                                else {
+                                    guessedFormat[j] = 'YYYY';
+                                }
+                            }
+                            else if (elem > 12 &&
+                                elem <= 31) {
+                                guessedFormat[j] = 'dd';
+                                madeDeduction = true;
+                            }
+                            else if (!guessedFormat[j].length) {
+                                guessedFormat[j] = 'mm';
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        if (madeDeduction) {
+            // This handles a few edge cases with hard to guess dates
+            for (j = 0; j < stable.length; j++) {
+                if (stable[j] !== false) {
+                    if (max[j] > 12 &&
+                        guessedFormat[j] !== 'YY' &&
+                        guessedFormat[j] !== 'YYYY') {
+                        guessedFormat[j] = 'YY';
+                    }
+                }
+                else if (max[j] > 12 && guessedFormat[j] === 'mm') {
+                    guessedFormat[j] = 'dd';
+                }
+            }
+            // If the middle one is dd, and the last one is dd,
+            // the last should likely be year.
+            if (guessedFormat.length === 3 &&
+                guessedFormat[1] === 'dd' &&
+                guessedFormat[2] === 'dd') {
+                guessedFormat[2] = 'YY';
+            }
+            format = guessedFormat.join('/');
+            // If the caculated format is not valid, we need to present an
+            // error.
+        }
+        // Save the deduced format in the converter options.
+        if (save) {
+            parser.options.dateFormat = format;
+        }
+        return format;
+    }
+    /**
+     * Emits an event on the DataConverter instance.
+     *
+     * @param {DataConverter.Event} [e]
+     * Event object containing additional event data
+     */
+    emit(e) {
+        fireEvent(this, e.type, e);
+    }
+    /**
+     * Registers a callback for a specific event.
+     *
+     * @param {string} type
+     * Event type as a string.
+     *
+     * @param {DataEventEmitter.Callback} callback
+     * Function to register for an modifier callback.
+     *
+     * @return {Function}
+     * Function to unregister callback from the modifier event.
+     */
+    on(type, callback) {
+        return addEvent(this, type, callback);
+    }
+    /**
+     * Parse a date and return it as a number.
+     *
+     * @param {string} value
+     * Value to parse.
+     *
+     * @param {string} dateFormatProp
+     * Which of the predefined date formats
+     * to use to parse date values.
+     */
+    parseDate(value, dateFormatProp) {
+        const converter = this, options = converter.options;
+        let dateFormat = dateFormatProp || options.dateFormat, result = NaN, key, match = null;
+        if (options.parseDate) {
+            result = options.parseDate(value);
+        }
+        else {
+            const dateFormats = converter.dateFormats;
+            // Auto-detect the date format the first time
+            if (!dateFormat) {
+                for (key in dateFormats) { // eslint-disable-line guard-for-in
+                    const format = dateFormats[key];
+                    match = value.match(format.regex);
+                    if (match) {
+                        dateFormat = key;
+                        result = format.parser(match);
+                        break;
+                    }
+                }
+                // Next time, use the one previously found
+            }
+            else {
+                let format = dateFormats[dateFormat];
+                if (!format) {
+                    // The selected format is invalid
+                    format = dateFormats['YYYY/mm/dd'];
+                }
+                match = value.match(format.regex);
+                if (match) {
+                    result = format.parser(match);
+                }
+            }
+            // Fall back to Date.parse
+            if (!match) {
+                const parsed = Date.parse(value);
+                if (!isNaN(parsed)) {
+                    result =
+                        parsed - new Date(parsed).getTimezoneOffset() * 60000;
+                    // Reset dates without year in Chrome
+                    if (!value.includes('2001') &&
+                        new Date(result).getFullYear() === 2001) {
+                        result = NaN;
+                    }
+                }
+            }
+        }
+        return result;
+    }
+}
+/* *
+ *
+ *  Static Properties
+ *
+ * */
+/**
+ * Default options
+ */
+DataConverter.defaultOptions = {
+    dateFormat: '',
+    firstRowAsNames: true
+};
+/* *
+ *
+ *  Class Namespace
+ *
+ * */
+/**
+ * Additionally provided types for events and conversion.
+ */
+(function (DataConverter) {
+    /* *
+     *
+     *  Declarations
+     *
+     * */
+    /* *
+     *
+     *  Constants
+     *
+     * */
+    /**
+     * Registry as a record object with connector names and their class.
+     */
+    DataConverter.types = {};
+    /* *
+     *
+     *  Functions
+     *
+     * */
+    /**
+     * Adds a converter class to the registry.
+     *
+     * @private
+     *
+     * @param {string} key
+     * Registry key of the converter class.
+     *
+     * @param {DataConverterTypes} DataConverterClass
+     * Connector class (aka class constructor) to register.
+     *
+     * @return {boolean}
+     * Returns true, if the registration was successful. False is returned, if
+     * their is already a converter registered with this key.
+     */
+    function registerType(key, DataConverterClass) {
+        return (!!key &&
+            !DataConverter.types[key] &&
+            !!(DataConverter.types[key] = DataConverterClass));
+    }
+    DataConverter.registerType = registerType;
+})(DataConverter || (DataConverter = {}));
+/* *
+ *
+ *  Default Export
+ *
+ * */
+export default DataConverter;

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

@@ -0,0 +1,40 @@
+/* *
+ *
+ *  (c) 2009-2025 Highsoft AS
+ *
+ *  License: www.highcharts.com/license
+ *
+ *  !!!!!!! SOURCE GETS TRANSPILED BY TYPESCRIPT. EDIT TS FILE ONLY. !!!!!!!
+ *
+ *  Authors:
+ *  - Jomar Hønsi
+ *
+ * */
+
+/* *
+ *
+ *  Declarations
+ *
+ * */
+
+/**
+ * Describes the converter registry as a record object with key and
+ * class constructor.
+ */
+export interface DataConverterTypes {
+    // Nothing here yet
+}
+
+/**
+ * Contains all possible connector types.
+ */
+export type DataConverterType =
+    DataConverterTypes[keyof DataConverterTypes]['prototype'];
+
+/* *
+ *
+ *  Default Export
+ *
+ * */
+
+export default DataConverterType;

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

@@ -0,0 +1,82 @@
+import DataConverter from './DataConverter';
+import DataTable from '../DataTable.js';
+declare namespace DataConverterUtils {
+    /**
+     * Converts a value to a Date.
+     *
+     * @param {DataConverter.Type} value
+     * Value to convert.
+     *
+     * @return {globalThis.Date}
+     * Converted value as a Date.
+     */
+    function asDate(value: DataConverter.Type, converter: DataConverter): Date;
+    /**
+     * Converts a value to a number.
+     *
+     * @param {DataConverter.Type} value
+     * Value to convert.
+     *
+     * @return {number}
+     * Converted value as a number.
+     */
+    function asNumber(value: DataConverter.Type, decimalRegExp?: RegExp): number;
+    /**
+     * Converts a value to a string.
+     *
+     * @param {DataConverter.Type} value
+     * Value to convert.
+     *
+     * @return {string}
+     * Converted value as a string.
+     */
+    function asString(value: DataConverter.Type): string;
+    /**
+     * Converts a value to a boolean.
+     *
+     * @param {DataConverter.Type} value
+     * Value to convert.
+     *
+     * @return {boolean}
+     * Converted value as a boolean.
+     */
+    function asBoolean(value: DataConverter.Type): boolean;
+    /**
+     * Guesses the potential type of a string value for parsing CSV etc.
+     *
+     * @param {*} value
+     * The value to examine.
+     *
+     * @return {'number' | 'string' | 'Date'}
+     * Type string, either `string`, `Date`, or `number`.
+     */
+    function guessType(value: unknown, converter: DataConverter): 'number' | 'string' | 'Date';
+    /**
+     * Trim a string from whitespaces.
+     *
+     * @param {string} str
+     * String to trim.
+     *
+     * @param {boolean} [inside=false]
+     * Remove all spaces between numbers.
+     *
+     * @return {string}
+     * Trimed string
+     */
+    function trim(str: string, inside?: boolean): string;
+    /**
+     * Parses an array of columns to a column collection. If more headers are
+     * provided, the corresponding, empty columns are added.
+     *
+     * @param {DataTable.Column[]} [columnsArray]
+     * Array of columns.
+     *
+     * @param {string[]} [headers]
+     * Column ids to use.
+     *
+     * @return {DataTable.ColumnCollection}
+     * Parsed columns.
+     */
+    function getColumnsCollection(columnsArray: DataTable.Column[] | undefined, headers: string[]): DataTable.ColumnCollection;
+}
+export default DataConverterUtils;