@arcgis/charts-components 4.34.0-next.74 → 4.34.0-next.76

package/dist/chart-rendering/common/data/box-plot/index.d.ts

@@ -1,5 +1,108 @@
-import { WebBoxPlot, WebChartDataItem, WebChartQuery } from '@arcgis/charts-spec';
-import { AbortControllerKeyType, ChartElementLimit, QueryObject } from '../../../../utils';
+import { WebBoxPlot, WebChartDataItem, WebChartQuery, WebChartStatisticType } from '@arcgis/charts-spec';
+import { AbortControllerKeyType, ChartElementLimit, QueryObject, BoxPlotYFieldKeys, ChartSubType } from '../../../../utils';
+import { OutliersFilterProps } from './interfaces';
+/**
+ * Builds a key (string) used to identify the properties carrying the global average and standard deviation stats
+ *
+ * @param y The numeric field
+ * @param statType The type of stat (Average or StandardDeviation)
+ */
+declare function getMeanAndStandardDeviationPerFieldKey(y: string, statType: WebChartStatisticType): string;
+/**
+ * calculate z-score for the given value
+ *
+ * @param props.value The current value
+ * @param props.mean The mean of the whole series
+ * @param props.stdDev The standard deviation of the whole series
+ */
+declare function calculateZScore(props: {
+    value: number;
+    mean: number;
+    stdDev: number;
+}): number;
+/**
+ * Adds z-score statistic property and value pair to the box plot data item
+ *
+ * @param props.dataItem The data item for the given box plot
+ * @param props.chartSubType The box plot sub type
+ * @param props.y The y value of the box plot series
+ * @param props.splitByValue The split-by value for the given box plot series
+ * @param props.meanPerField The mean from a whole numeric field
+ * @param props.stdDevPerField The standard deviation from a whole numeric field
+ */
+declare function addZScoreItemToDataItem(props: {
+    dataItem: WebChartDataItem;
+    chartSubType: ChartSubType;
+    y?: string;
+    splitByValue?: string;
+    meanPerField?: number;
+    stdDevPerField?: number;
+}): WebChartDataItem;
+/**
+ * Adds missing alternative data to the given chart configuration and data.
+ * This happens when fetchBoxPlotAlternativeData() doesn't bring back results for a specific field.
+ * In that case we set the alternative data to the original data.
+ *
+ * @param chartConfig The chart config
+ * @param data The data to add missing alternative data to
+ */
+declare function addMissingAlternativeData(chartConfig: WebBoxPlot, data: WebChartDataItem[]): void;
+/**
+ * Calculating the outliers threshold for a given data item (representing one candle and whiskers)
+ *
+ * @param dataItem The data item containing the stats
+ * @param yFieldNames The box plot y field names
+ */
+declare function getOutliersThresholds(dataItem: WebChartDataItem, yFieldNames: Record<BoxPlotYFieldKeys, string>): {
+    outlierMinThreshold?: number;
+    outlierMaxThreshold?: number;
+};
+/**
+ * Builds the query filter necessary to fetch either the outliers or the alternative data by using the x, y and split-by fields and values.
+ *
+ * @param props.yField The y-axis field
+ * @param props.xField The x-axis field
+ * @param props.xValue The category value
+ * @param props.splitByField The split-by field for a given series
+ * @param props.splitByValue The split-by value for a given series
+ * @param props.outlierMinThreshold The outlier min threshold for a given data item
+ * @param props.outlierMaxThreshold The outlier max threshold for a given data item
+ * @param props.target Whether the function is called to build the outliers or the alternative data filter
+ */
+declare function buildBoxPlotFilter(props: OutliersFilterProps): string;
+/**
+ * Generates the query filters necessary to fetch the box plot outliers and alternative data.
+ * The filters are returned as an array because if they contain too many operands they are split
+ * into multiple filters.
+ *
+ * @param props.data The main data set
+ * @param props.yField The numeric field
+ * @param props.x The x-axis field
+ * @param props.chartSubType The chart sub type
+ * @param props.splitByField The split-by field
+ */
+declare function generateBoxPlotQueriesFilter(props: {
+    data: WebChartDataItem[];
+    yField: string;
+    x?: string;
+    chartSubType: ChartSubType;
+    splitByField?: string;
+}): {
+    outliersFilterBatches: string[];
+    dataWithoutOutliersFilterBatches: string[];
+};
+/**
+ * Merges two data sets from the category and split-by field
+ *
+ * @param props.data The main data set
+ * @param props.additionalData The additional data
+ * @param props.chartConfig The chart's config
+ */
+declare function mergeBoxPlotAlternativeData(props: {
+    data: WebChartDataItem[];
+    additionalData: WebChartDataItem[];
+    chartConfig: WebBoxPlot;
+}): WebChartDataItem[];
 /**
  * Processes the fetched data for a box plot chart and transforms it into the appropriate format for the amCharts library.
  * Depending on the query type, the data may need to be grouped and/or flattened before being returned.
@@ -46,3 +149,14 @@ export declare function completeBoxPlotResults(props: {
     dataItems: WebChartDataItem[];
     outliers: WebChartDataItem[];
 }>;
+export declare const commonDataBoxplotPrivateFunctions: {
+    getOutliersThresholds: typeof getOutliersThresholds;
+    buildBoxPlotFilter: typeof buildBoxPlotFilter;
+    generateBoxPlotQueriesFilter: typeof generateBoxPlotQueriesFilter;
+    mergeBoxPlotAlternativeData: typeof mergeBoxPlotAlternativeData;
+    calculateZScore: typeof calculateZScore;
+    addZScoreItemToDataItem: typeof addZScoreItemToDataItem;
+    getMeanAndStandardDeviationPerFieldKey: typeof getMeanAndStandardDeviationPerFieldKey;
+    addMissingAlternativeData: typeof addMissingAlternativeData;
+};
+export {};

package/dist/chart-rendering/common/data/histogram/index.d.ts

@@ -1,6 +1,26 @@
-import { WebChart, WebChartQuery } from '@arcgis/charts-spec';
+import { WebChart, WebChartQuery, WebChartDataTransformations } from '@arcgis/charts-spec';
 import { DataInfo, QueryObject } from '../../../../utils';
 import { FetchDataProps } from '../../interfaces';
+/**
+ * Checks if the current transformation type (log | sqrt) is compatible with the dataset.
+ *
+ * @param dataTransformationType The transformation requested for the histogram
+ * @param min The min value from the data set
+ */
+declare function isDataCompatibleWithTransformation(dataTransformationType: WebChartDataTransformations | undefined, min: number): boolean;
+/**
+ * Create the bins for the original min and max value (Before applying the transformation).
+ *
+ * @param dataTransformationType The transformation requested for the histogram.
+ * @param min The min value from the data set.
+ */
+declare function createInvalidDataInfoForHistogram(dataTransformationType?: WebChartDataTransformations, dataCountIncompatible?: boolean): DataInfo;
+/**
+ *
+ * @param min Work around to reduce the decimal part by 1.
+ * @returns number
+ */
+declare function processMin(min: number): number;
 /**
  * Fetches the histogram data and proceed to the statistic calculations.
  * Returns information indicating whether the operation was a success and the data if so.
@@ -23,3 +43,9 @@ export declare function fetchHistogramSelectionData(props: {
     chartConfig: WebChart;
     x: string;
 }): Promise<DataInfo>;
+export declare const commonDataHistogramPrivateFunctions: {
+    processMin: typeof processMin;
+    isDataCompatibleWithTransformation: typeof isDataCompatibleWithTransformation;
+    createInvalidDataInfoForHistogram: typeof createInvalidDataInfoForHistogram;
+};
+export {};

package/dist/chart-rendering/common/data/index.d.ts

@@ -1,6 +1,15 @@
 import { IField, WebBoxPlot, WebChart, WebChartDataItem, WebChartQuery } from '@arcgis/charts-spec';
 import { AbortControllerKeyType, BinnedServerData, DataInfo, ErrorStrings, QueryObject } from '../../../utils';
 import { ChartOptions } from '../interfaces';
+declare function fetchFinishedDataWithFilterBySelection(props: {
+    queryObject?: QueryObject;
+    chartConfig: WebChart;
+    queryConfig: WebChartQuery;
+    currentSelectionDataItems?: WebChartDataItem[];
+    options?: ChartOptions;
+    errorStrings: ErrorStrings;
+    abortKey?: AbortControllerKeyType;
+}): Promise<DataInfo>;
 /**
  * Fetches a box plot data
  *
@@ -29,3 +38,7 @@ export declare function getData(props: {
     abortKey?: AbortControllerKeyType;
     fieldList?: IField[];
 }): Promise<DataInfo>;
+export declare const commonDataPrivateFunctions: {
+    fetchFinishedDataWithFilterBySelection: typeof fetchFinishedDataWithFilterBySelection;
+};
+export {};

package/dist/chart-rendering/common/data/scatter-plot/aggregation/index.d.ts

@@ -22,7 +22,7 @@ export declare function fetchAggregationDataStatistics(props: {
     abortKey?: AbortControllerKeyType;
 }): Promise<void>;
 /**
- * Fetches aggregated data for the scatter plot
+ * Fetches aggregated data for the scatterplot
  *
  * @param props.statsMap The Map already storing the common statistics
  * @param props.queryObject The query object (layer or layer view)

package/dist/chart-rendering/common/data/scatter-plot/trendline/index.d.ts

@@ -1,5 +1,15 @@
 import { WebChartDataItem } from '@arcgis/charts-spec';
 import { TrendlineDataProps } from './interfaces';
+/**
+ * Returns whether the supports computing the trendline information on the server.
+ * It is true when:
+ *   - the layer is not a feature collection (using client-side data)
+ *   - the query object is not a feature layer view
+ *   - the FS accepts query analytics
+ *
+ * @param props
+ */
+declare function isServerCalculationPossible(props: TrendlineDataProps): Promise<boolean>;
 /**
  * Uses a `linear` function to calculate the trendline data from the main series' data.
  *
@@ -20,3 +30,7 @@ export declare function getFinalTrendLineData(props: TrendlineDataProps): Promis
     r2: number;
     trendLinePoints: [WebChartDataItem, WebChartDataItem];
 }>;
+export declare const commonScatterplotTrendlinePrivateFunctions: {
+    isServerCalculationPossible: typeof isServerCalculationPossible;
+};
+export {};

package/dist/chart-rendering/common/data/selection/filter/index.d.ts

@@ -1,5 +1,6 @@
 import { WebChartDataItem } from '@arcgis/charts-spec';
 import { BuildSelectionFilterProps } from './interfaces';
+declare function buildSelectionFilterForAScatterplotElement(props: BuildSelectionFilterProps): string;
 /**
  * Builds a filter to be used by a query, based on a data context containing a date range provided as two timestamps.
  *
@@ -8,6 +9,16 @@ import { BuildSelectionFilterProps } from './interfaces';
  * @returns A filter as a string, usable to query
  */
 export declare function buildSelectionFilterForATimeBinningChartElement(xAxisField: string, dataContext: WebChartDataItem): string;
