@arcgis/charts-components 4.33.0-next.99 → 4.33.0

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

@@ -0,0 +1,224 @@
+import { IField, LegendItemVisibility, WebBoxPlot, WebChart, WebChartDataItem, WebChartDataItemValue, WebChartSeries, WebChartStackedKinds, OverlayTerms, WebChartSortOrderKinds, WebChartTemporalBinningUnits, WebChartTypes } from '@arcgis/charts-spec';
+import { ChartElementLimit } from '../defaults/interfaces';
+import { SelectionData, ChartSubType } from './interfaces';
+type WebChartType = typeof WebChartTypes.BarSeries | typeof WebChartTypes.BoxPlotSeries | typeof WebChartTypes.ComboLineAndBarSeries | typeof WebChartTypes.GaugeSeries | typeof WebChartTypes.HistogramSeries | typeof WebChartTypes.LineSeries | typeof WebChartTypes.PieSeries | typeof WebChartTypes.RadarSeries | typeof WebChartTypes.ScatterSeries;
+type XYChartType = typeof WebChartTypes.BarSeries | typeof WebChartTypes.BoxPlotSeries | typeof WebChartTypes.ComboLineAndBarSeries | typeof WebChartTypes.HistogramSeries | typeof WebChartTypes.LineSeries | typeof WebChartTypes.RadarSeries | typeof WebChartTypes.ScatterSeries;
+type SerialChartType = typeof WebChartTypes.BarSeries | typeof WebChartTypes.ComboLineAndBarSeries | typeof WebChartTypes.LineSeries | typeof WebChartTypes.RadarSeries;
+type SupportedChartType = typeof WebChartTypes.BarSeries | typeof WebChartTypes.BoxPlotSeries | typeof WebChartTypes.HistogramSeries | typeof WebChartTypes.LineSeries | typeof WebChartTypes.PieSeries | typeof WebChartTypes.RadarSeries | typeof WebChartTypes.ScatterSeries;
+export type ChartTypes = Extract<WebChartTypes, WebChartType>;
+export type XYChartTypes = Extract<WebChartTypes, XYChartType>;
+export type SerialChartTypes = Extract<WebChartTypes, SerialChartType>;
+export type SupportedCharts = Extract<ChartTypes, SupportedChartType>;
+/**
+ * Returns the color policy for the chart.  If it's not defined, `WebChartColoringPatterns.Single` will be used.
+ * @param chartConfig the chart config.
+ * @returns the color policy.
+ */
+export declare function getColorMatch(chartConfig?: WebChart): boolean;
+/**
+ * Indicates whether or not the chart is rotated.
+ * @param chartConfig the chart config.
+ * @returns
+ */
+export declare function isChartRotated(chartConfig?: WebChart): boolean;
+/**
+ * Getting the list of series types from a series config array.
+ * @param chartSeries The array of chart's series
+ */
+export declare function getSeriesTypes(chartSeries?: WebChartSeries[]): ChartTypes[];
+/**
+ * Returns the type of stacking (side-by-side, stacked...) to be used to display the chart.
+ * For Line, Bar, Box-plot, and Radar chart, default option is 'sideBySide'
+ * @param series
+ */
+export declare function getStackedType(config?: WebChart): WebChartStackedKinds | undefined;
+/**
+ * Escapes any single quote in the input string with a single quote for SQL.
+ * For example: Cote d'Ivoire -> Cote d''Ivoire
+ * @param string input string to replace for any special characters.
+ */
+export declare function escapeSQLString(string: string): string;
+/**
+ * Normalizes a string by
+ *   - trimming off white spaces
+ *   - if the value is a string and keepSurroundingQuotes is not true: stripping ' (single inverted comma), if present on both sides
+ *   - if escape is true (or undefined): escaping special characters like ", \, /.
+ * E.g.:
+ * "'alpha'" => "alpha"
+ * "'alpha" => No change
+ * "alpha'" => No change
+ * "alp'ha'" => alp''ha
+ * "  'alpha'" => "alpha"
+ * "alp"\/ha" => "alp\"\\\/ha"
+ * @param props.value The string to normalize
+ * @param props.keepSurroundingQuotes Whether to keep the surrounding quotes; default is false
+ * @param props.escape Whether to escape special characters; default is true
+ */
+export declare function normalizeString(props: {
+    value: string;
+    keepSurroundingQuotes?: boolean;
+    escape?: boolean;
+}): string;
+/**
+ * Indicates whether a bar, line or pie chart respects the number limit of elements (bars, markers or slices).
+ * For bar chart, different limits are set according to the number of series.
+ * For line chart, a limit on the number of series and the total number of markers are set.
+ * For pie chart, a limit on the number of slices is set.
+ * @param props.count Number total of elements on the chart
+ * @param props.seriesCount Number of series on the chart
+ * @param props.seriesType The series type
+ * @param props.chartLimits The runtime chart limits
+ */
+export declare function isNumberOfElementsUnderLimit(props: {
+    count: number;
+    seriesCount: number;
+    chartType?: WebChartTypes;
+    chartLimits?: ChartElementLimit;
+}): boolean;
+/**
+ * Returns the alias for the field name if it exists; otherwise return the field name itself.
+ * @param fieldName The field name to look for in the field array
+ * @param fields The list of fields containing all the information regarding the fields, including the alias
+ */
+export declare function getFieldAlias(fields: IField[] | undefined, fieldName: string): string;
+export declare function getFieldAlias(fields: IField[] | undefined, fieldName: undefined): undefined;
+export declare function getFieldAlias(fields: IField[] | undefined, fieldName: string | undefined): string | undefined;
+/**
+ * Return the field name for the field alias if it exists; otherwise return the field alias itself.
+ * @param fieldAlias The field alias to look for in the field array
+ * @param fields The list of fields containing all the information regarding the fields, including the alias
+ */
+export declare function getFieldNameFromFieldAlias(fields: IField[] | undefined, fieldAlias: string): string;
+/**
+ * Decides whether we can show the legend or not. If it returns `false`, then we should not show the legend even if `legend.visible` is `true`.
+ * For Pie charts, hide the legend when there is only one slice.
+ * @param chartSeries
+ */
+export declare function canShowLegend(chartSeries: WebChartSeries[]): boolean;
+/**
+ * Based on a provided list of supported chart types, this function returns a boolean indicating if the config
+ * contains supported series. An extra test is done for the scatter plot, pie, and histogram series.
+ * @param supportedChartTypes The list of supported chart types
+ * @param config The chart's config
+ */
+export declare function isSupportedChart(supportedChartTypes: WebChartTypes[], config?: WebChart): boolean;
+/**
+ * Indicates whether a string field is empty (different from undefined, null and empty string).
+ * The value is stringified before being trimmed to debunk edge cases like when the value is a numeric value.
+ * @param value The value to test
+ * @returns `true` if empty, `false` otherwise
+ */
+export declare function isEmptyStringField(value: string | null | undefined): boolean;
+/**
+ * Indicates whether an object contains a property key from list of properties.
+ * @param data the object to look into
+ * @param propertyList the array of property keys to search the data if one of them is present.
+ * @returns An object containing a boolean indicating the propertyList presence, and the property key that matched
+ */
+export declare function isPropertyKeyInData<T extends WebChartDataItem>(data: T, propertyList: string[]): {
+    isInItem: boolean;
+    expr?: string;
+};
+/**
+ * Indicates whether an object contains the result of a calculated expression coming from a
+ * query (similar to "EXPR_1").
+ * @param dataItem the object to look into
+ * @returns An object containing a boolean indicating the expression's presence, and the expression key that matched
+ */
+export declare function isQueryCalculatedExprInItem(dataItem: WebChartDataItem): {
+    isInItem: boolean;
+    expr?: string;
+};
+/**
+ * Finds localized string for the given `WebChartTemporalBinningUnits` unit type.
+ * @param unit
+ * @param strings
+ * @returns Localized unit type label
+ */
+export declare function getTimeIntervalUnitLabel(unit: WebChartTemporalBinningUnits, strings: {
+    seconds?: string;
+    minutes?: string;
+    hours?: string;
+    days?: string;
+    weeks?: string;
+    months?: string;
+    years?: string;
+}): string;
+/**
+ * Returns the appropriate `index` to fetch the default color from `overlayRamp[]` array for a histogram overlay
+ * @param overlayType
+ */
+export declare function getOverlayColorIndex(overlayType: OverlayTerms | undefined): number;
+/**
+ * Assigns visible property to a series or an overlay
+ * @param props.config The config that gets updated for each series visibility
+ * @param props.event The event that is currently being called
+ */
+export declare function updateSeriesVisibility(event: CustomEvent<LegendItemVisibility>, config?: WebBoxPlot | WebChart): void;
+/**
+ * Sanitize an HTML string to prevent XSS attacks (https://owasp.org/www-community/attacks/xss/)
+ * @param inputToSanitize The HTML string to sanitize
+ */
+export declare function sanitizeHTMLOutput(inputToSanitize: string): string;
+/** .
+ * Indicates if a provided number value is valid.
+ * An invalid value is: undefined | NaN | Infinite | -Infinite | null
+ * See for more details:
+ *   - https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/isFinite
+ *   - https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/isNaN
+ */
+export declare function isValidNumber(value: WebChartDataItemValue): boolean;
+/**
+ * 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;
+/**
+ * Gets the sorting field or (sorting type for box-plot) and orderBy from an input string.
+ * @param stringToParse The input string to parse, like `orderByField` of a query clause or `orderDataBy` property of a chart config.
+ * @param useDefault If set to `false`, the default sort order will not be used.
+ * @returns
+ */
+export declare function getOrderByComponents(stringToParse: string, useDefault?: boolean): {
+    fieldToSort: string;
+    orderBy?: WebChartSortOrderKinds;
+};
+/**
+ * Gets the fields listed in the `orderByFields` property of a chart config.
+ * @param {WebChart} chartConfig -  The chart config
+ * @returns {string[]} The list of fields to sort by
+ */
+export declare function getOrderByFields(chartConfig: WebChart): string[];
+/**
+ * Determines if certain chart subtype is a split by chart.
+ * @param chartSubType The chart subtype
+ * @returns true if the chart subtype is a split by chart, false otherwise
+ */
+export declare function isSplitByChart(chartSubType: ChartSubType): boolean;
+/**
+ * Util function to know if the selection data changed.
+ * The selection items and selection OIDs are compared, not the selection source nor the selection indexes.
+ * @param selectionA The first selection data
+ * @param selectionB The second selection data
+ * @returns a boolean indicating whether the two selections are equal
+ */
+export declare function hasSelectionChanged(selectionA?: SelectionData, selectionB?: SelectionData): boolean;
+/**
+ * Indicates whether the selection data is empty.
+ * @param selectionData The selection data to check
+ */
+export declare function isSelectionEmpty(selectionData: SelectionData | undefined): boolean;
+/**
+ * Sorts arrayA based on the indexes of the elements in arrayB
+ * @param {T[]} props.arrayA - The array to be sorted
+ * @param {T[]} props.arrayB - The array to be used for sorting
+ * @param {function} props.getKey - The function to get the key of an item
+ */
+export declare function sortArrayAUsingArrayB<T, K>(props?: {
+    arrayA: T[];
+    arrayB: T[];
+    getKey: (item: T) => K;
+}): T[];
+export {};

