@arcgis/charts-components 4.34.0-next.11 → 4.34.0-next.111

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';
 /**
@@ -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,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
  *
@@ -198,6 +212,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 +260,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 +315,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 +351,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 +368,17 @@ 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;
+    hasDataForFilterBySelectionChanged: typeof hasDataForFilterBySelectionChanged;
+    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, WebChartTemporalBinningTypes } 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.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/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 { IExtent, IField, IStatisticDefinition, WebChart, WebChartBarChartSeries, WebChartBoxPlotSeries, WebChartDataItem, WebChartDataItemValue, WebChartLineChartSeries, WebChartPieChartSeries, WebChartQuery, WebChartSeriesType } from '../../../../../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/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[]][];

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

@@ -1,5 +1,5 @@
 /// <reference types="@arcgis/core/interfaces.d.ts" />
-import { TimeIntervalInfo, WebChart, WebChartDataItem, WebChartQuery, WebChartSeriesType, WebChartNullPolicyTypes, WebChartTemporalBinningUnits } from '@arcgis/charts-spec';
+import { TimeIntervalInfo, WebChart, WebChartDataItem, WebChartQuery, WebChartSeriesType, WebChartNullPolicyTypes, WebChartTemporalBinningUnits } from '../../../../../../spec';
 import { DateRange, QueryObject, TimeBinningStatistics, WebChartSeriesSupportingTemporalBinning } from '../../../../../../utils';
 /**
  * Given `getNumberOfBinsWithinDataRange()` returns a diff in days for weeks, months and years, we need
@@ -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

@@ -1,4 +1,4 @@
-import { Color, ISimpleFillSymbol, WebChartCursorCrosshair, WebChartDataItem, WebChartPieChartGroupSlice, RESTHorizontalAlignment, RESTSimpleMarkerSymbolStyle, RESTVerticalAlignment, WebChartLegendPositions, WebChartLineSmoothedKinds, WebChartSortOrderKinds, WebChartStackedKinds } from '@arcgis/charts-spec';
+import { Color, ISimpleFillSymbol, WebChartCursorCrosshair, WebChartDataItem, WebChartPieChartGroupSlice, RESTHorizontalAlignment, RESTSimpleMarkerSymbolStyle, RESTVerticalAlignment, WebChartLegendPositions, WebChartLineSmoothedKinds, WebChartSortOrderKinds, WebChartStackedKinds } from '../../../spec';
 import { SelectionTheme, ActionModes } from '../../../utils';
 import { EsriColor } from '../types';
 export interface GaugeNeedleDefaults {
@@ -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/error-utils/index.d.ts

@@ -1,4 +1,4 @@
-import { WebChartTypes } from '@arcgis/charts-spec';
+import { WebChartTypes } from '../../../spec';
 import { ChartElementLimit, DataInfo, DataWarningObject, ErrorStrings, QueryObject, DataWarningKeywords } from '../../../utils';
 interface DataLimitSubError {
     outlierLimit?: boolean;

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

@@ -1,8 +1,8 @@
 import { DataWarningObject, PieSlicesSymbols, SelectionData, SeriesSymbolsMap, ValidationStatus } from '../../../utils';
-import { CalculatedMinMaxBoundsPayload, LegendItemVisibility, WebChart, WebChartDataItem, WebChartDataTypes, WebChartSeriesType } from '@arcgis/charts-spec';
+import { CalculatedMinMaxBoundsPayload, LegendItemVisibility, WebChart, WebChartDataItem, WebChartDataTypes, WebChartSeriesType } from '../../../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

@@ -1,8 +1,8 @@
-import { IField, SupportedLayer, WebBoxPlot, WebChart, WebChartDataFilters, WebChartDataItem, WebChartDataItemValue, WebChartDataTypes, WebChartPieChartSlice, WebChartQuery, WebGaugeChart } from '@arcgis/charts-spec';
+import { IField, SupportedLayer, WebBoxPlot, WebChart, WebChartDataFilters, WebChartDataItem, WebChartDataItemValue, WebChartDataTypes, WebChartPieChartSlice, WebChartQuery, WebGaugeChart } from '../../spec';
 import { default as MapView } from '@arcgis/core/views/MapView';
 import { default as SceneView } from '@arcgis/core/views/SceneView';
-import { default as FeatureLayerView } from '@arcgis/core/views/layers/FeatureLayerView';
-import { AbortControllerKeyType, ActionModes, BinnedServerData, ChartElementLimit, CommonStrings, CursorRange, ErrorStrings, LoaderColors, QueryObject, SelectionData, SelectionTheme } from '../../utils';
+import { FeatureLayerView } from '@arcgis/core/views/layers/FeatureLayerView';
+import { AbortControllerKeyType, ActionModes, BinnedServerData, ChartElementLimit, CursorRange, ErrorStrings, LoaderColors, QueryObject, SelectionData, SelectionTheme, UtilsStrings } from '../../utils';
 export declare const uuidNamespace: string;
 export interface NotifyOptions {
     closable?: boolean;
@@ -11,7 +11,7 @@ export type AnyConfigType = WebBoxPlot | WebChart | WebGaugeChart;
 export type ConfigWithILayer = WebBoxPlot | WebChart | WebGaugeChart;
 export type XYConfigWithILayer = WebBoxPlot | WebChart;
 export interface T9NStrings {
-    commonStrings: CommonStrings;
+    utilsStrings: UtilsStrings;
     errorStrings: ErrorStrings;
 }
 export interface CreateChartProps<ConfigType extends AnyConfigType> {
@@ -52,7 +52,7 @@ export interface UpdateChartElementsProps {
     forceDataUpdate?: boolean;
     updateOptions?: ChartOptions;
     updateGlobalOptions?: GlobalOptions;
-    commonStrings: CommonStrings;
+    utilsStrings: UtilsStrings;
 }
 export interface ExportChartImageOptions {
     format: "jpg" | "png";
@@ -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;
@@ -130,39 +130,30 @@ export type PreRenderCallback = (props: {
     data?: WebChartDataTypes;
     slices?: WebChartPieChartSlice[];
 }) => Promise<WebChart | WebGaugeChart>;
-/** Represents the options available to handle specific messages displayed by the chart. */
-export interface MessageOptions {
+/** JSON representation of the runtime chart options for the update or initialization. */
+export interface ChartOptions {
     /**
-     * Whether to display a warning message over the chart when the chart's data set is empty.
+     * Whether to allow the object id to be used as a statistic other than COUNT.
      *
-     * @default true
+     * @default false
      */
-    displayMessageWhenNoData?: boolean;
+    allowUsingObjectIdStat?: boolean;
     /**
      * Whether to consider a `null` statistic as valid. If set to `false` and the data has only
      * null values, the chart's dataset will be considered empty:
      * - the corresponding warning event will be sent
-     * - the "no data" message will be displayed (unless `displayMessageWhenNoData` is set to `false`)
+     * - the "no data" message will be displayed (unless `showUIMesssages` is set to `false`)
      *
      * @default false
      */
     nullAsValid?: boolean;
     /**
-     * Whether to display a warning message over the chart when the logarithmic scale can't be applied to an
-     * axis when the data contains values <= 0.
+     * Whether to display or hide all UI messages (e.g. no data warnings, or when the logarithmic scale can't be applied to an
+     * axis when the data contains values <= 0).
      *
      * @default true
      */
-    displayMessageWhenLogAxisNotPossible?: boolean;
-    /**
-     * Whether to allow the object id to be used as a statistic other than COUNT.
-     *
-     * @default false
-     */
-    allowUsingObjectIdStat?: boolean;
-}
-/** JSON representation of the runtime chart options for the update or initialization. */
-export interface ChartOptions {
+    showUIMessages?: boolean;
     /**
      * A property representing the selection to apply on the chart.
      * The properties are considered in the following order:
@@ -211,6 +202,12 @@ export interface ChartOptions {
      * default is true;
      */
     autoRecreateChart?: boolean;
+    /**
+     * Indicates whether to automatically inverse the data label text color when it's too dark or too light.
+     *
+     * @remark Currently this feature is only available for stacked bar series and pie charts with `dataLabelsInside` set to true.
+     */
+    autoInverseDataLabelTextColor?: boolean;
     /** optional create message to be displayed in the chart container. */
     createMessage?: string;
     /**
@@ -243,7 +240,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;
     /**
@@ -335,8 +332,6 @@ export interface ChartOptions {
      * be interpreted properly.
      */
     gaugeInnerLabelFormatter?: GaugeInnerLabelFormatCallback;
-    /** Represents the options available to handle specific messages displayed by the chart. */
-    messageOptions?: MessageOptions;
     /**
      * Used to disable the toggling of legend items for XYChart series, Pie slices,
      * Histogram overlays, and Scatter-plot trend line.