+/**
+ * The double fields can have a precision issue with the server.
+ * For instance if a value is equal to 4.73450600069336, a where clause set to `field=4.73450600069336` won't bring any result.
+ * The function tweaks the filter to bring back the expected results.
+ *
+ * @param xAxisValue
+ * @param xAxisField
+ * @returns
+ */
+declare function buildSelectionFilterForADoubleField(xAxisValue: number, xAxisField: string): string;
 /**
  * Builds a query filter for the box plot selection. It considers a specific data context from a box
  * by looking at the category, split-by and min/max values
@@ -23,6 +34,9 @@ export declare function buildSelectionFilterForATimeBinningChartElement(xAxisFie
  * @returns A string representing the filter
  */
 export declare function buildSelectionFilterForABoxPlotElement(props: BuildSelectionFilterProps): string;
+declare function buildSelectionFilterForABarOrLineElement(props: BuildSelectionFilterProps): string;
+declare function buildSelectionFilterForAPieChartElement(props: BuildSelectionFilterProps): string;
+declare function buildSelectionFilterForAHistogramElement(props: BuildSelectionFilterProps): string;
 /**
  * Builds a query filter for selection
  *
@@ -30,3 +44,11 @@ export declare function buildSelectionFilterForABoxPlotElement(props: BuildSelec
  * @returns
  */
 export declare function buildSelectionFilterForOneElement(props: BuildSelectionFilterProps): string;
