@highcharts/grid-pro 2.0.0

package/es-modules/Data/Formula/Functions/IF.d.ts

@@ -0,0 +1,21 @@
+import type { Arguments, Value } from '../FormulaTypes';
+import type DataTable from '../../DataTable';
+/**
+ * Processor for the `IF(test, value1, value2)` implementation. Returns one of
+ * the values based on the test result. `value1` will be returned, if the test
+ * result is not `0` or `FALSE`.
+ *
+ * @private
+ * @function Formula.processorFunctions.IF
+ *
+ * @param {Highcharts.FormulaArguments} args
+ * Arguments to process.
+ *
+ * @param {Highcharts.DataTable} [table]
+ * Table to use for references and ranges.
+ *
+ * @return {Highcharts.FormulaValue|Array<Highcharts.FormulaValue>}
+ * Result value of the process.
+ */
+declare function IF(args: Arguments, table?: DataTable): (Value | Array<Value>);
+export default IF;

package/es-modules/Data/Formula/Functions/IF.js

@@ -0,0 +1,54 @@
+/* *
+ *
+ *  (c) 2009-2025 Highsoft AS
+ *
+ *  License: www.highcharts.com/license
+ *
+ *  !!!!!!! SOURCE GETS TRANSPILED BY TYPESCRIPT. EDIT TS FILE ONLY. !!!!!!!
+ *
+ *  Authors:
+ *  - Sophie Bremer
+ *
+ * */
+'use strict';
+import FormulaProcessor from '../FormulaProcessor.js';
+const { getArgumentValue } = FormulaProcessor;
+/* *
+ *
+ *  Functions
+ *
+ * */
+/**
+ * Processor for the `IF(test, value1, value2)` implementation. Returns one of
+ * the values based on the test result. `value1` will be returned, if the test
+ * result is not `0` or `FALSE`.
+ *
+ * @private
+ * @function Formula.processorFunctions.IF
+ *
+ * @param {Highcharts.FormulaArguments} args
+ * Arguments to process.
+ *
+ * @param {Highcharts.DataTable} [table]
+ * Table to use for references and ranges.
+ *
+ * @return {Highcharts.FormulaValue|Array<Highcharts.FormulaValue>}
+ * Result value of the process.
+ */
+function IF(args, table) {
+    return (getArgumentValue(args[0], table) ?
+        getArgumentValue(args[1], table) :
+        getArgumentValue(args[2], table));
+}
+/* *
+ *
+ *  Registry
+ *
+ * */
+FormulaProcessor.registerProcessorFunction('IF', IF);
+/* *
+ *
+ *  Default Export
+ *
+ * */
+export default IF;

package/es-modules/Data/Formula/Functions/ISNA.d.ts

@@ -0,0 +1,20 @@
+import type { Arguments } from '../FormulaTypes';
+import type DataTable from '../../DataTable.js';
+/**
+ * Processor for the `ISNA(value)` implementation. Returns TRUE if value is not
+ * a number.
+ *
+ * @private
+ * @function Formula.processorFunctions.ISNA
+ *
+ * @param {Highcharts.FormulaArguments} args
+ * Arguments to process.
+ *
+ * @param {Highcharts.DataTable} [table]
+ * Table to use for references and ranges.
+ *
+ * @return {boolean}
+ * Result value of the process.
+ */
+declare function ISNA(args: Arguments, table?: DataTable): boolean;
+export default ISNA;

package/es-modules/Data/Formula/Functions/ISNA.js

@@ -0,0 +1,52 @@
+/* *
+ *
+ *  (c) 2009-2025 Highsoft AS
+ *
+ *  License: www.highcharts.com/license
+ *
+ *  !!!!!!! SOURCE GETS TRANSPILED BY TYPESCRIPT. EDIT TS FILE ONLY. !!!!!!!
+ *
+ *  Authors:
+ *  - Sophie Bremer
+ *
+ * */
+'use strict';
+import FormulaProcessor from '../FormulaProcessor.js';
+const { getArgumentValue } = FormulaProcessor;
+/* *
+ *
+ *  Functions
+ *
+ * */
+/**
+ * Processor for the `ISNA(value)` implementation. Returns TRUE if value is not
+ * a number.
+ *
+ * @private
+ * @function Formula.processorFunctions.ISNA
+ *
+ * @param {Highcharts.FormulaArguments} args
+ * Arguments to process.
+ *
+ * @param {Highcharts.DataTable} [table]
+ * Table to use for references and ranges.
+ *
+ * @return {boolean}
+ * Result value of the process.
+ */
+function ISNA(args, table) {
+    const value = getArgumentValue(args[0], table);
+    return (typeof value !== 'number' || isNaN(value));
+}
+/* *
+ *
+ *  Registry
+ *
+ * */
+FormulaProcessor.registerProcessorFunction('ISNA', ISNA);
+/* *
+ *
+ *  Default Export
+ *
+ * */
+export default ISNA;

