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

package/dist/chart-rendering/common/data/utils/categorical-data/index.d.ts

@@ -1,27 +0,0 @@
-import { WebChart, WebChartDataItem } from '../../../../../spec';
-import { CompleteDataWithMissingCategoriesProps } from './interfaces';
-/**
- * Completes a chart data by adding all the unique values not already in the array
- *
- * @param props
- */
-export declare function completeDataWithMissingCategories(props: CompleteDataWithMissingCategoriesProps): Promise<WebChartDataItem[]>;
-/**
- * Completes a chart data by adding 0s for any category with no value.
- * Example:
- * 3 series are defined (webChartSeries):
- *  - series 1: outStatisticFieldName = "series1y"
- *  - series 2: outStatisticFieldName = "series2y"
- *  - series 3: outStatisticFieldName = "series3y"
- * The data set (seriesData) does not contain data for the series 2:
- *  [{category1: "c1", series1y: 25, series3y: 11},
- *   {category1: "c2", series1y: 18, series3y: 36}]
- *
- * The function completes the data set as follow:
- *  [{category1: "c1", series1y: 25, series2y: 0, series3y: 11},
- *   {category1: "c2", series1y: 18, series2y: 0, series3y: 36}]
- *
- * @param seriesData The data to complete
- * @param chartConfig The chart's config
- */
-export declare function completeDataForEmptyCategoriesWithZeros(seriesData: WebChartDataItem[], chartConfig: WebChart): WebChartDataItem[];

package/dist/chart-rendering/common/data/utils/categorical-data/interfaces.d.ts

@@ -1,11 +0,0 @@
-import { QueryObject, AbortControllerKeyType, LimitBehavior } from '../../../../../utils';
-import { WebChartDataItem, WebChart, WebChartQuery } from '../../../../../spec';
-export interface CompleteDataWithMissingCategoriesProps {
-    seriesData: WebChartDataItem[];
-    chartConfig: WebChart;
-    categoryOrDateCount: number | undefined;
-    queryObject?: QueryObject;
-    queryConfig: WebChartQuery;
-    behaviorAfterLimit?: LimitBehavior;
-    abortKey?: AbortControllerKeyType;
-}

package/dist/chart-rendering/common/data/utils/misc/index.d.ts

