@highcharts/grid-pro 2.2.0 → 2.3.0

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

@@ -1,87 +1,90 @@
-import type DataTable from './DataTable';
+import type { CellType as DataTableCellType, Column as DataTableColumn } 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;
+/**
+ * Result of the `shift` function.
+ */
+export interface ShiftResult {
+    value: DataTableCellType;
+    array: DataTableColumn;
 }
+/**
+ * Result of the `splice` function.
+ */
+export interface SpliceResult<T extends DataTableColumn> {
+    removed: T;
+    array: T;
+}
+/**
+ * Sets the length of the column array.
+ *
+ * @param {DataTableColumn} 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 {DataTableColumn}
+ * Modified column.
+ *
+ * @private
+ */
+export declare function setLength(column: DataTableColumn, length: number, asSubarray?: boolean): DataTableColumn;
+/**
+ * Splices a column array.
+ *
+ * @param {DataTableColumn} 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
+ */
+export declare function splice(column: DataTableColumn, start: number, deleteCount: number, removedAsSubarray?: boolean, items?: DataTableCellType[] | Types.TypedArray): SpliceResult<DataTableColumn>;
+/**
+ * Converts a cell value to a number.
+ *
+ * @param {DataTableCellType} 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
+ */
+export declare function convertToNumber(value?: DataTableCellType, useNaN?: boolean): number | null;
+declare const ColumnUtils: {
+    convertToNumber: typeof convertToNumber;
+    setLength: typeof setLength;
+    splice: typeof splice;
+};
 export default ColumnUtils;

package/es-modules/Data/ColumnUtils.js

@@ -10,131 +10,121 @@
  *  - Dawid Dragula
  *
  * */
+/* *
+*
+* Functions
+*
+* */
 /**
- * Utility functions for columns that can be either arrays or typed arrays.
+ * Sets the length of the column array.
+ *
+ * @param {DataTableColumn} 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 {DataTableColumn}
+ * Modified column.
+ *
  * @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);
+export function setLength(column, length, asSubarray) {
+    if (Array.isArray(column)) {
+        column.length = length;
+        return column;
     }
-    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
-            };
+    return column[asSubarray ? 'subarray' : 'slice'](0, length);
+}
+/**
+ * Splices a column array.
+ *
+ * @param {DataTableColumn} 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
+ */
+export function splice(column, start, deleteCount, removedAsSubarray, items = []) {
+    if (Array.isArray(column)) {
+        if (!Array.isArray(items)) {
+            items = Array.from(items);
         }
-        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
+            removed: column.splice(start, deleteCount, ...items),
+            array: column
         };
     }
-    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);
-        }
+    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
+    };
+}
+/**
+ * Converts a cell value to a number.
+ *
+ * @param {DataTableCellType} 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
+ */
+export 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
  *
  * */
+const ColumnUtils = {
+    convertToNumber,
+    setLength,
+    splice
+};
 export default ColumnUtils;

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

@@ -1,7 +1,7 @@
-import type DataEvent from '../DataEvent';
+import type { DataEventDetail } from '../DataEvent';
 import type CSVConnectorOptions from './CSVConnectorOptions';
 import CSVConverter from '../Converters/CSVConverter.js';
-import DataConnector from './DataConnector.js';
+import DataConnector, { type Event as DataConnectorEvent } from './DataConnector.js';
 /**
  * Class that handles creating a DataConnector from CSV
  *
@@ -29,31 +29,26 @@ declare class CSVConnector extends DataConnector {
      * Overrides the DataConnector method. Emits an event on the connector to
      * all registered callbacks of this event.
      *
-     * @param {CSVConnector.Event} e
+     * @param {Event} e
      * Event object containing additional event information.
      */
-    emit(e: CSVConnector.Event): void;
+    emit(e: Event): void;
     /**
      * Initiates the loading of the CSV source to the connector
      *
-     * @param {DataEvent.Detail} [eventDetail]
+     * @param {DataEventDetail} [eventDetail]
      * Custom information for pending events.
      *
      * @emits CSVConnector#load
      * @emits CSVConnector#afterLoad
      */
