@arcgis/charts-components 5.0.0-next.13 → 5.0.0-next.130

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

@@ -1,8 +1,8 @@
 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 { IExtent, IField, IStatisticDefinition, WebChart, WebChartAxis, WebChartBarChartSeries, WebChartBoxPlotSeries, WebChartDataItem, WebChartDataItemValue, WebChartLineChartSeries, WebChartPieChartSeries, WebChartQuery, WebChartSeriesType, WebHeatChart, WebChartCalendarDatePartsUnits, WebChartSortOrderKinds, WebChartTypes } from '../../../../../spec';
+import { DataInfo, QueryObject, SubtypeInfo, ChartSubType, LimitBehavior } from '../../../../../utils';
 import { ChartOptions, FetchDataProps } from '../../../interfaces';
-import { ProcessUniqueQueryProps } from './interfaces';
+import { DataOrderParameters, ProcessUniqueQueryProps } from './interfaces';
 /**
  * Returns the feature extent and the extent key for a feature.
  *
@@ -101,11 +101,13 @@ declare function swapStatFieldNamesToStatisticFields(dataItem: WebChartDataItem,
  * @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.
+ * @param props.fieldOID The layer's object id field.
  */
 declare function renameYFieldForSplitByNoAggregation(props: {
     dataItem: WebChartDataItem;
     splitByField: string;
     y: string;
+    fieldOID?: string;
 }): void;
 /**
  * Removes a prefix added to the box plot out statistic field names by `buildUniqueBoxPlotOutStatistics()`.
@@ -146,6 +148,33 @@ declare function limitCategories(props: {
     x: string;
     chartSubType: ChartSubType;
 }): boolean;
+/**
+ * Adds fields description from coded domain or subtype to the provided attributes.
+ * @param props.attributes The attributes to be modified
+ * @param props.xValue The x value
+ * @param props.yValue The y value
+ * @param props.x The x field name
+ * @param props.y The y field name
+ * @param props.subtypeInfo The layer's subtype info
+ * @param props.fieldList The layer's field list
+ * @param props.chartType The chart type
+ * @param props.chartSubType The chart sub-type
+ * @param props.xAxisValueFormat The x axis value format
+ * @param props.yAxisValueFormat The y axis value format
+ */
+declare function addFieldsDescription(props: {
+    attributes: WebChartDataItem;
+    xValue: WebChartDataItemValue;
+    yValue: WebChartDataItemValue;
+    x: string;
+    y?: string[] | string;
+    subtypeInfo?: SubtypeInfo;
+    fieldList?: IField[];
+    chartType?: WebChartTypes;
+    chartSubType: ChartSubType;
+    xAxisValueFormat?: WebChartAxis["valueFormat"];
+    yAxisValueFormat?: WebChartAxis["valueFormat"];
+}): void;
 /**
  * Function executing a unique query and processing its results.
  *
@@ -171,7 +200,37 @@ export declare function getTotalElementCount(props: {
     elementCount?: number;
 }>;
 /**
- * Sort bar/line/pie chart data.
+ * Determines whether the provided sort type is allowed for heat chart.
+ * For a heat chart, direction sort is allow on any axis, and custom label sort is only allowed on category axes.
+ * @param orderBy The order by parameter which can be an array of custom labels or a directional order.
+ * @param axisFormatOptions The format options of the axis to determine if sorting is allowed.
+ * @returns
+ */
+declare function isDataSortTypeAllowedForHeatChart(props: {
+    orderBy?: string[] | WebChartSortOrderKinds;
+    axisFormatOptions?: WebChartAxis["valueFormat"];
+}): boolean;
+/**
+ * Compares two values based on the specified order criteria.
+ * @param a The first value to compare
+ * @param b The second value to compare
+ * @param order The order criteria which can be an array of custom labels or a directional order.
+ * @returns A number indicating the sort order between `a` and `b`.
+ */
+declare function compareByOrder(a: WebChartDataItemValue, b: WebChartDataItemValue, order: string[] | WebChartSortOrderKinds | undefined): number;
+/**
+ * Sorts the fetched heat chart data based on the provided order parameters.
+ * @param props.arrayToSort The array of data items to sort
+ * @param props.chartConfig The heat chart config
+ * @param props.dataOrderParamerters The order instructions for x and y axes
+ */
+declare function sortFetchedHeatChartData(props: {
+    arrayToSort: WebChartDataItem[];
+    chartConfig: WebHeatChart;
+    dataOrderParameters?: DataOrderParameters[];
+}): void;
+/**
+ * Sorts the data.
  * No sorting will be performed if no sorting instruction is provided via the chart config's `orderOptions.data` property.
  * Also, if it's a time binning series, the data is already sorted by the query and other routines, we won't need to resort them.
  *
@@ -198,6 +257,50 @@ export declare function fetchFinishedGenericChartData(props: FetchDataProps): Pr
  * @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;
+/**
+ * Determines whether empty rows and columns should be filtered out in a heat chart
+ * @param chartConfig The heat chart config
+ * @returns
+ */
+declare function shouldFilterOutEmptyRowsAndColumns(chartConfig: WebHeatChart): boolean;
+/**
+ * Filters out rows and columns that are completely empty (i.e., all values are equal to `valueToUse`)
+ * @param props
+ * @returns
+ */
+declare function filterOutEmptyRowsAndColumns(props: {
+    dataItems: WebChartDataItem[];
+    valueField: string;
+    valueToUse: 0 | null;
+    xField: string;
+    yField: string;
+}): WebChartDataItem[];
+/**
+ * Fills missing cells in a heat chart dataset with a specified value.
+ * It will return only the missing cells (with the filled values) to be added to the original dataset.
+ * @param props
+ * @returns
+ */
+declare function fillMissingCells(props: {
+    dataItems: WebChartDataItem[];
+    xUniqueValues: (number | string)[];
+    yUniqueValues: (number | string)[];
+    xField: string;
+    yField: string;
+    valueField: string;
+    valueToUse: 0 | null;
+}): WebChartDataItem[];
+/**
+ * Indicates whether the provided day and month combination is invalid
+ * @param props.day The day of the month
+ * @param props.month The month of the year
+ * @param props.includeLeapDay If we should include Feb 29th
+ */
+declare function isInvalidDayOfMonth(props: {
+    day: number;
+    month: number;
+    includeLeapDay?: boolean;
+}): boolean;
 /**
  * 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.
@@ -240,6 +343,7 @@ export declare function fetchFinishedGenericChartSelectionData(props: FetchDataP
  * @param props.abortKey The abort key to cancel queries
  */
 export declare function fetchFinishedBoxPlotSelectionData(props: FetchDataProps): Promise<DataInfo>;
