@arcgis/charts-components 5.0.0-next.89 → 5.0.0-next.90

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

@@ -6,22 +6,18 @@ import { SupportedLayer } from '../../interfaces';
 export declare abstract class ChartModel extends EventTarget {
     /**
      * Current configuration used for the chart.
-     * @category Protected
      */
     protected _config: ChartConfig;
     /**
      * Grouping of layer-related properties to be passed to external function more compactly.
-     * @category Protected
      */
     protected layerInfo: LayerInfo;
     /**
      * Common strings used in the model.
-     * @category Protected
      */
     protected commonStrings: CommonStrings;
     /**
      * Chart Type
-     * @category Protected
      */
     protected _chartType: ChartTypes;
     /**
@@ -31,9 +27,12 @@ export declare abstract class ChartModel extends EventTarget {
     protected dirtyAsyncSetters: string[];
     /**
      * Whether or not an async series update is currently in progress.
-     * @category Protected
      */
     protected asyncConfigUpdateInProgress: boolean;
+    /**
+     * Number of pending async updates.
+     */
+    protected pendingUpdates: number;
     /**
      * Function that resolves the setup promise.
      * @category Protected
@@ -41,23 +40,34 @@ export declare abstract class ChartModel extends EventTarget {
     protected resolveSetup?: () => void;
     /**
      * Completes the async setup process for the chart model. Must be called before using the model.
-     * @param {ModelParams} params The parameters to be used to set up the chart model.
+     * @param params The parameters to be used to set up the chart model.
      * @async **This method is `async` and must be awaited for the changes to take effect.**
      */
     abstract setup(params: ModelParams<ChartConfig>): Promise<void>;
     /**
      * Checks if the current chart model is for the same chart as another chart model.
-     * @param {ChartModel | undefined} otherModel The other chart model to compare to.
+     * @param otherModel The other chart model to compare to.
      */
     isSameChartAs(otherModel: ChartModel | undefined): boolean;
     /**
      * Generate the proper chart title from the current config.
      */
     abstract generateChartTitle(): string;
+    /**
+     * Can be awaited to allow any pending async updates to complete.
+     * @public
+     */
+    update(): Promise<void>;
     /**
      * Data store object that can be used to store any data needed for the chart.
      */
     dataStore: any;
+    /**
+     * Promise that resolves when the setup process is complete.
+     *
+     * **Note:** This promise does not need to be awaited if the `setup` method has already been awaited. It is simply provided as a way to await the setup process from other functions if needed to avoid race conditions.
+     */
+    asyncUpdatesPromise: Promise<void>;
     /**
      * The current chart configuration object.
      */
@@ -76,11 +86,6 @@ export declare abstract class ChartModel extends EventTarget {
      */
     get chartId(): string | undefined;
     set chartId(id: string | undefined);
-    /**
-     * Promise that resolves when the setup process is complete.
-     * **Note:** This promise does not need to be awaited if the `setup` method has already been awaited. It is simply provided as a way to await the setup process from other functions if needed to avoid race conditions.
-     */
-    setupFinished: Promise<void>;
     /**
      * The version of the chart configuration.
      */
@@ -166,16 +171,14 @@ export declare abstract class ChartModel extends EventTarget {
      * Gets the series ID for a given series index.
      * If the series index is out of bounds, this function will return `undefined`.
      *
-     * @param {number} seriesIndex The index of the series.
-     * @returns {string | undefined}
+     * @param seriesIndex The index of the series.
      */
     getSeriesId(seriesIndex: number): string | undefined;
     /**
      * Gets the series index for a given series ID.
      * If the series ID is not found, this function will return `undefined`.
      *
-     * @param {string} seriesId The ID of the series.
-     * @returns {number | undefined}
+     * @param seriesId The ID of the series.
      */
     getSeriesIndex(seriesId: string): number | undefined;
     /**
@@ -218,30 +221,35 @@ export declare abstract class ChartModel extends EventTarget {
     getDataFilters(): WebChartDataFilters | undefined;
     /**
      * Sets the data filter for the chart.
-     * @param {WebChartDataFilters | undefined} newDataFilters The new data filter.
+     * @param newDataFilters The new data filter.
      */
     setDataFilters(newDataFilters: WebChartDataFilters | undefined): Promise<void>;
     /**
      * Emits a config update event.
-     * @category Protected
      */
-    protected emitConfigUpdate(setterName: string): void;
+    protected emitConfigUpdate: (setterName: string) => void;
     /**
      * A function that generates the default config object when creating a new chart.
-     * @category Protected
      */
     protected abstract generateDefaultConfig(): Omit<typeof this._config, "iLayer">;
     /**
      * A function that loads the config based on the provided props.
-     * @category Protected
      * @param params.layer The layer to be used as the data source for the chart.
      * @param params.iLayer The layer description to use if the layer is not provided
      * @param params.config The config object to be loaded.
      */
     protected loadConfigFromLayer<T extends ModelTypes>(params: ModelParams<ChartConfig<T>>): Promise<void>;
+    /**
+     * Manually block the async guard to queue up config updates until unblocked.
+     */
+    protected startAsyncUpdate(): void;
+    /**
+     * Manually unblock the async guard to allow queued config updates to proceed.
+     */
+    protected finishAsyncUpdate(): void;
     /**
      * Guards a setter from being called while an async config update is in progress so that the value being set is not overwritten by the async config update.
      * @param setter The setter callback to call after setup or async config update is finished.
      */
-    protected guardSetterFromAsyncOverwrite(setter: (() => Promise<void>) | (() => void)): Promise<void>;
+    protected guardSetterFromAsyncOverwrite: (setter: (() => Promise<void>) | (() => void)) => Promise<void>;
 }

package/dist/model/decorators/model-setter.d.ts

@@ -0,0 +1,7 @@
+import { ChartModel } from '../chart-model/chart-model';
+/**
+ * Decorator for property setter in a chart model that will:
+ * - guard against async overwrite issues
+ * - emit a config update event
+ */
+export declare function modelSetter(_target: ChartModel, propertyKey: string, descriptor: PropertyDescriptor): PropertyDescriptor;

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

@@ -1,7 +1,7 @@
-import { ISimpleFillSymbol, WebChart, WebChartCalendarDatePartsBinning, WebChartHeatChartGradient, WebChartHeatChartHeatRulesTypes, WebChartNullCategory, WebChartNullPolicyTypes, WebChartStackedKinds, WebChartStatisticType, WebChartLegendPositions } from '../../spec';
+import { ISimpleFillSymbol, WebChart, WebChartCalendarDatePartsBinning, WebChartHeatChartGradient, WebChartHeatChartHeatRulesTypes, WebChartLegendPositions, WebChartNullCategory, WebChartNullPolicyTypes, WebChartStackedKinds, WebChartStatisticType, WebHeatChart } from '../../spec';
 import { ChartConfig } from '../../utils';
 import { ModelParams } from '../interfaces/chart-interfaces';
-import { LayerInfo, ModelTypes } from '../interfaces/common';
+import { LayerInfo, ModelTypes, SerialChartDataSortingKinds, HeatChartDataSortingKinds } from '../interfaces/common';
 import { ModelWithDataLabels, ModelWithTooltips } from '../mixins';
 import { SerialChartModel } from '../serial-chart-model/serial-chart-model';
 export type HeatChartConfig = ChartConfig<typeof ModelTypes.HeatChart, WebChart>;
@@ -10,7 +10,7 @@ export declare class HeatChartModel extends SerialChartModel {
     /**
      * Current configuration used for the Heat chart.
      */
-    protected _config: ChartConfig<typeof ModelTypes.HeatChart, WebChart>;
+    protected _config: ChartConfig<typeof ModelTypes.HeatChart, WebHeatChart>;
     protected _chartType: "heatSeries";
     protected layerInfo: LayerInfo;
     setup(params: ModelParams<ChartConfig<typeof ModelTypes.HeatChart>>): Promise<void>;
@@ -75,6 +75,15 @@ export declare class HeatChartModel extends SerialChartModel {
      */
     get aggregationType(): WebChartStatisticType;
     set aggregationType(aggregationType: WebChartStatisticType);
+    /**
+     * Split-by field is not used by heat chart
+     */
+    get splitByField(): string;
+    set splitByField(_: string);
+    /**
+     * The heat charts legend's title (not supported yet)
+     */
+    set legendTitleText(_: string);
     get legendPosition(): WebChartLegendPositions;
     /**
      * The heat charts legend's position
@@ -85,6 +94,33 @@ export declare class HeatChartModel extends SerialChartModel {
      * The heat charts null policy
      */
     set nullPolicy(policy: WebChartNullPolicyTypes | undefined);
+    getSortOrder(): HeatChartDataSortingKinds | SerialChartDataSortingKinds;
+    /**
+     * setSortOrder is not used by heat chart; instead use setXAxisSortOrder for the x axis and setYAxisSortOrder for the y axis
+     */
+    setSortOrder(_newSortOrder: HeatChartDataSortingKinds | SerialChartDataSortingKinds, _orderByList?: string[]): void;
+    /**
+     * Get the sort order on the x axis for the heat chart.
+     * @returns {"Asc" | "Desc" | "customSort"}
+     */
+    getXAxisSortOrder(): HeatChartDataSortingKinds;
+    /**
+     * Sets the sort order on the x axis for the heat chart.
+     * @param {"Asc" | "Desc" | "customSort"}  newSortOrder The new sort order.
+     * @param {string[]} orderByList The list of category's values to order by.
+     */
+    setXAxisSortOrder(newSortOrder: HeatChartDataSortingKinds, orderByList?: string[]): void;
+    /**
+     * Gets the sort order for on the y axis for heat chart.
+     * @returns {"Asc" | "Desc" | "customSort"}
+     */
+    getYAxisSortOrder(): HeatChartDataSortingKinds;
+    /**
+     * Sets the sort order on the y axis for heat chart.
+     * @param {"Asc" | "Desc" | "customSort"}  newSortOrder The new sort order.
+     * @param {string[]} orderByList The list of category's values to order by.
+     */
+    setYAxisSortOrder(newSortOrder: HeatChartDataSortingKinds, orderByList?: string[]): void;
     get emptyCellText(): string | undefined;
     /**
      * The heat charts empty cell text
@@ -103,15 +139,6 @@ export declare class HeatChartModel extends SerialChartModel {
      * The heat chart's stacked type (not supported)
      */
     set stackedType(_stackedType: WebChartStackedKinds | undefined);
-    /**
-     * Split-by field is not used by heat chart
-     */
-    get splitByField(): string;
-    set splitByField(_: string);
-    /**
-     * The heat charts legend's title (not supported yet)
-     */
-    set legendTitleText(_: string);
     /**
      * Bin temporal data for heat chart (not supported)
      */

package/dist/model/heat-chart-model/utils/heat-chart-data.d.ts

@@ -89,6 +89,12 @@ export declare const setYTemporalBinning: (binning: WebChartCalendarDatePartsBin
  * @param config the heat chart config
  */
 export declare const getYTemporalBinning: (config: HeatChartConfig) => WebChartCalendarDatePartsBinning | undefined;
+/**
+ * Set the order by list in the config. The order by list is only used when the sort order kind is custom sort.
+ * @param values The order by values
+ * @param config The heat chart config
+ */
+export declare const setHeatChartOrderByList: (values: string[], config: HeatChartConfig) => void;
 /**
  * Sets the grid line width
  * @param width the grid line width

package/dist/model/interfaces/common.d.ts

@@ -29,6 +29,12 @@ export declare const BoxPlotDataSortingKinds: {
     readonly customSort: "customSort";
 };
 export type BoxPlotDataSortingKinds = (typeof BoxPlotDataSortingKinds)[keyof typeof BoxPlotDataSortingKinds];
+export declare const HeatChartDataSortingKinds: {
+    readonly Asc: "Asc";
+    readonly Desc: "Desc";
+    readonly customSort: "customSort";
+};
+export type HeatChartDataSortingKinds = (typeof HeatChartDataSortingKinds)[keyof typeof HeatChartDataSortingKinds];
 export declare const PieChartDataSortingKinds: {
     readonly labelAsc: "labelAsc";
     readonly labelDesc: "labelDesc";

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

@@ -2,7 +2,7 @@ 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 { SerialChartDataSortingKinds } from '../interfaces/common';
+import { HeatChartDataSortingKinds, SerialChartDataSortingKinds } from '../interfaces/common';
 import { ModelWithColorMatch, ModelWithDataLabels, ModelWithLegend, ModelWithTooltips, ModelWithRotation, ModelWithTemporalBinning, ModelWithXGuides, ModelWithYGuides, ModelWithMultiAxes } from '../mixins';
 export declare abstract class SerialChartModel extends ChartModel {
     /**
@@ -70,13 +70,13 @@ export declare abstract class SerialChartModel extends ChartModel {
      * Gets the sort order for the bar chart.
      * @returns {"xAxisAsc" | "xAxisDesc" | "yAxisAsc" | "yAxisDesc" | "customSort"}
      */
-    getSortOrder(): SerialChartDataSortingKinds;
+    getSortOrder(): HeatChartDataSortingKinds | SerialChartDataSortingKinds;
     /**
      * Sets the sort order for the bar chart.
-     * @param {"xAxisAsc" | "xAxisDesc" | "yAxisAsc" | "yAxisDesc"}  newSortOrder The new sort order.
+     * @param {"Asc" | "Desc" | "xAxisAsc" | "xAxisDesc" | "yAxisAsc" | "yAxisDesc" | "customSort"}  newSortOrder The new sort order.
      * @param {string[]} orderByList The list of category's values to order by.
      */
-    setSortOrder(newSortOrder: SerialChartDataSortingKinds, orderByList?: string[]): void;
+    setSortOrder(newSortOrder: HeatChartDataSortingKinds | SerialChartDataSortingKinds, orderByList?: string[]): void;
     /**
      * Gets the list of the category values for the chart.
      * @returns {string[]}
@@ -84,7 +84,7 @@ export declare abstract class SerialChartModel extends ChartModel {
     getCustomSortValues(): Promise<string[]>;
     /**
      * Sets the data filter for the bar chart.
-     * @param {WebChartDataFilters | undefined} newDataFilter The new data filter.
+     * @param newDataFilter The new data filter.
      */
     setDataFilters(newDataFilter: WebChartDataFilters | undefined): Promise<void>;
     /**

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

@@ -1,7 +1,7 @@
 import { WebChartStatisticType } from '../../../spec';
 import { ChartConfig, CommonStrings } from '../../../utils';
 import { SerialChartConfig } from '../../interfaces/chart-interfaces';
-import { LayerInfo, SerialChartDataSortingKinds } from '../../interfaces/common';
+import { HeatChartDataSortingKinds, LayerInfo, SerialChartDataSortingKinds } from '../../interfaces/common';
 /**
  * Generate default series value
  * @param {number | undefined } props.seriesIndex - The series index.
@@ -46,7 +46,7 @@ export declare const getNumericFields: (config: SerialChartConfig) => string[];
 /**
  * Gets the sort order kind.
  */
-export declare const getSortOrderKind: (config: ChartConfig) => SerialChartDataSortingKinds;
+export declare const getSortOrderKind: (config: ChartConfig) => HeatChartDataSortingKinds[] | SerialChartDataSortingKinds[];
 /**
  * Build a series array based on a list of numeric fields and aggregation type,
  * when the chart has no category field.

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

@@ -1,9 +1,23 @@
+import { default as FeatureLayerView } from '@arcgis/core/views/layers/FeatureLayerView.js';
+import { IField, WebChartOrderDataByTypes, WebChartSortOrderKinds, WebChartStatisticType } from '../../spec';
 import { ChartConfig } from '../../utils';
-import { IField, WebChartStatisticType } from '../../spec';
-import { PieChartDataModes, SerialChartDataSortingKinds } from '../interfaces/common';
 import { SerialChartConfig } from '../interfaces/chart-interfaces';
-import { default as FeatureLayerView } from '@arcgis/core/views/layers/FeatureLayerView.js';
+import { HeatChartDataSortingKinds, PieChartDataModes, SerialChartDataSortingKinds } from '../interfaces/common';
 import { SupportedLayer } from '../../interfaces';
+/**
+ * Gets the sort order kind for serial charts.
+ * @param orderBy The order by value(s)
+ * @param orderType The order type value
+ * @returns
+ */
+export declare function getSerialChartSortOrderKind(orderBy: string[] | WebChartSortOrderKinds, orderType: Omit<WebChartOrderDataByTypes, "arcgis-charts-multi-axes">): SerialChartDataSortingKinds;
+/**
+ * Gets the sort order kind for heat charts.
+ * @param orderBy The order by value(s)
+ * @param orderType The order type value
+ * @returns
+ */
+export declare function getHeatChartSortOrderKind(orderBy: string[] | WebChartSortOrderKinds, orderType: Omit<WebChartOrderDataByTypes, "arcgis-charts-multi-axes">): HeatChartDataSortingKinds;
 /**
  * Get the sort order kind for the bar and line chart
  * @param {SerialChartConfig} config - the chart configuration
@@ -30,8 +44,9 @@ export declare const getOrderByList: (config: SerialChartConfig) => string[];
  * @param {SerialChartDataSortingKinds} newSortOrderKind - the new sort order kind
  * @param {ChartConfig} config - the chart configuration
  * @param {string[] | undefined} orderByList - the list of fields to order by
+ * @param {boolean | undefined} isYAxis - whether to set the sort order for y-axis (heat chart only)
  */
-export declare const setSortOrderKind: (newSortOrderKind: SerialChartDataSortingKinds, config: ChartConfig, orderByList?: string[]) => void;
+export declare const setSortOrderKind: (newSortOrderKind: HeatChartDataSortingKinds | SerialChartDataSortingKinds, config: ChartConfig, orderByList?: string[], isYAxis?: boolean) => void;
 /**
  * Gets the x-axis field.
  * @param {ChartConfig} config - The chart config.

package/dist/model.js

@@ -1,10 +1,10 @@
 import { M as i } from "./chunks/common.js";
-import { B as m, C as y, F as g, G as w, L as C, a as f, P as u, b, S as p, T as L, c as T } 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 b, b as p, S as L, T, c as S } from "./chunks/common.js";
 import { s as r, t as s, u as n } from "./chunks/type-guards.js";
-import { a as B, e as P, i as S, g as x, b as W, r as v, h as G, l as K, m as D, p as F, j as H, k as O, q as R, n as A, o as E, d as X, f as Y, c as $ } from "./chunks/type-guards.js";
+import { a as B, e as P, i as x, g as W, b as K, r as v, h as D, l as G, m as H, p as F, j as O, k as R, q as A, n as E, o as X, d as Y, f as $, c 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.89 */
+v5.0.0-next.90 */
 async function c(t) {
   const o = "config" in t ? r(t.config) : t.chartType;
   let a;
@@ -82,32 +82,33 @@ export {
   m as BoxPlotDataSortingKinds,
   y as ColorFormatKeys,
   g as FormatKeys,
-  w as GuideOrientation,
-  C as LineFormatKeys,
+  C as GuideOrientation,
+  w as HeatChartDataSortingKinds,
+  f as LineFormatKeys,
   i as ModelTypes,
-  f as PieChartDataModes,
-  u as PieChartDataSortingKinds,
-  b as PieChartSlicesDisplay,
-  p as SerialChartDataSortingKinds,
-  L as TextFormatKeys,
+  u as PieChartDataModes,
+  b as PieChartDataSortingKinds,
+  p as PieChartSlicesDisplay,
+  L as SerialChartDataSortingKinds,
+  T as TextFormatKeys,
   c as createModel,
-  T as customSortString,
+  S as customSortString,
   B as isBarChartModel,
   P as isBoxPlotModel,
-  S as isChartModel,
-  x as isHistogramModel,
-  W as isLineChartModel,
+  x as isChartModel,
+  W as isHistogramModel,
+  K as isLineChartModel,
   v as isModelOfType,
-  G as isModelWithBasicXAxis,
-  K as isModelWithDataLabels,
-  D as isModelWithGuides,
+  D as isModelWithBasicXAxis,
+  G as isModelWithDataLabels,
+  H as isModelWithGuides,
   F as isModelWithLegend,
-  H as isModelWithMultiAxes,
-  O as isModelWithRotation,
-  R as isModelWithTemporalBinning,
-  A as isModelWithXGuides,
-  E as isModelWithYGuides,
-  X as isPieChartModel,
-  Y as isScatterplotModel,
-  $ as isSerialChartModel
+  O as isModelWithMultiAxes,
+  R as isModelWithRotation,
+  A as isModelWithTemporalBinning,
+  E as isModelWithXGuides,
+  X as isModelWithYGuides,
+  Y as isPieChartModel,
+  $ as isScatterplotModel,
+  j as isSerialChartModel
 };

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

@@ -213,17 +213,42 @@ export declare const WebChartOrderDataByTypes: {
     readonly Mean: "arcgis-charts-mean";
     readonly Median: "arcgis-charts-median";
     readonly Category: "arcgis-charts-category";
+    readonly MultiAxes: "arcgis-charts-multi-axes";
 };
 export type WebChartOrderDataByTypes = (typeof WebChartOrderDataByTypes)[keyof typeof WebChartOrderDataByTypes];
 /**
- * A data order option that the items are to be ordered either ascending or descending.
- * It can be used for any type of order, like by category, by mean, by median, etc.
+ * A data order option that allows the items to be ordered on both the x- and y-axes;
+ *
+ * For each axis, the order can be either a direction (ascending or descending) for all axis types;
+ * or a predefined list of labels when the axis is categorical.
+ *
+ * @remarks This order option is currently only used in heat charts.
+ */
+export interface WebChartMultiAxesDataOrder {
+    /**
+     * The type of order, which is two dimensional.
+     */
+    orderType: "arcgis-charts-multi-axes";
+    /**
+     * The direction of the order for the x axis. If the axis is categorical, this can also be a predefined list of labels.
+     */
+    orderByX?: string[] | WebChartSortOrderKinds;
+    /**
+     * The direction of the order for the y axis. If the axis is categorical, this can also be a predefined list of labels.
+     */
+    orderByY?: string[] | WebChartSortOrderKinds;
+}
+/**
+ * A data order option that allows the items to be ordered either ascending or descending.
+ * This option can be used for the following types of order: by category, by mean, by median, and by y value.
+ *
+ * @remarks This order option is currently not available for Heat charts.
  */
 export interface WebChartDirectionalDataOrder {
     /**
      * The type of order, eg by category, by mean, by median, or by y value.
      */
-    orderType: WebChartOrderDataByTypes;
+    orderType: "arcgis-charts-category" | "arcgis-charts-mean" | "arcgis-charts-median" | "arcgis-charts-y-value";
     /**
      * The direction of the order, either ascending or descending.
      */
@@ -239,7 +264,7 @@ export interface WebChartDirectionalDataOrder {
     preferLabel?: boolean;
 }
 /**
- * A data order option for the items to be ordered by `category` based on a predefined list of labels.
+ * A data order option that allows the items to be ordered by `category` based on a predefined list of labels.
  */
 export interface WebChartPredefinedLabelsDataOrder {
     /**

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

@@ -1,4 +1,4 @@
-import { GaugeChartSubTypes, SizePolicyScaleTypes, WebChartCalendarDatePartsUnits, WebChartDataTransformations, WebChartDirectionalDataOrder, WebChartHeatChartHeatRulesTypes, WebChartLabelBehavior, WebChartLegendPositions, WebChartNullPolicyTypes, WebChartOrderSeriesBy, WebChartPredefinedLabelsDataOrder, WebChartRadarChartAxisLabelsOrientation, WebChartStackedKinds, WebChartTemporalBinningUnits, WebChartTimeAggregationTypes, WebChartTypes } from './chart-object-literals';
+import { GaugeChartSubTypes, SizePolicyScaleTypes, WebChartCalendarDatePartsUnits, WebChartDataTransformations, WebChartDirectionalDataOrder, WebChartHeatChartHeatRulesTypes, 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.6.0";
+export declare const WebChartCurrentVersion = "24.7.0";
 /**
  * Stores information regarding a numeric conversion
  */
@@ -1496,10 +1496,12 @@ export interface WebChart {
         series?: WebChartOrderSeriesBy;
         /**
          * How data for a chart should be ordered. It is recommended to use this property over its sibling `orderByFields` to order the chart data.
-         *
          * If not provided, the data will be displayed as it was retrieved from the server. No additional ordering will be applied.
+         *
+         * The WebChartDirectionalDataOrder and WebChartPredefinedLabelsDataOrder are applicable to all chart types except Heat chart.
+         * The WebChartMultiAxesDataOrder is specifically used for Heat chart.
          */
-        data?: WebChartDirectionalDataOrder | WebChartPredefinedLabelsDataOrder;
+        data?: WebChartDirectionalDataOrder | WebChartMultiAxesDataOrder | WebChartPredefinedLabelsDataOrder;
         /**
          * The orderByFields to be sent with the query when retrieving data for the chart.  It represents the desired sorting order of the output result from the server.
          *
@@ -1508,6 +1510,7 @@ export interface WebChart {
          * @example ["STATE_NAME DESC", "CITY_NAME ASC", "CITY_NAME"]
          *
          * In case both this property and its sibling `data` object are provided, the order of the chart elements are settled by the order instruction in the `data` property.
+         * This property is applicable to all chart types, but Heat chart.
          */
         orderByFields?: string[];
     };
@@ -1589,6 +1592,14 @@ export interface WebHeatChart extends WebChart, WebChartTemporalBinningExtras {
      * @minItems 1
      */
     series: WebChartHeatChartSeries[];
+    orderOptions?: Omit<WebChart["orderOptions"], "data" | "orderByFields"> & {
+        /**
+         * How data for a chart should be ordered.
+         *
+         * If not provided, the data will be displayed as it was retrieved from the server. No additional ordering will be applied.
+         */
+        data?: WebChartMultiAxesDataOrder;
+    };
     /**
      * Whether to hide entire rows or columns that are empty (i.e. contain no valid data).
      * @default false

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

@@ -408,12 +408,12 @@ declare function convertTo21x1x0(configToUpdate: WebChart): WebChart;
  */
 declare function convertTo23x3x0(configToUpdate: WebChart): WebChart;
 /**
- * Conversion for v24.6.0:
+ * Conversion for v24.7.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 convertTo24x6x0(configToUpdate: WebChart): WebChart;
+declare function convertTo24x7x0(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.
@@ -501,7 +501,7 @@ export declare const chartConfigConverterPrivateFunctions: {
     convertTo20x2x0: typeof convertTo20x2x0;
     convertTo21x1x0: typeof convertTo21x1x0;
     convertTo23x3x0: typeof convertTo23x3x0;
-    convertTo24x6x0: typeof convertTo24x6x0;
+    convertTo24x7x0: typeof convertTo24x7x0;
     convertTemporalBinningProps2: typeof convertTemporalBinningProps2;
     applyConversions: typeof applyConversions;
     convertDataSourceToILayer: typeof convertDataSourceToILayer;

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

@@ -19,7 +19,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

package/dist/utils/type-guards/chart-types.d.ts

@@ -0,0 +1,7 @@
+import { WebChart, WebHeatChart } from '../../spec';
+/**
+ * Determines if the chart config is a heat chart configuration
+ * @param chartConfig The chart configuration object.
+ * @returns True if the chart config is a heat chart configuration, false otherwise.
+ */
+export declare function isHeatChartConfig(chartConfig: WebChart): chartConfig is WebHeatChart;

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

@@ -1,6 +1,6 @@
 import { WebChart, WebChartTypes } from '../../spec';
 import { CommonStrings } from '../localization/interfaces';
-export declare function getChartIcon(chart: WebChart): string;
+export declare function getChartIcon(chart: WebChart): HTMLCalciteIconElement["icon"];
 /**
  * Fetches the chart type text based on the provided chart type.
  * @param chartType

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@arcgis/charts-components",
-  "version": "5.0.0-next.89",
+  "version": "5.0.0-next.90",
   "description": "Reusable ArcGIS charting Web Components.",
   "type": "module",
   "main": "dist/index.js",
@@ -28,8 +28,8 @@
   "dependencies": {
     "@amcharts/amcharts4": "^4.10.31",
     "@amcharts/amcharts5": "~5.14.4",
-    "@arcgis/lumina": "5.0.0-next.89",
-    "@arcgis/toolkit": "5.0.0-next.89",
+    "@arcgis/lumina": "5.0.0-next.90",
+    "@arcgis/toolkit": "5.0.0-next.90",
     "ajv": "6.12.6",
     "d3-array": "^3.2.1",
     "d3-shape": "^3.2.0",
@@ -43,8 +43,8 @@
     "uuid": "^11.1.0"
   },
   "peerDependencies": {
-    "@arcgis/core": "5.0.0-next.61",
-    "@esri/calcite-components": "^3.3.2"
+    "@arcgis/core": ">=5.0.0-next.62 <5.1",
+    "@esri/calcite-components": "^5.0.0-next.25"
   },
   "css.customData": [
     "dist/docs/vscode.css-custom-data.json"

package/dist/cdn/2FPDE35U.js

@@ -1,4 +0,0 @@
-/*! 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.89 */
-import b from"./ETR3G32Z.js";import{g as q}from"./WT6UCBDJ.js";import a from"./U2LF63KV.js";import{f as B}from"./XGNUEXQ2.js";import{w as v}from"./EHJ2UZ63.js";export default $arcgis.t(([,,,,,{Jc:j,Ob:S,Qc:N,Rc:T,Tc:E,Uc:M,Vc:P,k:b,mc:w,nb:f,oc:F,pc:x,rc:A,rd:$,sd:D,tc:O,x:C,zc:V},Q])=>{function re(n,t){let e;return t!==void 0&&(e={...t},e.legend!==void 0&&(e.legend.position=n)),e}function se(n,t){let e;return t!==void 0&&(e={...t},e.legend!==void 0&&(e.legend.visible=n)),e}function oe(n,t){let e;return t!==void 0&&(e={...t,rotated:n}),e}function ae(n){let t;return n!==void 0&&(t={...n},delete t.axes?.[0]?.minimum,delete t.axes?.[0]?.maximum,delete t.axes?.[1]?.minimum,delete t.axes?.[1]?.maximum),t}function ue(n,t){return t!=null||q(n)}async function J(n){let{queryObject:t,chartConfig:e,options:o,splitByField:r}=n,i=[],u,s=B(e),l=s.series[0],c=j({queryObject:t,chartConfig:s,runtimeDataFilters:o?.runtimeDataFilters,ignoreViewExtent:o?.ignoreViewExtent});if(c.outStatistics?.[0]?.outStatisticFieldName&&(c.outStatistics[0].outStatisticFieldName=C.outStatistics.outStatisticFieldName),P(l)&&M({xAxisValueFormatType:b(s),setTimeBinningInfoWhenNotProvided:o?.setTimeBinningInfoWhenNotProvided,seriesConfig:l})&&w(t)){let{temporalBinning:a,x:d}=l,{uniqueQuery:h}=await S({chartConfig:s,queryConfig:c,queryObject:t,options:o});u=await O({queryObject:t,dateField:d,splitByField:r,queryConfig:h,temporalBinning:a}),i=Array.from(new Set(u.flatMap(y=>{let{stackedAttributes:m}=y,g=[];return m&&(g=m.map(p=>p[r]).filter(p=>p!==void 0)),g})).values())}else{let{uniqueQuery:a}=await S({chartConfig:s,queryObject:t,queryConfig:c,options:o});u=await A({queryObject:t,queryConfig:a,featureCount:1}),i=Array.from(new Set(u.map(d=>d.attributes[r]).filter(d=>d!==void 0)).values())}return{allValues:i,preFetchedQueryResponse:u}}function R(n,t){let e=new Map;return n.series.forEach(o=>{let r=T({where:o.query?.where,normalize:!0,escape:!1});t&&r!==null&&(r=Number(r));let i=v([o]);i!==void 0&&e.set(i,[...e.get(i)??[],r])}),e}function U(n){let{allValues:t,configUniqueValuesPerSeriesType:e,initialConfigWasEmpty:o}=n,r=new Map;return Array.from(e.keys()).forEach(i=>{let u=e.get(i)??[],s=[];o?s=t:t.forEach(l=>{u.includes(l)||s.push(l)}),r.set(i,s)}),r}function I(n){let{chartConfig:t,missingValue:e,splitByField:o,seriesTemplate:r}=n,i=JSON.parse(JSON.stringify({...t.series[0],...r}));if(i.query){if(i.id=`${e}-${t.series.length}-${Date.now()}`,i.name=`${e}`,i.query.outStatistics?.[0]!==void 0){let s=i.id;i.query.outStatistics[0].outStatisticFieldName=s,"y"in i&&(i.y=s)}let u=typeof e=="number"||e===null?e:`'${e}'`;i.query.where=`${o}=${u}`}return i}async function L(n){let{updateSplitBySeries:t,config:e,options:o,queryObject:r}=n,{seriesTemplate:i}=t??{},u;if(t!==void 0&&e!==void 0&&(e.series.length>0||i!==void 0)&&t.addMissingSeries){let s=e.series.length===0;e.series.length===0&&i!==void 0&&e.series.push(i);let l=E(e.series);if((l===f.BoxPlotMonoFieldAndSplitBy||l===f.BoxPlotMultiFieldsAndSplitBy||l===f.BoxPlotMonoFieldAndCategoryAndSplitBy||l===f.BarAndLineSplitBy||l===f.BarAndLineSplitByNoAggregation)&&r!==void 0){let c=N(e.series[0]?.query?.where),a=F(r);await a.load();let d=a.getField(c)?.toJSON(),h=V(d),y=await J({queryObject:r,chartConfig:e,splitByField:c,options:o}),{allValues:m}=y;if({preFetchedQueryResponse:u}=y,m.length>0){let g=R(e,h),p=U({allValues:m,configUniqueValuesPerSeriesType:g,initialConfigWasEmpty:s});Array.from(p.keys()).forEach(k=>{(p.get(k)??[]).forEach(W=>{e.series.push(I({chartConfig:e,seriesTemplate:i,missingValue:W,splitByField:c}))}),s&&e.series.shift()})}}}return u}function z(n,t){t&&!q(t)&&(t=x({chartConfig:t,queryObject:n}))}async function le(n){let{configToAlter:t,layer:e,addMissingSeries:o,updateSplitBySeries:r,chartContainer:i,creation:u,queryObject:s,options:l,previousConfig:c}=n,a=t,d;return z(e,a),a=await Q(a,e),o&&(d=await L({updateSplitBySeries:r,config:a,options:l,queryObject:s})),(u||c&&$(c,a))&&(a=D(a,i)),{alteredConfig:a,preFetchedQueryResponse:d}}return{a:re,b:se,c:oe,d:ae,e:ue,f:le}},"geometry/support/jsonUtils","rest/support/AttributeBinsQuery","rest/support/Query","rest/support/StatisticDefinition","time/TimeExtent",a,b)