package/es-modules/Data/Formula/Functions/MAX.d.ts

@@ -0,0 +1,20 @@
+import type { Arguments } from '../FormulaTypes';
+import type DataTable from '../../DataTable';
+/**
+ * Processor for the `MAX(...values)` implementation. Calculates the largest
+ * of the given values that are numbers.
+ *
+ * @private
+ * @function Formula.processorFunctions.MAX
+ *
+ * @param {Highcharts.FormulaArguments} args
+ * Arguments to process.
+ *
+ * @param {Highcharts.DataTable} [table]
+ * Table to use for references and ranges.
+ *
+ * @return {number}
+ * Result value of the process.
+ */
+declare function MAX(args: Arguments, table?: DataTable): number;
+export default MAX;

package/es-modules/Data/Formula/Functions/MAX.js

@@ -0,0 +1,69 @@
+/* *
+ *
+ *  (c) 2009-2025 Highsoft AS
+ *
+ *  License: www.highcharts.com/license
+ *
+ *  !!!!!!! SOURCE GETS TRANSPILED BY TYPESCRIPT. EDIT TS FILE ONLY. !!!!!!!
+ *
+ *  Authors:
+ *  - Sophie Bremer
+ *
+ * */
+'use strict';
+import FormulaProcessor from '../FormulaProcessor.js';
+const { getArgumentsValues } = FormulaProcessor;
+/* *
+ *
+ *  Functions
+ *
+ * */
+/**
+ * Processor for the `MAX(...values)` implementation. Calculates the largest
+ * of the given values that are numbers.
+ *
+ * @private
+ * @function Formula.processorFunctions.MAX
+ *
+ * @param {Highcharts.FormulaArguments} args
+ * Arguments to process.
+ *
+ * @param {Highcharts.DataTable} [table]
+ * Table to use for references and ranges.
+ *
+ * @return {number}
+ * Result value of the process.
+ */
+function MAX(args, table) {
+    const values = getArgumentsValues(args, table);
+    let result = Number.NEGATIVE_INFINITY;
+    for (let i = 0, iEnd = values.length, value; i < iEnd; ++i) {
+        value = values[i];
+        switch (typeof value) {
+            case 'number':
+                if (value > result) {
+                    result = value;
+                }
+                break;
+            case 'object':
+                value = MAX(value);
+                if (value > result) {
+                    result = value;
+                }
+                break;
+        }
+    }
+    return isFinite(result) ? result : 0;
+}
+/* *
+ *
+ *  Registry
+ *
+ * */
+FormulaProcessor.registerProcessorFunction('MAX', MAX);
+/* *
+ *
+ *  Default Export
+ *
+ * */
+export default MAX;

package/es-modules/Data/Formula/Functions/MEDIAN.d.ts

@@ -0,0 +1,20 @@
+import type { Arguments } from '../FormulaTypes';
+import type DataTable from '../../DataTable';
+/**
+ * Processor for the `MEDIAN(...values)` implementation. Calculates the median
+ * average of the given values.
+ *
+ * @private
+ * @function Formula.processorFunctions.MEDIAN
+ *
+ * @param {Highcharts.FormulaArguments} args
+ * Arguments to process.
+ *
+ * @param {Highcharts.DataTable} [table]
+ * Table to process.
+ *
+ * @return {number}
+ * Result value of the process.
+ */
+declare function MEDIAN(args: Arguments, table?: DataTable): number;
+export default MEDIAN;

package/es-modules/Data/Formula/Functions/MEDIAN.js

