@arcgis/charts-components 4.33.0-next.100 → 4.33.0-next.102

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

@@ -0,0 +1,141 @@
+import { WebChartCalendarBasedBinning, WebChartDataItem, WebChartFixedDateBinning, WebChartQuery } from '@arcgis/charts-spec';
+import { default as Graphic } from '@arcgis/core/Graphic';
+import { ErrorStrings } from '../../../assets/t9n/utils/interfaces';
+import { ChartSubType } from '../../misc/interfaces';
+import { QueryObject } from '../interfaces';
+import { AbortControllerKeyType, Features } from './interfaces';
+/**
+ * Performs a query analytic.
+ * @param props.queryObject The object used to query (FL or FLV)
+ * @param props.queryConfig The WebChartQuery
+ * @param props.outAnalytics The out analytics
+ * @param props.outputFormat The output format
+ * @param props.dataFormat The data format
+ */
+export declare function queryAnalytic(props: {
+    queryObject: QueryObject;
+    queryConfig: WebChartQuery;
+    outAnalytics: string;
+    outputFormat: string;
+    dataFormat: string;
+}): Promise<WebChartDataItem | undefined>;
+/**
+ * Generates the aliases to use in the queryAttributeBins query to name the stacks and boundaries for the x field
+ * @param x The x field used for the stack alias
+ * @param y The y field used by the stacks
+ */
+export declare function getQueryAttributeBinsForScatterPlotFieldsAlias(x: string, y: string): {
+    lowerBoundaryAlias: string;
+    upperBoundaryAlias: string;
+    stackAlias: string;
+};
+/**
+ * Uses query(Attribute)Bins to fetch the aggregated scatterplot data
+ * @param props.queryObject The object used to query (FL or FLV)
+ * @param props.queryConfig The query configuration
+ * @param props.xStep The x step
+ * @param props.yStep The y step
+ * @param props.xMin The x min
+ * @param props.xMax The x max
+ * @param props.x The x field
+ * @param props.y The y field
+ * @param props.errorStrings The t9n error strings
+ */
+export declare function queryAttributeBinsForScatterPlot(props: {
+    queryObject: QueryObject;
+    queryConfig: WebChartQuery;
+    xStep: number;
+    yStep: number;
+    xMin: number;
+    xMax: number;
+    x: string;
+    y: string;
+    errorStrings: ErrorStrings;
+}): Promise<Graphic[]>;
+/**
+ * Performs a query feature count based on the provided parameters.
+ * @param props.queryObject The object used to query (FL or FLV)
+ * @param props.queryConfig The WebChartQuery containing parameters about the query to execute
+ * @param props.chartSubType The chart sub type
+ * @param props.x The x field
+ * @param props.isGaugeByFeature Indicate whether it's a gauge by feature. Will be defaulted to `false` if not provided.
+ */
+export declare function queryFeatureCount(props: {
+    queryObject: QueryObject;
+    queryConfig: WebChartQuery;
+    chartSubType: ChartSubType;
+    x: string;
+    isGaugeByFeature?: boolean;
+}): Promise<number | undefined>;
+/**
+ * Fetches multiple statistics (min, max, count...).
+ * Returns an object mapping the outStatisticFieldName with its value
+ * @param props.queryObject The object used to query (FL or FLV)
+ * @param props.queryConfig The WebChartQuery containing parameters about the query to execute
+ * @param props.abortKey The key to abort the query
+ */
+export declare function queryStatistics<T extends Date | number | string>(props: {
+    queryObject: QueryObject;
+    queryConfig: WebChartQuery;
+    abortKey?: AbortControllerKeyType;
+}): Promise<Map<string, T>>;
+/**
+ * Fetches all the features from the input QueryObject, according to the other specified input settings (query, outFields...).
+ * Handles the paging.
+ * @param props.queryObject The object used to query (FL or FLV)
+ * @param props.queryConfig The WebChartQuery containing parameters about the query to execute
+ * @param props.returnUniqueIdsOnly If true, the function will return only the unique IDs of the features
+ * @param props.featureCount The number of features to fetch
+ * @param props.noBatch If true, the function will not use the batching mechanism
+ * @param props.abortKey The key to abort the query
+ */
+export declare function queryAllFeatures(props: {
+    queryObject?: QueryObject;
+    queryConfig?: WebChartQuery;
+    returnUniqueIdsOnly?: boolean;
+    featureCount?: number;
+    noBatch?: boolean;
+    abortKey?: AbortControllerKeyType;
+}): Promise<Features>;
+/**
+ * Fetches the extent of all the features that are represented by their object ids
+ * @param props.queryObject The object used to query (FL or FLV)
+ * @param props.queryConfig The WebChartQuery containing parameters about the query to execute
+ * @param props.uniqueFeature Whether the query is made to fetch a unique feature
+ * @param props.abortKey The key to abort the query
+ */
+export declare function queryUniqueIDs(props: {
+    queryObject?: QueryObject;
+    queryConfig: WebChartQuery;
+    uniqueFeature?: boolean;
+    abortKey?: AbortControllerKeyType;
+}): Promise<number[]>;
+/**
+ * Aborts all existing queries and initializes a controller for new ones. The queries are associated
+ * to a unique key to avoid cancelling queries for other charts.
+ * @param key The key pointing to the abort controller to execute
+ */
+export declare function abortPendingQueries(key?: AbortControllerKeyType): void;
+export declare function getQueryAttributeBinsForTemporalDataAliases(x: string): {
+    lowerBoundaryAlias: string;
+    upperBoundaryAlias: string;
+};
+/**
+ * Fetches binned temporal data using queryAttributeBins().
+ * TODO: support for offset
+ * TODO: support for abortKey input parameter
+ * @param props.queryObject The object used to query (FL or FLV)
+ * @param props.queryConfig The WebChartQuery containing parameters about the query to execute
+ * @param props.temporalBinning The temporal binning configuration
+ * @param props.dateField The date field to bin
+ * @param props.splitByField The split-by field
+ * @param props.abortKey The key to abort the query
+ */
+export declare function queryAttributeBinsForTemporalData(props: {
+    queryObject?: QueryObject;
+    queryConfig: WebChartQuery;
+    temporalBinning?: WebChartCalendarBasedBinning | WebChartFixedDateBinning;
+    dateField: string;
+    splitByField?: string;
+    abortKey?: AbortControllerKeyType;
+}): Promise<WebChartDataItem[]>;

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

