@arcgis/charts-components 4.34.0-next.9 → 4.34.0-next.90

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

@@ -1,6 +1,26 @@
+import { WebChart, WebChartQuery, WebChartDataTransformations } from '@arcgis/charts-spec';
 import { DataInfo, QueryObject } from '../../../../utils';
-import { WebChart, WebChartQuery } from '@arcgis/charts-spec';
 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

@@ -1,8 +1,7 @@
 import { WebChart, WebChartQuery } from '@arcgis/charts-spec';
 import { default as Graphic } from '@arcgis/core/Graphic';
 import { default as AttributeBinsFeatureSet } from '@arcgis/core/rest/support/AttributeBinsFeatureSet.js';
-import { ErrorStrings } from '../../../../../assets/t9n/utils/interfaces';
-import { AbortControllerKeyType, QueryObject } from '../../../../../utils';
+import { AbortControllerKeyType, ErrorStrings, QueryObject } from '../../../../../utils';
 import { ChartOptions } from '../../../interfaces';
 /**
  * Fetches some additional statistics needed for the aggregation feature.
@@ -23,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/aggregation/interfaces.d.ts

@@ -1 +1 @@
-export declare const groupByWhenCaseForScatterplotAggregation = "${ groupByFieldsForStatistics } WHEN (${ y } ${ yMinOperand } ${ yValue } AND ${ y } ${ yMaxOperand } ${ yValuePlusStep } AND ${ x } ${ xMinOperand } ${ xValue } AND ${ x } ${ xMaxOperand } ${ xValuePlusStep }) THEN '${ xValue }|${ xValuePlusStep}|${ yValue }|${ yValuePlusStep }'";
+export declare const groupByWhenCaseForScatterplotAggregation = "{ groupByFieldsForStatistics } WHEN ({ y } { yMinOperand } { yValue } AND { y } { yMaxOperand } { yValuePlusStep } AND { x } { xMinOperand } { xValue } AND { x } { xMaxOperand } { xValuePlusStep }) THEN '{ xValue }|{ xValuePlusStep}|{ yValue }|{ yValuePlusStep }'";

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 { WebChartDataItem, WebChartDataItemValue, RESTFieldType } 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,31 @@ 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;
+/**
+ * Builds a selection filter for a heat chart element, considering the associated axis uses a calendar date parts binning.
+ * @param props.field The field used by the heat chart
+ * @param props.fieldType The field type
+ * @param props.fieldValue The value of the field
+ * @param props.unit The unit of the temporal binning
+ */
+declare function getHeatChartFilterForCalendarParts(props: {
+    field: string;
+    fieldType?: RESTFieldType;
+    fieldValue: WebChartDataItemValue;
+    unit?: string;
+}): string | undefined;
+/**
+ * Builds a selection filter for a heat chart element.
+ * It considers the different axes value format types to know how to build the filter.
+ * @param props.xAxisFieldType The x-axis field type
+ * @param props.yAxisFieldType The y-axis field type
+ * @param props.dataContext The data context containing the x and y values
+ * @param props.chartConfig The chart configuration
+ */
+declare function buildSelectionFilterForAHeatChartElement(props: BuildSelectionFilterProps): string;
+declare function buildSelectionFilterForAHistogramElement(props: BuildSelectionFilterProps): string;
 /**
  * Builds a query filter for selection
  *
@@ -30,3 +66,13 @@ export declare function buildSelectionFilterForABoxPlotElement(props: BuildSelec
  * @returns
  */
 export declare function buildSelectionFilterForOneElement(props: BuildSelectionFilterProps): string;
+export declare const commonSelectionFilterPrivateFunctions: {
+    getHeatChartFilterForCalendarParts: typeof getHeatChartFilterForCalendarParts;
+    buildSelectionFilterForAHeatChartElement: typeof buildSelectionFilterForAHeatChartElement;
+    buildSelectionFilterForAScatterplotElement: typeof buildSelectionFilterForAScatterplotElement;
+    buildSelectionFilterForABarOrLineElement: typeof buildSelectionFilterForABarOrLineElement;
+    buildSelectionFilterForADoubleField: typeof buildSelectionFilterForADoubleField;
+    buildSelectionFilterForAHistogramElement: typeof buildSelectionFilterForAHistogramElement;
+    buildSelectionFilterForAPieChartElement: typeof buildSelectionFilterForAPieChartElement;
+};
+export {};

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

