@arcgis/charts-components 5.0.0-next.1 → 5.0.0-next.100

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;
@@ -23,7 +25,7 @@ declare function fetchFinishedDataWithFilterBySelection(props: {
  * @param props.abortKey The key to abort queries
  */
 export declare function fetchFinishedBoxPlotData(props: {
-    chartConfig: WebBoxPlot | WebChart;
+    chartConfig: WebBoxPlot;
     queryConfig: WebChartQuery;
     queryObject?: QueryObject;
     options?: ChartOptions;
@@ -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/scatter-plot/aggregation/index.d.ts

@@ -1,6 +1,6 @@
-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 { WebChart, WebChartQuery } from '../../../../../spec';
 import { AbortControllerKeyType, ErrorStrings, QueryObject } from '../../../../../utils';
 import { ChartOptions } from '../../../interfaces';
 /**

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,149 +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 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;
-}): {
-    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.
  *
@@ -386,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 {};

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,7 +28,9 @@ 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[];
 export declare const totalFeatureCount = "arcgis_charts_total_feature_count";
+export declare const queryBinsServerLimit = 8000;

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,14 +76,11 @@ interface LineSeriesDefaults {
     stackedType: WebChartStackedKinds;
     stackNegativeValuesToBaseline: boolean;
     marker: {
-        markerSize: number;
-        markerStrokeWidth: number;
+        markerBigSize: number;
+        markerSizeThresholdForTooltipDisplay: number;
+        markerStyle: RESTSimpleMarkerSymbolStyle;
     };
 }
-interface LineMarkerDefaults {
-    markerSize: number;
-    markerStyle: RESTSimpleMarkerSymbolStyle;
-}
 export interface LabelProperties {
     wrap?: boolean;
     paddingLeft?: number;
@@ -151,7 +149,6 @@ export interface CommonChartDefaults {
     scatterplotSeries: Readonly<ScatterplotSeriesDefaults>;
     histogramSeries: Readonly<HistogramSeriesDefaults>;
     lineSeries: Readonly<LineSeriesDefaults>;
-    lineMarker: Readonly<LineMarkerDefaults>;
     xAxisLabelMaxWidth: number;
     yAxisLabelMaxWidth: number;
     axisLabelPadding: number;
@@ -166,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>;
@@ -252,6 +250,7 @@ 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;

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, ValidationStatus } 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;
@@ -51,12 +51,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 +64,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;