@arcgis/charts-components 5.0.0-next.9 → 5.0.0-next.91

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

@@ -1,41 +1,6 @@
-import { WebBoxPlot, WebChart, WebChartSeries, WebChartSortOrderKinds } from '../../../spec';
+import { WebBoxPlot, WebChart, WebChartSeries, WebHeatChart } from '../../../spec';
+import { DataOrderParameters } from '../data/utils/summarize-data/interfaces';
 import { EsriColor } from '../types';
-/**
- * Returns true when the time interval info was set previously and are not in the new config
- *
- * @param oldConfig the old chart config
- * @param newConfig the new chart config
- */
-export declare function hasTimeIntervalInfoBeenReset(oldConfig: WebChart, newConfig: WebChart): boolean;
-/**
- * Returns true when the dual axis feature was enabled or disabled (number of axes changed)
- *
- * @param oldConfig the old chart config
- * @param newConfig the new chart config
- */
-export declare function hasDualAxisChanged(oldConfig: WebChart, newConfig: WebChart): boolean;
-/**
- * Returns true when the series are not associated to the same axis anymore
- *
- * @param oldConfig the old chart config
- * @param newConfig the new chart config
- */
-export declare function hasSeriesAxisChanged(oldConfig: WebChart, newConfig: WebChart): boolean;
-/**
- * Returns true when at least one guide's 'above' property changed from an update to another.
- *
- * @param oldConfig The old chart config
- * @param newConfig The new chart config
- * @returns
- */
-export declare function hasAnyGuideAboveChanged(oldConfig: WebChart, newConfig: WebChart): boolean;
-/**
- * Returns true if the rotated property changed since the previous update.
- *
- * @param oldConfig the old chart config
- * @param newConfig the new chart config
- */
-export declare function hasRotationChanged(oldConfig: WebChart, newConfig: WebChart): boolean;
 /**
  * Returns the field to be used by the x-axis.
  *
@@ -49,119 +14,49 @@ export declare function getXAxisField(chartConfig: WebChart): string;
  */
 export declare function isChartStacked(config: WebChart): boolean;
 /**
- * Returns true if the rotated property changed since the previous update.
- *
- * @param oldConfig the old chart config
- * @param newConfig the new chart config
- */
-export declare function hasOutliersVisibilityChanged(oldConfig: WebChart, newConfig: WebChart): boolean;
-/**
- * Returns true if the 'standardizeValues' property changed in the chart config since the previous update.
- *
- * @param oldConfig the old chart config
- * @param newConfig the new chart config
- */
-export declare function hasStandardizeValuesVisibilityChanged(oldConfig: WebChart, newConfig: WebChart): boolean;
-/**
- * Returns true if the 'chartRenderer' property changed in the chart config since the previous update.
- *
- * @param oldConfig the old chart config
- * @param newConfig the new chart config
- */
-export declare function hasChartRendererChanged(oldConfig: WebChart, newConfig: WebChart): boolean;
-/**
- * Returns true if the 'timeZone' property from the axis value format changed in the chart config since the previous update.
- *
- * @param oldConfig the old chart config
- * @param newConfig the new chart config
- */
-export declare function hasIntlTimeZoneChanged(oldConfig: WebChart, newConfig: WebChart): boolean;
-/**
- * Determines if any of the series' name has changed between the previous and the new configs.
- *
- * The order of the series is preserved when comparing for changes.
- *
- * @param oldConfig The previous chart config
- * @param newConfig The new chart config
- * @returns
- */
-declare function hasConfigSeriesNamesChanged(oldConfig: WebChart, newConfig: WebChart): boolean;
-/**
- * Determines if the series order has changed between the old and the new configs.
- *
- * @param oldConfig The previous chart config
- * @param newConfig The new chart config
- * @returns
- */
-declare function hasSeriesOrderChanged(oldConfig: WebChart, newConfig: WebChart): boolean;
-/**
- * Determines whether a sort by series is needed.
- * A sort by series is needed when either the series order has changed or any of the series names have changed.
+ * Gets the `sortingField`s and `orderBy`s from the `orderOptions.data` for the heat chart.
+ * @param chartConfig The chart config
+ * @returns An array of two objects with sortingField and orderBy, one for x and one for y, or undefined.
  *
- * @param oldConfig The previous chart config.
- * @param newConfig The new chart config.
- * @returns
  */
