@arcgis/charts-components 4.34.0-next.9 → 4.34.0-next.90

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

@@ -1,5 +1,9 @@
 import { CSVOptions } from '../../interfaces';
-import { ChartModel } from '../../model';
+import { ModelTypes } from '../../model';
+import { IField, SupportedLayer } from '@arcgis/charts-spec';
+import { ChartConfig } from '../types';
+import { FeatureLayerView } from '@arcgis/core/views/layers/FeatureLayerView.js';
+import { SupportedLocalesForFormats } from '../localization/interfaces';
 /**
  * A utility function to compare if a value has changed deeply.
  * @param value
@@ -20,7 +24,11 @@ export declare function hasChangedDeepOrShallow<T>(value: T, oldValue?: T): bool
  *                               If `true`, all values will be quoted.
  *                               If `false` or `undefined`, only values that contain special characters will be quoted.
  */
-export declare const formatCell: (value: unknown, quoteAll?: boolean) => string;
+export declare const formatCell: (props: {
+    value: unknown;
+    quoteAll?: boolean;
+    locale?: SupportedLocalesForFormats;
+}) => string;
 /**
  * Converts an array of objects to a CSV string.
  * @param data - The data to convert.
@@ -31,7 +39,61 @@ export declare function arrayToCSV<T extends Record<string, unknown>>(data: T[],
 /**
  * Transform the raw data to a format that is suitable for exporting to CSV.
  * This function is used to transform the data before it is passed to the CSV export function.
- * @param rawData - The raw data to be transformed.
- * @param model - The model that defines the chart type and the data transformation.
+ * @param props.config - [Optional] The chart configuration that defines the chart type and data transformation.
+ * @param props.rawData - The raw data to be transformed, which is an array of objects.
+ * @param props.layer - [Optional] The layer associated with the chart, used for additional data context.
+ * @param props.fieldList - [Optional] The list of fields in the layer, used to determine field types and names.
  */
-export declare function transformChartData<T extends Record<string, unknown>>(rawData: T[], model?: ChartModel): T[];
+export declare function transformChartData<T extends Record<string, unknown>>(props: {
+    config?: ChartConfig;
+    rawData: T[];
+    layer?: FeatureLayerView | SupportedLayer;
+    fieldList?: IField[];
+}): T[];
+/**
+ * Transform the histogram data to a format that is suitable for exporting to CSV.
+ * @param config - The histogram model or config
+ * @param rows - The raw data to be transformed.
+ */
+export declare function transformHistogramData<T extends Record<string, unknown>>(config: ChartConfig<typeof ModelTypes.Histogram>, rows: T[]): T[];
+/**
+ * Processes the chart data for bar and line charts.
+ * @param props.config - The chart model.
+ * @param props.rows - The raw data to be transformed.
+ * @param props.layer - The layer associated with the chart.
+ */
+export declare function transformBarLineChartData<T extends Record<string, unknown>>(props: {
+    config: ChartConfig<typeof ModelTypes.BarChart | typeof ModelTypes.ComboBarLineChart | typeof ModelTypes.LineChart>;
+    rows: T[];
+    layer?: FeatureLayerView | SupportedLayer;
+    fieldList?: IField[];
+}): T[];
+/**
+ * Transform the pie chart data to a format that is suitable for exporting to CSV.
+ * @param props.model - The pie chart model.
+ * @param props.rows - The raw data to be transformed.
+ * @param props.layer - The layer associated with the chart.
+ */
+export declare function transformPieChartData<T extends Record<string, unknown>>(props: {
+    config: ChartConfig<typeof ModelTypes.PieChart>;
+    rows: T[];
+    layer?: FeatureLayerView | SupportedLayer;
+    fieldList?: IField[];
+}): T[];
+/**
+ * Transform the box plot data to a format that is suitable for exporting to CSV.
+ * @param model - The box plot model.
+ * @param rows - The raw data to be transformed.
+ * @returns The transformed data.
+ */
+export declare function transformBoxPlotData<T extends Record<string, unknown>>(props: {
+    config: ChartConfig<typeof ModelTypes.BoxPlot>;
+    rows: T[];
+    layer?: FeatureLayerView | SupportedLayer;
+    fieldList?: IField[];
+}): T[];
+/**
+ * Check if the provided date is valid.
+ * @param {unknown} date - The date to check, should be a string or a number.
+ */
+export declare const isValidDate: (date: unknown) => date is Date | number | string;