package/dist/utils/misc/interfaces.d.ts

@@ -0,0 +1,87 @@
+import { ISimpleFillSymbol, ISimpleMarkerSymbol, ISimpleLineSymbol, Color, WebChartDataItem, WebChartPieChartGroupSlice, WebChartPieChartSlice } from '@arcgis/charts-spec';
+export declare const ChartSubType: {
+    readonly NonSpecific: "nonSpecific";
+    readonly BarAndLineNoAggregation: "barAndLineNoAggregation";
+    readonly BarAndLineMonoField: "barAndLineMonoField";
+    readonly BarAndLineMultiFields: "barAndLineMultiFields";
+    readonly BarAndLineFromFields: "barAndLineFromFields";
+    readonly BarAndLineSplitBy: "barAndLineSplitBy";
+    readonly BarAndLineSplitByNoAggregation: "barAndLineSplitByNoAggregation";
+    readonly PieNoAggregation: "pieNoAggregation";
+    readonly PieFromCategory: "pieFromCategory";
+    readonly PieFromFields: "pieFromFields";
+    readonly BoxPlotMonoField: "boxPlotMonoField";
+    readonly BoxPlotMultiFields: "boxPlotMultiFields";
+    readonly BoxPlotMonoFieldAndCategory: "boxPlotMonoFieldAndCategory";
+    readonly BoxPlotMultiFieldsAndCategory: "boxPlotMultiFieldsAndCategory";
+    readonly BoxPlotMonoFieldAndSplitBy: "boxPlotMonoFieldAndSplitBy";
+    readonly BoxPlotMultiFieldsAndSplitBy: "boxPlotMultiFieldsAndSplitBy";
+    readonly BoxPlotMonoFieldAndCategoryAndSplitBy: "boxPlotMonoFieldAndCategoryAndSplitBy";
+};
+export type ChartSubType = (typeof ChartSubType)[keyof typeof ChartSubType];
+export declare const SelectionSource: {
+    readonly SelectionByClick: "SelectionByClick";
+    readonly SelectionByRange: "SelectionByRange";
+    readonly ProgrammaticSelection: "ProgrammaticSelection";
+    readonly ClearSelection: "ClearSelection";
+};
+export type SelectionSource = (typeof SelectionSource)[keyof typeof SelectionSource];
+export type SelectionIndexes = Map<number, {
+    indexesToSelect?: number[];
+}>;
+export interface SelectionData {
+    selectionItems?: WebChartDataItem[];
+    selectionIndexes?: SelectionIndexes;
+    selectionOIDs?: number[];
+    selectionSource?: SelectionSource;
+}
+export interface SelectionThemeProperties {
+    elementColor?: Color;
+    elementOutlineColor?: Color;
+    elementOutlineWidth?: number;
+    rotation?: number;
+    transformation?: {
+        opacity?: number;
+        scale?: number;
+    };
+}
+export interface SelectionTheme {
+    selectedElementsTheme?: SelectionThemeProperties;
+    nonSelectedElementsTheme?: SelectionThemeProperties;
+}
+export interface LoaderColors {
+    curtainColor?: Color;
+    spinnerColor?: Color;
+}
+export type BoxPlotSymbols = {
+    fillSymbol?: ISimpleFillSymbol;
+} | {
+    lineSymbol: ISimpleLineSymbol;
+    markerSymbol?: ISimpleMarkerSymbol;
+};
+export type LineChartSymbols = {
+    lineSymbol: ISimpleLineSymbol;
+    markerSymbol?: ISimpleMarkerSymbol;
+};
+export type SeriesSymbols = BoxPlotSymbols | ISimpleFillSymbol | ISimpleLineSymbol | ISimpleMarkerSymbol | LineChartSymbols | PieSlicesSymbols;
+/**
+ * Type used to provide information regarding a pie chart's slices:
+ * - `slices` contains an array of `WebChartPieChartSlice` related to the non-grouped slices
+ * - `groupedSlices` contains an array of `WebChartPieChartSlice` related to the non-visible grouped slices
+ * - `groupOfSlices` contains a `WebChartPieChartSlice`related to the group of slices
+ * The `WebChartPieChartSlice` contains information regarding a slice's id, symbol and label.
+ */
+export type PieSlicesSymbols = {
+    slices: WebChartPieChartSlice[];
+    groupedSlices?: WebChartPieChartSlice[];
+    groupOfSlices?: WebChartPieChartGroupSlice;
+};
+/**
+ * Map containing a chart's series symbols.
+ * The numeric key is the series' position in the series array.
+ * The value is either:
+ *   - a fill symbol (bar chart and histogram)
+ *   - a marker symbol (scatter plot)
+ *   - an object containing a line symbol and a marker symbol (line chart)
+ */
+export type SeriesSymbolsMap = Map<number, SeriesSymbols | undefined>;