+export declare const commonSelectionFilterPrivateFunctions: {
+    buildSelectionFilterForAScatterplotElement: typeof buildSelectionFilterForAScatterplotElement;
+    buildSelectionFilterForABarOrLineElement: typeof buildSelectionFilterForABarOrLineElement;
+    buildSelectionFilterForADoubleField: typeof buildSelectionFilterForADoubleField;
+    buildSelectionFilterForAHistogramElement: typeof buildSelectionFilterForAHistogramElement;
+    buildSelectionFilterForAPieChartElement: typeof buildSelectionFilterForAPieChartElement;
+};
+export {};

package/dist/chart-rendering/common/data/utils/misc/index.d.ts

@@ -1,5 +1,5 @@
 import { IExtent, IField, TimeIntervalInfo, ValueConversion, WebBoxPlot, WebChart, WebChartBin, WebChartDataItem, WebChartDataItemValue, WebChartDataTypes, WebChartSeriesType, WebGaugeChart, WebChartDataTransformations, WebChartSortOrderKinds } from '@arcgis/charts-spec';
-import { ChartElementLimit, SelectionIndexes } from '../../../../../utils';
+import { ChartElementLimit, SelectionIndexes, LimitBehavior } from '../../../../../utils';
 import { ChartOptions } from '../../../interfaces';
 import { DataUpdateNeededDetails } from './interfaces';
 /**
@@ -124,7 +124,7 @@ export declare function sanitizeData(props: {
     seriesConfig: WebChartSeriesType[];
 }): WebChartDataTypes | undefined;
 /**
- * A function to determine whether the scatter plot is aggregated.
+ * A function to determine whether the scatterplot is aggregated.
  * It can use a map of statistics containing the number of points (computed from the data side) or
  * a data context object usually stored within each marker.
  *
@@ -137,7 +137,7 @@ export declare function isScatterplotAggregated(props: {
 }): boolean;
 /**
  * A function to determine whether a chart is aggregated.
- * Supports scatter plot, bar chart and pie chart. Defaults to true for the other types of chart.
+ * Supports scatterplot, bar chart and pie chart. Defaults to true for the other types of chart.
  *
  * @param props
  */