@@ -0,0 +1,78 @@
+/* *
+ *
+ *  (c) 2009-2025 Highsoft AS
+ *
+ *  License: www.highcharts.com/license
+ *
+ *  !!!!!!! SOURCE GETS TRANSPILED BY TYPESCRIPT. EDIT TS FILE ONLY. !!!!!!!
+ *
+ *  Authors:
+ *  - Sophie Bremer
+ *
+ * */
+'use strict';
+import FormulaProcessor from '../FormulaProcessor.js';
+/* *
+ *
+ *  Functions
+ *
+ * */
+/**
+ * Processor for the `MEDIAN(...values)` implementation. Calculates the median
+ * average of the given values.
+ *
+ * @private
+ * @function Formula.processorFunctions.MEDIAN
+ *
+ * @param {Highcharts.FormulaArguments} args
+ * Arguments to process.
+ *
+ * @param {Highcharts.DataTable} [table]
+ * Table to process.
+ *
+ * @return {number}
+ * Result value of the process.
+ */
+function MEDIAN(args, table) {
+    const median = [], values = FormulaProcessor.getArgumentsValues(args, table);
+    for (let i = 0, iEnd = values.length, value; i < iEnd; ++i) {
+        value = values[i];
+        switch (typeof value) {
+            case 'number':
+                if (!isNaN(value)) {
+                    median.push(value);
+                }
+                break;
+            case 'object':
+                for (let j = 0, jEnd = value.length, value2; j < jEnd; ++j) {
+                    value2 = value[j];
+                    if (typeof value2 === 'number' &&
+                        !isNaN(value2)) {
+                        median.push(value2);
+                    }
+                }
+                break;
+        }
+    }
+    const count = median.length;
+    if (!count) {
+        return NaN;
+    }
+    const half = Math.floor(count / 2); // Floor because index starts at 0
+    return (count % 2 ?
+        median[half] : // Odd
+        (median[half - 1] + median[half]) / 2 // Even
+    );
+}
+/* *
+ *
+ *  Registry
+ *
+ * */
+FormulaProcessor.registerProcessorFunction('MEDIAN', MEDIAN);
+/* *
+ *
+ *  Default Export
+ *
+ * */
+export default MEDIAN;

package/es-modules/Data/Formula/Functions/MIN.d.ts

@@ -0,0 +1,20 @@
+import type { Arguments } from '../FormulaTypes';
+import type DataTable from '../../DataTable';
+/**
+ * Processor for the `MIN(...values)` implementation. Calculates the lowest
+ * of the given values that are numbers.
+ *
+ * @private
+ * @function Formula.processorFunctions.MIN
+ *
+ * @param {Highcharts.FormulaArguments} args
+ * Arguments to process.
+ *
+ * @param {Highcharts.DataTable} [table]
+ * Table to use for references and ranges.
+ *
+ * @return {number}
+ * Result value of the process.
+ */
+declare function MIN(args: Arguments, table?: DataTable): number;
+export default MIN;

package/es-modules/Data/Formula/Functions/MIN.js

@@ -0,0 +1,69 @@
+/* *
+ *
+ *  (c) 2009-2025 Highsoft AS
+ *
+ *  License: www.highcharts.com/license
+ *
+ *  !!!!!!! SOURCE GETS TRANSPILED BY TYPESCRIPT. EDIT TS FILE ONLY. !!!!!!!
+ *
+ *  Authors:
+ *  - Sophie Bremer
+ *
+ * */
+'use strict';
+import FormulaProcessor from '../FormulaProcessor.js';
+const { getArgumentsValues } = FormulaProcessor;
+/* *
+ *
+ *  Functions
+ *
+ * */
+/**
+ * Processor for the `MIN(...values)` implementation. Calculates the lowest
+ * of the given values that are numbers.
+ *
+ * @private
+ * @function Formula.processorFunctions.MIN
+ *
+ * @param {Highcharts.FormulaArguments} args
+ * Arguments to process.
+ *
+ * @param {Highcharts.DataTable} [table]
+ * Table to use for references and ranges.
+ *
+ * @return {number}
+ * Result value of the process.
+ */
+function MIN(args, table) {
+    const values = getArgumentsValues(args, table);
+    let result = Number.POSITIVE_INFINITY;
+    for (let i = 0, iEnd = values.length, value; i < iEnd; ++i) {
+        value = values[i];
+        switch (typeof value) {
+            case 'number':
+                if (value < result) {
+                    result = value;
+                }
+                break;
+            case 'object':
+                value = MIN(value);
+                if (value < result) {
+                    result = value;
+                }
+                break;
+        }
+    }
+    return isFinite(result) ? result : 0;
+}
+/* *
+ *
+ *  Registry
+ *
+ * */
+FormulaProcessor.registerProcessorFunction('MIN', MIN);
+/* *
+ *
+ *  Default Export
+ *
+ * */
+export default MIN;