-export declare function isSortBySeriesNeeded(oldConfig: WebChart, newConfig: WebChart): boolean;
+declare function getDataOrderParametersForHeatChart(chartConfig: WebHeatChart): DataOrderParameters[] | undefined;
 /**
  * Gets the `sortingField` and `orderBy` from the `orderOptions.data` for the boxplot chart.
  *
  * @param chartConfig The chart config
- * @returns A sortingField and orderBy object, or undefined.
+ * @returns An object with sortingField, optionally an orderBy and preferLabel, or undefined.
  */
-declare function getDataOrderParametersForBoxPlot(chartConfig: WebBoxPlot): {
-    sortingField: string;
-    orderBy: string[] | WebChartSortOrderKinds;
-} | undefined;
-/**
- * Gets the `sortingField` and `orderBy` from the `orderOptions.data` for the non-matrix heat chart.
- *
- * @param chartConfig The chart config
- * @returns A sortingField and orderBy object, or undefined
- *
- * @remarks For matrix heat chart, this function will return undefined.
- */
-declare function getDataOrderParametersForHeatChart(chartConfig: WebChart): {
-    sortingField: string;
-    orderBy: WebChartSortOrderKinds;
-} | undefined;
+declare function getDataOrderParametersForBoxPlot(chartConfig: WebBoxPlot): DataOrderParameters | undefined;
 /**
  * Gets the `sortingField` and `orderBy` from the `orderOptions.data` for bar, line, and pie charts,
  * It also considers other parameters such as the type of chart, stacked type or number of series
  * (for bar and line) when determining the sorting field.
  *
- * Notes: this function does not apply to boxplot, which is handled by `getDataOrderParametersForBoxPlot()`.
+ * **Note**: this function does not apply to boxplot, which is handled by `getDataOrderParametersForBoxPlot()`.
  *
- * @param chartConfig The chart configuration
- * @returns A sortingField and orderBy object, or undefined
+ * @param chartConfig - The chart configuration
+ * @returns An object with sortingField, optionally an orderBy and preferLabel, or undefined.
  */
-declare function getDataOrderParametersForCommonChart(chartConfig: WebChart): {
-    sortingField: string;
-    orderBy: string[] | WebChartSortOrderKinds;
-} | undefined;
+declare function getDataOrderParametersForCommonChart(chartConfig: WebChart): DataOrderParameters | undefined;
 /**
- * Constructs the `sortingField`, `orderBy`, and/or `preferLabel` for sorting the chart data.
+ * Constructs the `sortingField`, `orderBy`, and/or optionally `preferLabel` for sorting the chart data.
  *
  * @param chartConfig The chart configuration
- * @returns An object with info about sortingField, orderBy, and optionally preferLabel
+ * @returns An array of objects with sortingField, optionally an orderBy and preferLabel, or undefined.
  */
-export declare function getDataOrderParameters(chartConfig: WebChart): {
-    sortingField: string;
-    orderBy?: string[] | WebChartSortOrderKinds;
-    preferLabel?: boolean;
-} | undefined;
+export declare function getDataOrderParameters(chartConfig: WebChart): DataOrderParameters[] | undefined;
 /**
  * Returns true if the data order instructions (orderType or sortingField, orderBy, and/or preferLabel) have changed, or
  * the data update is needed.
  *
  * @param props.oldConfig The previous chart config
  * @param props.newConfig The new chart config
- * @param props.dataUpdateNeeded Indicates if data update is needed; this is used by and important for box-plot charts. It's ignored for non-boxplot charts.
+ * @param props.dataWasUpdated Indicates if the data was updated; this is used by and important for box-plot charts. It's ignored for non-boxplot charts.
  */
 export declare function isNewSortNeeded(props: {
     oldConfig: WebChart;
     newConfig: WebChart;
-    dataUpdateNeeded: boolean;
+    dataWasUpdated: boolean;
 }): boolean;
 /**
  * After comparing two arrays containing the same number of series, returns the potential changes
@@ -179,15 +74,6 @@ export declare function getPositionChanges(oldSeries: WebChartSeries[], newSerie
  * @param color2
  */
 export declare function areColorsEqual(color1?: EsriColor, color2?: EsriColor): boolean;
