@arcgis/charts-components 5.0.0-next.12 → 5.0.0-next.120

package/dist/utils/chart-config/converter/index.d.ts

@@ -1,5 +1,6 @@
 import { default as FeatureLayerView } from '@arcgis/core/views/layers/FeatureLayerView';
-import { SupportedLayer, WebBoxPlot, WebChart, WebChartBoxPlotSeries, WebChartDirectionalDataOrder, WebChartLineChartSeries, WebGaugeChart, WebHeatChart, WebChartOrderDataByTypes } from '../../../spec';
+import { SupportedLayer } from '../../../interfaces';
+import { WebBoxPlot, WebChart, WebChartBoxPlotSeries, WebChartDirectionalDataOrder, WebChartLineChartSeries, WebGaugeChart, WebHeatChart, WebChartOrderDataByTypes } from '../../../spec';
 import { FormerWebChartBoxPlotDataSortTypes, FormerWebChartDataValueTypes } from './interfaces';
 /** ***********************************************************************************
  *                                                                                    *
@@ -13,16 +14,17 @@ import { FormerWebChartBoxPlotDataSortTypes, FormerWebChartDataValueTypes } from
  * @param chartContainer The chart's container
  */
 declare function applyDefaultFirstDayOfWeek(props: {
-    configToUpdate: WebChart | WebHeatChart;
+    configToUpdate: WebHeatChart;
     chartContainer?: HTMLElement;
     layer?: SupportedLayer;
-}): WebChart | WebHeatChart;
+}): WebHeatChart;
+declare function adjustAxes(configToUpdate: WebChart): WebChart;
+declare function adjustSeries(configToUpdate: WebChart): WebChart;
 /**
  * Matches the config properties that have field names which mismatch the layer data source fields.
  *
- * @param {*} config The chart config
- * @param {*} layer The layer instance
- * @returns {Promise<WebChart>}
+ * @param config - The chart config
+ * @param layer - The layer instance
  */
 declare function matchChartFieldsToLayerFields(configToUpdate: WebChart, layer?: SupportedLayer): Promise<WebChart>;
 /**
@@ -61,6 +63,11 @@ declare function isBoxPlotConfigWithMeanLinesFromPro(config: WebBoxPlot): boolea
  * @returns the updated config
  */
 declare function adjustBoxPlotConfig(configToUpdate: WebBoxPlot): WebBoxPlot;
+/**
+ * Sets the legend max height to `NaN` when the provided value is not a finite number.
+ * @param configToUpdate The chart's config to update
+ */
+declare function resetLegendMaxHeight(configToUpdate: WebChart): WebChart;
 /**
  * Copies the information from the config.dataSource.layer into the newest config.iLayer
  * @param configToUpdate The config to update
@@ -88,6 +95,12 @@ declare function applyMandatoryConversions(props: {
  * @param configToUpdate The chart's config to update
  */
 declare function adjustPieFromFieldsDefaultNameAndValue(configToUpdate: WebChart): WebChart;
+/**
+ * Remove the optional `spacing` property for gauge chart (from version 2.0.0).
+ * @param configToUpdate The chart's config to update
+ * @returns
+ */
+declare function removeSpacingPropertyFromGauge(configToUpdate: WebChart): WebChart;
 /**
  * Moves the series[x].query.extent to config.dataFilters.geometry, and delete
  * the extent properties from all the series query.
@@ -221,6 +234,12 @@ declare function handleOrderOptionsChanges(configToUpdate: WebChart): WebChart;
  * @returns the updated chart config
  */
 declare function applyDataOrderInstructionForFromFieldsCharts(configToUpdate: WebChart): WebChart;
+/**
+ * we convert convert WebChartLabelBehavior.None -> WebChartLabelBehavior.Hide
+ * @param configToUpdate Config to update
+ * @returns the updated chart config
+ */
+declare function convertWebChartLabelBehaviorNoneToHide(configToUpdate: WebChart): WebChart;
 /**
  * Converts temporal binning properties from the old pattern to the new pattern introduced in version 19.0.0.
  * Former pattern:
@@ -253,6 +272,12 @@ declare function renameChartSubtitle(configToUpdate: WebChart): WebChart;
  * @param configToUpdate The chart's config to update
  */
 declare function convertTemporalBinningProps2(configToUpdate: WebChart): WebChart;