-    load(eventDetail?: DataEvent.Detail): Promise<this>;
+    load(eventDetail?: DataEventDetail): Promise<this>;
 }
 /**
- * Types for class-specific options and events.
+ * Event objects fired from CSVConnector events.
  */
-declare namespace CSVConnector {
-    /**
-     * Event objects fired from CSVConnector events.
-     */
-    interface Event extends DataConnector.Event {
-        readonly csv?: string;
-    }
+export interface Event extends DataConnectorEvent {
+    readonly csv?: string;
 }
 declare module './DataConnectorType' {
     interface DataConnectorTypes {

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

@@ -17,8 +17,7 @@
 'use strict';
 import CSVConverter from '../Converters/CSVConverter.js';
 import DataConnector from './DataConnector.js';
-import U from '../../Core/Utilities.js';
-const { merge, fireEvent } = U;
+import { fireEvent, merge } from '../../Shared/Utilities.js';
 /* *
  *
  *  Class
@@ -58,7 +57,7 @@ class CSVConnector extends DataConnector {
      * Overrides the DataConnector method. Emits an event on the connector to
      * all registered callbacks of this event.
      *
-     * @param {CSVConnector.Event} e
+     * @param {Event} e
      * Event object containing additional event information.
      */
     emit(e) {
@@ -67,7 +66,7 @@ class CSVConnector extends DataConnector {
     /**
      * Initiates the loading of the CSV source to the connector
      *
-     * @param {DataEvent.Detail} [eventDetail]
+     * @param {DataEventDetail} [eventDetail]
      * Custom information for pending events.
      *
      * @emits CSVConnector#load

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

@@ -1,14 +1,36 @@
 import type { DataConnectorTypes } from './DataConnectorType';
 import type { DataConnectorOptions, MetaColumn, Metadata } from './DataConnectorOptions';
-import type DataEvent from '../DataEvent';
+import type { DataEvent, DataEventCallback, DataEventEmitter } from '../DataEvent';
 import type DataConverterType from '../Converters/DataConverterType';
 import DataConverter from '../Converters/DataConverter.js';
-import DataTable from '../DataTable.js';
+import DataTable, { type ColumnCollection as DataTableColumnCollection } from '../DataTable.js';
 import { DeepPartial } from '../../Shared/Types';
 /**
  * Abstract class providing an interface for managing a DataConnector.
  */
-declare abstract class DataConnector implements DataEvent.Emitter<DataConnector.Event> {
+declare abstract class DataConnector implements DataEventEmitter<Event> {
+    /**
+     * Registry as a record object with connector names and their class.
+     */
+    static types: DataConnectorTypes;
+    /**
+     * Adds a connector class to the registry. The connector has to provide the
+     * `DataConnector.options` property and the `DataConnector.load` method to
+     * modify the table.
+     *
+     * @private
+     *
+     * @param {string} key
+     * Registry key of the connector class.
+     *
+     * @param {DataConnectorType} DataConnectorClass
+     * Connector class (aka class constructor) to register.
+     *
+     * @return {boolean}
+     * Returns true, if the registration was successful. False is returned, if
+     * their is already a connector registered with this key.
+     */
+    static registerType<T extends keyof DataConnectorTypes>(key: T, DataConnectorClass: DataConnectorTypes[T]): boolean;
     /**
      * The DataConverter responsible for handling conversion of provided data to
      * a DataConnector.
@@ -63,14 +85,14 @@ declare abstract class DataConnector implements DataEvent.Emitter<DataConnector.
      * @param {string} name
      * The name of the column to be described.
      *
-     * @param {DataConnector.MetaColumn} columnMeta
+     * @param {MetaColumn} columnMeta
      * The metadata to apply to the column.
      */
     describeColumn(name: string, columnMeta: MetaColumn): void;
     /**
      * Method for applying columns meta information to the whole DataConnector.
      *
-     * @param {Highcharts.Dictionary<DataConnector.MetaColumn>} columns
+     * @param {Record<string, MetaColumn>} columns
      * Pairs of column names and MetaColumn objects.
      */
     describeColumns(columns: Record<string, MetaColumn>): void;
@@ -88,7 +110,7 @@ declare abstract class DataConnector implements DataEvent.Emitter<DataConnector.
      * @return {Highcharts.DataTableColumnCollection}
      * An object with the properties `columnIds` and `columnValues`
      */
-    getSortedColumns(): DataTable.ColumnCollection;
+    getSortedColumns(): DataTableColumnCollection;
     /**
      * Sets the index and order of columns.
      *
@@ -135,10 +157,10 @@ declare abstract class DataConnector implements DataEvent.Emitter<DataConnector.
      * Emits an event on the connector to all registered callbacks of this
      * event.
      *
-     * @param {DataConnector.Event} e
+     * @param {Event} e
      * Event object containing additional event information.
      */
-    emit(e: DataConnector.Event): void;
+    emit(e: Event): void;
     /**
      * Registers a callback for a specific connector event.
      *
@@ -151,7 +173,7 @@ declare abstract class DataConnector implements DataEvent.Emitter<DataConnector.
      * @return {Function}
      * Function to unregister callback from the connector event.
      */
-    on<T extends DataConnector.Event['type']>(type: T, callback: DataEvent.Callback<this, Extract<DataConnector.Event, {
+    on<T extends Event['type']>(type: T, callback: DataEventCallback<this, Extract<Event, {
         type: T;
     }>>): Function;
     /**
@@ -161,55 +183,31 @@ declare abstract class DataConnector implements DataEvent.Emitter<DataConnector.
      * @param {T}[data]
      * Data specific to the corresponding converter.
      *
-     * @param {DataConnector.CreateConverterFunction}[createConverter]
+     * @param {CreateConverterFunction}[createConverter]
      * Creates a specific converter combining the dataTable options.
      *
-     * @param {DataConnector.ParseDataFunction<T>}[parseData]
+     * @param {ParseDataFunction<T>}[parseData]
      * Runs the converter parse method with the specific data type.
      */
-    initConverters<T>(data: T, createConverter: DataConnector.CreateConverterFunction, parseData: DataConnector.ParseDataFunction<T>): void;
+    initConverters<T>(data: T, createConverter: CreateConverterFunction, parseData: ParseDataFunction<T>): void;
 }
-declare namespace DataConnector {
-    /**
-     * The event type that is provided on events within DataConnector.
-     */
-    interface Event extends DataEvent {
-        readonly type: ('loadError' | 'load' | 'afterLoad' | 'beforeUpdate' | 'afterUpdate');
-        readonly error?: string | Error;
-    }
-    /**
-     * Creates a specific converter combining the dataTable options.
-     */
-    interface CreateConverterFunction {
-        (key: string): DataConverterType;
-    }
-    /**
-     * Runs the converter parse method with the specific data type.
-     */
-    interface ParseDataFunction<T> {
-        (converter: DataConverterType, data: T): DataTable.ColumnCollection;
-    }
-    /**
-     * Registry as a record object with connector names and their class.
-     */
-    const types: DataConnectorTypes;
-    /**
-     * Adds a connector class to the registry. The connector has to provide the
-     * `DataConnector.options` property and the `DataConnector.load` method to
-     * modify the table.
-     *
-     * @private
-     *
-     * @param {string} key
-     * Registry key of the connector class.
-     *
-     * @param {DataConnectorType} DataConnectorClass
-     * Connector class (aka class constructor) to register.
-     *
-     * @return {boolean}
-     * Returns true, if the registration was successful. False is returned, if
-     * their is already a connector registered with this key.
-     */
-    function registerType<T extends keyof DataConnectorTypes>(key: T, DataConnectorClass: DataConnectorTypes[T]): boolean;
+/**
+ * The event type that is provided on events within DataConnector.
+ */
+export interface Event extends DataEvent {
+    readonly type: ('loadError' | 'load' | 'afterLoad' | 'beforeUpdate' | 'afterUpdate');
+    readonly error?: string | Error;
+}
+/**
+ * Creates a specific converter combining the dataTable options.
+ */
+export interface CreateConverterFunction {
+    (key: string): DataConverterType;
+}
+/**
+ * Runs the converter parse method with the specific data type.
+ */
+export interface ParseDataFunction<T> {
+    (converter: DataConverterType, data: T): DataTableColumnCollection;
 }
 export default DataConnector;