@@ -180,6 +180,13 @@ export declare function convertMultipleNumericFieldsData(props: {
     y: string;
     fieldList?: IField[];
 }): WebChartDataItem[];
+/**
+ * Compares two gauge configs and indicates whether the series value conversion changed
+ *
+ * @param oldConfig The previous config
+ * @param newConfig The updated config
+ */
+declare function hasGaugeValueConversionChanged(oldConfig: WebChart, newConfig: WebChart): boolean;
 /**
  * Compares two configs and indicates whether the color type change
  *
@@ -198,6 +205,40 @@ export declare function hasSlicesConfigChanged(props: {
     oldConfig: WebChart;
     newConfig: WebChart;
 }): boolean;
+/**
+ * Compares the queries from two configs and indicates whether a query changed.  Noted that the query comparison
+ * includes the orderByFields from the orderOptions.
+ *
+ * A sort on the series is made before comparing to prevent a false positive on query reorder.
+ *
+ * @param props.oldConfig The former chart config
+ * @param props.newConfig The new chart config
+ * @param props.behaviorAfterLimit The chart's behavior once the data limit is reached
+ */
+declare function hasQueryChanged(props: {
+    oldConfig: WebChart;
+    newConfig: WebChart;
+    behaviorAfterLimit?: LimitBehavior;
+}): boolean;
+declare function hasFilterBySelectionChanged(filterBySelection?: boolean, options?: ChartOptions): boolean;
+declare function hasDataForFilterBySelectionChanged(props: {
+    currentSelectionOIDs?: number[];
+    options?: ChartOptions;
+}): boolean;
+/**
+ * Compares two config data filters and returns true if they are identical, false otherwise
+ *
+ * @param oldConfig
+ * @param newConfig
+ */
+declare function hasConfigFilterChanged(oldConfig: WebChart, newConfig: WebChart): boolean;
+/**
+ * Compares the `binTemporalData` property from two configs and returns true if they are identical, false otherwise
+ *
+ * @param oldConfig
+ * @param newConfig
+ */
+declare function hasBinTemporalDataChanged(oldConfig: WebChart, newConfig: WebChart): boolean;
 /**
  * Compares the split by value for each series element in the box plot config and returns true if the series has different split by value between new and old box plot config, false otherwise.
  *
@@ -212,6 +253,22 @@ export declare function hasSplitByValueChanged(oldSeries: WebChart["series"], ne
  * @param newSeries - The new series config
  */
 export declare function hasNumericFieldsChanged(oldSeries: WebChart["series"], newSeries: WebChart["series"]): boolean;