package/dist/utils/data/time-binning/interfaces.d.ts

@@ -26,4 +26,4 @@ export interface GroupProps {
     newDateMin: number;
     newDateMax: number;
 }
-export declare const groupByWhenCaseForMedianTimeBinning = "${ groupByFieldsForStatistics } WHEN ${ dateField }>='${ startDate }' AND ${ dateField }${ endDateOperand }'${ endDate }' THEN '${ y }|${ binIndex}'";
+export declare const groupByWhenCaseForMedianTimeBinning = "{ groupByFieldsForStatistics } WHEN { dateField }>='{ startDate }' AND { dateField }{ endDateOperand }'{ endDate }' THEN '{ y }|{ binIndex}'";

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

@@ -19,7 +19,7 @@ export declare const pieChartSpecialSlicesId: {
     emptySliceId: string;
 };
 export declare const defaultBoxPlotCategory = "arcgis_charts_box_plot_category";
-export declare const ramp: number[][];
+export declare const ramp: Color[];
 /**
  * Returns a specific color from the default ramp, given an index. If the index is > than the ramp length,
  * we use modulo to get the corresponding color.
@@ -184,7 +184,7 @@ export declare function getDefaultTimeAggregationTypeLabel(timeAggregationType:
  *  */
 export declare function getDefaultStackedType(): WebChartStackedKinds;
 /**
- * Returns the default label to show when there is no R2 value computed or set for scatter plot
+ * Returns the default label to show when there is no R2 value computed or set for scatterplot
  *
  * @returns {Promise<string>}
  */

package/dist/utils/index.d.ts

@@ -25,7 +25,6 @@ export * from './localization';
 export * from './localization/interfaces';
 export * from './misc';
 export * from './misc/interfaces';
-export type * from '../assets/t9n/utils/interfaces';
 export * from './type-guards';
 export * from './types';
 export * from './ui/chart-ui-utils';

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

@@ -1,7 +1,8 @@
 import { IFeatureLayer, IField, SupportedLayer, WebChart, WebChartDataFilters, WebChartQuery } from '@arcgis/charts-spec';
 import { default as FeatureLayer } from '@arcgis/core/layers/FeatureLayer.js';
+import { default as SubtypeGroupLayer } from '@arcgis/core/layers/SubtypeGroupLayer';
 import { default as Renderer } from '@arcgis/core/renderers/Renderer';
-import { QueryObject, QueryObjectProps, RendererInfo, SubtypeInfo } from './interfaces';
+import { IFeatureType, QueryObject, QueryObjectProps, RendererInfo, SubtypeInfo } from './interfaces';
 /**
  * Returns the renderer type and the field and normalization field if applicable.
  * @param layerRenderer
@@ -66,6 +67,29 @@ export declare function getLayerDateFields(fieldsInfo: IField[]): string[];
  * @param fieldsInfo
  */
 export declare function getLayerNumericFields(fieldsInfo: IField[]): string[];
