@arcgis/charts-components 5.0.0-next.8 → 5.0.0-next.80

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

@@ -1,6 +1,7 @@
 import { default as FeatureLayerView } from '@arcgis/core/views/layers/FeatureLayerView';
-import { SupportedLayer, WebBoxPlot, WebChart, WebChartBoxPlotSeries, WebChartDirectionalDataOrder, WebChartLineChartSeries, WebGaugeChart, WebHeatChart, WebChartOrderDataByTypes } from '../../../spec';
+import { WebBoxPlot, WebChart, WebChartBoxPlotSeries, WebChartDirectionalDataOrder, WebChartLineChartSeries, WebGaugeChart, WebHeatChart, WebChartOrderDataByTypes } from '../../../spec';
 import { FormerWebChartBoxPlotDataSortTypes, FormerWebChartDataValueTypes } from './interfaces';
+import { SupportedLayer } from '../../../interfaces';
 /** ***********************************************************************************
  *                                                                                    *
  * Routines that handle adjustments/conversions for chart regardless of chart version.*
@@ -17,6 +18,8 @@ declare function applyDefaultFirstDayOfWeek(props: {
     chartContainer?: HTMLElement;
     layer?: SupportedLayer;
 }): WebChart | 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.
  *
@@ -61,6 +64,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 +96,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 +235,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:
@@ -388,12 +408,12 @@ declare function convertTo21x1x0(configToUpdate: WebChart): WebChart;
  */
 declare function convertTo23x3x0(configToUpdate: WebChart): WebChart;
 /**
- * Conversion for v24.3.0:
+ * Conversion for v24.6.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 convertTo24x3x0(configToUpdate: WebChart): WebChart;
+declare function convertTo24x6x0(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.
@@ -430,12 +450,16 @@ declare function applyConversions<T extends WebChart>(props: {
  */
 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 +475,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,7 +501,7 @@ export declare const chartConfigConverterPrivateFunctions: {
     convertTo20x2x0: typeof convertTo20x2x0;
     convertTo21x1x0: typeof convertTo21x1x0;
     convertTo23x3x0: typeof convertTo23x3x0;
-    convertTo24x3x0: typeof convertTo24x3x0;
+    convertTo24x6x0: typeof convertTo24x6x0;
     convertTemporalBinningProps2: typeof convertTemporalBinningProps2;
     applyConversions: typeof applyConversions;
     convertDataSourceToILayer: typeof convertDataSourceToILayer;

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, WebChartSeriesType, 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,290 @@ 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 | WebChart, newConfig: WebBoxPlot | WebChart): 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: WebChart, newConfig: WebChart): 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: WebChart, newConfig: WebChart): boolean;
+/**
+ * Compares two configs and indicates whether additional tooltip fields (only non-numeric) changed
+ *
+ * **NOTE**: (only for scatterplot)
+ *
+ * @param {WebChart} props.previousConfig The previous config
+ * @param {WebChart} props.newConfig The updated config
+ * @param {IField[]|undefined} 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;
+/**
+ * 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: 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;
+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: 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;
+/**
+ * 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;
+/**
+ * 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.
+ *
+ * @param oldConfig The previous chart config.
+ * @param newConfig The new chart config.
+ * @returns
+ */
+export declare function isSortBySeriesNeeded(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;
+    hasSeriesOrderChanged: typeof hasSeriesOrderChanged;
+    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/config-update.d.ts

@@ -1,7 +1,10 @@
+import { default as Graphic } from '@arcgis/core/Graphic';
 import { default as FeatureLayerView } from '@arcgis/core/views/layers/FeatureLayerView';
 import { ChartOptions } from '../../chart-rendering/common/interfaces';
 import { ArcgisChart } from '../../components/arcgis-chart/customElement.js';
-import { SupportedLayer, WebChart, WebChartLegendPositions } from '../../spec';
+import { WebBoxPlot, WebChart, WebChartLegendPositions } from '../../spec';
+import { QueryObject } from '../../utils';
+import { SupportedLayer } from '../../interfaces';
 /**
  * Updates the legend position for a given WebChart config.
  * Returns the updated config.
@@ -18,6 +21,13 @@ export declare function updateLegendPosition(newLegendPosition: WebChartLegendPo
  * @param config
  */
 export declare function updateLegendVisibility(visible: boolean, config?: WebChart): WebChart | undefined;
+/**
+ * Updates the chart rotation for a given WebChart config.
+ * Returns the updated config.
+ * @param newRotation new rotation
+ * @param config the chart config
+ */
+export declare function updateRotation<T extends WebBoxPlot | WebChart>(newRotation: boolean, config?: T): T | undefined;
 /**
  * Resets the axes bounds.
  * Returns the updated config.
@@ -35,12 +45,23 @@ export declare function resetAxesBounds(config?: WebChart): WebChart | undefined
  */
 export declare function isValidDataSource(config?: WebChart, layer?: FeatureLayerView | SupportedLayer): boolean;
 /**
- * Will add missing series to the chart config if:
- * - the config uses a split-by field
- * - adding missing series was requested (through the `updateSplitBySeries` property)
- * - unique values for the given split-by field don't have a series associated
- *
- * @param component The chart component
- * @param options The runtime options
+ * Alters the providing config to prepare it for rendering:
+ * - add the iLayer if missing
+ * - convert it to the latest version
+ * @param props.configToAlter The config to alter
+ * @param props.layer The component's layer
  */
-export declare function addMissingSplitBySeries(component: ArcgisChart, config: WebChart | undefined, options: ChartOptions): Promise<void>;
+export declare function prepareConfigForRendering(props: {
+    creation: boolean;
+    configToAlter: WebChart | undefined;
+    chartContainer?: HTMLElement;
+    queryObject: QueryObject;
+    options: ChartOptions;
+    previousConfig?: WebChart | undefined;
+    updateSplitBySeries: ArcgisChart["updateSplitBySeries"];
+    addMissingSeries: boolean;
+    layer: ArcgisChart["layer"];
+}): Promise<{
+    alteredConfig: ArcgisChart["config"];
+    preFetchedQueryResponse?: Graphic[];
+}>;

package/dist/utils/components/data-update.d.ts

@@ -0,0 +1,36 @@
+import { ChartOptions } from '../../chart-rendering/common/interfaces';
+import { ArcgisChart } from '../../components/arcgis-chart/customElement.js';
+import { IField, WebChart } from '../../spec';
+import { DataUpdateDetails } from '../data/interfaces';
+import { SelectionData } from '../misc/interfaces';
+/**
+ * Indicates whether a data update is needed based on the changed properties.
+ * Checks for:
+ * - specific properties that require a data update when changed,
+ * - change of layer type (FeatureLayer to FeatureLayerView or vice-versa),
+ * - changes in the config that require a data update.
+ * @param props.config The current chart config
+ * @param props.previousConfig The previous chart config
+ * @param props.dataUpdateNeededProps The list of properties that require a data update when changed
+ * @param props.updatedProps A map of the properties that have been updated with their old and new values
+ * @param props.filterBySelection The current filterBySelection value
+ * @param props.previousSelectionOIDs The previous selection OIDs
+ * @param props.chartData The current chart data
+ * @param props.options The current chart options
+ * @param props.fieldList The list of fields in the layer or feature layer view
+ * @returns
+ */
+export declare function isDataUpdateNeeded(props: {
+    config: WebChart | undefined;
+    previousConfig: WebChart | undefined;
+    dataUpdateNeededProps: ArcgisChart["dataUpdateNeededProps"];
+    updatedProps: ArcgisChart["updatedProps"];
+    filterBySelection: ArcgisChart["filterBySelection"];
+    previousSelectionOIDs: SelectionData["selectionOIDs"];
+    chartData: ArcgisChart["chartData"];
+    options: ChartOptions;
+    fieldList: IField[];
+}): {
+    dataUpdateNeeded: boolean;
+    dataUpdateDetails: DataUpdateDetails | undefined;
+};

package/dist/utils/components/event-payloads.d.ts

@@ -12,9 +12,6 @@ export type DataChangeErrorPayload = {
     error: Error;
     model: ChartModel;
 };
-export type PopoverOpenChangePayload = {
-    open: boolean | undefined;
-};
 export type PopoverChangePayload = {
     open: boolean | undefined;
     element: JsxNode;

package/dist/utils/components/watch-handlers.d.ts

@@ -1,37 +1,37 @@
 import { ArcgisChart } from '../../components/arcgis-chart/customElement.js';
 /**
- * Adds a listener on the feature layer, so every time the definition expression (filter) is modified we update
+ * Adds a watch handler on the feature layer, so every time the definition expression (filter) is modified we update
  * the chart.
  *
  * @param component The chart component
  */
-export declare function addLayerFilterListener(component: ArcgisChart): Promise<IHandle | undefined>;
+export declare function watchLayerFilter(component: ArcgisChart): IHandle | undefined;
 /**
- * Adds a listener on the feature layer, so every time the renderer is modified we update the chart.
+ * Adds a watch handler on the feature layer, so every time the renderer is modified we update the chart.
  *
  * @param component The chart component
  */
-export declare function addLayerRendererListener(component: ArcgisChart): Promise<IHandle | undefined>;
+export declare function watchLayerRenderer(component: ArcgisChart): IHandle | undefined;
 /**
- * Adds a listener on the feature layer view, so every time the view's extent is modified we update
+ * Adds a watch handler on the feature layer view, so every time the view's extent is modified we update
  * the chart.
  *
  * @param props.component The chart component
  */
-export declare function addExtentChangeListener(component: ArcgisChart): Promise<IHandle[] | undefined>;
+export declare function watchExtentChange(component: ArcgisChart): Promise<IHandle[] | undefined>;
 /**
- * Adds a listener on the view's time extent, so every time extent is modified we update the chart.
+ * Adds a watch handler on the view's time extent, so every time extent is modified we update the chart.
  * @param component The chart component
  */
-export declare function addViewTimeExtentListener(component: ArcgisChart): Promise<IHandle | undefined>;
+export declare function watchViewTimeExtent(component: ArcgisChart): IHandle | undefined;
 /**
- * Adds a listener on the feature layer, so every time the fields are modified we update the chart.
+ * Adds a watch handler on the feature layer, so every time the fields are modified we update the chart.
  *
  * @param component The chart component
  */
-export declare function addLayerFieldsListener(component: ArcgisChart): Promise<IHandle | undefined>;
+export declare function watchLayerFields(component: ArcgisChart): IHandle | undefined;
 /**
- * Adds a listener on the layer's view; so every time the selection data is modified, we update the chart.
+ * Adds a watch handler on the layer's view; so every time the selection data is modified, we update the chart.
  * @param component The chart component
  */
-export declare function addSelectionsChangeInViewListener(component: ArcgisChart): Promise<IHandle | undefined>;
+export declare function watchSelectionsChangeInView(component: ArcgisChart): IHandle | undefined;

package/dist/utils/components/web-component-utils.d.ts

@@ -1,9 +1,9 @@
-import { CSVOptions } from '../../interfaces';
-import { ModelTypes } from '../../model';
-import { IField, SupportedLayer } from '../../spec';
-import { ChartConfig } from '../types';
 import { default as FeatureLayerView } from '@arcgis/core/views/layers/FeatureLayerView.js';
+import { SupportedLayer, CSVOptions } from '../../interfaces';
+import { ModelTypes } from '../../model';
+import { IField } from '../../spec';
 import { SupportedLocalesForFormats } from '../localization/interfaces';
+import { ChartConfig } from '../types';
 /**
  * A utility function to compare if a value has changed deeply.
  * @param value
@@ -97,3 +97,8 @@ export declare function transformBoxPlotData<T extends Record<string, unknown>>(
  * @param {unknown} date - The date to check, should be a string or a number.
  */
 export declare const isValidDate: (date: unknown) => date is Date | number | string;
+/**
+ * Returns a unique ID.
+ * Example: 33c2c20e-5a9e-c7be-1b23-b210e6218831
+ */
+export declare function generateGUID(): string;

package/dist/utils/data/index.d.ts

@@ -14,7 +14,7 @@ export declare function getBoxPlotStatisticFieldNames(y?: string): Record<BoxPlo
  * @param config the chart config
  * @default false
  */
-export declare function isGaugeByFeature(config: WebGaugeChart): boolean;
+export declare function isGaugeByFeature(config: WebChart): boolean;
 /**
  * From fetched data (type: WebChartDataTypes) returns the part containing the data that
  * is to be assigned to the chart (WebChartDataItem[] | WebChartBin[])
@@ -99,7 +99,7 @@ export declare function isEmptyDataset(props: {
     dataSet?: WebChartDataItem[];
 }): boolean;
 /**
- * Gets the data min and max values for a stacked series
+ * Gets the data min and max values for a stacked series; also an indicator whether the data has negative values.
  * @param seriesConfig The config for the series
  * @param filteredSeriesIds List of series ids to use as a filter
  * @param filteredData The data to look into
@@ -111,6 +111,7 @@ export declare function getDataMinMaxFromStackedSeries(props: {
 }): {
     stackedMinY: number;
     stackedMaxY: number;
+    dataHasNegativeValues: boolean;
 };
 /**
  * Looks for the min and max values from a data set, considering only the visible series.