@@ -0,0 +1,4 @@
+import { default as Graphic } from '@arcgis/core/Graphic';
+export type AbortControllerKeyType = Date | number | string;
+export declare const abortControllerMap: Map<AbortControllerKeyType, AbortController>;
+export type Features = (number | string)[] | Graphic[];

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

@@ -0,0 +1,76 @@
+/// <reference types="@arcgis/core/interfaces.d.ts" />
+import { SupportedLayer, WebChartCalendarBasedBinning, WebChartFixedDateBinning, WebChartQuery } from '@arcgis/charts-spec';
+import { default as AttributeBinsQuery } from '@arcgis/core/rest/support/AttributeBinsQuery.js';
+import { default as Query } from '@arcgis/core/rest/support/Query.js';
+import { default as TimeExtent } from '@arcgis/core/time/TimeExtent.js';
+import { default as Geometry } from '@arcgis/core/geometry/Geometry';
+import { QueryObject } from '../interfaces';
+/**
+ * Indicates whether a query can be cached. It is not when:
+ * - a geometry is set (unless it's an extent)
+ * - a date filter is set
+ * @param query The query object or query parameters
+ */
+export declare function isQueryCacheable(query: __esri.QueryProperties | AttributeBinsQuery | Query): boolean;
+export declare function getMaxRecords(layer?: SupportedLayer): number;
+/**
+ * Function building a where clause by concatenating a list of filters by using the AND operator.
+ * @param filterList The list of filters to combine
+ * @param operand The operand to use to combine the filters (OR, AND...)
+ */
+export declare function combineFilters(filterList: (string | null | undefined)[], operand?: string): string;
+/**
+ * Computes the time extent to be used by the query.
+ * @param queryObject The layer or feature layer view
+ * @param defaultTimeExtent The time extent defined at the series config level or provided at runtime
+ */
+export declare function getQueryTimeExtent(queryObject: QueryObject, defaultTimeExtent?: WebChartQuery["timeExtent"]): WebChartQuery["timeExtent"] | undefined;
+/**
+ * Computes the extent to be used by the query. We prioritize the feature layer view extent
+ * over the series config extent, unless `ignoreViewExtent` is set to true.
+ * @param props.queryObject The layer or feature layer view
+ * @param props.defaultGeometry The geometry defined at the series config level or provided at runtime
+ * @param props.ignoreViewExtent Whether to ignore the view's extent
+ */
+export declare function getQueryGeometry(props: {
+    queryObject: QueryObject;
+    defaultGeometry?: WebChartQuery["geometry"];
+    ignoreViewExtent?: boolean;
+}): WebChartQuery["geometry"] | undefined;
+/**
+ * Transforms a [timestamp, timestamp] to a JSAPI TimeExtent object
+ * @param timeExtentConfig The time extent filter from the config
+ */
+export declare function mapQueryTimeExtent(timeExtentConfig?: WebChartQuery["timeExtent"]): TimeExtent | undefined;
+/**
+ * Transforms a IGeometry to a JSAPI Geometry
+ * @param geometryConfig The geometry from the config
+ */
+export declare function mapQueryGeometry(geometryConfig?: WebChartQuery["geometry"]): Geometry | null | undefined;
+/**
+ * Maps properties from a WebChartQuery and properties specific to temporal binning into an AttributeBinsQuery object.
+ * @param props.queryObject The layer or feature layer view
+ * @param props.queryConfig The query configuration
+ * @param props.temporalBinning The temporal binning configuration
+ * @param props.dateField The date field to bin
+ * @param props.splitByField The split-by field
+ */
+export declare function mapAttributeBinsQuery(props: {
+    queryObject?: QueryObject;
+    queryConfig?: WebChartQuery;
+    temporalBinning: WebChartCalendarBasedBinning | WebChartFixedDateBinning;
+    dateField: string;
+    splitByField?: string;
+}): AttributeBinsQuery;
+/**
+ * Maps properties from a WebChartQuery into a Query object.
+ * @param props.queryObject The layer or feature layer view
+ * @param props.queryConfig The query configuration
+ * @param props.maxRecordCountFactor When set, the maximum number of features returned by the query will equal the `maxRecordCount` of the service multiplied by this factor.
+ */
+export declare function mapQuery(props: {
+    queryObject?: QueryObject;
+    queryConfig?: WebChartQuery;
+    maxRecordCountFactor?: number;
+}): Query;
+export declare function getMaxRecordCountFactor(layer?: SupportedLayer): number | undefined;

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