+/**
+ * Retrieve the subtype name from the subtype id, if available.
+ * Otherwise, just simply returns the original value.
+ * @param props.subtypeInfo The subtypeInfo which consists of a typeIdField and a list of subtypes.
+ * @param props.fieldName The field name to check against the subtype's typeIdField
+ * @param props.fieldValueToMatch The field value, mainly the subtype id, to find the matching subtype name (if it's from a field that holds the subtypes for the features).
+ * @returns The matching subtype name if it's a subtype field; otherwise undefined.
+ * //TODO: may need to revise regrading the typeIdField property (See https://devtopia.esri.com/WebGIS/arcgis-js-api/issues/42555)
+ */
+declare function getSubtypeName(props: {
+    subtypeInfo?: SubtypeInfo;
+    fieldName: string;
+    fieldValueToMatch: number | string;
+}): string | undefined;
+/**
+ * Get the feature types from the layer, including all coded-value domains
+ * defined in the feature types.
+ * @param layer The layer to retrieve the information.
+ * @param propName Whether to fetch the types or subtypes
+ * @returns the feature types or undefined
+ */
+declare function getFeatureTypes(layer: FeatureLayer, propName: "types"): IFeatureType[] | undefined;
+declare function getFeatureTypes(layer: FeatureLayer | SubtypeGroupLayer, propName: "subtypes"): IFeatureType[] | undefined;
 /**
  * Retrieve subtype information from the query object.
  * @param queryObject The query object from which to retrieve the feature layer.
@@ -94,6 +118,14 @@ export declare function getFieldDescription(props: {
  * @returns {Promise<string[]>}
  */
 export declare function getRendererFieldNames(layer: SupportedLayer): Promise<string[]>;
+/**
+ * Returns the ArcGIS server's rest/info url of the feature server given a feature layer url.
+ * @example   getServerRestInfo(https://servicesdev.arcgis.com/b5ADkBof6gCHCFQm/arcgis/rest/services/Steph_Curry/FeatureServer/2
+ * returns https://servicesdev.arcgis.com/b5ADkBof6gCHCFQm/arcgis/rest/info
+ * @param {string} resUrl
+ * @returns {string}
+ */
+declare function getServerRestInfo(resUrl: string): string;
 /**
  * Returns a boolean to indicate if the feature layer is on standard feature data store or not.
  * https://doc.arcgis.com/en/arcgis-online/reference/faq.htm#anchor7
@@ -168,3 +200,9 @@ export declare function extractFieldsUsedInConfig(config: WebChart, layer: Suppo
  * @returns {string[]} The list of layer fields
  */
 export declare function extractFieldsFromConfigList(layer: SupportedLayer): Promise<string[]>;
+export declare const layerPrivateFunctions: {
+    getServerRestInfo: typeof getServerRestInfo;
+    getSubtypeName: typeof getSubtypeName;
+    getFeatureTypes: typeof getFeatureTypes;
+};
+export {};

package/dist/utils/layer/inline-conversion/index.d.ts

@@ -1,6 +1,17 @@
-import { IFeatureLayer, WebChart, WebChartDataTypes } from '@arcgis/charts-spec';
+import { Color, IFeatureLayer, WebChart, WebChartDataItemValue, WebChartDataTypes } from '@arcgis/charts-spec';
 import { default as FeatureLayer } from '@arcgis/core/layers/FeatureLayer';
 import { WebChartConfigFields } from './interfaces';