@@ -1,5 +1,5 @@
-import { RESTFieldType, WebChartDataItem, WebChartDataTransformations, WebChartTypes } from '@arcgis/charts-spec';
-import { AbortControllerKeyType, ChartSubType } from '../../../../../utils';
+import { RESTFieldType, WebChart, WebChartDataItem } from '@arcgis/charts-spec';
+import { AbortControllerKeyType } from '../../../../../utils';
 import { ChartOptions } from '../../../interfaces';
 export declare const States: {
     readonly CustomActive: "custom-active";
@@ -11,17 +11,14 @@ export interface SelectionProps {
     xAxisField: string;
     yAxisField?: string;
     splitBy?: string;
-    dataTransformationType?: WebChartDataTransformations;
-    chartType?: WebChartTypes;
+    chartConfig: WebChart;
 }
 export interface BuildSelectionFilterProps extends SelectionProps {
     dataContext: WebChartDataItem;
+    xAxisFieldType?: RESTFieldType;
+    yAxisFieldType?: RESTFieldType;
     options?: ChartOptions;
     abortKey?: AbortControllerKeyType;
-    isDateAxis: boolean;
-    xAxisFieldType?: RESTFieldType;
-    chartSubType: ChartSubType;
-    showOutliers?: boolean;
 }
 export interface ElementSelectionCommonProps extends SelectionProps {
     elementDataContext?: WebChartDataItem;

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.
  *
@@ -72,6 +192,12 @@ export declare function sortFetchedData(props: {
  * @param props
  */
 export declare function fetchFinishedGenericChartData(props: FetchDataProps): Promise<DataInfo>;
+/**
+ * Fetching the data for a heat chart.
+ * It fetches the data from the attribute bins and processes it to match the heat chart data structure.
+ * @param props The list of properties required to fetch the data
+ */
+export declare function fetchFinishedHeatChartData(props: FetchDataProps): Promise<DataInfo>;
 /**
  * Fetching the data for specifically a line chart using time binning options.
  *
@@ -97,3 +223,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/data/utils/summarize-data/time-binning/index.d.ts

@@ -31,6 +31,7 @@ export declare function getTimeBinningStatistics(props: {
  * @param props.nullPolicy The null policy
  * @param props.x The series x field
  * @param props.y The series y field
+ * @param props.queryObject The query object used to fetch the data
  */
 export declare function mapTemporalBinningQueryAttributeBinsResults(props: {
     queryResults: __esri.AttributeBinsGraphic[];
@@ -39,7 +40,8 @@ export declare function mapTemporalBinningQueryAttributeBinsResults(props: {
     nullPolicy?: WebChartNullPolicyTypes;
     x: string;
     y?: string;
-}): WebChartDataItem[];
+    queryObject?: QueryObject;
+}): Promise<WebChartDataItem[]>;
 /**
  * Maps query results into a WebChartDataItem[] for a chart using the charts solution for temporal binning.
  * @param props.queryObject The object to query (layer or feature layer view)

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

@@ -209,6 +209,8 @@ export interface CommonChartDefaults {
     generalFontSize: number;
     chartEllipsis: string;
     backgroundColor: Readonly<EsriColor>;
+    lightTextColor: Readonly<EsriColor>;
+    darkTextColor: Readonly<EsriColor>;
     /** Note: Gauge has its own default value. See `gaugeMinGridDistance` */
     xAxisMinGridDistance: number;
     xCategoryAxisMinGridDistance: number;
@@ -289,6 +291,8 @@ export interface CommonChartDefaults {
     options: {
         /** represents default value to use for when `hideEmptySeries` is not defined in the `options` object. */
         hideEmptySeries: boolean;
+        /** indicates whether to automatically inverse the data label text color when it's too dark or too light */
+        autoInverseDataLabelTextColor: boolean;
         /** represents default value to use for when `replaceNoValueCategoryWithZero` is not defined in the `options` object. */
         replaceNoValueCategoryWithZero: boolean;
     };

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