@@ -1,251 +0,0 @@
-import { IExtent, IField, ValueConversion, WebChart, WebChartBin, WebChartDataItem, WebChartDataItemValue, WebChartDataTypes, WebChartSeriesType, WebGaugeChart, WebChartDataTransformations, WebChartSortOrderKinds } from '../../../../../spec';
-import { ChartElementLimit } from '../../../../../utils';
-/**
- * Merges an array of IExtent into one IExtent
- *
- * @param extentList
- * @returns
- */
-export declare function mergeExtents(extentList?: IExtent[]): IExtent | undefined;
-/**
- * Checks in the data context if some extra values has been stored.
- * - `typeOrDomainIdValue` is used for when preferLabel is false
- * - `originalCategoryValue` is used for the non-aggregated bar charts in order to handle the duplicated
- *   category names. In that case the categories are replaced by a unique key, different from the original category name.
- * - `originalDateValue` is used for storing the original non formatted category when it's a date
- * - `defaultPieFromFieldsName` is used by pie chart from field.
- *
- * @param props.value The default value
- * @param props.dataContext The data context
- * @param props.useRendererLabel Whether to use the renderer label
- * @param props.specificField A specific field to look for
- * @param props.preferLabel Whether to use field label instead of value
- * @param props.keepNullValues Whether to keep the null values
- * @param props.config The chart's config
- */
-export declare function getXAxisValueFromContext(props: {
-    value: Date | number | string;
-    dataContext?: WebChartDataItem;
-    useRendererLabel?: boolean;
-    specificField?: string;
-    preferLabel?: boolean;
-    keepNullValues?: boolean;
-    config?: WebChart;
-}): Date | number | string;
-/**
- * Looks for the original x value in the data context. Chooses by order of priority:
- * - the type or domain id value
- * - the original category value
- *
- * @param dataContext The data context
- */
-export declare function getOriginalXValueFromContext(dataContext?: WebChartDataItem): WebChartDataItemValue | undefined;
-/**
- * Sorting an array WebChartDataItem by either ascending or descending order.
- *
- * @param props.arrayToSort The array to sort
- * @param props.sortingField The field to sort by
- * @param props.orderBy The order by
- * @param props.forceAscendingOrder Whether to force the ascending order; only applies for non-heat charts
- * @param props.isNonAggregated Whether the chart is non-aggregated; only applies for non-heat charts
- * @param props.sortByCategory Whether to sort by the x-axis field; only applies for non-heat charts
- * @param props.preferLabel Whether to use data labels; only applies for non-heat charts
- * @param props.isPieOrByFieldsChart Whether it is a pie or by fields chart
- */
-export declare function sortWebChartDataItemsUsingDirectionalSort(props: {
-    arrayToSort: WebChartDataItem[];
-    sortingField: string;
-    orderBy?: WebChartSortOrderKinds;
-    forceAscendingOrder?: boolean;
-    isNonAggregated?: boolean;
-    sortByCategory?: boolean;
-    preferLabel?: boolean;
-    isPieOrByFieldsChart?: boolean;
-}): void;
-/**
- * Sorting an array WebChartDataItem according to the predefined labels.
- *
- * @param props.arrayToSort The array to sort
- * @param props.orderBy The order by object
- * @param props.sortingField The field to sort by
- * @param props.fieldList The layer field list
- * @param props.isByFieldsChart Whether the chart is a by fields chart (bar, line, pie from fields)
- * @param props.preferLabel Whether or not to use labels like field alias
- */
-export declare function sortWebChartDataItemsUsingPredefinedLabels(props: {
-    arrayToSort: WebChartDataItem[];
-    orderBy: string[];
-    sortingField: string;
-    fieldList?: IField[];
-    isByFieldsChart?: boolean;
-    preferLabel?: boolean;
-}): void;
-/**
- * This function reassigns the category/field name and stat value to the series x and y, while deleting the
- * technical field used during the rendering for technical reasons.
- *
- * @param modifiedData The data to revert
- * @param seriesConfig The series config
- */
-export declare function revertPieFromFieldsProperties<T extends WebChartDataItem[] | WebChartDataTypes>(modifiedData: T, seriesConfig?: WebChart["series"]): T;
-/**
- * This function reverts some changes done to process the chart's data set:
- * - removes the formatted dates used specifically for the queries
- * - switches back the values of the modified dates/categories to accommodate the rendering (axis labels, sort...)
- *
- * @param data The data containing modified x values
- * @param seriesConfig The series config
- */
-export declare function revertOriginalXValues<T extends WebChartDataItem[] | WebChartDataTypes>(data: T, seriesConfig?: WebChart["series"]): T;
-/**
- * Removes some technical properties including color ones from a data item
- *
- * @param dataItem The data item to sanitize
- * @returns The sanitized data item
- */
-export declare function removeAdditionalStatisticsPerItem(dataItem: WebChartDataItem): WebChartDataItem;
-/**
- * Before sending the event payload containing the data, we need to revert some changes done to sort the charts.
- *
- * @param data The data set to modify
- * @param seriesConfig The series config
- * @returns The sanitized data
- */
-export declare function removeAdditionalStatistics(data: WebChartDataTypes, seriesConfig: WebChartSeriesType[]): WebChartDataTypes;
-/**
- * Sanitizes data by reverting technical changes made to the data set.
- * The point is to send meaningful data to the user through events or the `chartWillRender()` function.
- *
- * @param props.data The data to sanitize
- * @param props.seriesConfig The series config
- */
-export declare function sanitizeData(props: {
-    data?: WebChartDataTypes;
-    seriesConfig: WebChartSeriesType[];
-}): WebChartDataTypes | undefined;
-/**
- * A function to determine whether the scatterplot is aggregated.
- * It can use a map of statistics containing the number of points (computed from the data side) or
- * a data context object usually stored within each marker.
- *
- * @param props
- */
-export declare function isScatterplotAggregated(props: {
-    statsMap?: Map<string, number>;
-    dataContext?: WebChartDataItem;
-    chartLimits?: ChartElementLimit;
-}): boolean;
-/**
- * A function to determine whether a chart is aggregated.
- * Supports scatterplot, bar chart and pie chart. Defaults to true for the other types of chart.
- *
- * @param props
- */
-export declare function isChartAggregated(props: {
-    dataContext?: WebChartBin | WebChartDataItem;
-    chartConfig: WebChart;
-    chartLimits?: ChartElementLimit;
-}): boolean;
-/**
- * Converts the field to have the transform functions applied in where clause.
- * Use by histogram.
- *
- * @param xAxisField
- * @param type
- */
-export declare function getTransformedQuery(xAxisField: string, type?: WebChartDataTransformations): string;
-/**
- * Transform a date into a format that can be used for querying.
- * Ex:
- *   - 1629862814560 => "8/25/2021 3:40:14 AM"
- *   - new Date(2005, 5, 5, 5, 5, 5) => "6/5/2005 12:05:05 PM"
- *
- * @param date
- * @returns
- */
-export declare function transformDateToQueryFormat(date: Date | number): number | string;
-/**
- * Construct an array of WebChartDataItem using every key/value pairs from the input data (of type WebChartDataItem).
- *
- * Currently only Pie chart uses this function.
- *
- * @param data The data to convert
- * @param x The x field name
- * @param y The y field name
- * @param fieldList The field list
- */
-export declare function convertMultipleNumericFieldsData(props: {
-    dataToConvert: WebChartDataItem | undefined;
-    x: string;
-    y: string;
-    fieldList?: IField[];
-}): WebChartDataItem[];
-/**
- * Check if the Pie chart data has slices with all positive or all negative values.
- *
- * Note: Pie with the following character is supported:
- * - no slice with positive and no slice with negative values
- * - the slices can have 0, null, or undefined values
- *
- * @param data the data to check for positive and negative values
- * @param fieldToCheckForValue to field containing the values
- */
-export declare function checkForSupportedPieChart(data: WebChartDataItem[], fieldToCheckForValue: string): boolean;
-/**
- * Calculates the limit for a given chart, considering a limit on the number of series and a limit
- * on the total number of elements on the chart.
- * For instance:
- * - if count total is 1,000, count per series is 100 and there are 5 series, the limit is 500
- * - if count total is 1,000, count per series is 100 and there are 20 series, the limit is 1,000
- *
- * @param props.countTotal The number max of elements for the whole chart
- * @param props.countPerSeries The number max of elements per series
- * @param props.numberOfSeries The number of series
- * @returns
- */
-declare function getMultiSeriesLimit(props: {
-    countTotal?: number;
-    countPerSeries?: number;
-    numberOfSeries: number;
-}): number | undefined;
-/**
- * Calculates the maximum number of features to fetch according to the runtime chart options 'chartLimits'.
- * For instance:
- * - on a pie chart, the limit is the maximum number of slices (`maxPieChartSliceCountTotal`)
- * - on a bar or line chart, the limits vary depending on number of series. Maximum number of series count is (`maxBarChartSeriesCount`) and (`maxLineChartSeriesCount`)
- *
- * @param chartConfig The chart's config
- * @param chartLimits The runtime chart limits
- */
-export declare function getMaximumNumberOfFeaturesToFetch(chartConfig: WebChart | WebGaugeChart, chartLimits?: ChartElementLimit): number | undefined;
-/**
- * Apply a conversion (from a factor and an offset) to a numeric value.
- * The factor is applied first and then the offset (when both are provided).
- *
- * @param value The value to convert
- * @param valueConversion The information regarding the conversion to apply
- * @returns The converted value, or the original value if the `valueConversion` is undefined or invalid
- */
-export declare function applyValueConversion(value: number, valueConversion?: ValueConversion): number;
-/**
- * Check if an input string represents a percentage value; meaning a string that:
- * - only contains digits (dot for decimal included), and
- * - has % symbol at the end (for LTR) or at the beginning (for RTL)
- * - the value falls between 0 - 100
- *
- * @param inputValue input string
- */
-declare function isValidPercentValue(inputValue: string): boolean;
-/**
- * Extract the value from the input string, without the %; valid percent value is between 0 - 100
- * it's safe that we extract upto 3 digits and not worry about having an invalid number like 100.5
- *
- * @param inputValue input string
- * @returns
- */
-export declare function extractPercentValue(inputValue: string): number | undefined;
-export declare const commonUtilsMiscPrivateFunctions: {
-    getMultiSeriesLimit: typeof getMultiSeriesLimit;
-    isValidPercentValue: typeof isValidPercentValue;
-};
-export {};