+/**
+ * Converts a hex color into a ESRI Color array ([number, number, number, number])
+ * @param hex The hex code to convert
+ */
+declare function hexToRGB(hex: string): Color | undefined;
+/**
+ * Converts an input value typed as WebChartDataItemValue into a Color.
+ * Only values representing a hex code or an ESRI color will yield a result.
+ * @param inputColor The input value to convert to a color
+ */
+declare function convertColor(inputColor?: WebChartDataItemValue): Color | undefined;
 /**
  * Creates a chart renderer based on the provided config fields and inline data
  * @param props.categoryField The category field
@@ -14,6 +25,17 @@ export declare function convertConfigFieldsToChartRenderer(props: {
     configFields?: WebChartConfigFields;
     inlineData: WebChartDataTypes;
 }): WebChart["chartRenderer"];
+/**
+ * Removes the config fields from the feature set to add to the feature collection
+ * @param numericFields The list of numeric fields
+ * @param configFields The config fields
+ * @param inlineData The data to cure
+ */
+declare function removeConfigFieldsFromData(props: {
+    numericFields: string[];
+    configFields: WebChartConfigFields;
+    inlineData: WebChartDataTypes;
+}): WebChartDataTypes;
 /**
  * Converts an array of inline data to a feature set and returns an IFeatureLayer
  * @param props.categoryField The category field
@@ -47,3 +69,9 @@ export declare function convertInlineConfigToLayerConfig(props: {
     iLayer?: IFeatureLayer;
     layer?: FeatureLayer;
 }>;
+export declare const inlineConversionPrivateFunctions: {
+    hexToRGB: typeof hexToRGB;
+    convertColor: typeof convertColor;
+    removeConfigFieldsFromData: typeof removeConfigFieldsFromData;
+};
+export {};

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

@@ -1,7 +1,7 @@
 import { RESTRendererType, WebChart, ICodedValue, SupportedLayer } from '@arcgis/charts-spec';
 import { default as MapView } from '@arcgis/core/views/MapView';
 import { default as SceneView } from '@arcgis/core/views/SceneView';
-import { default as FeatureLayerView } from '@arcgis/core/views/layers/FeatureLayerView';
+import { FeatureLayerView } from '@arcgis/core/views/layers/FeatureLayerView';
 export interface QueryObjectProps {
     chartConfig: WebChart;
     layer?: FeatureLayerView | SupportedLayer;

package/dist/utils/layer/query-features/index.d.ts

@@ -1,10 +1,10 @@
 /// <reference types="@arcgis/core/interfaces.d.ts" />
-import { WebChartCalendarBasedBinning, WebChartDataItem, WebChartFixedDateBinning, WebChartQuery } from '@arcgis/charts-spec';
+import { WebBoxPlot, WebChart, WebChartCalendarBasedBinning, WebChartDataItem, WebChartFixedDateBinning, WebChartQuery, WebHeatChart } from '@arcgis/charts-spec';
 import { default as AttributeBinsFeatureSet } from '@arcgis/core/rest/support/AttributeBinsFeatureSet.js';
-import { ErrorStrings } from '../../../assets/t9n/utils/interfaces';
 import { ChartSubType } from '../../misc/interfaces';
 import { QueryObject } from '../interfaces';
 import { AbortControllerKeyType, Features } from './interfaces';
+import { ErrorStrings } from '../../localization/interfaces';
 /**
  * Performs a query analytic.
  * @param props.queryObject The object used to query (FL or FLV)
@@ -30,6 +30,19 @@ export declare function getQueryAttributeBinsForScatterplotFieldsAlias(x: string
     upperBoundaryAlias: string;
     stackAlias: string;
 };
+/**
+ * Fetches and returns the heat chart data using query(Attribute)Bins
+ * @param props.chartConfig The chart configuration
+ * @param props.queryObject The object used to query (FL or FLV)
+ * @param props.queryConfig The query configuration
+ * @param props.errorStrings The t9n error strings
+ */
+export declare function queryAttributeBinsForHeatChart(props: {
+    chartConfig: WebBoxPlot | WebChart | WebHeatChart;
+    queryObject: QueryObject;
+    queryConfig: WebChartQuery;
+    errorStrings: ErrorStrings;
+}): Promise<AttributeBinsFeatureSet | undefined>;
 /**
  * Uses query(Attribute)Bins to fetch the aggregated scatterplot data
  * @param props.queryObject The object used to query (FL or FLV)

package/dist/utils/layer/query-parser/index.d.ts

@@ -1,5 +1,5 @@
 /// <reference types="@arcgis/core/interfaces.d.ts" />
-import { SupportedLayer, WebChartCalendarBasedBinning, WebChartFixedDateBinning, WebChartQuery } from '@arcgis/charts-spec';
+import { SupportedLayer, WebChartCalendarBasedBinning, WebChartFixedDateBinning, WebChartHeatChartSeries, WebChartQuery, RESTFieldType } from '@arcgis/charts-spec';
 import { default as Geometry } from '@arcgis/core/geometry/Geometry';
 import { default as AttributeBinsQuery } from '@arcgis/core/rest/support/AttributeBinsQuery.js';
 import { default as Query } from '@arcgis/core/rest/support/Query.js';
@@ -47,6 +47,13 @@ export declare function mapQueryTimeExtent(timeExtentConfig?: WebChartQuery["tim
  * @param geometryConfig The geometry from the config
  */
 export declare function mapQueryGeometry(geometryConfig?: WebChartQuery["geometry"]): Geometry | null | undefined;