package/dist/utils/type-guards/index.d.ts

@@ -0,0 +1,128 @@
+import { CategoryFormatOptions, DateTimeFormatOptions, IFeatureLayer, ISimpleFillSymbol, ISimpleLineSymbol, ISimpleMarkerSymbol, NumberFormatOptions, WebBoxPlot, WebChart, WebChartBarChartSeries, WebChartBoxPlotSeries, WebChartDataTypes, WebChartGenericDataItem, WebChartHistogramDataItem, WebChartLineChartSeries, WebChartRadarChartSeries, WebChartScatterplotDataItem, WebChartSeries, WebChartStackedKinds, WebChartTextSymbol, WebGaugeChart } from '@arcgis/charts-spec';
+import { ChartTypes } from '../misc';
+import { ChartConfig } from '../types';
+import { ModelTypes } from '../../model';
+export type StringIndexable<T> = Record<string, unknown> & T;
+/**
+ * Web chart series with rotated property
+ */
+export type WebChartSeriesWithRotatedProp = WebChartSeries & {
+    rotated?: boolean;
+};
+/**
+ * Check if the chart config supports rotation or not
+ * @param config - the chart config
+ */
+export declare function isRotationSupported(config: WebChart): config is WebChart & {
+    series: WebChartSeriesWithRotatedProp[];
+};
+/**
+ * Web chart series with stackedType property
+ */
+type WebChartSeriesWithStackedTypeProp = WebChartSeries & {
+    stackedType?: WebChartStackedKinds;
+};
+/**
+ * Check if the chart config supports rotation or not
+ * @param config - the chart config
+ */
+export declare function isStackedTypeSupported(config: WebChart): config is WebChart & {
+    series: WebChartSeriesWithStackedTypeProp[];
+};
+/**
+ * Type guard for ISimpleFillSymbol
+ * @param symbol
+ */
+export declare function isSFS(symbol: any): symbol is ISimpleFillSymbol;
+/**
+ * Type guard for ISimpleLineSymbol
+ * @param symbol
+ */
+export declare function isSLS(symbol: any): symbol is ISimpleLineSymbol;
+/**
+ * Type guard for ISimpleMarkerSymbol
+ * @param symbol
+ */
+export declare function isSMS(symbol: any): symbol is ISimpleMarkerSymbol;
+/**
+ * Type guard for WebChartTextSymbol
+ * @param symbol
+ */
+export declare function isWebChartTextSymbol(symbol: any): symbol is WebChartTextSymbol;
+/**
+ * Determines if the provided `config` has a `iLayer` property.
+ * @param config
+ */
+export declare function hasILayer<T extends ModelTypes>(config: ChartConfig<T> | undefined): config is ChartConfig<T, T extends "boxPlot" ? WebBoxPlot : T extends "gauge" ? WebGaugeChart : WebChart>;
+export declare function hasILayer(config: WebChart | undefined): config is WebChart & {
+    iLayer: IFeatureLayer;
+};
+/**
+ * Determines if the provided `config` is the specified chart type `T`.
+ * @param config The chart config to check.
+ * @param chartType The chart type to check against.
+ */
+export declare function isChartType<T extends ChartConfig>(config: WebChart | undefined, chartType: ChartTypes | undefined): config is T;
+/**
+ * Determines if the series is a box plot series.
+ * @param series The series to check.
+ */
+export declare function isBoxPlotSeries(series: WebChartSeries | undefined): series is WebChartBoxPlotSeries;
+/**
+ * Determines if the series is a line chart series.
+ * @param series The series to check.
+ */
+export declare function isLineChartSeries(series: WebChartSeries | undefined): series is WebChartLineChartSeries;
+export declare function isRadarChartSeries(series: WebChartSeries | undefined): series is WebChartRadarChartSeries;
+/**
+ * Determines if the series is a bar chart series.
+ * @param series The series to check.
+ */
+export declare function isBarChartSeries(series: WebChartSeries | undefined): series is WebChartBarChartSeries;
+/**
+ * Type guard to check if the series is a BarChartSeries.
+ * @param {WebChartSeries[]} series - The series to check.
+ * @returns {series is WebChartBarChartSeries[]}
+ */
+export declare const isBarChartSeriesArray: (series: WebChartSeries[]) => series is WebChartBarChartSeries[];
+/**
+ * Type guard to check if the series is a LineChartSeries.
+ * @param {WebChartSeries[]} series - The series to check.
+ * @returns {series is WebChartLineChartSeries[]}
+ */
+export declare const isLineChartSeriesArray: (series: WebChartSeries[]) => series is WebChartLineChartSeries[];
+/**
+ * Type guard to check if the series is a RadarChartSeries.
+ * @param {WebChartSeries[]} series - The series to check.
+ * @returns {series is WebChartLineChartSeries[]}
+ */
+export declare const isRadarChartSeriesArray: (series: WebChartSeries[]) => series is WebChartRadarChartSeries[];
+/**
+ * Determines if the series array is of type box plot series.
+ * @param series The series to check.
+ */
+export declare function isBoxPlotSeriesArray(series: WebChartSeries[]): series is WebChartBoxPlotSeries[];
+/**
+ * Type guard for axis format being NumberFormatOptions
+ * @param valueFormat - valueFormat to check
+ */
+export declare function isNumberFormatOptions(valueFormat: CategoryFormatOptions | DateTimeFormatOptions | NumberFormatOptions | undefined): valueFormat is NumberFormatOptions;
+/**
+ * Type guard for WebChartDataTypes being WebChartHistogramDataItem
+ * @param data - dataItem to check
+ */
+export declare function isWebChartHistogramDataItemOrUndefined(data: WebChartDataTypes | undefined): data is WebChartHistogramDataItem | undefined;
+/**
+ * Type guard for WebChartDataTypes being WebChartGenericDataItem
+ * @param data - dataItem to check
+ */
+export declare function isWebChartGenericDataItemOrUndefined(data: WebChartDataTypes | undefined): data is WebChartGenericDataItem | undefined;
+/**
+ * Type guard for WebChartDataTypes being WebChartScatterplotDataItem
+ * @param data - dataItem to check
+ */
+export declare function isWebChartScatterplotDataItemOrUndefined(data: WebChartDataTypes | undefined): data is WebChartScatterplotDataItem | undefined;
+export declare function isValueAxisDataItem<T extends object>(axisDataItem: T): axisDataItem is T & {
+    value: number;
+};
+export {};

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

