@highcharts/grid-pro 2.2.0 → 2.3.0

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

@@ -8,7 +8,7 @@ import type DataTable from './DataTable';
  * @name Data.DataCursor
  */
 declare class DataCursor {
-    constructor(stateMap?: DataCursor.StateMap);
+    constructor(stateMap?: StateMap);
     /**
      * Contains arguments currently in use of an emitting loop.
      */
@@ -16,17 +16,17 @@ declare class DataCursor {
     /**
      * Contains listeners of states on tables.
      */
-    readonly listenerMap: DataCursor.ListenerMap;
+    readonly listenerMap: ListenerMap;
     /**
      * Contains lasting states that are kept over multiple changes.
      */
-    readonly stateMap: DataCursor.StateMap;
+    readonly stateMap: StateMap;
     /**
      * This function registers a listener for a specific state and table.
      *
      * @example
      * ```TypeScript
-     * dataCursor.addListener(myTable.id, 'hover', (e: DataCursor.Event) => {
+     * dataCursor.addListener(myTable.id, 'hover', (e: DataCursorEvent) => {
      *     if (e.cursor.type === 'position') {
      *         console.log(`Hover over row #${e.cursor.row}.`);
      *     }
@@ -35,19 +35,19 @@ declare class DataCursor {
      *
      * @function #addListener
      *
-     * @param {Data.DataCursor.TableId} tableId
+     * @param {Data.DataCursorTableId} tableId
      * The ID of the table to listen to.
      *
-     * @param {Data.DataCursor.State} state
+     * @param {Data.DataCursorState} state
      * The state on the table to listen to.
      *
-     * @param {Data.DataCursor.Listener} listener
+     * @param {Data.DataCursorListener} listener
      * The listener to register.
      *
      * @return {Data.DataCursor}
      * Returns the DataCursor instance for a call chain.
      */
-    addListener(tableId: DataCursor.TableId, state: DataCursor.State, listener: DataCursor.Listener): this;
+    addListener(tableId: TableId, state: State, listener: Listener): this;
     /**
      * @private
      */
@@ -69,7 +69,7 @@ declare class DataCursor {
      * @param {Data.DataTable} table
      * The related table of the cursor.
      *
-     * @param {Data.DataCursor.Type} cursor
+     * @param {Data.DataCursorType} cursor
      * The state cursor to emit.
      *
      * @param {Event} [event]
@@ -82,7 +82,7 @@ declare class DataCursor {
      * @return {Data.DataCursor}
      * Returns the DataCursor instance for a call chain.
      */
-    emitCursor(table: DataTable, cursor: DataCursor.Type, event?: Event, lasting?: boolean): this;
+    emitCursor(table: DataTable, cursor: Type, event?: globalThis.Event, lasting?: boolean): this;
     /**
      * Removes a lasting state cursor.
      *
@@ -91,86 +91,81 @@ declare class DataCursor {
      * @param {string} tableId
      * ID of the related cursor table.
      *
-     * @param {Data.DataCursor.Type} cursor
+     * @param {Data.DataCursorType} cursor
      * Copy or reference of the cursor.
      *
      * @return {Data.DataCursor}
      * Returns the DataCursor instance for a call chain.
      */
-    remitCursor(tableId: string, cursor: DataCursor.Type): this;
+    remitCursor(tableId: string, cursor: Type): this;
     /**
      * This function removes a listener.
      *
      * @function #addListener
      *
-     * @param {Data.DataCursor.TableId} tableId
+     * @param {Data.DataCursorTableId} tableId
      * The ID of the table the listener is connected to.
      *
-     * @param {Data.DataCursor.State} state
+     * @param {Data.DataCursorState} state
      * The state on the table the listener is listening to.
      *
-     * @param {Data.DataCursor.Listener} listener
+     * @param {Data.DataCursorListener} listener
      * The listener to deregister.
      *
      * @return {Data.DataCursor}
      * Returns the DataCursor instance for a call chain.
      */
-    removeListener(tableId: DataCursor.TableId, state: DataCursor.State, listener: DataCursor.Listener): this;
+    removeListener(tableId: TableId, state: State, listener: Listener): this;
 }
+export type Type = (Position | Range);
+export interface Position {
+    type: 'position';
+    column?: string;
+    row?: number;
+    state: State;
+    sourceId?: string;
+}
+export interface Range {
+    type: 'range';
+    columns?: Array<string>;
+    firstRow: number;
+    lastRow: number;
+    state: State;
+    sourceId?: string;
+}
+export interface Event {
+    cursor: Type;
+    cursors: Array<Type>;
+    event?: globalThis.Event;
+    table: DataTable;
+}
+export type Listener = (this: DataCursor, e: Event) => void;
+export type ListenerMap = Record<TableId, Record<State, Array<Listener>>>;
+export type State = string;
+export type StateMap = Record<TableId, Record<State, Array<Type>>>;
+export type TableId = string;
+export type TableMap = Record<TableId, DataTable>;
 /**
- * @class Data.DataCursor
+ * Finds the index of an cursor in an array.
+ * @private
  */
-declare namespace DataCursor {
-    type Type = (Position | Range);
-    interface Position {
-        type: 'position';
-        column?: string;
-        row?: number;
-        state: State;
-        sourceId?: string;
-    }
-    interface Range {
-        type: 'range';
-        columns?: Array<string>;
-        firstRow: number;
-        lastRow: number;
-        state: State;
-        sourceId?: string;
-    }
-    interface Event {
-        cursor: Type;
-        cursors: Array<Type>;
-        event?: globalThis.Event;
-        table: DataTable;
-    }
-    type Listener = (this: DataCursor, e: Event) => void;
-    type ListenerMap = Record<TableId, Record<State, Array<Listener>>>;
-    type State = string;
-    type StateMap = Record<TableId, Record<State, Array<Type>>>;
-    type TableId = string;
-    type TableMap = Record<TableId, DataTable>;
-    /**
-     * Finds the index of an cursor in an array.
-     * @private
-     */
-    function getIndex(needle: DataCursor.Type, cursors: Array<DataCursor.Type>): number;
-    /**
-     * Checks whether two cursor share the same properties.
-     * @private
-     */
-    function isEqual(cursorA: Type, cursorB: Type): boolean;
-    /**
-     * Checks whether a cursor is in a range.
-     * @private
-     */
-    function isInRange(needle: Type, range: Type): boolean;
-    /**
-     * @private
-     */
-    function toPositions(cursor: Type): Array<Position>;
-    /**
-     * @private
-     */
-    function toRange(cursor: Type, defaultRange?: Range): Range;
-}
+export declare function getIndex(needle: Type, cursors: Array<Type>): number;
+/**
+ * Checks whether two cursor share the same properties.
+ * @private
+ */
+export declare function isEqual(cursorA: Type, cursorB: Type): boolean;
+/**
+ * Checks whether a cursor is in a range.
+ * @private
+ */
+export declare function isInRange(needle: Type, range: Type): boolean;
+/**
+ * @private
+ */
+export declare function toPositions(cursor: Type): Array<Position>;
+/**
+ * @private
+ */
+export declare function toRange(cursor: Type, defaultRange?: Range): Range;
 export default DataCursor;

package/es-modules/Data/DataCursor.js

@@ -50,7 +50,7 @@ class DataCursor {
      *
      * @example
      * ```TypeScript
-     * dataCursor.addListener(myTable.id, 'hover', (e: DataCursor.Event) => {
+     * dataCursor.addListener(myTable.id, 'hover', (e: DataCursorEvent) => {
      *     if (e.cursor.type === 'position') {
      *         console.log(`Hover over row #${e.cursor.row}.`);
      *     }
@@ -59,13 +59,13 @@ class DataCursor {
      *
      * @function #addListener
      *
-     * @param {Data.DataCursor.TableId} tableId
+     * @param {Data.DataCursorTableId} tableId
      * The ID of the table to listen to.
      *
-     * @param {Data.DataCursor.State} state
+     * @param {Data.DataCursorState} state
      * The state on the table to listen to.
      *
-     * @param {Data.DataCursor.Listener} listener
+     * @param {Data.DataCursorListener} listener
      * The listener to register.
      *
      * @return {Data.DataCursor}
@@ -117,7 +117,7 @@ class DataCursor {
      * @param {Data.DataTable} table
      * The related table of the cursor.
      *
-     * @param {Data.DataCursor.Type} cursor
+     * @param {Data.DataCursorType} cursor
      * The state cursor to emit.
      *
      * @param {Event} [event]
@@ -140,7 +140,7 @@ class DataCursor {
                 if (!cursors.length) {
                     stateMap[cursor.state] = cursors;
                 }
-                if (DataCursor.getIndex(cursor, cursors) === -1) {
+                if (getIndex(cursor, cursors) === -1) {
                     cursors.push(cursor);
                 }
             }
@@ -180,7 +180,7 @@ class DataCursor {
      * @param {string} tableId
      * ID of the related cursor table.
      *
-     * @param {Data.DataCursor.Type} cursor
+     * @param {Data.DataCursorType} cursor
      * Copy or reference of the cursor.
      *
      * @return {Data.DataCursor}
@@ -190,7 +190,7 @@ class DataCursor {
         const cursors = (this.stateMap[tableId] &&
             this.stateMap[tableId][cursor.state]);
         if (cursors) {
-            const index = DataCursor.getIndex(cursor, cursors);
+            const index = getIndex(cursor, cursors);
             if (index >= 0) {
                 cursors.splice(index, 1);
             }
@@ -202,13 +202,13 @@ class DataCursor {
      *
      * @function #addListener
      *
-     * @param {Data.DataCursor.TableId} tableId
+     * @param {Data.DataCursorTableId} tableId
      * The ID of the table the listener is connected to.
      *
-     * @param {Data.DataCursor.State} state
+     * @param {Data.DataCursorState} state
      * The state on the table the listener is listening to.
      *
-     * @param {Data.DataCursor.Listener} listener
+     * @param {Data.DataCursorListener} listener
      * The listener to deregister.
      *
      * @return {Data.DataCursor}
@@ -228,149 +228,129 @@ class DataCursor {
 }
 /* *
  *
- *  Class Namespace
+ *  Functions
  *
  * */
 /**
- * @class Data.DataCursor
+ * Finds the index of an cursor in an array.
+ * @private
  */
-(function (DataCursor) {
-    /* *
-     *
-     *  Declarations
-     *
-     * */
-    /* *
-     *
-     *  Functions
-     *
-     * */
-    /**
-     * Finds the index of an cursor in an array.
-     * @private
-     */
-    function getIndex(needle, cursors) {
-        if (needle.type === 'position') {
-            for (let cursor, i = 0, iEnd = cursors.length; i < iEnd; ++i) {
-                cursor = cursors[i];
-                if (cursor.type === 'position' &&
-                    cursor.state === needle.state &&
-                    cursor.column === needle.column &&
-                    cursor.row === needle.row) {
-                    return i;
-                }
+export function getIndex(needle, cursors) {
+    if (needle.type === 'position') {
+        for (let cursor, i = 0, iEnd = cursors.length; i < iEnd; ++i) {
+            cursor = cursors[i];
+            if (cursor.type === 'position' &&
+                cursor.state === needle.state &&
+                cursor.column === needle.column &&
+                cursor.row === needle.row) {
+                return i;
             }
         }
-        else {
-            const columnNeedle = JSON.stringify(needle.columns);
-            for (let cursor, i = 0, iEnd = cursors.length; i < iEnd; ++i) {
-                cursor = cursors[i];
-                if (cursor.type === 'range' &&
-                    cursor.state === needle.state &&
-                    cursor.firstRow === needle.firstRow &&
-                    cursor.lastRow === needle.lastRow &&
-                    JSON.stringify(cursor.columns) === columnNeedle) {
-                    return i;
-                }
+    }
+    else {
+        const columnNeedle = JSON.stringify(needle.columns);
+        for (let cursor, i = 0, iEnd = cursors.length; i < iEnd; ++i) {
+            cursor = cursors[i];
+            if (cursor.type === 'range' &&
+                cursor.state === needle.state &&
+                cursor.firstRow === needle.firstRow &&
+                cursor.lastRow === needle.lastRow &&
+                JSON.stringify(cursor.columns) === columnNeedle) {
+                return i;
             }
         }
-        return -1;
     }
-    DataCursor.getIndex = getIndex;
-    /**
-     * Checks whether two cursor share the same properties.
-     * @private
-     */
-    function isEqual(cursorA, cursorB) {
-        if (cursorA.type === 'position' && cursorB.type === 'position') {
-            return (cursorA.column === cursorB.column &&
-                cursorA.row === cursorB.row &&
-                cursorA.state === cursorB.state);
-        }
-        if (cursorA.type === 'range' && cursorB.type === 'range') {
-            return (cursorA.firstRow === cursorB.firstRow &&
-                cursorA.lastRow === cursorB.lastRow &&
-                (JSON.stringify(cursorA.columns) ===
-                    JSON.stringify(cursorB.columns)));
-        }
-        return false;
+    return -1;
+}
+/**
+ * Checks whether two cursor share the same properties.
+ * @private
+ */
+export function isEqual(cursorA, cursorB) {
+    if (cursorA.type === 'position' && cursorB.type === 'position') {
+        return (cursorA.column === cursorB.column &&
+            cursorA.row === cursorB.row &&
+            cursorA.state === cursorB.state);
     }
-    DataCursor.isEqual = isEqual;
-    /**
-     * Checks whether a cursor is in a range.
-     * @private
-     */
-    function isInRange(needle, range) {
-        if (range.type === 'position') {
-            range = toRange(range);
-        }
-        if (needle.type === 'position') {
-            needle = toRange(needle, range);
-        }
-        const needleColumns = needle.columns;
-        const rangeColumns = range.columns;
-        return (needle.firstRow >= range.firstRow &&
-            needle.lastRow <= range.lastRow &&
-            (!needleColumns ||
-                !rangeColumns ||
-                needleColumns.every((column) => rangeColumns.indexOf(column) >= 0)));
+    if (cursorA.type === 'range' && cursorB.type === 'range') {
+        return (cursorA.firstRow === cursorB.firstRow &&
+            cursorA.lastRow === cursorB.lastRow &&
+            (JSON.stringify(cursorA.columns) ===
+                JSON.stringify(cursorB.columns)));
     }
-    DataCursor.isInRange = isInRange;
-    /**
-     * @private
-     */
-    function toPositions(cursor) {
-        if (cursor.type === 'position') {
-            return [cursor];
-        }
-        const columns = (cursor.columns || []);
-        const positions = [];
-        const state = cursor.state;
-        for (let row = cursor.firstRow, rowEnd = cursor.lastRow; row < rowEnd; ++row) {
-            if (!columns.length) {
-                positions.push({
-                    type: 'position',
-                    row,
-                    state
-                });
-                continue;
-            }
-            for (let column = 0, columnEnd = columns.length; column < columnEnd; ++column) {
-                positions.push({
-                    type: 'position',
-                    column: columns[column],
-                    row,
-                    state
-                });
-            }
-        }
-        return positions;
+    return false;
+}
+/**
+ * Checks whether a cursor is in a range.
+ * @private
+ */
+export function isInRange(needle, range) {
+    if (range.type === 'position') {
+        range = toRange(range);
     }
-    DataCursor.toPositions = toPositions;
-    /**
-     * @private
-     */
-    function toRange(cursor, defaultRange) {
-        if (cursor.type === 'range') {
-            return cursor;
+    if (needle.type === 'position') {
+        needle = toRange(needle, range);
+    }
+    const needleColumns = needle.columns;
+    const rangeColumns = range.columns;
+    return (needle.firstRow >= range.firstRow &&
+        needle.lastRow <= range.lastRow &&
+        (!needleColumns ||
+            !rangeColumns ||
+            needleColumns.every((column) => rangeColumns.indexOf(column) >= 0)));
+}
+/**
+ * @private
+ */
+export function toPositions(cursor) {
+    if (cursor.type === 'position') {
+        return [cursor];
+    }
+    const columns = (cursor.columns || []);
+    const positions = [];
+    const state = cursor.state;
+    for (let row = cursor.firstRow, rowEnd = cursor.lastRow; row < rowEnd; ++row) {
+        if (!columns.length) {
+            positions.push({
+                type: 'position',
+                row,
+                state
+            });
+            continue;
         }
-        const range = {
-            type: 'range',
-            firstRow: (cursor.row ??
-                (defaultRange && defaultRange.firstRow) ??
-                0),
-            lastRow: (cursor.row ??
-                (defaultRange && defaultRange.lastRow) ??
-                Number.MAX_VALUE),
-            state: cursor.state
-        };
-        if (typeof cursor.column !== 'undefined') {
-            range.columns = [cursor.column];
+        for (let column = 0, columnEnd = columns.length; column < columnEnd; ++column) {
+            positions.push({
+                type: 'position',
+                column: columns[column],
+                row,
+                state
+            });
         }
-        return range;
     }
-    DataCursor.toRange = toRange;
-})(DataCursor || (DataCursor = {}));
+    return positions;
+}
+/**
+ * @private
+ */
+export function toRange(cursor, defaultRange) {
+    if (cursor.type === 'range') {
+        return cursor;
+    }
+    const range = {
+        type: 'range',
+        firstRow: (cursor.row ??
+            (defaultRange && defaultRange.firstRow) ??
+            0),
+        lastRow: (cursor.row ??
+            (defaultRange && defaultRange.lastRow) ??
+            Number.MAX_VALUE),
+        state: cursor.state
+    };
+    if (typeof cursor.column !== 'undefined') {
+        range.columns = [cursor.column];
+    }
+    return range;
+}
 /* *
  *
  *  Default Export

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

@@ -1,11 +1,11 @@
 /**
  * The event object to pass to a callback.
  */
-interface DataEvent {
+export interface DataEvent {
     /**
      * Additional event detail
      */
-    detail?: DataEvent.Detail;
+    detail?: DataEventDetail;
     /**
      * The event type
      */
@@ -14,68 +14,66 @@ interface DataEvent {
 /**
  * Additional types for the event object and the event callback.
  */
-declare namespace DataEvent {
-    /**
-     * Describes the callbacks expected types. This generic interface can be
-     * extended by implementing classes.
-     */
-    interface Callback<T, E extends DataEvent> {
-        /**
-         *
-         * @param this
-         * Event scope pointing to the class instance, where the event happens.
-         *
-         * @param e
-         * Event object with additional event information.
-         */
-        (this: T, e: E): void;
-    }
+/**
+ * Describes the callbacks expected types. This generic interface can be
+ * extended by implementing classes.
+ */
+export interface DataEventCallback<T, E extends DataEvent> {
     /**
-     * Additional detail of the event object.
+     *
+     * @param this
+     * Event scope pointing to the class instance, where the event happens.
+     *
+     * @param e
+     * Event object with additional event information.
      */
-    type Detail = Record<string, (boolean | number | string | null | undefined)>;
+    (this: T, e: E): void;
+}
+/**
+ * Additional detail of the event object.
+ */
+export type DataEventDetail = Record<string, (boolean | number | string | null | undefined)>;
+/**
+ * Describes methods to attach callbacks to events of a class instance.
+ */
+export interface DataEventEmitter<E extends DataEvent> {
     /**
-     * Describes methods to attach callbacks to events of a class instance.
+     * Registered events managed by Highcharts utility functions.
      */
-    interface Emitter<E extends DataEvent> {
-        /**
-         * Registered events managed by Highcharts utility functions.
-         */
-        hcEvents?: HCEventsCollection;
-        /**
-         * Emits an event on the class instance to all registered callbacks of
-         * this event.
-         *
-         * @param e
-         * Event object containing additional event information.
-         */
-        emit(e: E): void;
-        /**
-         * Registers a callback for a specific event.
-         *
-         * @param {string} type
-         * Event type as a string.
-         *
-         * @param {DataEvent.Callback} callback
-         * Function to register for an event callback.
-         *
-         * @return {Function}
-         * Function to unregister callback from the event.
-         */
-        on<T extends E['type']>(type: T, callback: Callback<this, Extract<E, {
-            type: T;
-        }>>): Function;
-    }
+    hcEvents?: DataEventHCEventsCollection;
     /**
-     * Object to manage an event.
+     * Emits an event on the class instance to all registered callbacks of
+     * this event.
+     *
+     * @param e
+     * Event object containing additional event information.
      */
-    interface HCEventObject {
-        fn: Callback<unknown, DataEvent>;
-        order?: number;
-    }
+    emit(e: E): void;
     /**
-     * Collection of events managed by Highcharts utility functions.
+     * Registers a callback for a specific event.
+     *
+     * @param {string} type
+     * Event type as a string.
+     *
+     * @param {DataEventCallback} callback
+     * Function to register for an event callback.
+     *
+     * @return {Function}
+     * Function to unregister callback from the event.
      */
-    type HCEventsCollection = (Record<string, Array<HCEventObject>>);
+    on<T extends E['type']>(type: T, callback: DataEventCallback<this, Extract<E, {
+        type: T;
+    }>>): Function;
 }
+/**
+ * Object to manage an event.
+ */
+export interface DataEventHCEventObject {
+    fn: DataEventCallback<unknown, DataEvent>;
+    order?: number;
+}
+/**
+ * Collection of events managed by Highcharts utility functions.
+ */
+export type DataEventHCEventsCollection = (Record<string, Array<DataEventHCEventObject>>);
 export default DataEvent;