+/**
+ * Sanitizes an outFields array by:
+ * - removing the duplicates
+ * @param outFields The array to sanitize
+ * @returns The sanitized array
+ */
+declare function sanitizeOutFields(outFields?: string[]): string[];
 /**
  * Maps properties from a WebChartQuery and properties specific to temporal binning into an AttributeBinsQuery object.
  * @param props.queryObject The layer or feature layer view
@@ -61,7 +68,39 @@ export declare function mapAttributeBinsQueryForTemporalData(props: {
     temporalBinning: WebChartCalendarBasedBinning | WebChartFixedDateBinning;
     dateField: string;
     splitByField?: string;
-}): AttributeBinsQuery;
+}): Promise<AttributeBinsQuery>;
+/**
+ * Builds a SQL expression as well as the start and end values necessary for the calendar date parts binning.
+ * @param props.field The field used by the heat chart
+ * @param props.fieldType The field type
+ * @param props.unit The unit of the temporal binning
+ */
+export declare function getCalendarDatePartsParameters(props: {
+    field: string;
+    fieldType?: RESTFieldType;
+    unit?: string;
+}): {
+    expression?: string;
+    start?: number;
+    end?: number;
+};
+/**
+ * Maps properties from a WebChartQuery and properties specific to heat chart into an AttributeBinsQuery object.
+ * @param props.queryObject The layer or feature layer view
+ * @param props.queryConfig The query configuration
+ * @param props.x The x field
+ * @param props.y The y field
+ * @param props.xTemporalBinning The x temporal binning configuration
+ * @param props.yTemporalBinning The y temporal binning configuration
+ */
+export declare function mapAttributeBinsQueryForHeatChart(props: {
+    queryObject?: QueryObject;
+    queryConfig?: WebChartQuery;
+    x: string;
+    y: string;
+    xTemporalBinning?: WebChartHeatChartSeries["xTemporalBinning"];
+    yTemporalBinning?: WebChartHeatChartSeries["yTemporalBinning"];
+}): Promise<AttributeBinsQuery>;
 /**
  * Maps properties from a WebChartQuery and properties specific to temporal binning into an AttributeBinsQuery object.
  * @param props.queryObject The layer or feature layer view
@@ -95,3 +134,7 @@ export declare function mapQuery(props: {
     maxRecordCountFactor?: number;
 }): Query;
 export declare function getMaxRecordCountFactor(layer?: SupportedLayer): number | undefined;
+export declare const queryParserPrivateFunctions: {
+    sanitizeOutFields: typeof sanitizeOutFields;
+};
+export {};

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

@@ -2,7 +2,7 @@ import { SupportedLayer, WebChart } from '@arcgis/charts-spec';
 import { default as FeatureLayer } from '@arcgis/core/layers/FeatureLayer';
 import { default as SubtypeGroupLayer } from '@arcgis/core/layers/SubtypeGroupLayer';
 import { default as SubtypeSublayer } from '@arcgis/core/layers/support/SubtypeSublayer';
-import { default as FeatureLayerView } from '@arcgis/core/views/layers/FeatureLayerView';
+import { FeatureLayerView } from '@arcgis/core/views/layers/FeatureLayerView';
 import { QueryObject } from '../interfaces';
 /**
  * Indicates whether the input object is a feature collection.
@@ -49,6 +49,12 @@ export declare function getMainLayer(layer: SupportedLayer | undefined): Feature
  * @returns A boolean
  */
 export declare function doesLayerSupportQueryWithDistance(layer: SupportedLayer): boolean;