@@ -0,0 +1,9 @@
+import { WebChartSeries } from '@arcgis/charts-spec';
+import { ChartTypes } from '../misc';
+/**
+ * Getting the type of a chart or series. If the input parameters are incorrect (empty array of series, or a mix of unknown/unallowed series types) the function returns `undefined`.
+ * To get the series type, a valid seriesIndex is required. Otherwise, the type of a chart is determined and returned.
+ * @param chartSeries The array of chart's series
+ * @param seriesIndex An index to get a specific series' type.  A valid index is required if the goal is to get the type of the series.
+ */
+export declare function getChartOrSeriesType(chartSeries: WebChartSeries[] | undefined, seriesIndex?: number): ChartTypes | undefined;

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

@@ -0,0 +1,170 @@
+import { WebBoxPlot, WebChart, WebChartBarChartSeries, WebChartBoxPlotSeries, WebChartGaugeSeries, WebChartHistogramSeries, WebChartLegend, WebChartLineChartSeries, WebChartPieChartLegend, WebChartPieChartSeries, WebChartRadarChartSeries, WebChartScatterplotSeries, WebGaugeChart } from '@arcgis/charts-spec';
+import { ModelTypes, ModelTypeToSeriesType } from '../../model/interfaces/common';
+/**
+ * Interface to hold action bar props
+ */
+export interface ActionBarHideActionsProps {
+    /**
+     * determines whether to hide clear selection action or not
+     */
+    hideClearSelection?: boolean;
+    /**
+     * determines whether to hide filter by extent action or not
+     */
+    hideFilterByExtent?: boolean;
+    /**
+     * determines whether to hide filter by selection action or not
+     */
+    hideFilterBySelection?: boolean;
+    /**
+     * determines whether to hide full extent action or not
+     */
+    hideFullExtent?: boolean;
+    /**
+     * determines whether to hide legend action or not
+     */
+    hideLegend?: boolean;
+    /**
+     * determines whether to hide rotate action or not
+     */
+    hideRotateChart?: boolean;
+    /**
+     * determines whether to hide selection action or not
+     */
+    hideSelection?: boolean;
+    /**
+     * determines whether to hide switch selection action or not
+     */
+    hideSwitchSelection?: boolean;
+    /**
+     * determines whether to hide zoom action or not
+     */
+    hideZoom?: boolean;
+    /**
+     * determines whether to hide expand action or not
+     */
+    hideExpandAction?: boolean;
+}
+export declare const ChartComponentEvents: {
+    readonly DataProcessComplete: "arcgisDataProcessComplete";
+    readonly DataFetchComplete: "arcgisDataFetchComplete";
+    readonly DataProcessError: "arcgisDataProcessError";
+    readonly LegendItemVisibilityChange: "arcgisLegendItemVisibilityChange";
+    readonly UpdateComplete: "arcgisUpdateComplete";
+    readonly SeriesColorChange: "arcgisSeriesColorChange";
+    readonly AxesMinMaxChange: "arcgisAxesMinMaxChange";
+    readonly DefaultActionSelect: "arcgisDefaultActionSelect";
+    readonly SelectionComplete: "arcgisSelectionComplete";
+    readonly ActionBarToggle: "arcgisActionBarToggle";
+    readonly NoRenderPropChange: "arcgisNoRenderPropChange";
+    readonly BadDataWarningRaise: "arcgisBadDataWarningRaise";
+    readonly SeriesOrder: "arcgisSeriesOrder";
+    readonly RuntimeError: "arcgisRuntimeError";
+    readonly ConfigChange: "arcgisConfigChange";
+};
+export declare const DefaultChartActions: {
+    readonly FilterBySelection: "filterBySelection";
+    readonly FilterByExtent: "filterByExtent";
+    readonly Legend: "legend";
+    readonly RotateChart: "rotateChart";
+    readonly Selection: "selection";
+    readonly ClearSelection: "clearSelection";
+    readonly SwitchSelection: "switchSelection";
+    readonly Zoom: "zoom";
+    readonly FullExtent: "fullExtent";
+    readonly EditChart: "editChart";
+    readonly ExportAsImage: "exportAsImage";
+    readonly ExportAsCSV: "exportAsCSV";
+};
+export type DefaultChartActions = (typeof DefaultChartActions)[keyof typeof DefaultChartActions];
+/**
+ * Type alias for a Histogram config.
+ */
+export type HistogramConfig = Omit<WebChart, "series"> & {
+    series: WebChartHistogramSeries[];
+};
+/**
+ * Type alias for a Scatter Plot config.
+ */
+export type ScatterplotConfig = Omit<WebChart, "series"> & {
+    series: WebChartScatterplotSeries[];
+};
+/**
+ * Type alias for a Gauge Chart config.
+ */
+export type GaugeChartConfig = WebGaugeChart;
+/**
+ * Type alias for a Box Plot config.
+ */
+export type BoxPlotConfig = WebBoxPlot;
+/**
+ * Type alias for the supported chart series types.
+ */
+export type SupportedChartSeries = WebChartBarChartSeries | WebChartBoxPlotSeries | WebChartGaugeSeries | WebChartHistogramSeries | WebChartLineChartSeries | WebChartPieChartSeries | WebChartRadarChartSeries | WebChartScatterplotSeries;
+/**
+ * Type alias for a Chart configuration.
+ *
+ * This type is generic and supports configuration for different chart types, data source types, and data source requirement policies.
+ *
+ * It extends and modifies the base `WebChart` while replacing the generic `series` with the specific series type.
+ *
+ *
+ * @template T - The series type. It can be any of the supported chart series types.
+ * @template V - The chart type. This acts as the base type for the configuration. Default type is derived from the series type.
+ */
+export type ChartConfig<T extends ModelTypes = ModelTypes, V extends WebChart = T extends typeof ModelTypes.BoxPlot ? WebBoxPlot : T extends typeof ModelTypes.Gauge ? WebGaugeChart : WebChart> = Omit<V, "legend" | "series"> & {
+    series: ModelTypeToSeriesType<T>[];
+    legend?: T extends typeof ModelTypes.PieChart ? WebChartPieChartLegend : WebChartLegend;
+};
+export declare const ActionToggle: {
+    readonly Active: "active";
+    readonly Inactive: "inactive";
+};
+export type ActionToggle = (typeof ActionToggle)[keyof typeof ActionToggle];
+export declare const ActionState: {
+    readonly Enabled: "enabled";
+    readonly Disabled: "disabled";
+};
+export type ActionState = (typeof ActionState)[keyof typeof ActionState];
+export declare const ErrorPolicy: {
+    readonly Ignore: "ignore";
+    readonly Throw: "throw";
+};
+export type ErrorPolicy = (typeof ErrorPolicy)[keyof typeof ErrorPolicy];
+declare const ChangePolicy: {
+    readonly Ignore: "ignore";
+    readonly Refresh: "refresh";
+};
+type ChangePolicy = (typeof ChangePolicy)[keyof typeof ChangePolicy];
+export declare const LayerFilterChangePolicy: {
+    readonly Ignore: "ignore";
+    readonly Refresh: "refresh";
+};
+export type LayerFilterChangePolicy = ChangePolicy;
+export declare const LayerRendererChangePolicy: {
+    readonly Ignore: "ignore";
+    readonly Refresh: "refresh";
+};
+export type LayerRendererChangePolicy = ChangePolicy;
+export declare const LayerFieldsChangePolicy: {
+    readonly Ignore: "ignore";
+    readonly Refresh: "refresh";
+};
+export type LayerFieldsChangePolicy = ChangePolicy;
+export declare const ViewTimeExtentChangePolicy: {
+    readonly Ignore: "ignore";
+    readonly Refresh: "refresh";
+};
+export type ViewTimeExtentChangePolicy = ChangePolicy;
+export declare const SyncSelectionsBetweenChartAndLayerViewPolicy: {
+    /**
+     * Enable syncing selections between chart and layer view
+     */
+    readonly Enabled: "enabled";
+    /**
+     * Disable syncing selections between chart and layer view
+     */
+    readonly Disabled: "disabled";
+};
+export type SyncSelectionsBetweenChartAndLayerViewPolicy = (typeof SyncSelectionsBetweenChartAndLayerViewPolicy)[keyof typeof SyncSelectionsBetweenChartAndLayerViewPolicy];
+export {};

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

@@ -0,0 +1,8 @@
+import { WebChart, WebChartTypes } from '@arcgis/charts-spec';
+export declare function getChartIcon(chart: WebChart): string;
+/**
+ * Gets the chart type text based on the provided chart type.
+ * @param chartType
+ * @category Private
+ */
+export declare function getChartText(chartType: WebChartTypes): Promise<string>;