+/**
+ * Compares the `showMean` from two configs and indicates whether they are different
+ *
+ * @param oldConfig The former chart config
+ * @param newConfig The new chart config
+ */
+declare function hasShowMeanChanged(oldConfig: WebBoxPlot | WebChart, newConfig: WebBoxPlot | WebChart): boolean;
+/**
+ * Indicates whether a change of value format type requires new data. Two cases require it:
+ * - change from date format to numeric format
+ * - specific to non aggregated charts: change from category format to value format
+ *
+ * @param oldConfig The former chart config
+ * @param newConfig The new chart config
+ */
+declare function isNewDataRequiredForValueFormatChange(oldConfig: WebBoxPlot | WebChart, newConfig: WebBoxPlot | WebChart): boolean;
 /**
  * Function saying if a data update is needed. We compare different properties from the former config and the new one
  * in order to decide if the update is needed.
@@ -251,6 +308,23 @@ export declare function isBinnedServerDataResetNeeded(dataUpdateNeededDetails: D
  * @param fieldToCheckForValue to field containing the values
  */
 export declare function checkForSupportedPieChart(data: WebChartDataItem[], fieldToCheckForValue: string): boolean;
+/**
+ * Calculates the limit for a given chart, considering a limit on the number of series and a limit
+ * on the total number of elements on the chart.
+ * For instance:
+ * - if count total is 1,000, count per series is 100 and there are 5 series, the limit is 500
+ * - if count total is 1,000, count per series is 100 and there are 20 series, the limit is 1,000
+ *
+ * @param props.countTotal The number max of elements for the whole chart
+ * @param props.countPerSeries The number max of elements per series
+ * @param props.numberOfSeries The number of series
+ * @returns
+ */
+declare function getMultiSeriesLimit(props: {
+    countTotal?: number;
+    countPerSeries?: number;
+    numberOfSeries: number;
+}): number | undefined;
 /**
  * Calculates the maximum number of features to fetch according to the runtime chart options 'chartLimits'.
  * For instance:
@@ -270,6 +344,15 @@ export declare function getMaximumNumberOfFeaturesToFetch(chartConfig: WebChart
  * @returns The converted value, or the original value if the `valueConversion` is undefined or invalid
  */
 export declare function applyValueConversion(value: number, valueConversion?: ValueConversion): number;
+/**
+ * Check if an input string represents a percentage value; meaning a string that:
+ * - only contains digits (dot for decimal included), and
+ * - has % symbol at the end (for LTR) or at the beginning (for RTL)
+ * - the value falls between 0 - 100
+ *
+ * @param inputValue input string
+ */
+declare function isValidPercentValue(inputValue: string): boolean;
 /**
  * Extract the value from the input string, without the %; valid percent value is between 0 - 100
  * it's safe that we extract upto 3 digits and not worry about having an invalid number like 100.5
@@ -278,3 +361,16 @@ export declare function applyValueConversion(value: number, valueConversion?: Va
  * @returns
  */
 export declare function extractPercentValue(inputValue: string): number | undefined;
+export declare const commonUtilsMiscPrivateFunctions: {
+    getMultiSeriesLimit: typeof getMultiSeriesLimit;
+    hasFilterBySelectionChanged: typeof hasFilterBySelectionChanged;
+    hasConfigFilterChanged: typeof hasConfigFilterChanged;
+    hasBinTemporalDataChanged: typeof hasBinTemporalDataChanged;
+    hasGaugeValueConversionChanged: typeof hasGaugeValueConversionChanged;
+    isNewDataRequiredForValueFormatChange: typeof isNewDataRequiredForValueFormatChange;
+    hasShowMeanChanged: typeof hasShowMeanChanged;
+    hasDataForFilterBySelectionChanged: typeof hasDataForFilterBySelectionChanged;
+    hasQueryChanged: typeof hasQueryChanged;
+    isValidPercentValue: typeof isValidPercentValue;
+};
+export {};

package/dist/chart-rendering/common/data/utils/query-parser/index.d.ts