@@ -0,0 +1,100 @@
+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 { QueryObject } from '../interfaces';
+/**
+ * Indicates whether the input object is a feature collection.
+ * @param queryObject
+ */
+export declare function isFeatureCollectionLayer(queryObject: QueryObject): queryObject is FeatureLayerView;
+/**
+ * Indicates whether the input object is an instance of `FeatureLayerView`.
+ * @param queryObject
+ */
+export declare function isFeatureLayerView(queryObject: QueryObject): queryObject is FeatureLayerView;
+/**
+ * Indicates whether the input object is an instance of `FeatureLayer`.
+ * @param queryObject
+ */
+export declare function isFeatureLayer(queryObject: QueryObject): queryObject is FeatureLayer;
+/**
+ * Indicates whether the input object is an instance of `SubtypeGroupLayer`.
+ * @param queryObject
+ */
+export declare function isSubtypeGroupLayer(queryObject: QueryObject | SubtypeGroupLayer): queryObject is SubtypeGroupLayer;
+/**
+ * Indicates whether the input object is an instance of `SubtypeSublayer`.
+ * @param queryObject
+ */
+export declare function isSubtypeSublayer(queryObject: QueryObject): queryObject is SubtypeSublayer;
+/**
+ * Indicates whether the input object is an instance of `SupportedLayer` (`FeatureLayer` or `SubtypeSublayer`).
+ * @param queryObject
+ */
+export declare function isSupportedLayer(queryObject: QueryObject): queryObject is SupportedLayer;
+/**
+ * Returns the main `Layer` instance associated with the layer being used.
+ *
+ * Only needed for the case where the layer is a `SubtypeSublayer`, in which case we use the parent layer which is a `SubtypeGroupLayer`.
+ *
+ * @param layer
+ */
+export declare function getMainLayer(layer: SupportedLayer): FeatureLayer | SubtypeGroupLayer;
+export declare function getMainLayer(layer: SupportedLayer | undefined): FeatureLayer | SubtypeGroupLayer | null | undefined;
+/**
+ * Indicates whether a layer supports queries with a `distance` parameter
+ * @param layer The layer to test
+ * @returns A boolean
+ */
+export declare function doesLayerSupportQueryWithDistance(layer: SupportedLayer): boolean;
+/**
+ * Indicates whether a layer supports the queryBins operation for the temporal data use case
+ * @param layer The layer to test
+ * @returns A boolean
+ */
+export declare function doesLayerSupportsQueryBinsForTemporalData(layer: FeatureLayer | SubtypeGroupLayer): boolean;
+/**
+ * Indicates whether the layer supports the cacheHint parameter for the queryBins operation
+ * @param queryObject The layer or feature layer view
+ */
+export declare function doesLayerSupportsCacheHintForQueryBins(queryObject: QueryObject): boolean;
+/**
+ * Indicates whether the layer supports the query bins operation for scatterplot:
+ * - supports queryBins
+ * - supports the type `fixedIntervalBin`
+ * - statistics: supports MAX and COUNT
+ * @param queryObject The layer or feature layer view
+ */
+export declare function doesLayerSupportsQueryBinsForScatterplot(queryObject: QueryObject): boolean;
+/**
+ * Returns a feature layer from a QueryObject instance.
+ * It will use the QueryObject itself if it's a Feature Layer, or the `layer` property from it if it's a Feature Layer View.
+ * @param queryObject
+ */
+export declare function getLayerFromLayerOrLayerView(layerOrLayerView: FeatureLayerView | SupportedLayer): SupportedLayer;
+/**
+ * Returns a feature layer from a QueryObject instance.
+ * It will use the QueryObject itself if it's a Feature Layer, or the `layer` property from it if it's a Feature Layer View.
+ * @param queryObject
+ */
+export declare function getLayerFromQueryObject(queryObject: QueryObject): SupportedLayer;
+/**
+ * Computes a feature layer capabilities regarding its spatial aggregation statistics.
+ * Only considers the 'EnvelopeAggregate' for now.
+ * @param layer The layer instance
+ * @returns A sum up of the capabilities
+ */
+export declare function getLayerSpatialAggregationStatisticsCapabilities(layer: SupportedLayer): boolean;
+/**
+ * Adds a iLayer to a WebChart.
+ * If the `queryObject` prop is provided an `iLayer` is added to the config.
+ * @param props.chartConfig The chart config with no iLayer
+ * @param props.queryObject The layer or feature layer view instance. Its information are **not** used to create the iLayer.
+ * @returns The update chart config with a `iLayer` property
+ */
+export declare function addILayer<T extends WebChart>(props: {
+    chartConfig: T;
+    queryObject?: FeatureLayerView | SupportedLayer;
+}): T & WebChart;

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