+/** @private */
 export declare const commonUtilsSummarizeDataPrivateFunctions: {
     restoreStatFieldNamesCase: typeof restoreStatFieldNamesCase;
     mergeDataItems: typeof mergeDataItems;
@@ -253,5 +357,13 @@ export declare const commonUtilsSummarizeDataPrivateFunctions: {
     limitCategories: typeof limitCategories;
     getExpectedValuesFromDatePartsUnit: typeof getExpectedValuesFromDatePartsUnit;
     trimTemporalDataset: typeof trimTemporalDataset;
+    shouldFilterOutEmptyRowsAndColumns: typeof shouldFilterOutEmptyRowsAndColumns;
+    isDataSortTypeAllowedForHeatChart: typeof isDataSortTypeAllowedForHeatChart;
+    compareByOrder: typeof compareByOrder;
+    sortFetchedHeatChartData: typeof sortFetchedHeatChartData;
+    filterOutEmptyRowsAndColumns: typeof filterOutEmptyRowsAndColumns;
+    fillMissingCells: typeof fillMissingCells;
+    isInvalidDayOfMonth: typeof isInvalidDayOfMonth;
+    addFieldsDescription: typeof addFieldsDescription;
 };
 export {};

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

@@ -1,5 +1,7 @@
-import { WebChartDataItemValue, WebChartDataItem, WebChartQuery, WebChart, IStatisticDefinition } from '../../../../../spec';
-import { QueryObject, AbortControllerKeyType, ChartElementLimit, ChartSubType } from '../../../../../utils';
+import { default as Graphic } from '@arcgis/core/Graphic.js';
+import { WebChartDataItemValue, WebChartDataItem, WebChartQuery, WebChart, IStatisticDefinition, WebChartSortOrderKinds } from '../../../../../spec';
+import { QueryObject, AbortControllerKeyType, ChartElementLimit } from '../../../../../utils';
+import { ChartSubType } from '../../../../../utils/misc/interfaces';
 export interface SummarizeDataProps {
     data: [WebChartDataItemValue, WebChartDataItem[]][];
     statType: IStatisticDefinition["statisticType"];
@@ -7,6 +9,14 @@ export interface SummarizeDataProps {
     seriesX: string;
     seriesY?: string;
 }
+/**
+ * Ordering instructions to use when sorting chart data.
+ */
+export interface DataOrderParameters {
+    sortingField: string;
+    orderBy?: string[] | WebChartSortOrderKinds;
+    preferLabel?: boolean;
+}
 export interface ProcessUniqueQueryProps {
     queryObject?: QueryObject;
     uniqueQuery: WebChartQuery;
@@ -18,6 +28,7 @@ export interface ProcessUniqueQueryProps {
     chartLimits?: ChartElementLimit;
     abortKey?: AbortControllerKeyType;
     usePopupTemplateFieldsInfo?: boolean;
+    preFetchedQueryResponse?: Graphic[];
 }
 /** List of chart subtypes that support direct category trimming. */
 export declare const supportedSubTypesForCategoryTrimming: ChartSubType[];

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

@@ -1,4 +1,4 @@
-/// <reference types="@arcgis/core/interfaces.d.ts" />
+import { default as AttributeBinsGraphic } from '@arcgis/core/AttributeBinsGraphic.js';
 import { TimeIntervalInfo, WebChart, WebChartDataItem, WebChartQuery, WebChartSeriesType, WebChartNullPolicyTypes, WebChartTemporalBinningUnits } from '../../../../../../spec';
 import { DateRange, QueryObject, TimeBinningStatistics, WebChartSeriesSupportingTemporalBinning } from '../../../../../../utils';
 /**
@@ -36,7 +36,7 @@ export declare function getTimeBinningStatistics(props: {
  */
 export declare function mapTemporalBinningQueryAttributeBinsResults(props: {
     chartConfig: WebChart;
-    queryResults: __esri.AttributeBinsGraphic[];
+    queryResults: AttributeBinsGraphic[];
     mapToStatField: Map<number | string | null, string>;
     splitByField?: string;
     nullPolicy?: WebChartNullPolicyTypes;

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

@@ -1,5 +1,6 @@
 import { Color, ISimpleFillSymbol, WebChartCursorCrosshair, WebChartDataItem, WebChartNullCategory, WebChartPieChartGroupSlice, RESTHorizontalAlignment, RESTSimpleMarkerSymbolStyle, RESTVerticalAlignment, WebChartLegendPositions, WebChartLineSmoothedKinds, WebChartSortOrderKinds, WebChartStackedKinds } from '../../../spec';
-import { SelectionTheme, ActionModes } from '../../../utils';
+import { SelectionTheme } from '../../../utils';
+import { ActionModes } from '../../../utils/cursor/interfaces';
 import { EsriColor } from '../types';
 export interface GaugeNeedleDefaults {
     startWidth: number;
@@ -75,9 +76,8 @@ interface LineSeriesDefaults {
     stackedType: WebChartStackedKinds;
     stackNegativeValuesToBaseline: boolean;
     marker: {
-        markerSmallSize: number;
         markerBigSize: number;
-        markerStrokeWidth: number;
+        markerSizeThresholdForTooltipDisplay: number;
         markerStyle: RESTSimpleMarkerSymbolStyle;
     };
 }
@@ -163,6 +163,7 @@ export interface CommonChartDefaults {
     dataTooltipStyleReversed?: Readonly<Partial<ISimpleFillSymbol>>;
     cursorCrosshair: Readonly<Required<Omit<WebChartCursorCrosshair, "type">>>;
     buffer: boolean;
+    treatZeroValueAs: number;
     elementLimitForSmoothRendering: number;
     headerContainer: Readonly<ContainerProperties>;
     footerContainer: Readonly<ContainerProperties>;
@@ -249,10 +250,8 @@ export interface CommonChartDefaults {
     dateBinModel: string;
     /** Query defaults */
     originalCategoryValue: string;
+    originalYCategoryValue: string;
     originalDateValue: string;
-    /** Subtype related; used in tooltips, data labels, color match for bar/line/pie */
-    typeOrDomainFieldName: string;
-    typeOrDomainIdValue: string;
     dateFormatUTC: Intl.DateTimeFormatOptions;
     dayDefaultFormat: Intl.DateTimeFormatOptions;
     weekDefaultFormat: Intl.DateTimeFormatOptions;
@@ -301,6 +300,9 @@ export interface CommonChartDefaults {
     nullCategory: WebChartNullCategory;
     /** gray color used for various purposes */
     grayColor: EsriColor;
+    classBreaks: {
+        breaksCount: number;
+    };
 }
 /**
  * A nested dictionary which contains default values for cases when a property is undefined.

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

@@ -35,7 +35,7 @@ export declare function getDataWarningObject(props: {
     filterBySelection?: boolean;
     queryObject?: QueryObject;
     formatLocale?: string;
-    isTemporalLineChart?: boolean;
+    isTemporalChart?: boolean;
     errorStrings: ErrorStrings;
-}): Promise<DataWarningObject>;
+}): DataWarningObject;
 export {};

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

@@ -1,5 +1,5 @@
-import { CalculatedMinMaxBoundsPayload, LegendItemVisibility, WebChart, WebChartDataItem, WebChartDataTypes, WebChartSeriesType } from '../../../spec';
-import { DataWarningObject, PieSlicesSymbols, SelectionData, SeriesSymbolsMap, ValidationStatus } from '../../../utils';
+import { CalculatedMinMaxBoundsPayload, LegendItemVisibility, WebChart, WebChartDataTypes, WebChartSeriesType } from '../../../spec';
+import { HeatSeriesColorChangePayload, DataWarningObject, PieSlicesSymbols, SelectionData, SeriesSymbolsMap } from '../../../utils';
 /**
  * Sending an event carrying the chart processed data at any data update.
  * Contains the statistics for Histogram and Scatterplot
@@ -23,7 +23,7 @@ export declare function notifyDataProcessed(props: {
  * @param props.htmlContainer The chart's HTML container
  */
 export declare function notifyDataFetched(props: {
-    data: WebChartDataItem[];
+    data: WebChartDataTypes;
     chartConfig: WebChart;
     htmlContainer?: HTMLElement;
 }): void;
@@ -34,13 +34,6 @@ export declare function notifyDataFetched(props: {
  * @param htmlContainer
  */
 export declare function notifyLegendItemVisibilityChanged(data: LegendItemVisibility, htmlContainer?: HTMLElement): void;
-/**
- * Sending an event indicating that the chart is updated with the new config
- *
- * @param data
- * @param htmlContainer
- */
-export declare function notifyChartUpdated(data: ValidationStatus, htmlContainer?: HTMLElement): void;
 /**
  * Sending an event indicating all the chart's series (non-overlays) are [`ready`](https://www.amcharts.com/docs/v4/reference/series/#ready_event)
  *
@@ -51,12 +44,10 @@ export declare function notifyRenderingCompleted(htmlContainer?: HTMLElement): v
  * Sending selectionEvent on range select
  *
  * @param props.data The selection data
- * @param props.seriesConfig The array of series config
  * @param props.htmlContainer The chart's HTML container
  */
 export declare function notifySelectionCompleted(props: {
     data: SelectionData;
-    seriesConfig?: WebChartSeriesType[];
     htmlContainer?: HTMLElement;
 }): void;
 /**
@@ -66,14 +57,16 @@ export declare function notifySelectionCompleted(props: {
  */
 export declare function notifyTooManySelectedElements(htmlContainer?: HTMLElement): void;
 /**
- * Sending an event containing the either the symbols assigned to a chart's series, or information regarding
+ * Sending an event containing the either the symbols assigned to a chart's series, a heat series color change payload, or information regarding
  * a pie chart slices.
  *
  * @param data an item representing the symbols applied to the chart's series
  * @param htmlContainer The chart's html container, used to propagate the event
+ * @param chartId The chart's id
+ * @param colorMatchApplied If color match has been applied
  */
 export declare function notifySeriesColorsChange(props: {
-    data?: PieSlicesSymbols | SeriesSymbolsMap;
+    data?: HeatSeriesColorChangePayload | PieSlicesSymbols | SeriesSymbolsMap;
     htmlContainer?: HTMLElement;
     chartId?: string;
     colorMatchApplied: boolean;
@@ -92,6 +85,12 @@ export declare function notifyAxesMinMaxChange(data?: CalculatedMinMaxBoundsPayl
  * @param htmlContainer
  */
 export declare function notifyBadDataRaise(data?: DataWarningObject, htmlContainer?: HTMLElement): void;
+/**
+ * Sending an event containing info on invalid config warning
+ * @param data
+ * @param htmlContainer
+ */
+export declare function notifyInvalidConfigRaise(data?: DataWarningObject, htmlContainer?: HTMLElement): void;
 /**
  * Sending an event carrying the series order on the chart.
  *

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

@@ -1,6 +1,7 @@
 export declare const ChartEvents: {
     readonly DataProcessComplete: "arcgisChartsJSDataProcessComplete";
     readonly DataFetchComplete: "arcgisChartsJSDataFetchComplete";
+    readonly InvalidConfigWarningRaise: "arcgisChartsJSInvalidConfigWarningRaise";
     readonly LegendItemVisibilityChange: "arcgisChartsJSLegendItemVisibilityChange";
     readonly UpdateComplete: "arcgisChartsJSUpdateComplete";
     readonly RenderingComplete: "arcgisChartsJSRenderingComplete";

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

@@ -1,33 +1,54 @@
+import { default as AttributeBinsGraphic } from '@arcgis/core/AttributeBinsGraphic.js';
+import { default as Graphic } from '@arcgis/core/Graphic.js';
 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 { IField, SupportedLayer, WebBoxPlot, WebChart, WebChartDataFilters, WebChartDataItem, WebChartDataItemValue, WebChartDataTypes, WebChartPieChartSlice, WebChartQuery, WebGaugeChart } from '../../spec';
-import { AbortControllerKeyType, ActionModes, BinnedServerData, ChartElementLimit, CursorRange, ErrorStrings, LoaderColors, QueryObject, SelectionData, SelectionTheme, UtilsStrings } from '../../utils';
+import { SupportedLayer } from '../../interfaces';
+import { WebBoxPlot, WebChart, WebChartDataFilters, WebChartPieChartSlice, WebChartQuery, WebGaugeChart, WebHeatChart, WebRadarChart } from '../../spec/web-chart';
+import { IField } from '../../spec/rest-js-types';
+import { WebChartDataItem, WebChartDataItemValue, WebChartDataTypes } from '../../spec/data-source';
+import { ErrorStrings, UtilsStrings } from '../../utils/localization/interfaces';
+import { ValidationStatus } from '../../utils/chart-config/validator/interfaces';
+import { QueryObject } from '../../utils/layer/interfaces';
+import { DataInfo, DataUpdateDetails } from '../../utils/data/interfaces';
+import { AbortControllerKeyType } from '../../utils/layer/query-features/interfaces';
+import { ActionModes, CursorRange } from '../../utils/cursor/interfaces';
+import { LoaderColors, SelectionData, SelectionTheme } from '../../utils/misc/interfaces';
+import { ChartElementLimit } from '../../utils/defaults/interfaces';
+import { LoaderHandle } from './loading-indicator';
 export declare const uuidNamespace: string;
 export interface NotifyOptions {
     closable?: boolean;
 }
-export type AnyConfigType = WebBoxPlot | WebChart | WebGaugeChart;
-export type ConfigWithILayer = WebBoxPlot | WebChart | WebGaugeChart;
+export type ConfigWithILayer = WebBoxPlot | WebChart | WebGaugeChart | WebHeatChart | WebRadarChart;
 export type XYConfigWithILayer = WebBoxPlot | WebChart;
 export interface T9NStrings {
     utilsStrings: UtilsStrings;
     errorStrings: ErrorStrings;
 }
-export interface CreateChartProps<ConfigType extends AnyConfigType> {
+export interface CreateChartProps<ConfigType extends ConfigWithILayer> {
     chartContainer?: HTMLElement;
+    configValidationStatus: ValidationStatus;
     chartConfig?: ConfigType;
     queryObject?: QueryObject;
     options?: ChartOptions;
     globalOptions?: GlobalOptions;
-    inputData?: WebChartDataItem[];
+    dataInfo?: DataInfo;
     t9nStrings: T9NStrings;
+    uniqueInternalID?: string;
+    loaderHandle: LoaderHandle;
 }
 export interface UpdateChartProps {
     newChartConfig?: WebChart | WebGaugeChart;
+    configValidationStatus: ValidationStatus;
     updateOptions?: ChartOptions;
     updateGlobalOptions?: GlobalOptions;
+    dataWasUpdated: boolean;
+    dataUpdateDetails?: DataUpdateDetails;
     t9nStrings: T9NStrings;
+    queryObject: QueryObject;
+    dataInfo?: DataInfo;
+    loaderHandle: LoaderHandle;
 }
 export interface FetchDataProps {
     queryObject?: QueryObject;
@@ -35,7 +56,6 @@ export interface FetchDataProps {
     queryConfig: WebChartQuery;
     filterBySelectionChanged?: boolean;
     options?: ChartOptions;
-    binnedServerData?: BinnedServerData;
     abortKey?: AbortControllerKeyType;
     errorStrings: ErrorStrings;
     /** indicates whether to calculate z-score or not for the box plots. */
@@ -47,13 +67,20 @@ export interface FetchDataProps {
     fetchFullBoxPlotData?: boolean;
     completeHeatChartDataset?: boolean;
     fieldList?: IField[];
+    preFetchedQueryResponse?: AttributeBinsGraphic[] | Graphic[];
 }
 export interface UpdateChartElementsProps {
     newConfig?: WebChart | WebGaugeChart;
+    queryObject: QueryObject;
     forceDataUpdate?: boolean;
     updateOptions?: ChartOptions;
     updateGlobalOptions?: GlobalOptions;
+    dataWasUpdated: boolean;
+    dataUpdateDetails?: DataUpdateDetails;
     utilsStrings: UtilsStrings;
+    configValidationStatus: ValidationStatus;
+    dataInfo?: DataInfo;
+    loaderHandle: LoaderHandle;
 }
 export interface ExportChartImageOptions {
     format: "jpg" | "png";
@@ -71,12 +98,12 @@ export interface ExportChartImageOptions {
 export interface ChartInstance {
     update: (updateProps: UpdateChartProps) => Promise<void>;
     dispose: () => void;
-    notify: (message?: string, heading?: string, options?: NotifyOptions) => void;
     resetZoom: () => void;
     clearSelection: () => void;
     switchSelection: () => Promise<void>;
     setActionMode: (actionMode?: ActionModes, cursorRange?: CursorRange) => void;
     exportImage: (exportProps: ExportChartImageOptions) => Promise<File>;
+    loaderHandle: LoaderHandle;
 }
 export type HeatChartLabelFormatCallback = (statValue: number, x?: number | string, y?: number | string) => string;
 /** Describes the signature of the callback function used to customize the pie chart data labels and tooltips */
@@ -139,8 +166,6 @@ export type TooltipFormatters = BarAndLineTooltipFormatCallback | BoxPlotTooltip
 export interface ChartOptions {
     /**
      * Whether to allow the object id to be used as a statistic other than COUNT.
-     *
-     * @default false
      */
     allowUsingObjectIdStat?: boolean;
     /**
@@ -148,15 +173,11 @@ export interface ChartOptions {
      * 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 `showUIMesssages` is set to `false`)
-     *
-     * @default false
      */
     nullAsValid?: boolean;
     /**
      * 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
      */
     showUIMessages?: boolean;
     /**
@@ -169,14 +190,10 @@ export interface ChartOptions {
     /**
      * Indicates if the object ids need to be computed whenever a selection is made on or passed to the chart.
      * Only considered for a data source using a feature layer.
-     *
-     * @default true
      */
     returnSelectionOIDs?: boolean;
     /**
      * Indicates if the selection indexes need to be computed whenever a selection is made on or passed to the chart.
-     *
-     * @default false
      */
     returnSelectionIndexes?: boolean;
     /**
@@ -185,8 +202,6 @@ export interface ChartOptions {
      *   - charts using an aggregation
      *   - data source using a feature layer compatible with envelope aggregation
      * The extent (IExtent) is returned through a property called `arcgis_charts_features_extent`.
-     *
-     * @default false
      */
     returnFeaturesExtent?: boolean;
     /**
@@ -210,22 +225,18 @@ export interface ChartOptions {
     /**
      * 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.
+     * **Note**: 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;
     /**
      * Used to hide the loader animation (curtain and spinner), showed by default at every update.
-     *
-     * @default false
      */
     hideLoaderAnimation?: boolean;
     /**
      * Hide the series from the chart if it doesn't have data (i.e. empty)
      * For example, after apply data filters, filter by attribute or geometry (as when using the filter by extent)
-     *
-     * @default true
      */
     hideEmptySeries?: boolean;
     /**
@@ -238,8 +249,6 @@ export interface ChartOptions {
      *
      * When data is retrieved from the server, the server excludes all features having a count of 0 from the response; hence resulting in missing entries on the charts.
      * When this property is set to true, a process is applied to complete the dataset with 0s for the empty or missing categories, to display them on the chart without gaps.
-     *
-     * @default true
      */
     replaceNoValueCategoryWithZero?: boolean;
     /**
@@ -280,15 +289,11 @@ export interface ChartOptions {
      * By default the queries made by the chart will consider the view's extent as the unique geometry filter applicable. This implies ignoring any
      * geometry passed through the config (component.config.dataFilters) or the runtime filters (component.runtimeDataFilters).
      * Setting this property to `false` signals the queries to ignore the view's extent, whether an additional geometry filter is provided or not.
-     *
-     * @default false
      */
     ignoreViewExtent?: boolean;
     /**
      * Can be used when creating or updating a chart compatible with time binning. If this option is `true`, the series properties
      * `unit` and `size` become optional and will be automatically set to values that fit the data set.
-     *
-     * @default false
      */
     setTimeBinningInfoWhenNotProvided?: boolean;
     /**
@@ -299,8 +304,6 @@ export interface ChartOptions {
      * This property will be set when the chart is created and cannot be updated after that.
      *
      * It's recommended that this property should only be set to true for small datasets.
-     *
-     * @default false
      */
     ignoreSmoothRenderingLimit?: boolean;
     /**
@@ -341,8 +344,6 @@ export interface ChartOptions {
      * Used to disable the toggling of legend items for XYChart series, Pie slices,
      * Histogram overlays, and Scatter-plot trend line.
      * This option is not applied for Gauge.
-     *
-     * @default false
      */
     disableTogglingLegendItems?: boolean;
     /**

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

@@ -83,6 +83,7 @@ export declare function attachInlineCSS(props: {
  * @param input The input string to transform
  */
 export declare function kebabize(input?: string): string | undefined;
+/** @private */
 export declare const commonLabelPrivateFunctions: {
     mapFontStyle: typeof mapFontStyle;
     mapKerning: typeof mapKerning;

package/dist/chart-rendering/common/loading-indicator/index.d.ts

@@ -0,0 +1,4 @@
+export interface LoaderHandle {
+    showLoader: () => void;
+    hideLoader: () => void;
+}

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

@@ -1,4 +1,4 @@
-import { ActionModes, BinnedServerData, QueryObject, SelectionIndexes } from '../../../utils';
+import { ActionModes, QueryObject, SelectionIndexes } from '../../../utils';
 import { IField, OverlayTerms, ScatterplotTrendLineData, TimeIntervalInfo, WebChart, WebChartDataItem, WebChartLabelBehavior, WebChartQuery, WebChartStackedKinds, WebChartTypes } from '../../../spec';
 import { AxisLabelFormatCallback, BarAndLineDataLabelFormatCallback, BarAndLineTooltipFormatCallback, BoxPlotTooltipFormatCallback, ChartOptions, GuideTooltipFormatCallback, HeatChartDataLabelFormatCallback, HeatChartLabelFormatCallback, HistogramLabelFormatCallback, PieChartLabelFormatCallback, PieChartLegendValueLabelFormatCallback, ScatterplotLabelFormatCallback } from '../interfaces';
 export interface CommonStorageType {
@@ -17,7 +17,7 @@ export interface CommonStorageType {
         filterBySelection?: boolean;
         seriesFilteredOut?: boolean;
         currentSelectionDataItems?: WebChartDataItem[];
-        currentSelectionOIDs?: number[];
+        currentSelectionOIDs?: (number | string)[];
         currentSelectionIndexes?: SelectionIndexes;
         computedSelectionIndexes?: SelectionIndexes;
         computedSelectionDataItems?: WebChartDataItem[];
@@ -26,7 +26,6 @@ export interface CommonStorageType {
         chartWasUpdatedWhileHidden?: boolean;
         pendingSelectionQueries?: boolean;
         actionMode?: ActionModes;
-        binnedServerData?: BinnedServerData;
         gaugeData?: number;
         options?: ChartOptions;
         formatLocale?: string;

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

@@ -1,4 +1,4 @@
-import { WebChartBin, WebChartDataItem, WebChartTypes } from '../../../spec';
+import { WebChartBin, WebChartDataItem, WebChartDataItemValue, WebChartTypes } from '../../../spec';
 import { ChartSubType } from '../../../utils';
 import { ChartOptions } from '../interfaces';
 /**
@@ -36,6 +36,20 @@ export declare function isSliceMatchingSelection(props: {
     xAxisField: string;
     layerOidField?: string;
 }): boolean;
+/**
+ * Returns the value to be used for matching the heat chart selection. It looks into the data context for:
+ * - the original category value
+ * - a specific field if provided
+ * - the placeholder heat chart field
+ * @param props.dataContext The data context
+ * @param props.specificField A specific field to look into
+ * @param props.xOrY Whether we are looking for the x or y value
+ */
+declare function getHeatChartValueFromContext(props: {
+    dataContext: WebChartDataItem;
+    specificField?: string;
+    xOrY: "x" | "y";
+}): WebChartDataItemValue | undefined;
 /**
  * This function helps matching a list of selection data with a specific element (column, marker, slice) represented by its data context.
  * Each type of series has its own set of rules to defined what is a match.
@@ -66,7 +80,9 @@ export declare function getSelectedElementData(props: {
     showOutliers?: boolean;
     isFeatureCollectionLayer: boolean;
 }): WebChartDataItem;
+/** @private */
 export declare const commonSelectionPrivateFunctions: {
     getBoxPlotSelectionPredicate: typeof getBoxPlotSelectionPredicate;
+    getHeatChartValueFromContext: typeof getHeatChartValueFromContext;
 };
 export {};