@@ -1,7 +1,36 @@
-import { TimeIntervalInfo, WebBoxPlot, WebChart, WebChartQuery } from '@arcgis/charts-spec';
-import { QueryObject } from '../../../../../utils';
+import { TimeIntervalInfo, WebBoxPlot, WebChart, WebChartQuery, WebChartTemporalBinningTypes } from '@arcgis/charts-spec';
+import { QueryObject, ChartSubType } from '../../../../../utils';
 import { ChartOptions } from '../../../interfaces';
 import { UniqueQuery } from './interfaces';
+/**
+ * Modifies the input `WebChartQuery` by assigning a default value for its `outStatisticFieldName`.
+ *
+ * When the statisticType is `WebChartStatisticType.DiscretePercentile` or `WebChartStatisticType.ContinuousPercentile,
+ * if the query is for a time binning series, this function will delete the `statisticParameters` object and
+ * resets the `statisticType` to Count regardless; otherwise it adds the statisticParameters and/or assigns
+ * a default value to the `outStatistics` properties of the query if `statisticParameters` is not present.
+ *
+ * Notes: outStatistics should only be modified through this function
+ *
+ * @param props.uniqueQuery The WebChartQuery to modify
+ * @param props.y The y field
+ * @param props.useGenericOutStatFieldName Whether to use a generic stat field over the y field
+ * @param props.queryObject  The query object (layer or feature layer view)
+ * @param props.chartSubType The chart sub type
+ * @param props.isTimeBinningSeries Whether the chart is using time binning
+ * @param props.temporalBinningType The temporal binning type
+ * @param props.returnFeaturesExtent Whether the features extent need to be fetched by the query
+ */
+declare function modifyOutStatistics(props: {
+    uniqueQuery: WebChartQuery;
+    y?: string[] | string;
+    useGenericOutStatFieldName: boolean;
+    queryObject?: QueryObject;
+    chartSubType: ChartSubType;
+    isTimeBinningSeries: boolean;
+    temporalBinningType?: WebChartTemporalBinningTypes;
+    returnFeaturesExtent?: boolean;
+}): void;
 /**
  * Handles the limitation of features on the chart (when the chart limits are reached but the requested behavior is to render up to the limit).
  * See https://devtopia.esri.com/WebGIS/arcgis-charts/issues/5126
@@ -36,3 +65,7 @@ export declare function buildUniqueQuery(props: {
     setTimeBinningInfoWhenNotProvided?: boolean;
     fetchFullBoxPlotData?: boolean;
 }): Promise<UniqueQuery>;
+export declare const commonUtilsQueryParserPrivateFunctions: {
+    modifyOutStatistics: typeof modifyOutStatistics;
+};
+export {};

package/dist/chart-rendering/common/data/utils/summarize-data/index.d.ts

@@ -1,7 +1,36 @@
-import { IField, WebChart, WebChartDataItem, WebChartQuery } from '@arcgis/charts-spec';
-import { DataInfo, QueryObject, LimitBehavior } from '../../../../../utils';
+import { IExtent, IField, IStatisticDefinition, WebChart, WebChartBarChartSeries, WebChartBoxPlotSeries, WebChartDataItem, WebChartDataItemValue, WebChartLineChartSeries, WebChartPieChartSeries, WebChartQuery, WebChartSeriesType } from '@arcgis/charts-spec';
+import { default as Graphic } from '@arcgis/core/Graphic';
+import { DataInfo, QueryObject, ChartSubType, LimitBehavior } from '../../../../../utils';
 import { FetchDataProps } from '../../../interfaces';
 import { ProcessUniqueQueryProps } from './interfaces';
+/**
+ * Returns the feature extent and the extent key for a feature.
+ *
+ * @param props.feature The feature to fetch the extent from
+ * @param props.splitByField The split-by field from the config
+ * @param props.chartSubType The chart subtype
+ * @returns
+ */
+declare function getFeatureGeometryExtent(props: {
+    feature: Graphic;
+    splitByField?: string;
+    chartSubType?: ChartSubType;
+}): {
+    featureExtent: IExtent | undefined;
+    featureExtentKey: string;
+};
+/**
+ * Regroups all the data items related to a same category together.
+ *
+ * @param props.input The scattered list of data items
+ * @param props.x The category field used to group the data
+ * @param props.splitByField The split-by field from the config
+ */
+declare function mergeDataItems(props: {
+    input: WebChartDataItem[];
+    x: string;
+    splitByField?: string;
+}): WebChartDataItem;
 /**
  * Group a dataset over a x field
  *
@@ -18,6 +47,23 @@ export declare function groupDataByCategory(props: {
     x: string;
     splitByField?: string;
 }): WebChartDataItem[];
+/**
+ * Calculates for each data item (category) for bar and line:
+ *   - the category's sum
+ *   - the percent for the first series
+ *
+ * @param data The chart's data
+ * @param seriesConfig The series config
+ * @returns
+ */
+declare function calculateSeriesPercent(data: WebChartDataItem[], seriesConfig: WebChartBarChartSeries[] | WebChartBoxPlotSeries[] | WebChartLineChartSeries[] | WebChartPieChartSeries[]): WebChartDataItem[];
+/**
+ * Calculate the Interquartile Range (IQR) for the given attributes and return the processed attributes objects with calculated IQR property .
+ *   IQR is the difference between the first quartile and the third quartile.
+ *   `@param` {WebChartBoxPlotSeries[]} seriesConfig - The list of series in the box plot chart config
+ *   `@param` {WebChartDataItem} attributes - The data object containing the first and third quartile values.
+ */
+declare function calculateInterQuartileRange(seriesConfig: WebChartBoxPlotSeries[], attributes: WebChartDataItem): WebChartDataItem;
 /**
  * Assigns the specified property to a best-guessed value from the query results.
  * If its upper-cased or lowercased corresponding properties (that are not coming from the config) exist, remove them as well.
@@ -26,6 +72,80 @@ export declare function groupDataByCategory(props: {
  * @param propertyNames The properties referencing the proper case
  */
 export declare function restoreAttributesCase(attributes: WebChartDataItem, propertyNames: (string | undefined)[] | string): void;