package/dist/chart-rendering/common/data/utils/query-parser/index.d.ts

@@ -1,71 +0,0 @@
-import { TimeIntervalInfo, WebBoxPlot, WebChart, WebChartQuery } from '../../../../../spec';
-import { QueryObject, ChartSubType } from '../../../../../utils';
-import { ChartOptions } from '../../../interfaces';
-import { UniqueQuery } from './interfaces';
-/**
- * Modifies the input `WebChartQuery` by assigning a default value for its `outStatisticFieldName`.
- *
- * When the statisticType is `WebChartStatisticType.DiscretePercentile` or `WebChartStatisticType.ContinuousPercentile,
- * if the query is for a time binning series, this function will delete the `statisticParameters` object and
- * resets the `statisticType` to Count regardless; otherwise it adds the statisticParameters and/or assigns
- * a default value to the `outStatistics` properties of the query if `statisticParameters` is not present.
- *
- * Notes: outStatistics should only be modified through this function
- *
- * @param props.uniqueQuery The WebChartQuery to modify
- * @param props.y The y field
- * @param props.useGenericOutStatFieldName Whether to use a generic stat field over the y field
- * @param props.queryObject  The query object (layer or feature layer view)
- * @param props.chartSubType The chart sub type
- * @param props.isTimeBinningSeries Whether the chart is using time binning
- * @param props.returnFeaturesExtent Whether the features extent need to be fetched by the query
- * @param props.splitByField The split-by field
- */
-declare function modifyOutStatistics(props: {
-    uniqueQuery: WebChartQuery;
-    y?: string[] | string;
-    useGenericOutStatFieldName: boolean;
-    queryObject?: QueryObject;
-    chartSubType: ChartSubType;
-    isTimeBinningSeries: boolean;
-    returnFeaturesExtent?: boolean;
-    splitByField?: string;
-}): void;
-/**
- * Handles the limitation of features on the chart (when the chart limits are reached but the requested behavior is to render up to the limit).
- * See https://devtopia.esri.com/WebGIS/arcgis-charts/issues/5126
- * Temporal charts are handled differently in `fetchFinishedBinnedTemporalData()` as we can't predict beforehand how many time bins there will be on the chart.
- *
- * @param props.chartConfig The chart's config
- * @param props.uniqueQuery The web chart query
- * @param props.options The runtime chart's options
- */
-export declare function addFeatureLimitation(props: {
-    chartConfig: WebChart;
-    uniqueQuery: WebChartQuery;
-    options?: ChartOptions;
-}): void;
-/**
- * Function building a unique query based on the chart series config.
- *
- * @param props.chartConfig The chart config
- * @param props.queryObject The query object
- * @param props.queryConfig The config query
- * @param props.options Runtime options
- * @param props.timeIntervalInfo Time interval info.
- * @param props.setTimeBinningInfoWhenNotProvided indicator whether to set time binning info when not provided
- * @param props.fetchFullBoxPlotData Whether to fetch the full box plot data
- */
-export declare function buildUniqueQuery(props: {
-    chartConfig: WebBoxPlot | WebChart;
-    queryObject?: QueryObject;
-    queryConfig: WebChartQuery;
-    options?: ChartOptions;
-    timeIntervalInfo?: TimeIntervalInfo;
-    setTimeBinningInfoWhenNotProvided?: boolean;
-    fetchFullBoxPlotData?: boolean;
-}): Promise<UniqueQuery>;
-export declare const commonUtilsQueryParserPrivateFunctions: {
-    modifyOutStatistics: typeof modifyOutStatistics;
-};
-export {};

