@arcgis/charts-components 5.0.0-next.114 → 5.0.0-next.116

package/dist/model/properties/rotated-state.d.ts

@@ -0,0 +1,24 @@
+import { ChartConfig } from '../../utils/types';
+import { ChartModelBase } from '../chart-model/chart-model-base';
+/**
+ * Type guard for model `WithRotatedState`.
+ */
+export declare function isModelWithRotatedState(model: ChartModelBase | undefined): model is WithRotatedState;
+/**
+ * Whether the chart is rotated.
+ */
+export declare const getRotatedState: (config: ChartConfig) => boolean;
+/**
+ * Whether the chart is rotated.
+ */
+export declare const setRotatedState: (rotated: boolean, config: ChartConfig) => void;
+/**
+ * Adds support for working with the chart rotated state.
+ */
+export declare abstract class WithRotatedState extends ChartModelBase {
+    /**
+     * Whether the chart is rotated.
+     */
+    get rotatedState(): boolean;
+    set rotatedState(rotated: boolean);
+}

package/dist/model/radar-chart-model/radar-chart-model.d.ts

@@ -4,6 +4,7 @@ import { SerialChartModel } from '../serial-chart-model/serial-chart-model';
 import { ModelParams } from '../interfaces/chart-interfaces';
 import { ModelWithLineMarkerStyling } from '../mixins';
 import { LayerInfo, ModelTypes } from '../interfaces/common';
+import { MixinInstances } from '../shared/utils';
 import { WithNegativeValuesStackedToBaseline } from '../properties/series/negative-values-stacked-to-baseline';
 export declare class RadarChartModel extends SerialChartModel {
     /**
@@ -31,5 +32,7 @@ export declare class RadarChartModel extends SerialChartModel {
      */
     resetAvailable(): boolean;
 }