+/**
+ * Builds a list of the outStatisticFieldName used in the config and restore their case to prevent a shift between
+ * the query results' case and the config's.
+ * See issues:
+ * - https://devtopia.esri.com/webgis/arcgis-charts/issues/6038
+ * - https://devtopia.esri.com/WebGIS/arcgis-charts/issues/7837
+ *
+ * @param attributes The attributes associated with a feature returned from the query result
+ * @param seriesConfig The series config
+ */
+declare function restoreStatFieldNamesCase(attributes: WebChartDataItem, seriesConfig: WebChartSeriesType[]): void;
+/**
+ * This function goes through the properties of the dataItem and compare them with the outStatisticFieldNames
+ * in the list of outStatistics. If a match is found, swap that property to its corresponding onStatisticField
+ * property instead.
+ *
+ * Refer to issue https://devtopia.esri.com/webgis/arcgis-charts/issues/6018 for details
+ *
+ * @param dataItem The dataItem of which properties may change.
+ * @param outStatistics The list of outStatistics to find the matching onStatisticFields for the properties in the dataItem.
+ */
+declare function swapStatFieldNamesToStatisticFields(dataItem: WebChartDataItem, outStatistics: IStatisticDefinition[]): WebChartDataItem;
+/**
+ * Since the series's dataFields.valueY was set to `${y}_${splitByValue},
+ * we need to add a new property to the dataItem using that format and populate it with the value from to the y property.
+ *
+ * @param props.dataItem The dataItem of which properties are to be manipulated.
+ * @param props.splitByField The split-by-field
+ * @param props.y The y property for all series.
+ */
+declare function renameYFieldForSplitByNoAggregation(props: {
+    dataItem: WebChartDataItem;
+    splitByField: string;
+    y: string;
+}): void;
+/**
+ * Removes a prefix added to the box plot out statistic field names by `buildUniqueBoxPlotOutStatistics()`.
+ * The prefix was added to avoid the queries to fail on some specific services. Refer to https://devtopia.esri.com/WebGIS/arcgis-charts/issues/7376
+ *
+ * @param attributes The attributes to be modified
+ * @param y The numeric field name used as a prefix
+ */
+declare function removeBoxPlotOutStatisticFieldNamePrefix(attributes: WebChartDataItem, y: string): void;
+/**
+ * Trims the number of categories based on the provided `maxCategoryCount`. This is possible only for charts having
+ * a query response for which each result is a category. If a result contains potentially multiple categories it will
+ * be handled by the `limitCategories()` function.
+ *
+ * @param props.queryResponse The query response to be trimmed
+ * @param props.chartConfig The chart configuration
+ * @param props.maxCategoryCount The maximum number of categories to keep
+ */
+declare function trimCategories(props: {
+    queryResponse: Graphic[];
+    chartConfig: WebChart;
+    maxCategoryCount?: number;
+}): Graphic[];
+/**
+ * Limits the number of categories based on the provided `maxCategoryCount`.
+ * This function is called for each data item and will decide whether to keep the item or not.
+ *
+ * @param props.attributes The attributes to be checked
+ * @param props.uniqueCategoryList The list of unique categories to keep track of how many categories have been processed
+ * @param props.maxCategoryCount The maximum number of categories to keep
+ * @param props.x The x field
+ * @param props.chartSubType The chart sub-type
+ */
+declare function limitCategories(props: {
+    attributes: WebChartDataItem;
+    uniqueCategoryList: Set<WebChartDataItemValue>;
+    maxCategoryCount?: number;
+    x: string;
+    chartSubType: ChartSubType;
+}): boolean;
 /**
  * Function executing a unique query and processing its results.
  *
@@ -97,3 +217,16 @@ export declare function fetchFinishedGenericChartSelectionData(props: FetchDataP
  * @param props.abortKey The abort key to cancel queries
  */
 export declare function fetchFinishedBoxPlotSelectionData(props: FetchDataProps): Promise<DataInfo>;