package/dist/chart-rendering/common/data/utils/query-parser/interfaces.d.ts

@@ -1,15 +0,0 @@
-import { WebChartQuery, IStatisticDefinition } from '../../../../../spec';
-export interface UniqueQuery {
-    uniqueQuery: WebChartQuery;
-    mapToStatField: Map<number | string | null, string>;
-}
-export interface StatFieldNameProps {
-    whereValue?: number | string | null;
-    outStatistics?: IStatisticDefinition;
-    y?: string[] | string;
-}
-export interface GroupByFieldProps {
-    uniqueQuery: WebChartQuery;
-    splitByField?: string;
-    x?: string;
-}

package/dist/chart-rendering/common/data/utils/query-parser/time-binning/index.d.ts

@@ -1,19 +0,0 @@
-import { WebChartTemporalBinningUnits } from '../../../../../../spec';
-/**
- * Generates the INTERVAL SQL instruction to shift date values from the data time zone to the output time zone.
- * This is inspired by the Dashboards implementation currently found here:
- * https://devtopia.esri.com/WebGIS/arcgis-dashboards/blob/develop-4/packages/dashboard-view-models/addon/-private/service-dataset.js.
- * @param props.outTimeZone The output time zone (typically the user locale)
- * @param props.dataTimeZone The data time zone (usually UTC but can be set differently on the layer)
- * @param props.runsOnClientQueryEngine Whether the query will be executed on the client query engine (FeatureLayerView) or on the server
- */
-export declare function getIntervalStatement(props: {
-    outTimeZone?: string;
-    dataTimeZone?: string | null;
-    runsOnClientQueryEngine?: boolean;
-}): string;
-export declare function getTimeBinGroupByFieldsForStatistics(props: {
-    dateFieldName: string;
-    unit: WebChartTemporalBinningUnits;
-    runsOnClientQueryEngine?: boolean;
-}): string[];

