@highcharts/grid-pro 2.2.0 → 2.3.0

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

@@ -1,4 +1,4 @@
-import type DataEvent from './DataEvent';
+import type { DataEventCallback, DataEventEmitter } from './DataEvent';
 import type DataConnectorType from './Connectors/DataConnectorType';
 import type { DataConnectorTypeOptions } from './Connectors/DataConnectorType';
 import type DataPoolOptions from './DataPoolOptions';
@@ -11,7 +11,7 @@ import type DataPoolOptions from './DataPoolOptions';
  * @param {DataPoolOptions} options
  * Pool options with all connectors.
  */
-declare class DataPool implements DataEvent.Emitter<DataPool.Event> {
+declare class DataPool implements DataEventEmitter<Event> {
     protected static readonly defaultOptions: DataPoolOptions;
     /**
      * Internal dictionary with the connectors and their IDs.
@@ -31,10 +31,10 @@ declare class DataPool implements DataEvent.Emitter<DataPool.Event> {
      * Emits an event on this data pool to all registered callbacks of the given
      * event.
      *
-     * @param {DataTable.Event} e
+     * @param {DataTableEvent} e
      * Event object with event information.
      */
-    emit(e: DataPool.Event): void;
+    emit(e: Event): void;
     /**
      * Loads the connector.
      *
@@ -110,21 +110,14 @@ declare class DataPool implements DataEvent.Emitter<DataPool.Event> {
      * @return {Function}
      * Function to unregister callback from the event.
      */
-    on<T extends DataPool.Event['type']>(type: T, callback: DataEvent.Callback<this, Extract<DataPool.Event, {
+    on<T extends Event['type']>(type: T, callback: DataEventCallback<this, Extract<Event, {
         type: T;
     }>>): Function;
-    /**
-     * Sets connector options under the specified `options.id`.
-     *
-     * @param options
-     * Connector options to set.
-     */
-    setConnectorOptions(options: DataConnectorTypeOptions): void;
+    setConnectorOptions(options: DataConnectorTypeOptions, update?: boolean): void;
+    setConnectorOptions(options: DataConnectorTypeOptions, update: true): Promise<void>;
 }
-declare namespace DataPool {
-    interface Event {
-        type: ('load' | 'afterLoad' | 'setConnectorOptions' | 'afterSetConnectorOptions');
-        options: DataConnectorTypeOptions;
-    }
+export interface Event {
+    type: ('load' | 'afterLoad' | 'setConnectorOptions' | 'afterSetConnectorOptions');
+    options: DataConnectorTypeOptions;
 }
 export default DataPool;

package/es-modules/Data/DataPool.js

@@ -12,8 +12,7 @@
  * */
 'use strict';
 import DataConnector from './Connectors/DataConnector.js';
-import U from '../Core/Utilities.js';
-const { addEvent, fireEvent, merge } = U;
+import { addEvent, fireEvent, merge } from '../Shared/Utilities.js';
 /* *
  *
  *  Class
@@ -48,7 +47,7 @@ class DataPool {
      * Emits an event on this data pool to all registered callbacks of the given
      * event.
      *
-     * @param {DataTable.Event} e
+     * @param {DataTableEvent} e
      * Event object with event information.
      */
     emit(e) {
@@ -215,8 +214,12 @@ class DataPool {
      *
      * @param options
      * Connector options to set.
+     *
+     * @param update
+     * Whether to update the existing connector with the new options and reload
+     * it (`true`) or replace it with a new connector instance (`false`).
      */
-    setConnectorOptions(options) {
+    async setConnectorOptions(options, update) {
         const connectorsOptions = this.options.connectors;
         const connectorsInstances = this.connectors;
         this.emit({
@@ -229,12 +232,20 @@ class DataPool {
                 break;
             }
         }
-        // TODO: Check if can be refactored
-        if (connectorsInstances[options.id]) {
-            connectorsInstances[options.id].stopPolling();
-            delete connectorsInstances[options.id];
+        let existingConnector = connectorsInstances[options.id];
+        if (existingConnector) {
+            if (update) {
+                await existingConnector.update(options, true);
+            }
+            else {
+                existingConnector.stopPolling();
+                existingConnector = void 0;
+                delete connectorsInstances[options.id];
+            }
+        }
+        if (!existingConnector) {
+            connectorsOptions.push(options);
         }
-        connectorsOptions.push(options);
         this.emit({
             type: 'afterSetConnectorOptions',
             options

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

@@ -1,4 +1,4 @@
-import type DataEvent from './DataEvent';
+import type { DataEvent, DataEventCallback, DataEventDetail, DataEventEmitter } from './DataEvent';
 import type DataModifier from './Modifiers/DataModifier';
 import type DataTableOptions from './DataTableOptions';
 import type { DataTableValue } from './DataTableOptions';
@@ -15,7 +15,7 @@ import DataTableCore from './DataTableCore.js';
  * @param {Highcharts.DataTableOptions} [options]
  * Options to initialize the new DataTable instance.
  */
-declare class DataTable extends DataTableCore implements DataEvent.Emitter<DataTable.Event> {
+declare class DataTable extends DataTableCore implements DataEventEmitter<Event> {
     constructor(options?: DataTableOptions);
     private modifier?;
     private localRowIndexes?;
@@ -40,7 +40,7 @@ declare class DataTable extends DataTableCore implements DataEvent.Emitter<DataT
      * @emits #cloneTable
      * @emits #afterCloneTable
      */
-    clone(skipColumns?: boolean, eventDetail?: DataEvent.Detail): DataTable;
+    clone(skipColumns?: boolean, eventDetail?: DataEventDetail): DataTable;
     /**
      * Deletes columns from the table.
      *
@@ -59,7 +59,7 @@ declare class DataTable extends DataTableCore implements DataEvent.Emitter<DataT
      * @emits #deleteColumns
      * @emits #afterDeleteColumns
      */
-    deleteColumns(columnIds?: Array<string>, eventDetail?: DataEvent.Detail): (DataTable.ColumnCollection | undefined);
+    deleteColumns(columnIds?: Array<string>, eventDetail?: DataEventDetail): (ColumnCollection | undefined);
     /**
      * Deletes the row index references. This is useful when the original table
      * is deleted, and the references are no longer needed. This table is
@@ -88,16 +88,16 @@ declare class DataTable extends DataTableCore implements DataEvent.Emitter<DataT
      * @emits #deleteRows
      * @emits #afterDeleteRows
      */
-    deleteRows(rowIndex?: number | number[], rowCount?: number, eventDetail?: DataEvent.Detail): Array<DataTable.Row>;
+    deleteRows(rowIndex?: number | number[], rowCount?: number, eventDetail?: DataEventDetail): Array<Row>;
     /**
      * Emits an event on this table to all registered callbacks of the given
      * event.
      * @private
      *
-     * @param {DataTable.Event} e
+     * @param {Event} e
      * Event object with event information.
      */
-    emit(e: DataTable.Event): void;
+    emit(e: Event): void;
     /**
      * Fetches a single cell value.
      *
@@ -112,7 +112,7 @@ declare class DataTable extends DataTableCore implements DataEvent.Emitter<DataT
      * @return {Highcharts.DataTableCellType|undefined}
      * Returns the cell value or `undefined`.
      */
-    getCell(columnId: string, rowIndex: number): (DataTable.CellType | undefined);
+    getCell(columnId: string, rowIndex: number): (CellType | undefined);
     /**
      * Fetches the given column by the canonical column name.
      * This function is a simplified wrap of {@link getColumns}.
@@ -128,7 +128,7 @@ declare class DataTable extends DataTableCore implements DataEvent.Emitter<DataT
      * @return {Highcharts.DataTableColumn|undefined}
      * A copy of the column, or `undefined` if not found.
      */
-    getColumn(columnId: string, asReference?: boolean): (DataTable.Column | undefined);
+    getColumn(columnId: string, asReference?: boolean): (Column | undefined);
     /**
      * Fetches all column IDs.
      *
@@ -138,9 +138,9 @@ declare class DataTable extends DataTableCore implements DataEvent.Emitter<DataT
      * Returns all column IDs.
      */
     getColumnIds(): Array<string>;
-    getColumns(columnIds?: Array<string>, asReference?: boolean): DataTable.ColumnCollection;
-    getColumns(columnIds: (Array<string> | undefined), asReference: true): Record<string, DataTable.Column>;
-    getColumns(columnIds: (Array<string> | undefined), asReference: false, asBasicColumns: true): Record<string, DataTable.BasicColumn>;
+    getColumns(columnIds?: Array<string>, asReference?: boolean): ColumnCollection;
+    getColumns(columnIds: (Array<string> | undefined), asReference: true): Record<string, Column>;
+    getColumns(columnIds: (Array<string> | undefined), asReference: false, asBasicColumns: true): Record<string, BasicColumn>;
     /**
      * Takes the original row index and returns the local row index in the
      * modified table for which this function is called.
@@ -187,7 +187,7 @@ declare class DataTable extends DataTableCore implements DataEvent.Emitter<DataT
      * @return {Highcharts.DataTableRow}
      * Returns the row values, or `undefined` if not found.
      */
-    getRow(rowIndex: number, columnIds?: Array<string>): (DataTable.Row | undefined);
+    getRow(rowIndex: number, columnIds?: Array<string>): (Row | undefined);
     /**
      * Returns the number of rows in this table.
      *
@@ -214,7 +214,7 @@ declare class DataTable extends DataTableCore implements DataEvent.Emitter<DataT
      * @return {number|undefined}
      * Index of the first row matching the cell value.
      */
-    getRowIndexBy(columnId: string, cellValue: DataTable.CellType, rowIndexOffset?: number): (number | undefined);
+    getRowIndexBy(columnId: string, cellValue: CellType, rowIndexOffset?: number): (number | undefined);
     /**
      * Retrieves the row at a given index. This function is a simplified wrap of
      * {@link getRowObjects}.
@@ -230,7 +230,7 @@ declare class DataTable extends DataTableCore implements DataEvent.Emitter<DataT
      * @return {Highcharts.DataTableRowObject}
      * Returns the row values, or `undefined` if not found.
      */
-    getRowObject(rowIndex: number, columnIds?: Array<string>): (DataTable.RowObject | undefined);
+    getRowObject(rowIndex: number, columnIds?: Array<string>): (RowObject | undefined);
     /**
      * Fetches all or a number of rows as an object.
      *
@@ -248,7 +248,7 @@ declare class DataTable extends DataTableCore implements DataEvent.Emitter<DataT
      * @return {Highcharts.DataTableRowObject}
      * Returns retrieved rows.
      */
-    getRowObjects(rowIndex?: number, rowCount?: number, columnIds?: Array<string>): (Array<DataTable.RowObject>);
+    getRowObjects(rowIndex?: number, rowCount?: number, columnIds?: Array<string>): (Array<RowObject>);
     /**
      * Fetches all or a number of rows as an array.
      *
@@ -266,7 +266,7 @@ declare class DataTable extends DataTableCore implements DataEvent.Emitter<DataT
      * @return {Highcharts.DataTableRow}
      * Returns retrieved rows.
      */
-    getRows(rowIndex?: number, rowCount?: number, columnIds?: Array<string>): (Array<DataTable.Row>);
+    getRows(rowIndex?: number, rowCount?: number, columnIds?: Array<string>): (Array<Row>);
     /**
      * Returns the unique version tag of the current state of the table.
      *
@@ -302,7 +302,7 @@ declare class DataTable extends DataTableCore implements DataEvent.Emitter<DataT
      * @return {boolean}
      * True, if a row has been found, otherwise false.
      */
-    hasRowWith(columnId: string, cellValue: DataTable.CellType): boolean;
+    hasRowWith(columnId: string, cellValue: CellType): boolean;
     /**
      * Registers a callback function to be executed when a specific event is
      * emitted. To stop listening to the event, call the function returned by
@@ -319,7 +319,7 @@ declare class DataTable extends DataTableCore implements DataEvent.Emitter<DataT
      * @return {Function}
      * Function to unregister callback from the event.
      */
-    on<T extends DataTable.Event['type']>(type: T, callback: DataEvent.Callback<this, Extract<DataTable.Event, {
+    on<T extends Event['type']>(type: T, callback: DataEventCallback<this, Extract<Event, {
         type: T;
     }>>): Function;
     /**
@@ -361,7 +361,7 @@ declare class DataTable extends DataTableCore implements DataEvent.Emitter<DataT
      * @emits #setCell
      * @emits #afterSetCell
      */
-    setCell(columnId: string, rowIndex: number, cellValue: DataTable.CellType, eventDetail?: DataEvent.Detail): void;
+    setCell(columnId: string, rowIndex: number, cellValue: CellType, eventDetail?: DataEventDetail): void;
     /**
      * Replaces or updates multiple columns in the table with new data. If a
      * column does not exist, it will be created and added to the table.
@@ -386,7 +386,7 @@ declare class DataTable extends DataTableCore implements DataEvent.Emitter<DataT
      * @emits #setColumns
      * @emits #afterSetColumns
      */
-    setColumns(columns: DataTable.ColumnCollection, rowIndex?: number, eventDetail?: DataEvent.Detail, typeAsOriginal?: boolean): void;
+    setColumns(columns: ColumnCollection, rowIndex?: number, eventDetail?: DataEventDetail, typeAsOriginal?: boolean): void;
     /**
      * Assigns a new data modifier to the table.
      *
@@ -406,7 +406,7 @@ declare class DataTable extends DataTableCore implements DataEvent.Emitter<DataT
      * @emits #setModifier
      * @emits #afterSetModifier
      */
-    setModifier(modifier?: DataModifier, eventDetail?: DataEvent.Detail): Promise<DataTable>;
+    setModifier(modifier?: DataModifier, eventDetail?: DataEventDetail): Promise<DataTable>;
     /**
      * Sets the original row indexes for the table. It is used to keep the
      * reference to the original rows when modifying the table.
@@ -442,7 +442,7 @@ declare class DataTable extends DataTableCore implements DataEvent.Emitter<DataT
      * @emits #setRows
      * @emits #afterSetRows
      */
-    setRow(row: (DataTable.Row | DataTable.RowObject), rowIndex?: number, insert?: boolean, eventDetail?: DataEvent.Detail): void;
+    setRow(row: (Row | RowObject), rowIndex?: number, insert?: boolean, eventDetail?: DataEventDetail): void;
     /**
      * Sets cell values for multiple rows. Will insert new rows, if no index was
      * was provided, or if the index is higher than the total number of table
@@ -465,99 +465,97 @@ declare class DataTable extends DataTableCore implements DataEvent.Emitter<DataT
      * @emits #setRows
      * @emits #afterSetRows
      */
-    setRows(rows: Array<(DataTable.Row | DataTable.RowObject)>, rowIndex?: number, insert?: boolean, eventDetail?: DataEvent.Detail): void;
+    setRows(rows: Array<(Row | RowObject)>, rowIndex?: number, insert?: boolean, eventDetail?: DataEventDetail): void;
 }
 /**
  * Additionally it provides necessary types for events.
  */
-declare namespace DataTable {
-    /**
-     * Possible value types for a table cell.
-     */
-    type CellType = (boolean | number | null | string | undefined);
-    /**
-     * Conventional array of table cells typed as `CellType`.
-     */
-    interface BasicColumn extends Array<DataTable.CellType> {
-        [index: number]: CellType;
-    }
-    /**
-     * Array of table cells in vertical expansion.
-     */
-    type Column = BasicColumn | TypedArray;
-    /**
-     * Collection of columns, where the key is the column name and
-     * the value is an array of column values.
-     */
-    interface ColumnCollection {
-        [columnId: string]: Column;
-    }
-    /**
-     * Event object for cell-related events.
-     */
-    interface CellEvent extends DataEvent {
-        readonly type: ('setCell' | 'afterSetCell');
-        readonly cellValue: DataTable.CellType;
-        readonly columnId: string;
-        readonly rowIndex: number;
-    }
-    /**
-     * Event object for clone-related events.
-     */
-    interface CloneEvent extends DataEvent {
-        readonly type: ('cloneTable' | 'afterCloneTable');
-        readonly tableClone?: DataTable;
-    }
-    /**
-     * Event object for column-related events.
-     */
-    interface ColumnEvent extends DataEvent {
-        readonly type: ('deleteColumns' | 'afterDeleteColumns' | 'setColumns' | 'afterSetColumns');
-        readonly columns?: ColumnCollection;
-        readonly columnIds: Array<string>;
-        readonly rowIndex?: number;
-    }
-    /**
-     * All information objects of DataTable events.
-     */
-    type Event = (CellEvent | CloneEvent | ColumnEvent | SetModifierEvent | RowEvent);
-    /**
-     * Event object for modifier-related events.
-     */
-    interface ModifierEvent extends DataEvent {
-        readonly type: ('setModifier' | 'afterSetModifier');
-        readonly modifier: (DataModifier | undefined);
-    }
-    /**
-     * Array of table cells in horizontal expansion. Index of the array is the
-     * index of the column names.
-     */
-    interface Row extends Array<CellType> {
-        [index: number]: CellType;
-    }
-    /**
-     * Event object for row-related events.
-     */
-    interface RowEvent extends DataEvent {
-        readonly type: ('deleteRows' | 'afterDeleteRows' | 'setRows' | 'afterSetRows');
-        readonly rowCount: number;
-        readonly rowIndex: number | number[];
-        readonly rows?: Array<Row | RowObject>;
-    }
-    /**
-     * Object of row values, where the keys are the column names.
-     */
-    interface RowObject extends Record<string, CellType> {
-        [column: string]: CellType;
-    }
-    /**
-    * Event object for the setModifier events.
-    */
-    interface SetModifierEvent extends DataEvent {
-        readonly type: ('setModifier' | 'afterSetModifier' | 'setModifierError');
-        readonly error?: unknown;
-        readonly modifier?: DataModifier;
-        readonly modified?: DataTable;
-    }
+/**
+ * Possible value types for a table cell.
+ */
+export type CellType = (boolean | number | null | string | undefined);
+/**
+ * Conventional array of table cells typed as `CellType`.
+ */
+export interface BasicColumn extends Array<CellType> {
+    [index: number]: CellType;
+}
+/**
+ * Array of table cells in vertical expansion.
+ */
+export type Column = BasicColumn | TypedArray;
+/**
+ * Collection of columns, where the key is the column name and
+ * the value is an array of column values.
+ */
+export interface ColumnCollection {
+    [columnId: string]: Column;
+}
+/**
+ * Event object for cell-related events.
+ */
+export interface CellEvent extends DataEvent {
+    readonly type: ('setCell' | 'afterSetCell');
+    readonly cellValue: CellType;
+    readonly columnId: string;
+    readonly rowIndex: number;
+}
+/**
+ * Event object for clone-related events.
+ */
+export interface CloneEvent extends DataEvent {
+    readonly type: ('cloneTable' | 'afterCloneTable');
+    readonly tableClone?: DataTable;
+}
+/**
+ * Event object for column-related events.
+ */
+export interface ColumnEvent extends DataEvent {
+    readonly type: ('deleteColumns' | 'afterDeleteColumns' | 'setColumns' | 'afterSetColumns');
+    readonly columns?: ColumnCollection;
+    readonly columnIds: Array<string>;
+    readonly rowIndex?: number;
+}
+/**
+ * All information objects of DataTable events.
+ */
+export type Event = (CellEvent | CloneEvent | ColumnEvent | SetModifierEvent | RowEvent);
+/**
+ * Event object for modifier-related events.
+ */
+export interface ModifierEvent extends DataEvent {
+    readonly type: ('setModifier' | 'afterSetModifier');
+    readonly modifier: (DataModifier | undefined);
+}
+/**
+ * Array of table cells in horizontal expansion. Index of the array is the
+ * index of the column names.
+ */
+export interface Row extends Array<CellType> {
+    [index: number]: CellType;
+}
+/**
+ * Event object for row-related events.
+ */
+export interface RowEvent extends DataEvent {
+    readonly type: ('deleteRows' | 'afterDeleteRows' | 'setRows' | 'afterSetRows');
+    readonly rowCount: number;
+    readonly rowIndex: number | number[];
+    readonly rows?: Array<Row | RowObject>;
+}
+/**
+ * Object of row values, where the keys are the column names.
+ */
+export interface RowObject extends Record<string, CellType> {
+    [column: string]: CellType;
+}
+/**
+* Event object for the setModifier events.
+*/
+export interface SetModifierEvent extends DataEvent {
+    readonly type: ('setModifier' | 'afterSetModifier' | 'setModifierError');
+    readonly error?: unknown;
+    readonly modifier?: DataModifier;
+    readonly modified?: DataTable;
 }
 export default DataTable;

package/es-modules/Data/DataTable.js

@@ -17,8 +17,8 @@
 import DataTableCore from './DataTableCore.js';
 import ColumnUtils from './ColumnUtils.js';
 const { splice, setLength } = ColumnUtils;
-import U from '../Core/Utilities.js';
-const { addEvent, defined, extend, fireEvent, isNumber, uniqueKey } = U;
+import { addEvent, defined, extend, fireEvent, isNumber } from '../Shared/Utilities.js';
+import { uniqueKey } from '../Core/Utilities.js';
 /* *
  *
  *  Class
@@ -256,7 +256,7 @@ class DataTable extends DataTableCore {
      * event.
      * @private
      *
-     * @param {DataTable.Event} e
+     * @param {Event} e
      * Event object with event information.
      */
     emit(e) {

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

@@ -1,5 +1,5 @@
-import type DataEvent from './DataEvent.js';
-import type DataTable from './DataTable.js';
+import type { DataEventDetail } from './DataEvent.js';
+import type { Column as DataTableColumn, ColumnCollection as DataTableColumnCollection, Row as DataTableRow, RowObject as DataTableRowObject } from './DataTable.js';
 import type DataTableOptions from './DataTableOptions.js';
 /**
  * Class to manage columns and rows in a table structure. It provides methods
@@ -31,7 +31,7 @@ declare class DataTableCore {
      */
     constructor(options?: DataTableOptions);
     readonly autoId: boolean;
-    readonly columns: Record<string, DataTable.Column>;
+    readonly columns: Record<string, DataTableColumn>;
     readonly id: string;
     modified?: this;
     rowCount: number;
@@ -69,7 +69,7 @@ declare class DataTableCore {
      * @return {Highcharts.DataTableColumn|undefined}
      * A copy of the column, or `undefined` if not found.
      */
-    getColumn(columnId: string, asReference?: true): (DataTable.Column | undefined);
+    getColumn(columnId: string, asReference?: true): (DataTableColumn | undefined);
     /**
      * Retrieves all or the given columns. Simplified version of the full
      * `DataTable.getColumns` method, always returning by reference.
@@ -81,7 +81,7 @@ declare class DataTableCore {
      * Collection of columns. If a requested column was not found, it is
      * `undefined`.
      */
-    getColumns(columnIds?: Array<string>, asReference?: true): DataTable.ColumnCollection;
+    getColumns(columnIds?: Array<string>, asReference?: true): DataTableColumnCollection;
     /**
      * Retrieves the row at a given index.
      *
@@ -94,7 +94,7 @@ declare class DataTableCore {
      * @return {Record<string, number|string|undefined>|undefined}
      * Returns the row values, or `undefined` if not found.
      */
-    getRow(rowIndex: number, columnIds?: Array<string>): (DataTable.Row | undefined);
+    getRow(rowIndex: number, columnIds?: Array<string>): (DataTableRow | undefined);
     /**
      * Sets cell values for a column. Will insert a new column, if not found.
      *
@@ -113,7 +113,7 @@ declare class DataTableCore {
      * @emits #setColumns
      * @emits #afterSetColumns
      */
-    setColumn(columnId: string, column?: DataTable.Column, rowIndex?: number, eventDetail?: DataEvent.Detail): void;
+    setColumn(columnId: string, column?: DataTableColumn, rowIndex?: number, eventDetail?: DataEventDetail): void;
     /**
      * Sets cell values for multiple columns. Will insert new columns, if not
      * found. Simplified version of the full `DataTableCore.setColumns`, limited
@@ -132,7 +132,7 @@ declare class DataTableCore {
      * @emits #setColumns
      * @emits #afterSetColumns
      */
-    setColumns(columns: DataTable.ColumnCollection, rowIndex?: number, eventDetail?: DataEvent.Detail): void;
+    setColumns(columns: DataTableColumnCollection, rowIndex?: number, eventDetail?: DataEventDetail): void;
     /**
      * Sets cell values of a row. Will insert a new row if no index was
      * provided, or if the index is higher than the total number of table rows.
@@ -152,7 +152,7 @@ declare class DataTableCore {
      *
      * @emits #afterSetRows
      */
-    setRow(row: DataTable.RowObject, rowIndex?: number, insert?: boolean, eventDetail?: DataEvent.Detail): void;
+    setRow(row: DataTableRowObject, rowIndex?: number, insert?: boolean, eventDetail?: DataEventDetail): void;
     /**
      * Returns the modified (clone) or the original data table if the modified
      * one does not exist.

package/es-modules/Data/DataTableCore.js

@@ -15,8 +15,8 @@
 'use strict';
 import ColumnUtils from './ColumnUtils.js';
 const { setLength, splice } = ColumnUtils;
-import U from '../Core/Utilities.js';
-const { fireEvent, objectEach, uniqueKey } = U;
+import { fireEvent, objectEach } from '../Shared/Utilities.js';
+import { uniqueKey } from '../Core/Utilities.js';
 /* *
  *
  *  Class

package/es-modules/Data/Formula/FormulaParser.js

@@ -11,8 +11,7 @@
  *
  * */
 'use strict';
-import U from '../../Core/Utilities.js';
-const { isString } = U;
+import { isString } from '../../Shared/Utilities.js';
 /* *
  *
  *  Constants

package/es-modules/Data/Formula/FormulaProcessor.js

@@ -11,10 +11,9 @@
  *
  * */
 'use strict';
+import { defined } from '../../Shared/Utilities.js';
 import FormulaTypes from './FormulaTypes.js';
 const { isFormula, isFunction, isOperator, isRange, isReference, isValue } = FormulaTypes;
-import U from '../../Core/Utilities.js';
-const { defined } = U;
 /* *
  *
  *  Constants