-export interface RadarChartModel extends WithNegativeValuesStackedToBaseline, ModelWithLineMarkerStyling {
+declare const radarChartMixins: readonly [typeof WithNegativeValuesStackedToBaseline, typeof ModelWithLineMarkerStyling];
+export interface RadarChartModel extends MixinInstances<typeof radarChartMixins> {
 }
+export {};

package/dist/model/scatterplot-model/scatterplot-model.d.ts

@@ -1,10 +1,13 @@
 import { ISimpleLineSymbol, ISimpleMarkerSymbol, WebChart, SizePolicy, ScatterplotOverlays } from '../../spec';
 import { ChartConfig, XYChartTypes } from '../../utils';
+import { MixinInstances } from '../shared/utils';
 import { ModelParams } from '../interfaces/chart-interfaces';
 import { LayerInfo, ModelTypes } from '../interfaces/common';
 import { ChartModel } from '../chart-model/chart-model';
-import { ModelWithDataLabels, ModelWithXGuides, ModelWithYGuides, ModelWithLegend, ModelWithMultiAxes, ModelWithTooltips } from '../mixins';
+import { ModelWithXGuides, ModelWithYGuides, ModelWithLegend, ModelWithMultiAxes, ModelWithTooltips } from '../mixins';
 import { WithColorMatch } from '../properties/color-match';
+import { WithDataLabelsVisibility } from '../properties/data-labels/data-labels-visibility';
+import { WithDataLabelsSymbol } from '../properties/data-labels/data-labels-symbol';
 export declare class ScatterplotModel extends ChartModel {
     /**
      * Current configuration used for the scatterplot.
@@ -69,5 +72,7 @@ export declare class ScatterplotModel extends ChartModel {
     generateYAxisTitle(): string;
     protected generateDefaultConfig(): Omit<typeof this._config, "iLayer">;
 }
-export interface ScatterplotModel extends ModelWithMultiAxes, ModelWithLegend, ModelWithTooltips, WithColorMatch, ModelWithDataLabels, ModelWithXGuides, ModelWithYGuides {
+declare const scatterplotMixins: readonly [typeof ModelWithMultiAxes, typeof ModelWithLegend, typeof ModelWithTooltips, typeof WithColorMatch, typeof WithDataLabelsVisibility, typeof WithDataLabelsSymbol, typeof ModelWithXGuides, typeof ModelWithYGuides];
+export interface ScatterplotModel extends MixinInstances<typeof scatterplotMixins> {
 }
+export {};

package/dist/model/serial-chart-model/serial-chart-model.d.ts

@@ -2,9 +2,13 @@ import { SerialChartTypes } from '../../utils';
 import { ChartModel } from '../chart-model/chart-model';
 import { Color, WebChartDataFilters, WebChartNullCategory, WebChartStackedKinds, WebChartStatisticType } from '../../spec';
 import { SerialChartConfig } from '../interfaces/chart-interfaces';
+import { MixinInstances } from '../shared/utils';
 import { HeatChartDataSortingKinds, SerialChartDataSortingKinds } from '../interfaces/common';
-import { ModelWithDataLabels, ModelWithLegend, ModelWithTooltips, ModelWithRotation, ModelWithTemporalBinning, ModelWithXGuides, ModelWithYGuides, ModelWithMultiAxes } from '../mixins';
+import { ModelWithLegend, ModelWithTooltips, ModelWithTemporalBinning, ModelWithXGuides, ModelWithYGuides, ModelWithMultiAxes } from '../mixins';
 import { WithColorMatch } from '../properties/color-match';
+import { WithRotatedState } from '../properties/rotated-state';
+import { WithDataLabelsVisibility } from '../properties/data-labels/data-labels-visibility';
+import { WithDataLabelsSymbol } from '../properties/data-labels/data-labels-symbol';
 export declare abstract class SerialChartModel extends ChartModel {
     /**
      * Current chart type.
@@ -208,5 +212,7 @@ export declare abstract class SerialChartModel extends ChartModel {
      */
     generateYAxisTitle(): string;
 }
-export interface SerialChartModel extends ModelWithMultiAxes, ModelWithLegend, ModelWithTooltips, WithColorMatch, ModelWithRotation, ModelWithDataLabels, ModelWithXGuides, ModelWithYGuides, ModelWithTemporalBinning {
+declare const serialChartMixins: readonly [typeof ModelWithMultiAxes, typeof ModelWithLegend, typeof ModelWithTooltips, typeof WithColorMatch, typeof WithRotatedState, typeof WithDataLabelsVisibility, typeof WithDataLabelsSymbol, typeof ModelWithXGuides, typeof ModelWithYGuides, typeof ModelWithTemporalBinning];
+export interface SerialChartModel extends MixinInstances<typeof serialChartMixins> {
 }
+export {};

package/dist/model/shared/axes.d.ts

@@ -67,13 +67,6 @@ export declare const setMinXBound: (config: ChartConfig, newMinXBound: number |
  */
 export declare const getXAxisValueFormat: (config: ChartConfig) => CategoryFormatOptions | DateTimeFormatOptions | NumberFormatOptions | undefined;
 export declare const setXAxisValueFormat: (config: ChartConfig, commonStrings: CommonStrings, valueFormat?: CategoryFormatOptions | DateTimeFormatOptions | NumberFormatOptions) => void;
-/**
- * Get the valueFormat of the y-axis.
- *
- * @param config - the config object
- */
-export declare const getYAxisValueFormat: (config: ChartConfig) => NumberFormatOptions | undefined;
-export declare const setYAxisValueFormat: (config: ChartConfig, commonStrings: CommonStrings, valueFormat?: NumberFormatOptions) => void;
 /**
  * Set the integer only values in the axis
  * @param config - the config object

package/dist/model/shared/type-guards.d.ts

@@ -1,17 +1,23 @@
-import { BarChartModel, BoxPlotModel, ChartModel, ComboBarLineChartModel, GaugeModel, HistogramModel, LineChartModel, ModelOfType, ModelTypes, PieChartLegendModel, PieChartModel, ScatterplotModel, SerialChartModel } from '..';
 import { WebChart } from '../../spec';
+import { ModelWithBasicXAxis, ModelWithGuides, ModelWithLegend, ModelWithLineMarkerStyling, ModelWithMultiAxes, ModelWithTemporalBinning, ModelWithTooltips, ModelWithXGuides, ModelWithYGuides } from '../mixins/index';
 import { HeatChartModel } from '../heat-chart-model/heat-chart-model';
-import { ModelWithBasicXAxis, ModelWithDataLabels, ModelWithGuides, ModelWithLegend, ModelWithLineMarkerStyling, ModelWithMultiAxes, ModelWithRotation, ModelWithTemporalBinning, ModelWithTooltips, ModelWithXGuides, ModelWithYGuides } from '../mixins/index';
+import { BarChartModel } from '../bar-chart-model/bar-chart-model';
+import { BoxPlotModel } from '../box-plot-model/box-plot-model';
+import { ChartModel } from '../chart-model/chart-model';
+import { ComboBarLineChartModel } from '../combo-bar-line-chart-model/combo-bar-line-chart-model';
+import { GaugeModel } from '../gauge-model/gauge-model';
+import { HistogramModel } from '../histogram-model/histogram-model';
+import { ModelTypes, ModelOfType } from '../interfaces/common';
+import { LineChartModel } from '../line-chart-model/line-chart-model';
+import { PieChartLegendModel } from '../pie-chart-model/pie-chart-legend-model';
+import { PieChartModel } from '../pie-chart-model/pie-chart-model';
+import { ScatterplotModel } from '../scatterplot-model/scatterplot-model';
+import { SerialChartModel } from '../serial-chart-model/serial-chart-model';
 /**
  * Determines if the provided model or config is a `ChartModel`.
  * @param model The model to check.
  */
 export declare function isChartModel(model: ChartModel | WebChart | undefined): model is ChartModel;
-/**
- * Determines if the provided `model` is of type `HeatChartModel`.
- * @param model The model to check.
- */
-export declare function isHeatChartModel(model: ChartModel | undefined): model is HeatChartModel;
 /**
  * Determines if the provided `model` is of type `BarChartModel`.
  * @param model The model to check.
@@ -54,6 +60,11 @@ export declare function isScatterplotModel(model: ChartModel | undefined): model
  * @param model The model to check.
  */
 export declare function isHistogramModel(model: ChartModel | undefined): model is HistogramModel;
+/**
+ * Determines if the provided `model` is of type `HeatChartModel`.
+ * @param {ChartModel | undefined} model The model to check.
+ */
+export declare function isHeatChartModel(model: ChartModel | undefined): model is HeatChartModel;
 /**
  * Determines if the provided `model` is of type `GaugeModel`.
  * @param model The model to check.
@@ -79,16 +90,6 @@ export declare function isModelWithLineMarkerStyling(model: ChartModel | undefin
  * @param model
  */
 export declare function isModelWithTooltips(model: ChartModel | undefined): model is ModelWithTooltips;
-/**
- * Type guard for ModelWithRotation
- * @param model
- */
-export declare function isModelWithRotation(model: ChartModel | undefined): model is ModelWithRotation;
-/**
- * Determines if the provided `model` is of type `ModelWithDataLabels`.
- * @param model The model to check.
- */
-export declare function isModelWithDataLabels(model: ChartModel | undefined): model is ModelWithDataLabels;
 /**
  * Determines if the provided `model` is of type `ModelWithGuides`.
  * @param model The model to check.

package/dist/model/shared/utils.d.ts

@@ -1,5 +1,6 @@
 import { SupportedLayer } from '../../interfaces';
-import { IField, WebChart, WebChartAxis, WebChartGaugeAxis } from '../../spec';
+import { IField, WebChart, WebChartAxis, WebChartGaugeAxis, WebHeatChart } from '../../spec';
+import { ChartConfig } from '../../utils';
 import { LayerInfo, SplitByFieldInfos } from '../interfaces/common';
 /**
  * Returns the necessary information for building series based on a split-by field.
@@ -24,10 +25,16 @@ export declare function getSplitByFieldInfos(props: {
 export declare function isWebGaugeChartAxis(params: WebChartAxis[] | [WebChartGaugeAxis] | undefined): params is [WebChartGaugeAxis];
 export declare function isValidSplitByField(layerFieldsInfo: IField[], splitByField: string): boolean;
 export declare function isValidNumericFields(layerFieldsInfo: IField[], numericFields: string[]): boolean;
+type AbstractConstructor = abstract new (...args: any) => any;
+export type MixinInstances<T extends readonly AbstractConstructor[]> = T extends readonly [infer H, ...infer R] ? H extends AbstractConstructor ? R extends readonly AbstractConstructor[] ? InstanceType<H> & MixinInstances<R> : InstanceType<H> : unknown : unknown;
 /**
- * This function applies mixins to a class. [source](https://www.typescriptlang.org/docs/handbook/mixins.html)
+ * Runtime helper that copies prototype members from each mixin constructor onto the target.
+ *
+ * Accepts a readonly tuple so it lines up with the typed mixin lists used in MixinInstances.
+ *
+ * [source](https://www.typescriptlang.org/docs/handbook/mixins.html)
  */
-export declare function applyMixins(derivedCtor: any, constructors: any[]): void;
+export declare function applyMixins(derivedCtor: any, constructors: readonly AbstractConstructor[]): void;
 /**
  * Get the list of category's values or labels from the layer.
  *
@@ -40,3 +47,12 @@ export declare function getCategoryLabels(props: {
     config: WebChart;
     category: string;
 }): Promise<string[]>;
+/**
+ * Checks if the given chart config is a matrix heat chart.  A matrix heat chart is defined as a heat chart with
+ * both axes using a category value format.
+ *
+ * @param chartConfig The chart config
+ * @returns True if the chart is a matrix heat chart, false otherwise
+ */
+export declare function isMatrixHeatChart(chartConfig?: ChartConfig | WebHeatChart): boolean;
+export {};

package/dist/model.js

@@ -1,11 +1,11 @@
 import { M as i } from "./chunks/common.js";
 import { B as m, C as y, F as g, G as C, H as w, L as f, a as u, P as L, b, S as p, T, c as S } from "./chunks/common.js";
-import { y as r, z as s, A as n } from "./chunks/type-guards.js";
-import { b as B, g as P, i as x, d as W, k as v, a as G, j as H, c as K, x as D, l as F, q as A, r as O, u as R, n as E, m as X, p as Y, w as $, o as j, s as q, t as z, v as I, f as J, h as N, e as Q } from "./chunks/type-guards.js";
+import { w as r, x as s, y as n } from "./chunks/type-guards.js";
+import { a as B, f as P, i as x, c as W, k as v, j as G, h as H, b as K, v as D, l as F, p as O, s as A, n as E, m as R, u as X, o as Y, q as $, r as j, t as q, e as z, g as I, d as J } from "./chunks/type-guards.js";
 /*! All material copyright Esri, All Rights Reserved, unless otherwise specified.
 See https://js.arcgis.com/5.0/esri/copyright.txt for details.
-v5.0.0-next.114 */
-async function h(t) {
+v5.0.0-next.116 */
+async function c(t) {
   const o = "config" in t ? r(t.config) : t.chartType;
   let a;
   if (!("layer" in t) && !("iLayer" in t) && "config" in t && t.config.iLayer === void 0)
@@ -91,7 +91,7 @@ export {
   b as PieChartSlicesDisplay,
   p as SerialChartDataSortingKinds,
   T as TextFormatKeys,
-  h as createModel,
+  c as createModel,
   S as customSortString,
   B as isBarChartModel,
   P as isBoxPlotModel,
@@ -103,18 +103,16 @@ export {
   K as isLineChartModel,
   D as isModelOfType,
   F as isModelWithBasicXAxis,
-  A as isModelWithDataLabels,
   O as isModelWithGuides,
-  R as isModelWithLegend,
+  A as isModelWithLegend,
   E as isModelWithLineMarkerStyling,
-  X as isModelWithMultiAxes,
-  Y as isModelWithRotation,
-  $ as isModelWithTemporalBinning,
-  j as isModelWithTooltips,
-  q as isModelWithXGuides,
-  z as isModelWithYGuides,
-  I as isPieChartLegendModel,
-  J as isPieChartModel,
-  N as isScatterplotModel,
-  Q as isSerialChartModel
+  R as isModelWithMultiAxes,
+  X as isModelWithTemporalBinning,
+  Y as isModelWithTooltips,
+  $ as isModelWithXGuides,
+  j as isModelWithYGuides,
+  q as isPieChartLegendModel,
+  z as isPieChartModel,
+  I as isScatterplotModel,
+  J as isSerialChartModel
 };

package/dist/spec/chart-object-literals.d.ts

@@ -312,3 +312,30 @@ export interface WebChartOrderSeriesBy {
      */
     orderBy?: WebChartSortOrderKinds;
 }
+/**
+ * Represents the different types of views that can be applied to a heat chart.
+ */
+export declare const WebChartHeatChartViewTypes: {
+    /**
+     * A single calendar view showing all data in one calendar.
+     */
+    readonly singleCalendarView: "SingleCalendarView";
+    /**
+     * Multiple sequential calendar views (e.g., years).
+     */
+    readonly sequentialCalendarViews: "SequentialCalendarViews";
+};
+export type WebChartHeatChartViewTypes = (typeof WebChartHeatChartViewTypes)[keyof typeof WebChartHeatChartViewTypes];
+/**
+ * Class break types for data classification in charts.
+ */
+export declare const WebChartClassBreakTypes: {
+    readonly equalInterval: "equal-interval";
+    readonly quantile: "quantile";
+    readonly naturalBreaks: "natural-breaks";
+    readonly manual: "manual";
+};
+/**
+ * Class break types for data classification in charts.
+ */
+export type WebChartClassBreakTypes = (typeof WebChartClassBreakTypes)[keyof typeof WebChartClassBreakTypes];

package/dist/spec/web-chart.d.ts

@@ -1,4 +1,4 @@
-import { GaugeChartSubTypes, SizePolicyScaleTypes, WebChartCalendarDatePartsUnits, WebChartDataTransformations, WebChartDirectionalDataOrder, WebChartHeatChartHeatRulesTypes, WebChartLabelBehavior, WebChartLegendPositions, WebChartMultiAxesDataOrder, WebChartNullPolicyTypes, WebChartOrderSeriesBy, WebChartPredefinedLabelsDataOrder, WebChartRadarChartAxisLabelsOrientation, WebChartStackedKinds, WebChartTemporalBinningUnits, WebChartTimeAggregationTypes, WebChartTypes } from './chart-object-literals';
+import { GaugeChartSubTypes, SizePolicyScaleTypes, WebChartCalendarDatePartsUnits, WebChartClassBreakTypes, WebChartDataTransformations, WebChartDirectionalDataOrder, WebChartHeatChartHeatRulesTypes, WebChartHeatChartViewTypes, WebChartLabelBehavior, WebChartLegendPositions, WebChartMultiAxesDataOrder, WebChartNullPolicyTypes, WebChartOrderSeriesBy, WebChartPredefinedLabelsDataOrder, WebChartRadarChartAxisLabelsOrientation, WebChartStackedKinds, WebChartTemporalBinningUnits, WebChartTimeAggregationTypes, WebChartTypes } from './chart-object-literals';
 import { TimeIntervalInfo } from './data-source';
 import { RESTUnits } from './rest-js-object-literals';
 import { Color, IDrawingInfo, IEnvelope, IExtent, IFeatureLayer, IPoint, IPolygon, IPolygonWithCurves, IPolyline, ISimpleFillSymbol, ISimpleLineSymbol, ISimpleMarkerSymbol, IStatisticDefinition, ITextSymbol } from './rest-js-types';
@@ -6,7 +6,7 @@ import { QueryMixin } from '@arcgis/core/rest/support/QueryMixin';
 /**
  * Version of the current specification.
  */
-export declare const WebChartCurrentVersion = "24.8.0";
+export declare const WebChartCurrentVersion = "25.0.0";
 /**
  * Stores information regarding a numeric conversion.
  */
@@ -763,6 +763,11 @@ interface WebChartTemporalBinningExtras {
     nullPolicy?: WebChartNullPolicyTypes;
 }
 export interface WebChartCalendarDatePartsBinning extends WebChartTemporalBinningBase {
+    /**
+     * Represents a unique string identifier for the CalendarDatePartsBinning object.
+     * For CalendarDatePartsBinning object, it is "calendarDateParts".
+     */
+    type: typeof WebChartTypes.CalendarDateParts;
     /**
      * Represents the unit to use to bin the data.
      */
@@ -1326,6 +1331,38 @@ export interface WebChartHeatChartGradient {
      */
     outsideRangeUpperColor?: Color;
 }
+/**
+ * JSON representation of the Heat chart - class breaks type
+ */
+export interface WebChartHeatChartHeatClassBreaks {
+    /**
+     * The number of classes breaks to be used for the heat chart.
+     *
+     * @default 5
+     */
+    breaksCount?: number;
+    /**
+     * The classification method to be used for the  heat chart.
+     */
+    classificationMethod?: WebChartClassBreakTypes;
+}
+/**
+ * JSON representation of the Heat chart empty cell configuration
+ */
+export interface WebChartHeatChartEmptyCell {
+    /**
+     * Specifies the text to use by the empty cells.
+     * If none is provided, the default `null` text will be used.
+     *
+     * @default `null`
+     */
+    text?: string;
+    /**
+     * Specifies the symbol to use by the empty cells.
+     * If none is provided, the default symbol will be used.
+     */
+    symbol?: ISimpleFillSymbol;
+}
 /**
  * JSON representation of the Heat chart series
  */
@@ -1358,23 +1395,14 @@ export interface WebChartHeatChartSeries extends WebChartSeries {
      * Specifies the details of the gradient rules for the heat chart.
      */
     gradientRules?: WebChartHeatChartGradient;
+    /**
+     * Specifies the details of the class breaks rules for the heat chart.
+     */
+    classBreaksRules?: WebChartHeatChartHeatClassBreaks;
     /**
      * Specifies how to display the empty cells, in terms of text and symbology.
      */
-    emptyCells?: {
-        /**
-         * Specifies the text to use by the empty cells.
-         * If none is provided, the default `null` text will be used.
-         *
-         * @default `null`
-         */
-        text?: string;
-        /**
-         * Specifies the symbol to use by the empty cells.
-         * If none is provided, the default symbol will be used.
-         */
-        symbol?: ISimpleFillSymbol;
-    };
+    emptyCells?: WebChartHeatChartEmptyCell;
 }
 export type WebChartRadarChartSeries = WebChartLineChartSeries<"radarSeries">;
 /**
@@ -1607,6 +1635,12 @@ export interface WebHeatChart extends WebChart, WebChartTemporalBinningExtras {
      * @default false
      */
     hideEmptyRowsAndColumns?: boolean;
+    /**
+     * The calendar view type for the heat chart.
+     *
+     * **NOTE**: This property is only applicable to the Calendar heat chart.
+     */
+    viewType?: WebChartHeatChartViewTypes;
     /**
      * Whether to include leap day (Feb. 29th) in queries
      * @default false

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

@@ -272,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
@@ -413,6 +419,13 @@ declare function convertTo23x3x0(configToUpdate: WebChart): WebChart;
  * @returns The updated chart config
  */
 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.
@@ -499,7 +512,9 @@ export declare const chartConfigConverterPrivateFunctions: {
     convertTo21x1x0: typeof convertTo21x1x0;
     convertTo23x3x0: typeof convertTo23x3x0;
     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

@@ -401,23 +401,6 @@ export declare function doesConfigChangeRequireNewData(props: {
  * @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.
@@ -437,7 +420,6 @@ export declare const chartConfigUtilsPrivateFunctions: {
     isNewDataRequiredForValueFormatChange: typeof isNewDataRequiredForValueFormatChange;
     hasShowMeanChanged: typeof hasShowMeanChanged;
     hasHeatChartBinningChanged: typeof hasHeatChartBinningChanged;
-    hasSeriesOrderChanged: typeof hasSeriesOrderChanged;
     hasConfigSeriesNamesChanged: typeof hasConfigSeriesNamesChanged;
 };
 export {};

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;
@@ -110,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;

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

@@ -2,9 +2,9 @@ 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 } from '../../interfaces';
 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.
@@ -49,15 +49,18 @@ export declare function isValidDataSource(config?: WebChart, layer?: FeatureLaye
  * - add the iLayer if missing
  * - convert it to the latest version
  * @param props.configToAlter The config to alter
+ * @param props.chartContainer The chart container
+ * @param props.queryObject The query object
+ * @param props.options The runtime options
+ * @param props.updateSplitBySeries The updateSplitBySeries property
+ * @param props.addMissingSeries Whether to add missing series for split-by charts
  * @param props.layer The component's layer
  */
 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"];