package/dist/chart-rendering/common/data/utils/query-utils/index.d.ts

@@ -1,12 +0,0 @@
-import { WebChartDataItemValue } from '../../../../../spec';
-/**
- * Transform a couple key/value to where clause equivalent to 'key = value'.
- * It adds quotes around the value if it's not detected as a number.
- *
- * TODO: the value parameter is a `WebChartDataItemValue` but most of types from that union wouldn't be
- * accepted in a SQL where clause. It might be more needed to specify more strict types.
- *
- * @param key
- * @param value
- */
-export declare function objectToWhereQuery(key: string, value: WebChartDataItemValue): string;

package/dist/chart-rendering/common/data/utils/query-utils/interfaces.d.ts

@@ -1,5 +0,0 @@
-export declare const GroupByKeywords: {
-    readonly groupByCaseBegin: "CASE";
-    readonly groupByOutKeyword: "OUT";
-    readonly groupByCaseEnd: "ELSE 'OUT' END";
-};

package/dist/chart-rendering/common/data/utils/selection/index.d.ts

@@ -1,39 +0,0 @@
-import { WebChart, WebChartDataItem, WebChartDataTypes, WebChartQuery } from '../../../../../spec';
-import { ErrorStrings, QueryObject } from '../../../../../utils';
-import { ChartOptions } from '../../../interfaces';
-/**
- * Fetches data from a list of OIDs. If the chart is non aggregated we directly read the OIDs stored in the data context,
- * and if the chart is aggregated we perform queries to fetch the data.
- *
- * @param props.chartData The data fetched by the last call to `getData()`
- * @param props.chartConfig The chart's config
- * @param props.queryConfig The query config
- * @param props.queryObject The query object (layer or feature layer view)
- * @param props.dataWasUpdated Whether the data was updated
- * @param props.currentSelectionOIDs The OIDs representing the selection currently active on the chart
- * @param props.options The runtime options
- * @param props.errorStrings The t9n error strings
- */
-export declare function getSelectionItemsFromOIDs(props: {
-    chartData?: WebChartDataTypes;
-    chartConfig: WebChart;
-    queryConfig?: WebChartQuery;
-    queryObject: QueryObject;
-    dataWasUpdated?: boolean;
-    currentSelectionOIDs?: (number | string)[];
-    options?: ChartOptions;
-    errorStrings: ErrorStrings;
-}): Promise<WebChartDataItem[] | undefined>;
-/**
- * Fetches OIDs based on a where clause gathering information from multiples elements (markers, bars...)
- * TODO: add a threshold to limit the number of data items to bring back
- *
- * @param props
- * @returns a list of OIDs matching the provided the where clause
- */
-export declare function fetchOIDsFromWhereClause(props: {
-    whereList: string[];
-    queryObject: QueryObject;
-    queryFilter?: string;
-    queryConfig: WebChartQuery;
-}): Promise<(number | string)[]>;