@arcgis/charts-components 4.34.0-next.13 → 4.34.0-next.131

package/dist/chart-rendering/common/color-match/renderer-color-match/index.d.ts

@@ -1,5 +1,5 @@
 import { QueryObject, ChartSubType } from '../../../../utils';
-import { IRendererSymbol, ISimpleFillSymbol, ISimpleLineSymbol, ISimpleMarkerSymbol, WebChart, WebChartDataItem, WebChartSeriesType, RESTRendererType } from '@arcgis/charts-spec';
+import { IRendererSymbol, ISimpleFillSymbol, ISimpleLineSymbol, ISimpleMarkerSymbol, WebChart, WebChartBarChartSeries, WebChartBoxPlotSeries, WebChartDataItem, WebChartLineChartSeries, WebChartRadarChartSeries, WebChartSeriesType, RESTRendererType } from '../../../../spec';
 import { default as Graphic } from '@arcgis/core/Graphic.js';
 import { default as Renderer } from '@arcgis/core/renderers/Renderer';
 import { RendererOrigin } from './interfaces';
@@ -27,6 +27,62 @@ export declare function getRendererType(chartRenderer?: WebChart["chartRenderer"
  * @param dataContext The data context to look into
  */
 export declare function getDataItemRendererLabel(dataContext: WebChartDataItem): string | undefined;
+/**
+ * Determines whether a renderer symbol is valid.
+ *
+ * @param rendererSymbol The renderer symbol to validate
+ * @returns
+ */
+declare function isValidRendererSymbol(rendererSymbol?: IRendererSymbol): boolean;
+/**
+ * Updates a data item by adding a renderer symbol to it, after eventually tweaking the color opacity.
+ *
+ * @param props.symbolField The field name to use to store the symbol
+ * @param props.dataItem The data item to complete
+ * @param props.rendererSymbol The symbol to store within the data item
+ * @param props.rendererOrigin Whether the renderer comes from the chart renderer or the layer's
+ * @returns Whether the color match was applied to the data item.
+ */
+declare function updateDataItemWithRendererSymbol(props: {
+    symbolField: string;
+    dataItem: WebChartDataItem;
+    rendererSymbol?: IRendererSymbol;
+    rendererOrigin: RendererOrigin;
+}): boolean;
+/**
+ * Returns the suffix symbol key(s) to use to retrieve the renderer symbol from a data item,
+ * base on the chart sub type and the renderer type.
+ *
+ * Any combination of chart sub type and renderer type that is not handled here will return the default symbol key `CommonChartDefaults.rendererSymbolField`.
+ *
+ * The caller should handle the case where the return is an array of strings to match with the dataItem
+ * to find the correct symbol suffix key.  At this time, this only happens for BoxPlot series with PieChart renderer.
+ *
+ * @param props.seriesConfig The series config
+ * @param props.chartSubType The chart sub type
+ * @param props.rendererType The renderer type using the kebab case
+ * @returns The suffix key(s) or the default color key `CommonChartDefaults.rendererSymbolField` to use to retrieve the renderer color from a data item.
+ */
+declare function getRendererSymbolSuffixKey(props: {
+    seriesConfig: WebChartBarChartSeries | WebChartBoxPlotSeries | WebChartLineChartSeries | WebChartRadarChartSeries;
+    chartSubType: ChartSubType;
+    rendererType?: RESTRendererType;
+}): string[] | string;
+/**
+ * Returns the symbol field to retrieve the renderer symbol from a data item.
+ *
+ * @param props.seriesConfig The series config
+ * @param props.chartSubType The chart sub type
+ * @param props.rendererType The renderer type
+ * @param props.dataItem The data item to retrieve the renderer symbol (only used for BoxPlot series with PieChart renderer)
+ * @returns The symbol field to use to retrieve the renderer symbol from a data item.
+ */
+declare function getRendererSymbolField(props: {
+    seriesConfig: WebChartBarChartSeries | WebChartBoxPlotSeries | WebChartLineChartSeries | WebChartRadarChartSeries;
+    chartSubType: ChartSubType;
+    rendererType?: RESTRendererType;
+    dataItem?: WebChartDataItem;
+}): string;
 /**
  * Gets a graphic template to use to compute the renderer color.
  *
@@ -66,6 +122,30 @@ export declare function computeRendererSymbol(props: {
     rendererSymbol: IRendererSymbol | undefined;
     colorMatchApplied: boolean;
 }>;
+/**
+ * Values passed as `null` are ignored by the `@arcgis/core` functions `getDisplayedSymbol()` & `getDisplayedColor()`
+ * To bypass it we transcode the `null` value to a string beforehand.
+ * `computeRendererSymbol()` applies the same transformation on the data item itself to ensure the color is correctly computed.
+ * We only apply this transformation to a chart renderer (not layer renderer).
+ * Refer to https://devtopia.esri.com/WebGIS/arcgis-charts/issues/7770
+ *
+ * @param chartRenderer The chart renderer
+ */
+declare function replaceChartRendererNullValue(chartRenderer?: WebChart["chartRenderer"]): WebChart["chartRenderer"];
+/**
+ * Encodes `null` by `CommonChartDefaults.nullValue` or reverts it.
+ *
+ * @param props.mode Encode or revert the null values
+ * @param props.attributes The attributes to update
+ * @param props.splitByField The split by field
+ * @param props.x The x field
+ */
+declare function handleNullValuesForRenderer(props: {
+    mode: "encode" | "revert";
+    attributes: WebChartDataItem;
+    splitByField?: string;
+    x: string;
+}): void;
 /**
  * Completes a data set with renderer colors.
  *
@@ -114,6 +194,13 @@ export declare function mergeRendererSymbolWithSeriesSymbol<T extends ISimpleFil
     rendererSymbol?: IRendererSymbol;
     colorIndex?: number;
 }): T;
+/**
+ * Returns the category (fields) of a by field chart.
+ *
+ * @param chartConfig The chart config
+ * @returns The categories of the by field chart
+ */
+declare function getCategoriesFromByFieldChart(chartConfig: WebChart): string[];
 /**
  * Determines whether renderer's label can be used.
  *
@@ -129,3 +216,13 @@ export declare function canUseRendererLabel(chartConfig?: WebChart, rendererFiel
  * @returns The fields used by the renderer
  */
 export declare function getChartRendererFieldNames(chartRenderer: WebChart["chartRenderer"]): string[];
+export declare const commonRenderColorMatchPrivateFunctions: {
+    getRendererSymbolSuffixKey: typeof getRendererSymbolSuffixKey;
+    getRendererSymbolField: typeof getRendererSymbolField;
+    updateDataItemWithRendererSymbol: typeof updateDataItemWithRendererSymbol;
+    isValidRendererSymbol: typeof isValidRendererSymbol;
+    replaceChartRendererNullValue: typeof replaceChartRendererNullValue;
+    handleNullValuesForRenderer: typeof handleNullValuesForRenderer;
+    getCategoriesFromByFieldChart: typeof getCategoriesFromByFieldChart;
+};
+export {};

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

@@ -1,4 +1,4 @@
-import { WebBoxPlot, WebChart, WebChartSeries, WebChartSortOrderKinds } from '@arcgis/charts-spec';
+import { WebBoxPlot, WebChart, WebChartSeries, WebChartSortOrderKinds } from '../../../spec';
 import { EsriColor } from '../types';
 /**
  * Returns true when the time interval info was set previously and are not in the new config
@@ -76,6 +76,24 @@ export declare function hasChartRendererChanged(oldConfig: WebChart, newConfig:
  * @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.
@@ -85,6 +103,30 @@ export declare function hasIntlTimeZoneChanged(oldConfig: WebChart, newConfig: W
  * @returns
  */
 export declare function isSortBySeriesNeeded(oldConfig: WebChart, newConfig: WebChart): boolean;
+/**
+ * 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.
+ */
+declare function getDataOrderParametersForBoxPlot(chartConfig: WebBoxPlot): {
+    sortingField: string;
+    orderBy: string[] | WebChartSortOrderKinds;
+} | 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()`.
+ *
+ * @param chartConfig The chart configuration
+ * @returns A sortingField and orderBy object, or undefined
+ */
+declare function getDataOrderParametersForCommonChart(chartConfig: WebChart): {
+    sortingField: string;
+    orderBy: string[] | WebChartSortOrderKinds;
+} | undefined;
 /**
  * Constructs the `sortingField`, `orderBy`, and/or `preferLabel` for sorting the chart data.
  *
@@ -143,3 +185,10 @@ export declare function sortConfigSeries<T extends WebChart | undefined>(chartCo
  * the split-by field and apply the right combination
  */
 export declare function getMeanLinesBoxPlotConfig(chartConfig: WebBoxPlot): WebBoxPlot;
+export declare const commonConfigutilsPrivateFunctions: {
+    hasSeriesOrderChanged: typeof hasSeriesOrderChanged;
+    hasConfigSeriesNamesChanged: typeof hasConfigSeriesNamesChanged;
+    getDataOrderParametersForCommonChart: typeof getDataOrderParametersForCommonChart;
+    getDataOrderParametersForBoxPlot: typeof getDataOrderParametersForBoxPlot;
+};
+export {};

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

@@ -1,5 +1,108 @@
-import { WebBoxPlot, WebChartDataItem, WebChartQuery } from '@arcgis/charts-spec';
-import { AbortControllerKeyType, ChartElementLimit, QueryObject } from '../../../../utils';
+import { WebBoxPlot, WebChartDataItem, WebChartQuery, WebChartStatisticType } from '../../../../spec';
+import { AbortControllerKeyType, ChartElementLimit, QueryObject, BoxPlotYFieldKeys, ChartSubType } from '../../../../utils';
+import { OutliersFilterProps } from './interfaces';
+/**
+ * Builds a key (string) used to identify the properties carrying the global average and standard deviation stats
+ *
+ * @param y The numeric field
+ * @param statType The type of stat (Average or StandardDeviation)
+ */
+declare function getMeanAndStandardDeviationPerFieldKey(y: string, statType: WebChartStatisticType): string;
+/**
+ * calculate z-score for the given value
+ *
+ * @param props.value The current value
+ * @param props.mean The mean of the whole series
+ * @param props.stdDev The standard deviation of the whole series
+ */
+declare function calculateZScore(props: {
+    value: number;
+    mean: number;
+    stdDev: number;
+}): number;
+/**
+ * Adds z-score statistic property and value pair to the box plot data item
+ *
+ * @param props.dataItem The data item for the given box plot
+ * @param props.chartSubType The box plot sub type
+ * @param props.y The y value of the box plot series
+ * @param props.splitByValue The split-by value for the given box plot series
+ * @param props.meanPerField The mean from a whole numeric field
+ * @param props.stdDevPerField The standard deviation from a whole numeric field
+ */
+declare function addZScoreItemToDataItem(props: {
+    dataItem: WebChartDataItem;
+    chartSubType: ChartSubType;
+    y?: string;
+    splitByValue?: string;
+    meanPerField?: number;
+    stdDevPerField?: number;
+}): WebChartDataItem;
+/**
+ * Adds missing alternative data to the given chart configuration and data.
+ * This happens when fetchBoxPlotAlternativeData() doesn't bring back results for a specific field.
+ * In that case we set the alternative data to the original data.
+ *
+ * @param chartConfig The chart config
+ * @param data The data to add missing alternative data to
+ */
+declare function addMissingAlternativeData(chartConfig: WebBoxPlot, data: WebChartDataItem[]): void;
+/**
+ * Calculating the outliers threshold for a given data item (representing one candle and whiskers)
+ *
+ * @param dataItem The data item containing the stats
+ * @param yFieldNames The box plot y field names
+ */
+declare function getOutliersThresholds(dataItem: WebChartDataItem, yFieldNames: Record<BoxPlotYFieldKeys, string>): {
+    outlierMinThreshold?: number;
+    outlierMaxThreshold?: number;
+};
+/**
+ * Builds the query filter necessary to fetch either the outliers or the alternative data by using the x, y and split-by fields and values.
+ *
+ * @param props.yField The y-axis field
+ * @param props.xField The x-axis field
+ * @param props.xValue The category value
+ * @param props.splitByField The split-by field for a given series
+ * @param props.splitByValue The split-by value for a given series
+ * @param props.outlierMinThreshold The outlier min threshold for a given data item
+ * @param props.outlierMaxThreshold The outlier max threshold for a given data item
+ * @param props.target Whether the function is called to build the outliers or the alternative data filter
+ */
+declare function buildBoxPlotFilter(props: OutliersFilterProps): string;
+/**
+ * Generates the query filters necessary to fetch the box plot outliers and alternative data.
+ * The filters are returned as an array because if they contain too many operands they are split
+ * into multiple filters.
+ *
+ * @param props.data The main data set
+ * @param props.yField The numeric field
+ * @param props.x The x-axis field
+ * @param props.chartSubType The chart sub type
+ * @param props.splitByField The split-by field
+ */
+declare function generateBoxPlotQueriesFilter(props: {
+    data: WebChartDataItem[];
+    yField: string;
+    x?: string;
+    chartSubType: ChartSubType;
+    splitByField?: string;
+}): {
+    outliersFilterBatches: string[];
+    dataWithoutOutliersFilterBatches: string[];
+};
+/**
+ * Merges two data sets from the category and split-by field
+ *
+ * @param props.data The main data set
+ * @param props.additionalData The additional data
+ * @param props.chartConfig The chart's config
+ */
+declare function mergeBoxPlotAlternativeData(props: {
+    data: WebChartDataItem[];
+    additionalData: WebChartDataItem[];
+    chartConfig: WebBoxPlot;
+}): WebChartDataItem[];
 /**
  * Processes the fetched data for a box plot chart and transforms it into the appropriate format for the amCharts library.
  * Depending on the query type, the data may need to be grouped and/or flattened before being returned.
@@ -46,3 +149,14 @@ export declare function completeBoxPlotResults(props: {
     dataItems: WebChartDataItem[];
     outliers: WebChartDataItem[];
 }>;
+export declare const commonDataBoxplotPrivateFunctions: {
+    getOutliersThresholds: typeof getOutliersThresholds;
+    buildBoxPlotFilter: typeof buildBoxPlotFilter;
+    generateBoxPlotQueriesFilter: typeof generateBoxPlotQueriesFilter;
+    mergeBoxPlotAlternativeData: typeof mergeBoxPlotAlternativeData;
+    calculateZScore: typeof calculateZScore;
+    addZScoreItemToDataItem: typeof addZScoreItemToDataItem;
+    getMeanAndStandardDeviationPerFieldKey: typeof getMeanAndStandardDeviationPerFieldKey;
+    addMissingAlternativeData: typeof addMissingAlternativeData;
+};
+export {};

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

@@ -1,4 +1,4 @@
-import { WebChartQuery, WebGaugeChart } from '@arcgis/charts-spec';
+import { WebChartQuery, WebGaugeChart } from '../../../../spec';
 import { AbortControllerKeyType, DataInfo, QueryObject } from '../../../../utils';
 import { ChartOptions } from '../../interfaces';
 /**

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

@@ -1,6 +1,26 @@
+import { WebChart, WebChartQuery, WebChartDataTransformations } from '../../../../spec';
 import { DataInfo, QueryObject } from '../../../../utils';
-import { WebChart, WebChartQuery } from '@arcgis/charts-spec';
 import { FetchDataProps } from '../../interfaces';
+/**
+ * Checks if the current transformation type (log | sqrt) is compatible with the dataset.
+ *
+ * @param dataTransformationType The transformation requested for the histogram
+ * @param min The min value from the data set
+ */
+declare function isDataCompatibleWithTransformation(dataTransformationType: WebChartDataTransformations | undefined, min: number): boolean;
+/**
+ * Create the bins for the original min and max value (Before applying the transformation).
+ *
+ * @param dataTransformationType The transformation requested for the histogram.
+ * @param min The min value from the data set.
+ */
+declare function createInvalidDataInfoForHistogram(dataTransformationType?: WebChartDataTransformations, dataCountIncompatible?: boolean): DataInfo;
+/**
+ *
+ * @param min Work around to reduce the decimal part by 1.
+ * @returns number
+ */
+declare function processMin(min: number): number;
 /**
  * Fetches the histogram data and proceed to the statistic calculations.
  * Returns information indicating whether the operation was a success and the data if so.
@@ -23,3 +43,9 @@ export declare function fetchHistogramSelectionData(props: {
     chartConfig: WebChart;
     x: string;
 }): Promise<DataInfo>;
+export declare const commonDataHistogramPrivateFunctions: {
+    processMin: typeof processMin;
+    isDataCompatibleWithTransformation: typeof isDataCompatibleWithTransformation;
+    createInvalidDataInfoForHistogram: typeof createInvalidDataInfoForHistogram;
+};
+export {};

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

@@ -1,5 +1,5 @@
 import { AbortControllerKeyType, ErrorStrings, QueryObject } from '../../../../utils';
-import { WebChart, WebChartDataItem, WebChartDataTransformations, WebChartQuery } from '@arcgis/charts-spec';
+import { WebChart, WebChartDataItem, WebChartDataTransformations, WebChartQuery } from '../../../../spec';
 import { default as Graphic } from '@arcgis/core/Graphic';
 import { ChartOptions, FetchDataProps } from '../../interfaces';
 export interface TwoDimPoint {

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

@@ -1,6 +1,17 @@
-import { IField, WebBoxPlot, WebChart, WebChartDataItem, WebChartQuery } from '@arcgis/charts-spec';
+import { IField, WebBoxPlot, WebChart, WebChartDataItem, WebChartDataTypes, WebChartQuery } from '../../../spec';
 import { AbortControllerKeyType, BinnedServerData, DataInfo, ErrorStrings, QueryObject } from '../../../utils';
 import { ChartOptions } from '../interfaces';
+declare function fetchFinishedDataWithFilterBySelection(props: {
+    queryObject?: QueryObject;
+    chartConfig: WebChart;
+    queryConfig: WebChartQuery;
+    currentChartData?: WebChartDataTypes;
+    currentSelectionDataItems?: WebChartDataItem[];
+    currentSelectionOIDs?: number[];
+    options?: ChartOptions;
+    errorStrings: ErrorStrings;
+    abortKey?: AbortControllerKeyType;
+}): Promise<DataInfo>;
 /**
  * Fetches a box plot data
  *
@@ -22,10 +33,16 @@ export declare function fetchFinishedBoxPlotData(props: {
 export declare function getData(props: {
     chartConfig: WebChart;
     queryObject?: QueryObject;
+    currentChartData?: WebChartDataTypes;
     currentSelectionDataItems?: WebChartDataItem[];
+    currentSelectionOIDs?: number[];
     binnedServerData?: BinnedServerData;
     options?: ChartOptions;
     errorStrings: ErrorStrings;
     abortKey?: AbortControllerKeyType;
     fieldList?: IField[];
 }): Promise<DataInfo>;
+export declare const commonDataPrivateFunctions: {
+    fetchFinishedDataWithFilterBySelection: typeof fetchFinishedDataWithFilterBySelection;
+};
+export {};

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

@@ -1,4 +1,4 @@
-import { WebChart, WebChartDataItem } from '@arcgis/charts-spec';
+import { WebChart, WebChartDataItem } from '../../../../spec';
 /**
  * Indicates whether the data context is associated to a slice group.
  *

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

@@ -1,8 +1,7 @@
-import { WebChart, WebChartQuery } from '@arcgis/charts-spec';
+import { WebChart, WebChartQuery } from '../../../../../spec';
 import { default as Graphic } from '@arcgis/core/Graphic';
 import { default as AttributeBinsFeatureSet } from '@arcgis/core/rest/support/AttributeBinsFeatureSet.js';
-import { ErrorStrings } from '../../../../../assets/t9n/utils/interfaces';
-import { AbortControllerKeyType, QueryObject } from '../../../../../utils';
+import { AbortControllerKeyType, ErrorStrings, QueryObject } from '../../../../../utils';
 import { ChartOptions } from '../../../interfaces';
 /**
  * Fetches some additional statistics needed for the aggregation feature.
@@ -23,7 +22,7 @@ export declare function fetchAggregationDataStatistics(props: {
     abortKey?: AbortControllerKeyType;
 }): Promise<void>;
 /**
- * Fetches aggregated data for the scatter plot
+ * Fetches aggregated data for the scatterplot
  *
  * @param props.statsMap The Map already storing the common statistics
  * @param props.queryObject The query object (layer or layer view)

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

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

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

@@ -1,4 +1,4 @@
-import { WebChartScatterplotDataItem } from '@arcgis/charts-spec';
+import { WebChartScatterplotDataItem } from '../../../../spec';
 import { FetchScatterplotDataProps } from './interfaces';
 /**
  * Creates a WebChartScatterplotDataItem object with default values for r2 and trendLinePoints.

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

@@ -1,6 +1,6 @@
 import { AbortControllerKeyType, QueryObject } from '../../../../utils';
 import { FetchDataProps } from '../../interfaces';
-import { WebChart, WebChartQuery } from '@arcgis/charts-spec';
+import { WebChart, WebChartQuery } from '../../../../spec';
 export interface FetchScatterplotDataProps extends FetchDataProps {
     statsMap?: Map<string, number>;
     sortData?: boolean;

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

@@ -1,5 +1,15 @@
-import { WebChartDataItem } from '@arcgis/charts-spec';
+import { WebChartDataItem } from '../../../../../spec';
 import { TrendlineDataProps } from './interfaces';
+/**
+ * Returns whether the supports computing the trendline information on the server.
+ * It is true when:
+ *   - the layer is not a feature collection (using client-side data)
+ *   - the query object is not a feature layer view
+ *   - the FS accepts query analytics
+ *
+ * @param props
+ */
+declare function isServerCalculationPossible(props: TrendlineDataProps): Promise<boolean>;
 /**
  * Uses a `linear` function to calculate the trendline data from the main series' data.
  *
@@ -20,3 +30,7 @@ export declare function getFinalTrendLineData(props: TrendlineDataProps): Promis
     r2: number;
     trendLinePoints: [WebChartDataItem, WebChartDataItem];
 }>;
+export declare const commonScatterplotTrendlinePrivateFunctions: {
+    isServerCalculationPossible: typeof isServerCalculationPossible;
+};
+export {};

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

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

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

@@ -1,5 +1,6 @@
-import { WebChartDataItem } from '@arcgis/charts-spec';
+import { WebChartDataItem, WebChartDataItemValue, RESTFieldType } from '../../../../../spec';
 import { BuildSelectionFilterProps } from './interfaces';
+declare function buildSelectionFilterForAScatterplotElement(props: BuildSelectionFilterProps): string;
 /**
  * Builds a filter to be used by a query, based on a data context containing a date range provided as two timestamps.
  *
@@ -8,6 +9,16 @@ import { BuildSelectionFilterProps } from './interfaces';
  * @returns A filter as a string, usable to query
  */
 export declare function buildSelectionFilterForATimeBinningChartElement(xAxisField: string, dataContext: WebChartDataItem): string;
+/**
+ * The double fields can have a precision issue with the server.
+ * For instance if a value is equal to 4.73450600069336, a where clause set to `field=4.73450600069336` won't bring any result.
+ * The function tweaks the filter to bring back the expected results.
+ *
+ * @param xAxisValue
+ * @param xAxisField
+ * @returns
+ */
+declare function buildSelectionFilterForADoubleField(xAxisValue: number, xAxisField: string): string;
 /**
  * Builds a query filter for the box plot selection. It considers a specific data context from a box
  * by looking at the category, split-by and min/max values
@@ -23,6 +34,31 @@ export declare function buildSelectionFilterForATimeBinningChartElement(xAxisFie
  * @returns A string representing the filter
  */
 export declare function buildSelectionFilterForABoxPlotElement(props: BuildSelectionFilterProps): string;
+declare function buildSelectionFilterForABarOrLineElement(props: BuildSelectionFilterProps): string;
+declare function buildSelectionFilterForAPieChartElement(props: BuildSelectionFilterProps): string;
+/**
+ * Builds a selection filter for a heat chart element, considering the associated axis uses a calendar date parts binning.
+ * @param props.field The field used by the heat chart
+ * @param props.fieldType The field type
+ * @param props.fieldValue The value of the field
+ * @param props.unit The unit of the temporal binning
+ */
+declare function getHeatChartFilterForCalendarParts(props: {
+    field: string;
+    fieldType?: RESTFieldType;
+    fieldValue: WebChartDataItemValue;
+    unit?: string;
+}): string | undefined;
+/**
+ * Builds a selection filter for a heat chart element.
+ * It considers the different axes value format types to know how to build the filter.
+ * @param props.xAxisFieldType The x-axis field type
+ * @param props.yAxisFieldType The y-axis field type
+ * @param props.dataContext The data context containing the x and y values
+ * @param props.chartConfig The chart configuration
+ */
+declare function buildSelectionFilterForAHeatChartElement(props: BuildSelectionFilterProps): string;
+declare function buildSelectionFilterForAHistogramElement(props: BuildSelectionFilterProps): string;
 /**
  * Builds a query filter for selection
  *
@@ -30,3 +66,13 @@ export declare function buildSelectionFilterForABoxPlotElement(props: BuildSelec
  * @returns
  */
 export declare function buildSelectionFilterForOneElement(props: BuildSelectionFilterProps): string;
+export declare const commonSelectionFilterPrivateFunctions: {
+    getHeatChartFilterForCalendarParts: typeof getHeatChartFilterForCalendarParts;
+    buildSelectionFilterForAHeatChartElement: typeof buildSelectionFilterForAHeatChartElement;
+    buildSelectionFilterForAScatterplotElement: typeof buildSelectionFilterForAScatterplotElement;
+    buildSelectionFilterForABarOrLineElement: typeof buildSelectionFilterForABarOrLineElement;
+    buildSelectionFilterForADoubleField: typeof buildSelectionFilterForADoubleField;
+    buildSelectionFilterForAHistogramElement: typeof buildSelectionFilterForAHistogramElement;
+    buildSelectionFilterForAPieChartElement: typeof buildSelectionFilterForAPieChartElement;
+};
+export {};

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

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

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

@@ -1,4 +1,4 @@
-import { WebChart, WebChartDataItem } from '@arcgis/charts-spec';
+import { WebChart, WebChartDataItem } from '../../../../spec';
 import { ChartOptions } from '../../interfaces';
 /**
  * Function comparing two array containing selection items.

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

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

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

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