+export declare const commonUtilsSummarizeDataPrivateFunctions: {
+    restoreStatFieldNamesCase: typeof restoreStatFieldNamesCase;
+    mergeDataItems: typeof mergeDataItems;
+    removeBoxPlotOutStatisticFieldNamePrefix: typeof removeBoxPlotOutStatisticFieldNamePrefix;
+    calculateSeriesPercent: typeof calculateSeriesPercent;
+    calculateInterQuartileRange: typeof calculateInterQuartileRange;
+    getFeatureGeometryExtent: typeof getFeatureGeometryExtent;
+    swapStatFieldNamesToStatisticFields: typeof swapStatFieldNamesToStatisticFields;
+    renameYFieldForSplitByNoAggregation: typeof renameYFieldForSplitByNoAggregation;
+    trimCategories: typeof trimCategories;
+    limitCategories: typeof limitCategories;
+};
+export {};

package/dist/chart-rendering/common/events/index.d.ts

@@ -2,7 +2,7 @@ import { DataWarningObject, PieSlicesSymbols, SelectionData, SeriesSymbolsMap, V
 import { CalculatedMinMaxBoundsPayload, LegendItemVisibility, WebChart, WebChartDataItem, WebChartDataTypes, WebChartSeriesType } from '@arcgis/charts-spec';
 /**
  * Sending an event carrying the chart processed data at any data update.
- * Contains the statistics for Histogram and Scatter Plot
+ * Contains the statistics for Histogram and Scatterplot
  *
  * @param props.data The data payload
  * @param props.seriesConfig The array of series config

package/dist/chart-rendering/common/interfaces.d.ts

@@ -83,7 +83,7 @@ export type PieChartLabelFormatCallback = (category: string, value?: number, per
 export type PieChartLegendValueLabelFormatCallback = (value?: number, percent?: number) => string;
 /** Describes the signature of the callback function used to customize the histogram tooltips */
 export type HistogramLabelFormatCallback = (count: number, binMinValue: number, binMaxValue: number) => string;
-/** Describes the signature of the callback function used to customize the scatter plot tooltips */
+/** Describes the signature of the callback function used to customize the scatterplot tooltips */
 export type ScatterplotLabelFormatCallback = (x: number, y: number, sizePolicyValue?: number) => string;
 export interface BarAndLineTooltipFormatCallbackProps {
     seriesName: string;
@@ -249,7 +249,7 @@ export interface ChartOptions {
     /**
      * Used to customize the chart's limits, especially the maximum number of elements (bars, markers...) to be displayed.
      * The chart's behavior once that limit is reached can be adjusted through the `behaviorAfterLimit` nested property, to either reject the creation
-     * or update of the chart, or render the elements up to the given limits. Available on all charts but scatter plot and histogram.
+     * or update of the chart, or render the elements up to the given limits. Available on all charts but scatterplot and histogram.
      */
     chartLimits?: ChartElementLimit;
     /**