@arcgis/charts-components 4.34.0-next.14 → 4.34.0-next.140

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

@@ -1,5 +1,5 @@
 import { QueryObject } from '../../../../../utils';
-import { WebChart, WebChartDataItem, WebChartQuery } from '@arcgis/charts-spec';
+import { WebChart, WebChartDataItem, WebChartQuery } from '../../../../../spec';
 import { ChartOptions } from '../../../interfaces';
 export interface TrendlineDataProps {
     data?: WebChartDataItem[];

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 '../../../../../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 '../../../../../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/selection/index.d.ts

@@ -1,4 +1,4 @@
-import { WebChart, WebChartDataItem } from '@arcgis/charts-spec';
+import { WebChart, WebChartDataItem } from '../../../../spec';
 import { ChartOptions } from '../../interfaces';
 /**
  * Function comparing two array containing selection items.
@@ -6,11 +6,17 @@ import { ChartOptions } from '../../interfaces';
  * @param props.itemsA First array
  * @param props.itemsB Second array
  * @param props.isPieFromFields Flag to indicate if the chart is a pie chart from fields
+ * @param props.x The x-axis field. Currently only used for a specific case related to the heat chart
+ * @param props.y The y-axis field. Currently only used for a specific case related to the heat chart
+ * @param props.outStatisticFieldName The out statistic field name. Currently only used for a specific case related to the heat chart
  */
 export declare function hasSelectionByItemsChanged(props: {
     itemsA?: WebChartDataItem[];
     itemsB?: WebChartDataItem[];
     isPieFromFields?: boolean;
+    x?: string;
+    y?: string;
+    outStatisticFieldName?: string;
 }): boolean;
 export declare function getSelectedData(props: {
     chartConfig: WebChart;

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

@@ -1,4 +1,4 @@
-import { WebChart, WebChartDataItem } from '@arcgis/charts-spec';
+import { WebChart, WebChartDataItem } from '../../../../../spec';
 import { CompleteDataWithMissingCategoriesProps } from './interfaces';
 /**
  * Completes a chart data by adding all the unique values not already in the array

package/dist/chart-rendering/common/data/utils/categorical-data/interfaces.d.ts

@@ -1,5 +1,5 @@
 import { QueryObject, AbortControllerKeyType, LimitBehavior } from '../../../../../utils';
-import { WebChartDataItem, WebChart, WebChartQuery } from '@arcgis/charts-spec';
+import { WebChartDataItem, WebChart, WebChartQuery } from '../../../../../spec';
 export interface CompleteDataWithMissingCategoriesProps {
     seriesData: WebChartDataItem[];
     chartConfig: WebChart;

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 { IExtent, IField, TimeIntervalInfo, ValueConversion, WebBoxPlot, WebChart, WebChartBin, WebChartDataItem, WebChartDataItemValue, WebChartDataTypes, WebChartSeriesType, WebGaugeChart, WebChartDataTransformations, WebChartSortOrderKinds } from '../../../../../spec';
+import { ChartElementLimit, SelectionIndexes, LimitBehavior } from '../../../../../utils';
 import { ChartOptions } from '../../../interfaces';
 import { DataUpdateNeededDetails } from './interfaces';
 /**
@@ -23,6 +23,7 @@ export declare function mergeExtents(extentList?: IExtent[]): IExtent | undefine
  * @param props.specificField A specific field to look for
  * @param props.preferLabel Whether to use field label instead of value
  * @param props.keepNullValues Whether to keep the null values
+ * @param props.config The chart's config
  */
 export declare function getXAxisValueFromContext(props: {
     value: Date | number | string;
@@ -31,6 +32,7 @@ export declare function getXAxisValueFromContext(props: {
     specificField?: string;
     preferLabel?: boolean;
     keepNullValues?: boolean;
+    config?: WebChart;
 }): Date | number | string;
 /**
  * Looks for the original x value in the data context. Chooses by order of priority:
@@ -124,7 +126,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 +139,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 +182,20 @@ 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 heat chart configs to see if binning has changed
+ *
+ * @param oldConfig The previous config
+ * @param newConfig The updated config
+ */
+declare function hasHeatChartBinningChanged(oldConfig: WebChart, newConfig: WebChart): boolean;
 /**
  * Compares two configs and indicates whether the color type change
  *
@@ -187,6 +203,20 @@ export declare function convertMultipleNumericFieldsData(props: {
  * @param newConfig The updated config
  */
 export declare function hasColorMatchChanged(oldConfig: WebChart, newConfig: WebChart): boolean;
+/**
+ * Compares two configs and indicates whether the legend visibilty changed
+ *
+ * @param oldConfig The previous config
+ * @param newConfig The updated config
+ */
+export declare function hasHeatLegendConfigChanged(oldConfig: WebChart, newConfig: WebChart): boolean;
+/**
+ * Compares two configs and indicates whether the gradient rules changed
+ *
+ * @param oldConfig The previous config
+ * @param newConfig The updated config
+ */
+export declare function hasGradientRulesChanged(oldConfig: WebChart, newConfig: WebChart): boolean;
 /**
  * Compares the 'slices' array from the pie series, and indicates whether they are different.
  * Compare only the slices id and label to avoid false positives.
@@ -198,6 +228,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;
+export 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 +276,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 +331,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 +367,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 +384,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;
+    hasHeatChartBinningChanged: typeof hasHeatChartBinningChanged;
+    hasQueryChanged: typeof hasQueryChanged;
+    isValidPercentValue: typeof isValidPercentValue;
+};
+export {};

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

@@ -21,4 +21,7 @@ export interface DataUpdateNeededDetails {
     boxPlot: {
         showMeanChanged: boolean;
     };
+    heatChart: {
+        binningChanged: boolean;
+    };
 }

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 } from '../../../../../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.returnFeaturesExtent Whether the features extent need to be fetched by the query
+ * @param props.splitByField The split-by field
+ */
+declare function modifyOutStatistics(props: {
+    uniqueQuery: WebChartQuery;
+    y?: string[] | string;
+    useGenericOutStatFieldName: boolean;
+    queryObject?: QueryObject;
+    chartSubType: ChartSubType;
+    isTimeBinningSeries: boolean;
+    returnFeaturesExtent?: boolean;
+    splitByField?: string;
+}): 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/query-parser/interfaces.d.ts

@@ -1,4 +1,4 @@
-import { WebChartQuery, IStatisticDefinition } from '@arcgis/charts-spec';
+import { WebChartQuery, IStatisticDefinition } from '../../../../../spec';
 export interface UniqueQuery {
     uniqueQuery: WebChartQuery;
     mapToStatField: Map<number | string | null, string>;

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

@@ -1,2 +1,2 @@
-import { WebChartTemporalBinningUnits } from '@arcgis/charts-spec';
+import { WebChartTemporalBinningUnits } from '../../../../../../spec';
 export declare function getTimeBinGroupByFieldsForStatistics(dateFieldName: string, unit: WebChartTemporalBinningUnits): string[];

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

@@ -1,4 +1,4 @@
-import { WebChartDataItemValue } from '@arcgis/charts-spec';
+import { WebChartDataItemValue } from '../../../../../spec';
 /**
  * Transform a couple key/value to where clause equivalent to 'key = value'.
  * It adds quotes around the value if it's not detected as a number.

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

@@ -1,13 +1,6 @@
-import { WebChart, WebChartDataItem, WebChartDataTypes, WebChartQuery } from '@arcgis/charts-spec';
+import { WebChart, WebChartDataItem, WebChartDataTypes, WebChartQuery } from '../../../../../spec';
 import { ErrorStrings, QueryObject } from '../../../../../utils';
 import { ChartOptions } from '../../../interfaces';
-/**
- * Builds a where clause following the pattern `<OID field> in (<list_of_OIDs>)`
- *
- * @param fieldOID
- * @param listOIDs
- */
-export declare function joinOIDs(fieldOID: string, listOIDs?: number[]): string | undefined;
 /**
  * Fetches data from a list of OIDs. If the chart is non aggregated we directly read the OIDs stored in the data context,
  * and if the chart is aggregated we perform queries to fetch the data.

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 { FetchDataProps } from '../../../interfaces';
+import { default as Graphic } from '@arcgis/core/Graphic';
+import { IExtent, IField, IStatisticDefinition, WebChart, WebChartBarChartSeries, WebChartBoxPlotSeries, WebChartCalendarDatePartsUnits, WebChartDataItem, WebChartDataItemValue, WebChartLineChartSeries, WebChartPieChartSeries, WebChartQuery, WebChartSeriesType } from '../../../../../spec';
+import { DataInfo, QueryObject, ChartSubType, LimitBehavior } from '../../../../../utils';
+import { ChartOptions, 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
+ */
+export 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,29 @@ export declare function sortFetchedData(props: {
  * @param props
  */
 export declare function fetchFinishedGenericChartData(props: FetchDataProps): Promise<DataInfo>;
+/**
+ * Generates an array of values based on the given unit
+ * @param unit The unit used to generate the values to return
+ * @returns an array of string values, from "1" to the maximum value of the unit (e.g. "12" for MonthOfYear)
+ */
+declare function getExpectedValuesFromDatePartsUnit(unit: WebChartCalendarDatePartsUnits): string[] | undefined;
+/**
+ * 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>;
+/**
+ * Function trimming the temporal dataset by considering the rendering limits.
+ * @param props.chartConfig The chart's config
+ * @param props.options The chart's options
+ * @param props.data The data to trim
+ */
+declare function trimTemporalDataset(props: {
+    chartConfig: WebChart;
+    options?: ChartOptions;
+    data: WebChartDataItem[];
+}): WebChartDataItem[];
 /**
  * Fetching the data for specifically a line chart using time binning options.
  *
@@ -97,3 +240,18 @@ 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;
+    getExpectedValuesFromDatePartsUnit: typeof getExpectedValuesFromDatePartsUnit;
+    trimTemporalDataset: typeof trimTemporalDataset;
+};
+export {};

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

@@ -1,4 +1,4 @@
-import { WebChartDataItemValue, WebChartDataItem, WebChartQuery, WebChart, IStatisticDefinition } from '@arcgis/charts-spec';
+import { WebChartDataItemValue, WebChartDataItem, WebChartQuery, WebChart, IStatisticDefinition } from '../../../../../spec';
 import { QueryObject, AbortControllerKeyType, ChartElementLimit, ChartSubType } from '../../../../../utils';
 export interface SummarizeDataProps {
     data: [WebChartDataItemValue, WebChartDataItem[]][];