+/**
+ * Indicates whether a layer supports the queryBins operation for the heat chart use case.
+ * @param layer The layer to test
+ * @returns A boolean indicating whether the operation is supported
+ */
+export declare function doesLayerSupportsQueryBinsForHeatChart(layer: SupportedLayer): boolean;
 /**
  * Indicates whether a layer supports the queryBins operation for the temporal data use case.
  * We currently only use the "date" operation.

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

@@ -1,18 +1,11 @@
-import { ComponentLocaleItem, LocaleInfo, LocaleItem } from './interfaces';
 import { default as MapView } from '@arcgis/core/views/MapView';
-import { CommonStrings, ErrorStrings } from '../../assets/t9n/utils/interfaces';
+import { ErrorStrings, LocaleInfo, UtilsStrings, SupportedLocalesForFormats } from './interfaces';
 /**
- * Generates and returns a message with the keys in the input statement replaced with new values.
- * @param message
- * @param parameters
+ * Finds the locale info of the closest element to the given element.
+ *
+ * @param element The element to get the locale info from.
  */
-export declare function formatMessage(statement: Readonly<string>, parameters: Readonly<LocaleItem>): string;
-/**
- * Finds the locale of the closest element to the given element.
- * If no element given, and converts `window.navigator.language` into a supported locale.
- * @param element
- */
-export declare function getLocaleInfo(element?: Element): LocaleInfo;
+export declare function getLocaleInfo(element?: HTMLElement): LocaleInfo;
 /**
  * Converts the given `timeZone` from ArcGIS `MapView` to a valid time zone string.
  * @param {MapView["timeZone"] | undefined} timeZone
@@ -33,41 +26,24 @@ export declare function getDateStringInCalciteDatePickerFormat(date: Date, timeZ
  * @returns {string}
  */
 export declare function getTimeStringInCalciteTimePickerFormat(date: Date, timeZone: string): string;
-/**
- * Fetches locale string for a given component
- * @param element The component's HTML element
- * @param baseURL The base URL to fetch the locale file
- * @param removeArcgisPrefix Whether to remove the `arcgis-` from the file name (currently used by the charts-config package).
- */
-export declare function fetchComponentLocaleStrings<T extends LocaleItem>(element: Element, baseURL: string, removeArcgisPrefix?: boolean): Promise<ComponentLocaleItem<T>>;
-/**
- * Fetches locale error strings for a given component
- * @param element The component's HTML element
- * @param baseURL The base URL to fetch the locale file
- */
-export declare function fetchComponentLocaleCommonStrings<T extends CommonStrings | ErrorStrings>(props: {
-    element: Element;
-    baseURL: string;
-    filePrefix: "common" | "errors";
-}): Promise<T>;
-/**
- * Returns if the detected language is rtl or ltr and returns the direction
- * @param element
- */
-export declare function fetchLanguageDirection(element?: Element): "ltr" | "rtl";
 /**
  * Performs locale aware parse float
  * @param localizedString string that has to be parsed
  * @param locale  locale used for parsing the float
  */
 export declare function localeParseFloat(localizedString: string, locale?: string): number;
+/**
+ * Gets the format locale from the given element.
+ * @param element HTMLElement to get the locale from
+ */
+export declare function getElementFormatLocale(element: HTMLElement): SupportedLocalesForFormats;
 /**
  * Returns a default `CommonStrings` t9n object.
  * This is used by the chart components unit tests and the charts-js Storybook demos.
  */
-export declare function getDefaultErrorsStrings(): ErrorStrings;
+export declare function getDefaultErrorsStrings(): Promise<ErrorStrings>;
 /**
- * Returns a default `CommonStrings` t9n object.
+ * Returns a default `UtilsStrings` t9n object.
  * This is used by the chart components unit tests and the charts-js Storybook demos.
  */
-export declare function getDefaultCommonStrings(): CommonStrings;
+export declare function getDefaultUtilsStrings(): Promise<UtilsStrings>;