package/es-modules/Data/Formula/Functions/MOD.d.ts

@@ -0,0 +1,20 @@
+import type { Arguments } from '../FormulaTypes';
+import type DataTable from '../../DataTable';
+/**
+ * Processor for the `MOD(value1, value2)` implementation. Calculates the rest
+ * of the division with the given values.
+ *
+ * @private
+ * @function Formula.processorFunctions.MOD
+ *
+ * @param {Highcharts.FormulaArguments} args
+ * Arguments to process.
+ *
+ * @param {Highcharts.DataTable} [table]
+ * Table to use for references and ranges.
+ *
+ * @return {number}
+ * Result value of the process.
+ */
+declare function MOD(args: Arguments, table?: DataTable): number;
+export default MOD;

package/es-modules/Data/Formula/Functions/MOD.js

@@ -0,0 +1,63 @@
+/* *
+ *
+ *  (c) 2009-2025 Highsoft AS
+ *
+ *  License: www.highcharts.com/license
+ *
+ *  !!!!!!! SOURCE GETS TRANSPILED BY TYPESCRIPT. EDIT TS FILE ONLY. !!!!!!!
+ *
+ *  Authors:
+ *  - Sophie Bremer
+ *
+ * */
+'use strict';
+import FormulaProcessor from '../FormulaProcessor.js';
+const { getArgumentValue } = FormulaProcessor;
+/* *
+ *
+ *  Functions
+ *
+ * */
+/**
+ * Processor for the `MOD(value1, value2)` implementation. Calculates the rest
+ * of the division with the given values.
+ *
+ * @private
+ * @function Formula.processorFunctions.MOD
+ *
+ * @param {Highcharts.FormulaArguments} args
+ * Arguments to process.
+ *
+ * @param {Highcharts.DataTable} [table]
+ * Table to use for references and ranges.
+ *
+ * @return {number}
+ * Result value of the process.
+ */
+function MOD(args, table) {
+    let value1 = getArgumentValue(args[0], table), value2 = getArgumentValue(args[1], table);
+    if (typeof value1 === 'object') {
+        value1 = value1[0];
+    }
+    if (typeof value2 === 'object') {
+        value2 = value2[0];
+    }
+    if (typeof value1 !== 'number' ||
+        typeof value2 !== 'number' ||
+        value2 === 0) {
+        return NaN;
+    }
+    return value1 % value2;
+}
+/* *
+ *
+ *  Registry
+ *
+ * */
+FormulaProcessor.registerProcessorFunction('MOD', MOD);
+/* *
+ *
+ *  Default Export
+ *
+ * */
+export default MOD;

package/es-modules/Data/Formula/Functions/MODE.d.ts

@@ -0,0 +1,41 @@
+import type { Arguments } from '../FormulaTypes';
+import type DataTable from '../../DataTable';
+/**
+ * Processor for the `MODE.MULT(...values)` implementation. Calculates the most
+ * frequent values of the give values.
+ *
+ * @private
+ * @function Formula.processorFunctions.MULT
+ *
+ * @param {Highcharts.FormulaArguments} args
+ * Arguments to process.
+ *
+ * @param {Highcharts.DataTable} [table]
+ * Table to process.
+ *
+ * @return {number|Array<number>}
+ * Result value of the process.
+ */
+declare function MULT(args: Arguments, table?: DataTable): (number | Array<number>);
+/**
+ * Processor for the `MODE.SNGL(...values)` implementation. Calculates the
+ * lowest most frequent value of the give values.
+ *
+ * @private
+ * @function Formula.processorFunctions['MODE.SNGL']
+ *
+ * @param {Highcharts.FormulaArguments} args
+ * Arguments to process.
+ *
+ * @param {Highcharts.DataTable} [table]
+ * Table to process.
+ *
+ * @return {number}
+ * Result value of the process.
+ */
+declare function SNGL(args: Arguments, table?: DataTable): number;
+declare const MODE: {
+    MULT: typeof MULT;
+    SNGL: typeof SNGL;
+};
+export default MODE;

package/es-modules/Data/Formula/Functions/MODE.js