@@ -0,0 +1,73 @@
+import { ComponentLocaleItem, LocaleInfo, LocaleItem } from './interfaces';
+import { default as MapView } from '@arcgis/core/views/MapView';
+import { CommonStrings, ErrorStrings } from '../../assets/t9n/utils/interfaces';
+/**
+ * Generates and returns a message with the keys in the input statement replaced with new values.
+ * @param message
+ * @param parameters
+ */
+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;
+/**
+ * Converts the given `timeZone` from ArcGIS `MapView` to a valid time zone string.
+ * @param {MapView["timeZone"] | undefined} timeZone
+ * @returns {MapView["timeZone"] | undefined}
+ */
+export declare function convertTimeZone(timeZone: MapView["timeZone"] | undefined): string | undefined;
+/**
+ * Returns the date string in the Calcite date picker's expected format `YYYY-MM-DD` based on the given date and time zone.
+ * @param {Date} date
+ * @param {string} timeZone
+ * @returns {string}
+ */
+export declare function getDateStringInCalciteDatePickerFormat(date: Date, timeZone: string): string;
+/**
+ * Returns the time string in the Calcite time picker's expected format `HH:mm` based on the given date and time zone.
+ * @param {Date} date
+ * @param {string} timeZone
+ * @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;
+/**
+ * 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;
+/**
+ * Returns a default `CommonStrings` t9n object.
+ * This is used by the chart components unit tests and the charts-js Storybook demos.
+ */
+export declare function getDefaultCommonStrings(): CommonStrings;

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