-/**
- * Sorts the series in the config based on the series sort options.
- * When no sort option is provide, no sorting is performed.
- *
- * @param chartConfig The optional chart config to sort the series
- * @param chartContainer The HTML chart container
- * @returns The updated chart config with the series sorted, or undefined if the input config is undefined
- */
-export declare function sortConfigSeries<T extends WebChart | undefined>(chartConfig: T, chartContainer?: HTMLElement): T;
 /**
  * In "Mean lines" mode, the boxes are not matching their config anymore:
  * - C5 becomes C1
@@ -206,8 +92,6 @@ export declare function getMeanLinesBoxPlotConfig(chartConfig: WebBoxPlot): WebB
  */
 export declare function isMatrixHeatChart(chartConfig?: WebChart): boolean;
 export declare const commonConfigutilsPrivateFunctions: {
-    hasSeriesOrderChanged: typeof hasSeriesOrderChanged;
-    hasConfigSeriesNamesChanged: typeof hasConfigSeriesNamesChanged;
     getDataOrderParametersForCommonChart: typeof getDataOrderParametersForCommonChart;
     getDataOrderParametersForBoxPlot: typeof getDataOrderParametersForBoxPlot;
     getDataOrderParametersForHeatChart: typeof getDataOrderParametersForHeatChart;

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

@@ -108,10 +108,10 @@ declare function mergeBoxPlotAlternativeData(props: {
  * Depending on the query type, the data may need to be grouped and/or flattened before being returned.
  * If the query type is BoxPlotMonoFieldAndCategory, the data is already in the correct format and no further transformation is needed.
  *
- * @param {WebBoxPlot} props.chartConfig The configuration object for the chart.
- * @param {WebChartDataItem[]} props.data The fetched data to be processed.
- * @param {boolean} props.calculateZScore determines whether to calculate z-score or not for the box plots.
- * @param {WebChartDataItem} props.meanAndStdDevPerField Object containing the mean and stddev for all the numeric fields used by the chart
+ * @param props.chartConfig - The configuration object for the chart.
+ * @param props.data - The fetched data to be processed.
+ * @param props.calculateZScore - Determines whether to calculate z-score or not for the box plots.
+ * @param props.meanAndStdDevPerField - Object containing the mean and stddev for all the numeric fields used by the chart
  * @returns The processed data in the appropriate format for the amCharts library.
  */
 export declare function processDataForBoxPlot(props: {

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

@@ -20,7 +20,7 @@ declare function createInvalidDataInfoForHistogram(dataTransformationType?: WebC
  * @param min Work around to reduce the decimal part by 1.
  * @returns number
  */
-declare function processMin(min: number): number;
+declare function processMin(min?: number | null): number | null | undefined;
 /**
  * Fetches the histogram data and proceed to the statistic calculations.
  * Returns information indicating whether the operation was a success and the data if so.

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

@@ -1,13 +1,15 @@
+import { default as Graphic } from '@arcgis/core/Graphic.js';
 import { IField, WebBoxPlot, WebChart, WebChartDataItem, WebChartDataTypes, WebChartQuery } from '../../../spec';
-import { AbortControllerKeyType, BinnedServerData, DataInfo, ErrorStrings, QueryObject } from '../../../utils';
+import { AbortControllerKeyType, DataInfo, ErrorStrings, QueryObject } from '../../../utils';
 import { ChartOptions } from '../interfaces';
 declare function fetchFinishedDataWithFilterBySelection(props: {
     queryObject?: QueryObject;
     chartConfig: WebChart;
     queryConfig: WebChartQuery;
-    currentChartData?: WebChartDataTypes;
+    fullDatasetBeforeFBS?: WebChartDataTypes;
     currentSelectionDataItems?: WebChartDataItem[];
-    currentSelectionOIDs?: number[];
+    currentSelectionOIDs?: (number | string)[];
+    dataForFilterBySelectionChanged?: boolean;
     options?: ChartOptions;
     errorStrings: ErrorStrings;
     abortKey?: AbortControllerKeyType;
@@ -33,14 +35,15 @@ export declare function fetchFinishedBoxPlotData(props: {
 export declare function getData(props: {
     chartConfig: WebChart;
     queryObject?: QueryObject;
-    currentChartData?: WebChartDataTypes;
+    fullDatasetBeforeFBS?: WebChartDataTypes;
     currentSelectionDataItems?: WebChartDataItem[];
-    currentSelectionOIDs?: number[];
-    binnedServerData?: BinnedServerData;
+    currentSelectionOIDs?: (number | string)[];
+    dataForFilterBySelectionChanged?: boolean;
     options?: ChartOptions;
     errorStrings: ErrorStrings;
     abortKey?: AbortControllerKeyType;
     fieldList?: IField[];
+    preFetchedQueryResponse?: Graphic[];
 }): Promise<DataInfo>;
 export declare const commonDataPrivateFunctions: {
     fetchFinishedDataWithFilterBySelection: typeof fetchFinishedDataWithFilterBySelection;

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

@@ -42,12 +42,18 @@ declare function buildSelectionFilterForAPieChartElement(props: BuildSelectionFi
  * @param props.fieldType The field type
  * @param props.fieldValue The value of the field
  * @param props.unit The unit of the temporal binning
+ * @param props.outTimeZone The output time zone
+ * @param props.dataTimeZone The data time zone
+ * @param props.runsOnClientQueryEngine Whether the query will be executed on the client query engine (FeatureLayerView) or on the server
  */
 declare function getHeatChartFilterForCalendarParts(props: {
     field: string;
     fieldType?: RESTFieldType;
     fieldValue: WebChartDataItemValue;
     unit?: string;
+    outTimeZone?: string;
+    dataTimeZone?: string | null;
+    runsOnClientQueryEngine?: boolean;
 }): string | undefined;
 /**
  * Builds a selection filter for a heat chart element.
@@ -56,6 +62,9 @@ declare function getHeatChartFilterForCalendarParts(props: {
  * @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
+ * @param props.outTimeZone The output time zone
+ * @param props.dataTimeZone The data time zone
+ * @param props.runsOnClientQueryEngine Whether the query will be executed on the client query engine (FeatureLayerView) or on the server
  */
 declare function buildSelectionFilterForAHeatChartElement(props: BuildSelectionFilterProps): string;
 declare function buildSelectionFilterForAHistogramElement(props: BuildSelectionFilterProps): string;

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

@@ -17,6 +17,9 @@ export interface BuildSelectionFilterProps extends SelectionProps {
     dataContext: WebChartDataItem;
     xAxisFieldType?: RESTFieldType;
     yAxisFieldType?: RESTFieldType;
+    outTimeZone?: string;
+    dataTimeZone?: string | null;
+    runsOnClientQueryEngine?: boolean;
     options?: ChartOptions;
     abortKey?: AbortControllerKeyType;
 }

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

@@ -1,7 +1,5 @@
-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';
+import { IExtent, IField, ValueConversion, WebChart, WebChartBin, WebChartDataItem, WebChartDataItemValue, WebChartDataTypes, WebChartSeriesType, WebGaugeChart, WebChartDataTransformations, WebChartSortOrderKinds } from '../../../../../spec';
+import { ChartElementLimit } from '../../../../../utils';
 /**
  * Merges an array of IExtent into one IExtent
  *
@@ -177,164 +175,11 @@ export declare function transformDateToQueryFormat(date: Date | number): number
  * @param fieldList The field list
  */
 export declare function convertMultipleNumericFieldsData(props: {
-    dataToConvert: WebChartDataItem;
+    dataToConvert: WebChartDataItem | undefined;
     x: string;
     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 additional tooltip fields (only non-numeric) changed
- *
- * **NOTE**: (only for scatterplot)
- *
- * @param {WebChart} props.oldConfig The previous config
- * @param {WebChart} props.newConfig The updated config
- * @param {IField[]|undefined} props.fieldList The layer field list
- */
-export declare function hasAdditionalTooltipFieldsChanged(props: {
-    oldConfig: WebChart;
-    newConfig: WebChart;
-    fieldList?: IField[];
-}): boolean;
-/**
- * Compares two configs and indicates whether the color type change
- *
- * @param oldConfig The previous config
- * @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.
- *
- * @param props.oldConfig The previous chart config
- * @param props.newConfig The newest chart config
- */
-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.
- *
- * @param oldSeries The former series config
- * @param newSeries The new series config
- */
-export declare function hasSplitByValueChanged(oldSeries: WebChart["series"], newSeries: WebChart["series"]): boolean;
-/**
- * Verify if the order of the numeric fields has changed
- *
- * @param oldSeries - The previous series config
- * @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.
- *
- * @param props
- */
-export declare function isDataUpdateNeeded(props: {
-    forceDataUpdate?: boolean;
-    oldConfig: WebBoxPlot | WebChart;
-    newConfig: WebBoxPlot | WebChart;
-    options?: ChartOptions;
-    formerFilterBySelection?: boolean;
-    timeIntervalInfo?: TimeIntervalInfo;
-    currentSelectionDataItems?: WebChartDataItem[];
-    currentSelectionOIDs?: number[];
-    currentSelectionIndexes?: SelectionIndexes;
-    fieldList?: IField[];
-}): {
-    dataUpdateNeeded: boolean;
-    updateNeededDetails: DataUpdateNeededDetails;
-};
-/**
- * Function used on temporal charts.
- * Indicates whether resetting the previously fetched binned data is necessary.
- * It is necessary when the time interval unit or any common data property changes.
- *
- * @param dataUpdateNeededDetails
- */
-export declare function isBinnedServerDataResetNeeded(dataUpdateNeededDetails: DataUpdateNeededDetails): boolean;
 /**
  * Check if the Pie chart data has slices with all positive or all negative values.
  *
@@ -401,14 +246,6 @@ declare function isValidPercentValue(inputValue: string): boolean;
 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/query-parser/time-binning/index.d.ts

@@ -1,2 +1,19 @@
 import { WebChartTemporalBinningUnits } from '../../../../../../spec';
-export declare function getTimeBinGroupByFieldsForStatistics(dateFieldName: string, unit: WebChartTemporalBinningUnits): string[];
+/**
+ * Generates the INTERVAL SQL instruction to shift date values from the data time zone to the output time zone.
+ * This is inspired by the Dashboards implementation currently found here:
+ * https://devtopia.esri.com/WebGIS/arcgis-dashboards/blob/develop-4/packages/dashboard-view-models/addon/-private/service-dataset.js.
+ * @param props.outTimeZone The output time zone (typically the user locale)
+ * @param props.dataTimeZone The data time zone (usually UTC but can be set differently on the layer)
+ * @param props.runsOnClientQueryEngine Whether the query will be executed on the client query engine (FeatureLayerView) or on the server
+ */
+export declare function getIntervalStatement(props: {
+    outTimeZone?: string;
+    dataTimeZone?: string | null;
+    runsOnClientQueryEngine?: boolean;
+}): string;
+export declare function getTimeBinGroupByFieldsForStatistics(props: {
+    dateFieldName: string;
+    unit: WebChartTemporalBinningUnits;
+    runsOnClientQueryEngine?: boolean;
+}): string[];

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

@@ -20,7 +20,7 @@ export declare function getSelectionItemsFromOIDs(props: {
     queryConfig?: WebChartQuery;
     queryObject: QueryObject;
     dataWasUpdated?: boolean;
-    currentSelectionOIDs?: number[];
+    currentSelectionOIDs?: (number | string)[];
     options?: ChartOptions;
     errorStrings: ErrorStrings;
 }): Promise<WebChartDataItem[] | undefined>;
@@ -36,4 +36,4 @@ export declare function fetchOIDsFromWhereClause(props: {
     queryObject: QueryObject;
     queryFilter?: string;
     queryConfig: WebChartQuery;
-}): Promise<number[]>;
+}): Promise<(number | string)[]>;

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 { IExtent, IField, IStatisticDefinition, WebChart, WebChartAxis, WebChartBarChartSeries, WebChartBoxPlotSeries, WebChartDataItem, WebChartDataItemValue, WebChartLineChartSeries, WebChartPieChartSeries, WebChartQuery, WebChartSeriesType, WebHeatChart, WebChartCalendarDatePartsUnits, WebChartSortOrderKinds } from '../../../../../spec';
 import { DataInfo, QueryObject, 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()`.
@@ -170,6 +172,36 @@ export declare function getTotalElementCount(props: {
     categoryOrDateCount?: number;
     elementCount?: number;
 }>;
+/**
+ * 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;
 /**
  * Sort bar/line/pie chart data.
  * No sorting will be performed if no sorting instruction is provided via the chart config's `orderOptions.data` property.
@@ -198,6 +230,48 @@ 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
+ */
+declare function isInvalidDayOfMonth(props: {
+    day: number;
+    month: number;
+}): 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.
@@ -253,5 +327,12 @@ 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;
 };
 export {};