+/**
+ * Add the `type` property to temporal binning properties in the heat chart series
+ * @param configToUpdate
+ * @returns
+ */
+declare function transformPropsInHeatChart(configToUpdate: WebChart): WebChart;
 /**
  * Conversions for 1.0.1:
  *   - orderByField adjustment for PieFromFields
@@ -388,12 +413,19 @@ declare function convertTo21x1x0(configToUpdate: WebChart): WebChart;
  */
 declare function convertTo23x3x0(configToUpdate: WebChart): WebChart;
 /**
- * Conversion for v24.4.0:
+ * Conversion for v24.8.0:
  * - Converts the temporal binning properties from the old pattern to the new pattern
  * @param configToUpdate The chart's config to update
  * @returns The updated chart config
  */
-declare function convertTo24x4x0(configToUpdate: WebChart): WebChart;
+declare function convertTo24x8x0(configToUpdate: WebChart): WebChart;
+/**
+ * Conversion for v25.0.0:
+ * - Add the `type` property to temporal binning properties in the heat chart series
+ * @param configToUpdate The chart's config to update
+ * @returns The updated chart config
+ */
+declare function convertTo25x0x0(configToUpdate: WebChart): WebChart;
 /**
  * Apply the needed function calls depending on the current chart version.
  * Note: Additional switch cases and convertToxxx functions are to be added to this function accordingly.
@@ -418,24 +450,26 @@ declare function applyConversions<T extends WebChart>(props: {
 /**
  * Main function that converts the chart config with older chart JSON Schema, comparing to the current version.
  *
- * Notes:
- * 1. This function will convert and update the chart config to the current version if the version is older or unrecognized.
- * 2. This function will also call mandatory conversion functions that are not related to the spec version
- * to ensure certain features are working properly.
- *
- * @param {*} config The chart config
- * @param {*} layer The layer instance
+ * **Note**:
+ *   1. This function will convert and update the chart config to the current version if the version is older or unrecognized.
+ *   2. This function will also call mandatory conversion functions that are not related to the spec version to ensure certain features are working properly.
  *
- * @returns the updated web chart config.
+ * @param config - The chart config
+ * @param layer - The layer instance
+ * @returns the updated web chart config
  */
 export declare function convertChartSpec<T extends WebChart | WebGaugeChart>(config?: T, layerOrLayerView?: FeatureLayerView | SupportedLayer, chartContainer?: HTMLElement): Promise<T>;
 export declare const chartConfigConverterPrivateFunctions: {
+    adjustAxes: typeof adjustAxes;
+    adjustSeries: typeof adjustSeries;
     matchChartFieldsToLayerFields: typeof matchChartFieldsToLayerFields;
+    resetLegendMaxHeight: typeof resetLegendMaxHeight;
     moveSeriesQueryExtent: typeof moveSeriesQueryExtent;
     moveSeriesRotatedPropToChart: typeof moveSeriesRotatedPropToChart;
     renameDataSourceProperties: typeof renameDataSourceProperties;
     copyDataSourceFilterToConfig: typeof copyDataSourceFilterToConfig;
     adjustPieFromFieldsDefaultNameAndValue: typeof adjustPieFromFieldsDefaultNameAndValue;
+    removeSpacingPropertyFromGauge: typeof removeSpacingPropertyFromGauge;
     moveBoxPlotSeriesPropsToChart: typeof moveBoxPlotSeriesPropsToChart;
     movePieSeriesSortLabelsPropToChart: typeof movePieSeriesSortLabelsPropToChart;
     getProBoxPlotSortDataOption: typeof getProBoxPlotSortDataOption;
@@ -451,6 +485,7 @@ export declare const chartConfigConverterPrivateFunctions: {
     getDataOrderFromOrderByFields: typeof getDataOrderFromOrderByFields;
     convertWebChartDataValueTypes: typeof convertWebChartDataValueTypes;
     moveOrConvertSeriesOrderByFieldsToChartOrderOptions: typeof moveOrConvertSeriesOrderByFieldsToChartOrderOptions;
+    convertWebChartLabelBehaviorNoneToHide: typeof convertWebChartLabelBehaviorNoneToHide;
     handleOrderOptionsChanges: typeof handleOrderOptionsChanges;
     applyDataOrderInstructionForFromFieldsCharts: typeof applyDataOrderInstructionForFromFieldsCharts;
     convertTemporalBinningProps: typeof convertTemporalBinningProps;
@@ -476,8 +511,10 @@ export declare const chartConfigConverterPrivateFunctions: {
     convertTo20x2x0: typeof convertTo20x2x0;
     convertTo21x1x0: typeof convertTo21x1x0;
     convertTo23x3x0: typeof convertTo23x3x0;
-    convertTo24x4x0: typeof convertTo24x4x0;
+    convertTo24x8x0: typeof convertTo24x8x0;
+    convertTo25x0x0: typeof convertTo25x0x0;
     convertTemporalBinningProps2: typeof convertTemporalBinningProps2;
+    transformPropsInHeatChart: typeof transformPropsInHeatChart;
     applyConversions: typeof applyConversions;
     convertDataSourceToILayer: typeof convertDataSourceToILayer;
     applyDefaultFirstDayOfWeek: typeof applyDefaultFirstDayOfWeek;

package/dist/utils/chart-config/converter/interfaces.d.ts

@@ -1,4 +1,4 @@
-import { IFeatureLayer, WebChart, WebChartCalendarBinningOffsetUnits, WebChartDataTypes, WebChartNullPolicyTypes, WebChartSeries, WebChartSeriesQuery, WebChartSortOrderKinds, WebChartTemporalSeries, WebChartText, WebChartTimeAggregationTypes } from '../../../spec';
+import { IFeatureLayer, WebChart, WebChartCalendarBinningOffsetUnits, WebChartCalendarDatePartsUnits, WebChartClassBreakTypes, WebChartDataTypes, WebChartNullPolicyTypes, WebChartSeries, WebChartSeriesQuery, WebChartSortOrderKinds, WebChartTemporalSeries, WebChartText, WebChartTimeAggregationTypes } from '../../../spec';
 export type FormerWebChartSubtitle = WebChart & {
     subTitle?: WebChartText;
 };
@@ -46,6 +46,18 @@ export type FormerWebChartWithDataPreferLabel = WebChart & {
         };
     };
 };
+export type FormerWebHeatChartWithDifferentProps = WebChart & {
+    series: {
+        breaksCount?: number;
+        classificationMethod?: WebChartClassBreakTypes;
+        xTemporalBinning: {
+            unit: WebChartCalendarDatePartsUnits;
+        };
+        yTemporalBinning: {
+            unit: WebChartCalendarDatePartsUnits;
+        };
+    }[];
+};
 /**
  * JSON representation of the inline data source
  */

package/dist/utils/chart-config/utils/class-breaks/index.d.ts

@@ -0,0 +1,16 @@
+import { RESTSymbolType, RESTSimpleFillSymbolStyle, Color } from '../../../../spec';
+export interface ClassBreakInfo {
+    label: string;
+    classMinValue: number;
+    classMaxValue: number;
+    symbol: {
+        type: RESTSymbolType;
+        style: RESTSimpleFillSymbolStyle;
+        color: Color;
+        outline: {
+            style: RESTSimpleFillSymbolStyle;
+            color: Color;
+            width: number;
+        };
+    };
+}

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

@@ -1,4 +1,7 @@
-import { WebChart, WebChartSeriesType, RESTSymbolType, WebChartTypes, WebChartVersionStatus } from '../../../spec';
+import { ChartOptions } from '../../../chart-rendering/common/interfaces';
+import { IField, TimeIntervalInfo, WebBoxPlot, WebChart, WebChartLegend, WebChartSeriesType, WebHeatChart, RESTSymbolType, WebChartTypes, WebChartVersionStatus } from '../../../spec';
+import { DataUpdateDetails } from '../../data/interfaces';
+import { LimitBehavior } from '../../defaults/interfaces';
 import { ChartSubType } from '../../misc/interfaces';
 import { WebChartSeriesSupportingTemporalBinning } from './interfaces';
 /**
@@ -124,8 +127,299 @@ export declare function isSeriesUsingTimeBinning(props: {
  * @param series The series to test
  */
 export declare function doesSeriesSupportTemporalBinning(series: WebChartSeriesType): series is WebChartSeriesSupportingTemporalBinning;
+/**
+ * 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.previousConfig 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: {
+    previousConfig: WebChart;
+    newConfig: WebChart;
+    behaviorAfterLimit?: LimitBehavior;
+}): boolean;
+/**
+ * Compares two config data filters and returns true if they are identical, false otherwise
+ *
+ * @param previousConfig
+ * @param newConfig
+ */
+export declare function hasConfigFilterChanged(previousConfig: WebChart, newConfig: WebChart): boolean;
+/**
+ * Indicates whether the filter by selection was enabled or disabled
+ * @param previousFilterBySelection The previous valued for the filter by selection
+ * @param options The runtime options containing the new value for the filter by selection
+ */
+declare function hasFilterBySelectionChanged(previousFilterBySelection?: boolean, options?: ChartOptions): boolean;
+/**
+ * Compares the `binTemporalData` property from two configs and returns true if they are identical, false otherwise
+ *
+ * @param previousConfig
+ * @param newConfig
+ */
+declare function hasBinTemporalDataChanged(previousConfig: WebChart, newConfig: 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 previousConfig The former chart config
+ * @param newConfig The new chart config
+ */
+declare function isNewDataRequiredForValueFormatChange(previousConfig: WebBoxPlot | WebChart, newConfig: WebBoxPlot | WebChart): boolean;
+/**
+ * Compares the `showMean` from two configs and indicates whether they are different
+ *
+ * @param previousConfig The former chart config
+ * @param newConfig The new chart config
+ */
+declare function hasShowMeanChanged(previousConfig: WebBoxPlot, newConfig: WebBoxPlot): boolean;
+/**
+ * Compares two gauge configs and indicates whether the series value conversion changed
+ *
+ * @param previousConfig The previous config
+ * @param newConfig The updated config
+ */
+declare function hasGaugeValueConversionChanged(previousConfig: WebChart, newConfig: WebChart): boolean;
+/**
+ * Compares two heat chart configs to see if binning has changed
+ *
+ * @param previousConfig The previous config
+ * @param newConfig The updated config
+ */
+declare function hasHeatChartBinningChanged(previousConfig: WebHeatChart, newConfig: WebHeatChart): boolean;
+/**
+ * Compares two heat chart configs and indicates whether the hide empty rows and columns option changed
+ *
+ * @param previousConfig The previous config
+ * @param newConfig The updated config
+ */
+export declare function hasHeatChartHideEmptyRowsAndColumnsChanged(previousConfig: WebHeatChart, newConfig: WebHeatChart): boolean;
+/**
+ * Compares two heat chart configs and indicates whether to include leap day
+ *
+ * @param previousConfig The previous config
+ * @param newConfig The updated config
+ */
+export declare function hasHeatChartIncludeLeapDayChanged(previousConfig: WebChart, newConfig: WebChart): boolean;
+/**
+ * Compares two configs and indicates whether additional tooltip fields (only non-numeric) changed
+ *
+ * **NOTE**: Only applicable to scatterplot
+ *
+ * @param props.previousConfig - The previous config
+ * @param props.newConfig - The updated config
+ * @param props.fieldList - The layer field list
+ */
+export declare function hasAdditionalTooltipFieldsChanged(props: {
+    previousConfig: 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 stacked type changed
+ * @param oldConfig The previous config
+ * @param newConfig The updated config
+ * @returns
+ */
+export declare function hasStackedTypeChanged(oldConfig: WebChart, newConfig: WebChart): boolean;
+/**
+ * Normalizes the legend position
+ * @param legend The legend
+ * @returns The normalized legend
+ */
+export declare function normalizeLegendPosition(legend: WebChartLegend): WebChartLegend;
+/**
+ * Compares two configs and indicates whether the legend visibility changed
+ *
+ * @param oldConfig The previous config
+ * @param newConfig The updated config
+ */
+export declare function hasHeatLegendConfigChanged(oldConfig: WebHeatChart, newConfig: WebHeatChart): boolean;
+/**
+ * Compates two configs and indicates whether the heat legend position changed
+ *
+ * @param oldConfig The previous config
+ * @param newConfig The updated config
+ */
+export declare function hasHeatLegendPositionChanged(oldConfig: WebHeatChart, newConfig: WebHeatChart): 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: WebHeatChart, newConfig: WebHeatChart): boolean;
+/**
+ * Compares two configs and indicates whether the heat rules type changed
+ *
+ * @param oldConfig The previous config
+ * @param newConfig The updated config
+ */
+export declare function hasHeatRulesTypeChanged(oldConfig: WebHeatChart, newConfig: WebHeatChart): 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;
+export declare function hasDataForFilterBySelectionChanged(props: {
+    previousSelectionOIDs?: (number | string)[];
+    options?: ChartOptions;
+}): 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;
+/**
+ * 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 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: WebBoxPlot, newConfig: WebBoxPlot): 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: WebBoxPlot, newConfig: WebBoxPlot): 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;
+/**
+ * Indicates whether the size policy changed from the previous update
+ * @param oldConfig the old chart config
+ * @param newConfig the new chart config
+ */
+export declare function hasSizePolicyChanged(oldConfig: WebChart, newConfig: WebChart): boolean;
+/**
+ * Indicates whether a series reinitialization is necessary due to size policy changes
+ * @param oldConfig The old chart config
+ * @param newConfig The new chart config
+ */
+export declare function doSizePolicyChangesRequireSeriesReinit(oldConfig: WebChart, newConfig: 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 doesConfigChangeRequireNewData(props: {
+    previousConfig: WebBoxPlot | WebChart;
+    newConfig: WebBoxPlot | WebChart;
+    options?: ChartOptions;
+    previousFilterBySelection?: boolean;
+    previousTimeIntervalInfo?: TimeIntervalInfo;
+    previousSelectionOIDs?: (number | string)[];
+    fieldList?: IField[];
+}): {
+    dataUpdateNeeded: boolean;
+    dataUpdateDetails: DataUpdateDetails;
+};
+/**
+ * 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;
+/**
+ * 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;
 export declare const chartConfigUtilsPrivateFunctions: {
     getPieChartChartSubType: typeof getPieChartChartSubType;
     getBarLineChartSubType: typeof getBarLineChartSubType;
+    hasQueryChanged: typeof hasQueryChanged;
+    hasFilterBySelectionChanged: typeof hasFilterBySelectionChanged;
+    hasBinTemporalDataChanged: typeof hasBinTemporalDataChanged;
+    hasGaugeValueConversionChanged: typeof hasGaugeValueConversionChanged;
+    isNewDataRequiredForValueFormatChange: typeof isNewDataRequiredForValueFormatChange;
+    hasShowMeanChanged: typeof hasShowMeanChanged;
+    hasHeatChartBinningChanged: typeof hasHeatChartBinningChanged;
+    hasConfigSeriesNamesChanged: typeof hasConfigSeriesNamesChanged;
 };
 export {};

package/dist/utils/chart-config/validator/index.d.ts

@@ -61,16 +61,6 @@ declare function findWarnings(props: {
  * @param chartConfig The chart config
  */
 declare function findCustomErrors(queryObject?: QueryObject, chartConfig?: WebChart | WebGaugeChart): Promise<CustomErrorObject[]>;
-export declare const chartConfigValidatorPrivateFunctions: {
-    findCustomErrors: typeof findCustomErrors;
-    findWarnings: typeof findWarnings;
-    findNumericAggregationWarnings: typeof findNumericAggregationWarnings;
-    findDuplicateSeriesIDWarnings: typeof findDuplicateSeriesIDWarnings;
-    findLayerLoadError: typeof findLayerLoadError;
-    createStartingSchema: typeof createStartingSchema;
-    extractSchemaNameFromRefPath: typeof extractSchemaNameFromRefPath;
-    customizeValidationErrors: typeof customizeValidationErrors;
-};
 /**
  * Validates the `WebChart` config by checking for  and displays `Errors` and `Warnings`.
  * - `Errors` are violations in the config w.r.t the JSON schema.
@@ -90,4 +80,14 @@ export declare function validateWebChart(props: {
  * @param config The config to analyze
  */
 export declare function isPartialConfig(config?: WebChart): boolean;
+export declare const chartConfigValidatorPrivateFunctions: {
+    findCustomErrors: typeof findCustomErrors;
+    findWarnings: typeof findWarnings;
+    findNumericAggregationWarnings: typeof findNumericAggregationWarnings;
+    findDuplicateSeriesIDWarnings: typeof findDuplicateSeriesIDWarnings;
+    findLayerLoadError: typeof findLayerLoadError;
+    createStartingSchema: typeof createStartingSchema;
+    extractSchemaNameFromRefPath: typeof extractSchemaNameFromRefPath;
+    customizeValidationErrors: typeof customizeValidationErrors;
+};
 export {};

package/dist/utils/components/action-bar-utils.d.ts

@@ -5,8 +5,8 @@ import { ChartTypes, DefaultChartActions } from '../../utils';
 /**
  * Returns the default actions for a given chart type
  *
- * @param {ChartTypes} chartType The chart type for which to get the default actions
- * @returns {DefaultChartActions[]} The default actions for the given chart type
+ * @param props.chartType - The chart type for which to get the default actions
+ * @returns The default actions for the given chart type
  */
 export declare function getDefaultChartActions(chartType: ChartTypes | undefined): DefaultChartActions[];
 /**
@@ -19,10 +19,10 @@ export declare const onActionBarSlotChange: (e: Event, chartComponent: HTMLArcgi
 /**
  * Updates the action bar states based on the properties of the chart component and the config object.
  *
- * @param {HTMLArcgisChartsActionBarElement} props.actionBar - The action bar element to update.
- * @param {HTMLArcgisChartElement} props.chartComponent - The chart component element.
- * @param {WebChart} [props.config] - The configuration object for the chart.
- * @param {boolean} [props.isWarningDisplayed] - Optional flag to indicate if a warning is displayed.
+ * @param props.actionBar - The action bar element to update.
+ * @param props.chartComponent - The chart component element.
+ * @param props.config - The configuration object for the chart.
+ * @param props.isWarningDisplayed - Optional flag to indicate if a warning is displayed.
  *
  */
 export declare function updateActionBarStates(props: {

package/dist/utils/components/chart-ui-utils.d.ts

@@ -1,6 +1,7 @@
 import { RESTSimpleLineSymbolStyle } from '../../spec';
-import { NumericFieldsChangeProps } from '../../interfaces';
+import { NumericFieldsChangeProps, WebChartCalendarTypes } from '../../interfaces';
 import { FormatKeys } from '../../model';
+import { HeatChartModel } from '../../model/heat-chart-model/heat-chart-model';
 export interface RGB {
     r: number;
     g: number;
@@ -19,7 +20,7 @@ export declare const DefaultStatNumberFormat: {
 };
 export declare const aggregationList: ("count" | "sum" | "min" | "max" | "avg" | "percentile-continuous" | "no_aggregation")[];
 export declare const pieAggregationList: ("count" | "sum")[];
-export declare function getFormatIcon(formatKey: FormatKeys | undefined): string | undefined;
+export declare function getFormatIcon(formatKey: FormatKeys | undefined): HTMLCalciteIconElement["icon"] | undefined;
 /**
  * Validates a value entered in a numeric calcite-input.
  * Controls that the value is not undefined, not empty (invalid) and in between the [min, max] range if provided
@@ -85,30 +86,22 @@ export declare function sanitizeColor(color: RGB | undefined): RGB | null;
 /**
  * Handler for "keydown" event on numberic input element. Prevents input of "e" character.
  *
- * @param e Input element "keydown" event
+ * @param e - Input element "keydown" event
  */
 export declare const blockNumericE: (e: KeyboardEvent) => void;
 /**
- * emit numeric field change event
- *
- * @param props.pickListElement
- * @param props.eventEmitter
- * @param props.contentKind
- * @category Public
+ * Emit numeric field change event.
  */
 export declare const emitNumericFieldsChange: (props: NumericFieldsChangeProps) => void;
 /**
  * Returns the line style type based on the provided line style.
- *
- * @param lineStyle
  */
 export declare function getLineStyleType(lineStyle: RESTSimpleLineSymbolStyle | undefined): string;
 /**
  * Downloads an object as a file using a data URL.
  *
- * @param {string} objectURL - The data URL of the object to download.
- * @param {string} downloadString - The name of the file to download.
- * @category Public
+ * @param objectURL - The data URL of the object to download.
+ * @param downloadString - The name of the file to download.
  */
 export declare function downloadFile(objectURL: string, downloadString: string): void;
 /**
@@ -118,3 +111,9 @@ export declare function downloadFile(objectURL: string, downloadString: string):
  * @returns Null return for caller to easily reset tooltip object to null
  */
 export declare function destroyTooltip(tooltip: HTMLCalciteTooltipElement | null | undefined): null;
+/**
+ * Gets the calendar type based on the heat chart model's temporal binning configuration.
+ * @param {HeatChartModel} model - The heat chart model.
+ * @returns {WebChartCalendarTypes | undefined} The calendar type, or undefined if not applicable.
+ */
+export declare function getCalendarType(model: HeatChartModel): WebChartCalendarTypes | undefined;