@@ -0,0 +1,63 @@
+export interface LocaleItem {
+    [key: string]: LocaleItem | string;
+}
+export interface ComponentLocaleItem<T extends LocaleItem> {
+    strings: T;
+    direction: "ltr" | "rtl";
+}
+/**
+ * Locale list (in alphabetical order) adopted from [JSAPI](https://devtopia.esri.com/WebGIS/arcgis-js-api/tree/master/esri/nls)
+ * Full forms adopted from [1](https://www.science.co.il/language/Locale-codes.php) and [2](https://saimana.com/list-of-country-locale-code/)
+ */
+export declare const SupportedLocales: {
+    readonly Arabic: "ar";
+    readonly ArabicLatin: "ar-u-nu-latn";
+    readonly Bosnian: "bs";
+    readonly Bulgarian: "bg";
+    readonly Catalan: "ca";
+    readonly Czech: "cs";
+    readonly Danish: "da";
+    readonly German: "de";
+    readonly Greek: "el";
+    readonly English: "en";
+    readonly EnglishUSA: "en-US";
+    readonly Spanish: "es";
+    readonly Estonian: "et";
+    readonly Finnish: "fi";
+    readonly French: "fr";
+    readonly Hebrew: "he";
+    readonly Croatian: "hr";
+    readonly Hungarian: "hu";
+    readonly Indonesian: "id";
+    readonly Italian: "it";
+    readonly Japanese: "ja";
+    readonly Korean: "ko";
+    readonly Lithuanian: "lt";
+    readonly Latvian: "lv";
+    readonly NorwegianBokml: "no";
+    readonly Dutch: "nl";
+    readonly Polish: "pl";
+    readonly PortugueseBrazil: "pt-BR";
+    readonly PortuguesePortugal: "pt-PT";
+    readonly Romanian: "ro";
+    readonly Russian: "ru";
+    readonly Serbian: "sr";
+    readonly Slovenian: "sl";
+    readonly Slovak: "sk";
+    readonly Swedish: "sv";
+    readonly Thai: "th";
+    readonly Turkish: "tr";
+    readonly Ukrainian: "uk";
+    readonly Vietnamese: "vi";
+    readonly ChineseChina: "zh-CN";
+    readonly ChineseHongKong: "zh-HK";
+    readonly ChineseTaiwan: "zh-TW";
+};
+export type SupportedLocales = (typeof SupportedLocales)[keyof typeof SupportedLocales];
+export declare const SupportedLocalesForFormats: string[];
+export type SupportedLocalesForFormats = SupportedLocales | "de-AT" | "de-CH" | "de-DE" | "en-AU" | "en-GB" | "es-ES" | "es-MX" | "it-CH" | "it-IT";
+export interface LocaleInfo {
+    locale: SupportedLocales;
+    formatLocale: SupportedLocalesForFormats;
+    rtl: boolean;
+}