@@ -0,0 +1,149 @@
+/* *
+ *
+ *  (c) 2009-2025 Highsoft AS
+ *
+ *  License: www.highcharts.com/license
+ *
+ *  !!!!!!! SOURCE GETS TRANSPILED BY TYPESCRIPT. EDIT TS FILE ONLY. !!!!!!!
+ *
+ *  Authors:
+ *  - Sophie Bremer
+ *
+ * */
+'use strict';
+import FormulaProcessor from '../FormulaProcessor.js';
+/* *
+ *
+ *  Functions
+ *
+ * */
+/**
+ * Creates the mode map of the given arguments.
+ *
+ * @private
+ * @function Formula.processorFunctions.MULT
+ *
+ * @param {Highcharts.FormulaArguments} args
+ * Arguments to process.
+ *
+ * @param {Highcharts.DataTable} [table]
+ * Table to process.
+ *
+ * @return {number}
+ * Result value of the process.
+ */
+function getModeMap(args, table) {
+    const modeMap = {}, values = FormulaProcessor.getArgumentsValues(args, table);
+    for (let i = 0, iEnd = values.length, value; i < iEnd; ++i) {
+        value = values[i];
+        switch (typeof value) {
+            case 'number':
+                if (!isNaN(value)) {
+                    modeMap[value] = (modeMap[value] || 0) + 1;
+                }
+                break;
+            case 'object':
+                for (let j = 0, jEnd = value.length, value2; j < jEnd; ++j) {
+                    value2 = value[j];
+                    if (typeof value2 === 'number' &&
+                        !isNaN(value2)) {
+                        modeMap[value2] = (modeMap[value2] || 0) + 1;
+                    }
+                }
+                break;
+        }
+    }
+    return modeMap;
+}
+/**
+ * Processor for the `MODE.MULT(...values)` implementation. Calculates the most
+ * frequent values of the give values.
+ *
+ * @private
+ * @function Formula.processorFunctions.MULT
+ *
+ * @param {Highcharts.FormulaArguments} args
+ * Arguments to process.
+ *
+ * @param {Highcharts.DataTable} [table]
+ * Table to process.
+ *
+ * @return {number|Array<number>}
+ * Result value of the process.
+ */
+function MULT(args, table) {
+    const modeMap = getModeMap(args, table), keys = Object.keys(modeMap);
+    if (!keys.length) {
+        return NaN;
+    }
+    let modeKeys = [parseFloat(keys[0])], modeCount = modeMap[keys[0]];
+    for (let i = 1, iEnd = keys.length, key, count; i < iEnd; ++i) {
+        key = keys[i];
+        count = modeMap[key];
+        if (modeCount < count) {
+            modeKeys = [parseFloat(key)];
+            modeCount = count;
+        }
+        else if (modeCount === count) {
+            modeKeys.push(parseFloat(key));
+        }
+    }
+    return modeCount > 1 ? modeKeys : NaN;
+}
+/**
+ * Processor for the `MODE.SNGL(...values)` implementation. Calculates the
+ * lowest most frequent value of the give values.
+ *
+ * @private
+ * @function Formula.processorFunctions['MODE.SNGL']
+ *
+ * @param {Highcharts.FormulaArguments} args
+ * Arguments to process.
+ *
+ * @param {Highcharts.DataTable} [table]
+ * Table to process.
+ *
+ * @return {number}
+ * Result value of the process.
+ */
+function SNGL(args, table) {
+    const modeMap = getModeMap(args, table), keys = Object.keys(modeMap);
+    if (!keys.length) {
+        return NaN;
+    }
+    let modeKey = parseFloat(keys[0]), modeCount = modeMap[keys[0]];
+    for (let i = 1, iEnd = keys.length, key, keyValue, count; i < iEnd; ++i) {
+        key = keys[i];
+        count = modeMap[key];
+        if (modeCount < count) {
+            modeKey = parseFloat(key);
+            modeCount = count;
+        }
+        else if (modeCount === count) {
+            keyValue = parseFloat(key);
+            if (modeKey > keyValue) {
+                modeKey = keyValue;
+                modeCount = count;
+            }
+        }
+    }
+    return modeCount > 1 ? modeKey : NaN;
+}
+/* *
+ *
+ *  Registry
+ *
+ * */
+FormulaProcessor.registerProcessorFunction('MODE', SNGL);
+FormulaProcessor.registerProcessorFunction('MODE.MULT', MULT);
+FormulaProcessor.registerProcessorFunction('MODE.SNGL', SNGL);
+/* *
+ *
+ *  Default Export
+ *
+ * */
+const MODE = {
+    MULT,
+    SNGL
+};
+export default MODE;