@arcgis/charts-components 4.33.0-next.101 → 4.33.0-next.103

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

@@ -0,0 +1,190 @@
+import { CategoryFormatOptions, Color, DateTimeFormatOptions, HistogramOverlays, IFont, ISimpleFillSymbol, ISimpleLineSymbol, ISimpleMarkerSymbol, NumberFormatOptions, ScatterPlotOverlays, SizePolicy, WebBoxPlot, WebChart, WebChartAxis, WebChartBarChartSeries, WebChartBoxPlotSeries, WebChartGaugeAxis, WebChartGaugeSeries, WebChartHistogramSeries, WebChartLegend, WebChartLineChartSeries, WebChartNeedle, WebChartOverlay, WebChartPieChartSeries, WebChartPieChartTick, WebChartRadarChartSeries, WebChartScatterPlotSeries, WebChartText, WebChartTextSymbol, WebGaugeChart, WebChartStackedKinds, WebChartTypes } from '@arcgis/charts-spec';
+import { ChartElementLimit, ChartElementTechnicalLimit, ChartTextProps, QueryDefaults, TextElements } from './interfaces';
+export declare const histogramBinCount = 32;
+export declare const featuresExtentField = "arcgis_charts_features_extent";
+export declare const queryDefaults: QueryDefaults;
+export declare const queryCalculatedExpr: string[];
+export declare const fullOpacity = 1;
+export declare const reducedOpacity = 0.7;
+export declare const defaultGridLineOpacity = 25;
+export declare const defaultAxisLineColor: Color;
+export declare const defaultPieTickColor: Color;
+export declare const defaultLineSymbolStyle: "esriSLSSolid";
+export declare const defaultLineSymbolWidth = 2;
+export declare const pieChartSpecialSlicesId: {
+    defaultGroupOfSlicesId: string;
+    sliceIdPrefix: string;
+    undefinedSliceId: string;
+    nullSliceId: string;
+    emptySliceId: string;
+};
+export declare const defaultBoxPlotCategory = "arcgis_charts_box_plot_category";
+export declare const ramp: number[][];
+/**
+ * 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.
+ * @param props.colorIndex The index to fetch the color from the `ramp` or `overlayRamp` array
+ * @param props.opacity The opacity to set the alpha value, set to 255 as default
+ * @param props.histogramOverlays The boolean that is used to identify from which array to fetch default colors
+ */
+export declare function getOneRampColor(props: {
+    colorIndex?: number;
+    opacity?: number;
+    histogramOverlays?: boolean;
+}): Color;
+export declare function getDefaultColor(opacity?: number): Color;
+/**
+ * random color with alpha 70% for authoring page.
+ * @param opacityPercentage default is 1
+ */
+export declare function generateRandomRestColor(opacityPercentage?: number): Color;
+export declare function getDefaultFont(type?: TextElements): IFont;
+export declare function getDefaultTextSymbol(text?: string, font?: IFont, type?: TextElements): WebChartTextSymbol;
+export declare function getDefaultChartText(props?: ChartTextProps): WebChartText;
+export declare function getDefaultLineSymbol(props?: {
+    color?: Color;
+    useRandomColor?: boolean;
+    useRampColor?: {
+        colorIndex?: number;
+    };
+    width?: number;
+    opacity?: number;
+    isHistogramOverlay?: boolean;
+}): ISimpleLineSymbol;
+export declare function getDefaultCategoryFormat(): CategoryFormatOptions;
+export declare function getDefaultDateFormat(): DateTimeFormatOptions;
+export declare function getDefaultNumberFormat(): NumberFormatOptions;
+export declare function getDefaultStatNumberFormat(): NumberFormatOptions;
+export declare function getDefaultPercentNumberFormat(): NumberFormatOptions;
+export declare function getDefaultValueAxis(text?: string): WebChartAxis;
+export declare function getDefaultLegend(): WebChartLegend;
+export declare function getDefaultOverlay(overlayIndex: number): WebChartOverlay;
+export declare function getDefaultBackground(): Color;
+export declare function getDefaultTitle(): Promise<string>;
+export declare function getDefaultBoxPlotElementSymbol(seriesIndex?: number, useRandomColor?: boolean): ISimpleFillSymbol;
+/**
+ * Returns a default marker symbol for a line chart
+ * @param seriesIndex The series index to pick a symbol color
+ * @param useRandomColor Whether to randomize the marker color
+ * @returns
+ */
+export declare function getDefaultLineChartMarkerSymbol(seriesIndex?: number): ISimpleMarkerSymbol;
+/**
+ * Returns a default line symbol for a line chart
+ * @param seriesIndex The series index to pick a symbol color
+ */
+export declare function getDefaultLineChartLineSymbol(seriesIndex?: number): ISimpleLineSymbol;
+export declare function getDefaultScatterPlotMarkerSymbol(useRandomColor?: boolean): ISimpleMarkerSymbol;
+export declare function getDefaultScatterPlotSizePolicy(): Required<SizePolicy>;
+export declare function getDefaultTrendLine(useRandomColor?: boolean): Required<ScatterPlotOverlays>;
+export declare function getScatterPlotSeries(): WebChartScatterPlotSeries;
+/**
+ * Returns default axes based on chart type as per the WebChart Specification
+ * @param chartType The type of WebChart which is of type WebChartTypes
+ *
+ */
+export declare function getDefaultAxes(chartType: WebChartTypes): Promise<WebChartAxis[]>;
+/**
+ * Returns the default gauge needle
+ */
+export declare function getDefaultGaugeNeedle(): WebChartNeedle;
+/**
+ * Returns the gauge axes
+ */
+export declare function getGaugeAxes(): Promise<WebChartGaugeAxis[]>;
+/**
+ * Returns a default LineChartSeries object as per the WebChart Specification
+ */
+export declare function getDefaultLineChartSeries(props: {
+    objectIDField?: string;
+    seriesIndex?: number;
+}): Promise<Required<Pick<WebChartLineChartSeries, "dataLabels" | "lineSymbol" | "markerSymbol" | "query">> & WebChartLineChartSeries>;
+/**
+ * Returns a default RadarChartSeries object as per the WebChart Specification
+ */
+export declare function getDefaultRadarChartSeries(props: {
+    objectIDField?: string;
+    seriesIndex?: number;
+}): Promise<Required<Pick<WebChartRadarChartSeries, "dataLabels" | "lineSymbol" | "markerSymbol" | "query">> & WebChartRadarChartSeries>;
+/**
+ * Returns a default symbol for a bar chart series
+ * @param seriesIndex The series index to pick a symbol color
+ */
+export declare function getDefaultBarChartSeriesSymbol(seriesIndex?: number): ISimpleFillSymbol;
+/**
+ * Returns a default BarChartSeries object as per the WebChart Specification
+ */
+export declare function getDefaultBarChartSeries(props: {
+    objectIDField?: string;
+    seriesIndex?: number;
+}): Promise<Required<Pick<WebChartBarChartSeries, "dataLabels" | "fillSymbol" | "query">> & WebChartBarChartSeries>;
+/**
+ * Returns a default BoxPlotSeries object as per the WebBoxPlot Specification
+ */
+export declare function getDefaultBoxPlotSeries(seriesIndex?: number): Promise<WebChartBoxPlotSeries>;
+/**
+ * Returns a default pie chart tick object as per the WebChart Specification
+ */
+export declare function getDefaultPieChartTick(): WebChartPieChartTick;
+/**
+ * Returns a default symbol for a pie chart
+ */
+export declare function getDefaultPieChartSymbol(): ISimpleFillSymbol;
+/**
+ * Returns a default PieChartSeries object as per the WebChart Specification
+ */
+export declare function getDefaultPieChartSeries(objectIDField?: string): Promise<Required<Pick<WebChartPieChartSeries, "dataLabels" | "fillSymbol" | "query">> & WebChartPieChartSeries>;
+/**
+ * Returns a default GaugeSeries object as per the WebChart Specification
+ */
+export declare function getDefaultGaugeSeries(props: {
+    objectIDField?: string;
+}): WebChartGaugeSeries;
+/**
+ * Returns the default chart rotation.
+ */
+export declare function getDefaultChartRotation(): boolean;
+export declare function getDefaultBarChart(id?: string): Promise<WebChart>;
+export declare function getDefaultBoxPlot(id?: string): Promise<WebBoxPlot>;
+export declare function getDefaultLineChart(id?: string): Promise<WebChart>;
+export declare function getDefaultRadarChart(id?: string): Promise<WebChart>;
+export declare function getDefaultPieChart(id?: string): Promise<WebChart>;
+export declare function getDefaultGauge(id?: string): Promise<WebGaugeChart>;
+export declare function getDefaultScatterPlot(id?: string): Promise<WebChart>;
+export declare function getDefaultHistogramOverlays(): Required<HistogramOverlays>;
+export declare function getDefaultHistogramSymbol(): ISimpleFillSymbol;
+export declare function getDefaultHistogramSeries(): Omit<Required<WebChartHistogramSeries>, "dataTooltipDateFormat" | "dataTooltipPercentFormat" | "dataTooltipValueFormat" | "query">;
+export declare function getDefaultHistogram(id?: string): Promise<WebChart>;
+/**
+ * Returns a list of render limitations, mainly set for performance reasons. They can be overridden through the chart options,
+ * or let as defaults.
+ */
+export declare function getChartLimits(customizedLimits?: ChartElementLimit): Required<ChartElementLimit>;
+/**
+ * Returns a list of technical limitations, mainly to the size of large queries.
+ */
+export declare function getChartTechnicalLimits(): ChartElementTechnicalLimit;
+/**
+ * Returns the label for the provided aggregation type.
+ * @param aggregationType
+ */
+export declare function getDefaultAggregationTypeLabel(aggregationType: string | undefined): Promise<string>;
+/**
+ * Returns the label for the provided time aggregation type.
+ * @param aggregationType
+ */
+export declare function getDefaultTimeAggregationTypeLabel(timeAggregationType: string | undefined): Promise<string>;
+/**
+ * Returns the default stacked type for Bar or Line chart with multiple series.
+ *  */
+export declare function getDefaultStackedType(): WebChartStackedKinds;
+/**
+ * Returns the default label to show when there is no R2 value computed or set for scatter plot
+ *
+ * @returns {Promise<string>}
+ */
+export declare function getDefaultNoR2Label(): Promise<string>;
+export declare const pieChartInnerRadius = 0;
+export declare const boxPlotOutliersSuffix = "_arcgis_charts_outliers";
+export declare const boxPlotZScoreSuffix = "_arcgis_charts_z_score";
+export declare const defaultColorForBoxPlotWithMeanLines: Color;

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

@@ -0,0 +1,65 @@
+import { IFont, IStatisticDefinition } from '@arcgis/charts-spec';
+export declare const LimitBehavior: {
+    readonly Reject: "reject";
+    readonly RenderUpToTheLimit: "renderUpToTheLimit";
+};
+export type LimitBehavior = (typeof LimitBehavior)[keyof typeof LimitBehavior];
+export interface ChartElementLimit {
+    behaviorAfterLimit?: LimitBehavior;
+    maxCategoryCount?: number;
+    maxBarChartSeriesCount?: number;
+    maxBarUniqueSeriesCountTotal?: number;
+    maxBarTwoSeriesCountPerSeries?: number;
+    maxBarTwoSeriesCountTotal?: number;
+    maxBarThreePlusSeriesCountPerSeries?: number;
+    maxBarThreePlusSeriesCountTotal?: number;
+    maxScatterPointsBeforeAggregation?: number;
+    maxScatterPointsAfterAggregation?: number;
+    maxLineChartSeriesCount?: number;
+    maxLineUniqueSeriesCountTotal?: number;
+    maxLineTwoSeriesCountPerSeries?: number;
+    maxLineTwoSeriesCountTotal?: number;
+    maxLineThreePlusSeriesCountPerSeries?: number;
+    maxLineThreePlusSeriesCountTotal?: number;
+    maxPieChartSliceCountTotal?: number;
+    maxGaugeByFeaturesLimit?: number;
+    maxBoxPlotSeriesCount?: number;
+    maxBoxUniqueSeriesCountTotal?: number;
+    maxBoxTwoSeriesCountTotal?: number;
+    maxBoxTwoSeriesCountPerSeries?: number;
+    maxBoxThreePlusSeriesCountTotal?: number;
+    maxBoxThreePlusSeriesCountPerSeries?: number;
+    maxBoxPlotOutlierLimit?: number;
+}
+export interface ChartElementTechnicalLimit {
+    maxScatterCellsPerQuery: number;
+    maxScatterCellsPerQueryForStandard: number;
+    maxElementsPerSelectionQuery: number;
+    maxOIDsPerSelectionQuery: number;
+    maxOperandsPerWhereClause: number;
+}
+export interface QueryDefaults {
+    maxRecordCountFactor: number;
+    maxParallelRequests: number;
+    maxRecords: number;
+    outStatistics: Readonly<IStatisticDefinition>;
+    uniqueIdsName: string;
+    orderByJSAPIDelimiter: string;
+}
+export interface ChartTextProps {
+    text: string;
+    visible: boolean;
+    font: IFont;
+    type?: TextElements;
+}
+export declare const TextElements: {
+    readonly AxisLabels: "axisLabels";
+    readonly GuideLabel: "guideLabel";
+    readonly AxisTitle: "axisTitle";
+    readonly ChartTitle: "chartTitle";
+    readonly DataLabels: "dataLabels";
+    readonly LegendTitle: "legendTitle";
+    readonly LegendText: "legendText";
+    readonly DescriptionText: "descriptionText";
+};
+export type TextElements = (typeof TextElements)[keyof typeof TextElements];

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

@@ -0,0 +1,27 @@
+/**
+ * ArcgisChartsError is a class that enhances the debugging and error handling process. Rather than returning a generic [JavaScript
+ * error](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error),
+ * this ArcgisChartsError returns a standardized error object with several properties.
+ */
+export declare class ArcgisChartsError<T = any> extends Error {
+    /**
+     * A unique error name. This can be used to map to a localized error message to present to the user.
+     *
+     */
+    name: string;
+    /**
+     * The details object provides additional details specific to the error,
+     * giving more information about why the error was raised. For example, the details object includes
+     * additional information to help the developer diagnose issues with a problematic request.
+     *
+     */
+    details?: T;
+    /**
+     * Creates a new ArcgisChartsError instance.
+     *
+     * @param {string} name - A unique error name.
+     * @param {string} [message] - A message describing the details of the error.
+     * @param {Object} [details] - The details object provides additional details specific to the error.
+     */
+    constructor(name: string, message?: string, details?: T);
+}

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

@@ -0,0 +1,8 @@
+export declare const ErrorKeywords: {
+    readonly Default: "defaultError";
+    readonly LayerLoadFailure: "layerLoadFailure";
+    readonly QueryFeaturesError: "queryFeaturesError";
+    readonly ChartDisposed: "ChartDisposeError";
+    readonly LayerFieldsNotFound: "layerFieldsNotFound";
+};
+export type ErrorKeywords = (typeof ErrorKeywords)[keyof typeof ErrorKeywords];

package/dist/utils/index.d.ts

@@ -0,0 +1,32 @@
+export * from './chart-config/converter';
+export * from './chart-config/interfaces';
+export * from './chart-config/utils';
+export * from './chart-config/utils/interfaces';
+export * from './chart-config/validator';
+export * from './chart-config/validator/interfaces';
+export * from './cursor/interfaces';
+export * from './data';
+export * from './data/categorical-data';
+export * from './data/interfaces';
+export * from './data/time-binning/interfaces';
+export * from './defaults';
+export * from './defaults/interfaces';
+export * from './errors';
+export * from './errors/interfaces';
+export * from './layer';
+export * from './layer/inline-conversion';
+export type * from './layer/inline-conversion/interfaces';
+export type * from './layer/interfaces';
+export * from './layer/query-features';
+export * from './layer/query-features/interfaces';
+export * from './layer/query-parser';
+export * from './layer/utils';
+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';
+export * from './ui/popover-ui-utils';

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

@@ -0,0 +1,170 @@
+import { IFeatureLayer, IField, SupportedLayer, WebChart, WebChartDataFilters, WebChartQuery } from '@arcgis/charts-spec';
+import { default as FeatureLayer } from '@arcgis/core/layers/FeatureLayer.js';
+import { default as Renderer } from '@arcgis/core/renderers/Renderer';
+import { QueryObject, QueryObjectProps, RendererInfo, SubtypeInfo } from './interfaces';
+/**
+ * Returns the renderer type and the field and normalization field if applicable.
+ * @param layerRenderer
+ */
+export declare function getRendererInfo(layerRenderer?: Renderer): RendererInfo;
+/**
+ * Function creating a FeatureLayer from a set of parameters.
+ * It returns the created Feature Layer.
+ * It is memoized (cached) to avoid multiple requests for a same feature layer.
+ */
+export declare const getFeatureLayer: (featureLayer: IFeatureLayer) => Promise<FeatureLayer>;
+/**
+ * Returns the proper query object to use according to the situation.
+ * If can return either a FeatureLayer or a FeatureLayerView (and possibly nothing)
+ * @param props
+ */
+export declare function getQueryObject(props: QueryObjectProps): Promise<QueryObject>;
+/**
+ * Fetches all the fields info a feature layer.
+ * @param queryObject
+ * @param usePopupTemplateFieldsInfo whether to use the aliases from the popupTemplate
+ */
+export declare function fetchLayerFieldsInfo(queryObject: QueryObject, usePopupTemplateFieldsInfo?: boolean): Promise<IField[]>;
+/**
+ * Looks into a list of fields for one having a specific name, and returning it if found.
+ * Returns nothing if the field is not found.
+ * @param fields The list of fields containing all the information regarding the fields, including the name
+ */
+export declare function getFieldFromName(fieldName: string, fields?: IField[]): IField | undefined;
+/**
+ * Look for an OID field among a list of feature layer fields.
+ * The function `find` used can return in theory an `undefined` value, but in our case we're sure to bring back
+ * the field ID (every feature layer has one).
+ * As a consequence the backup value returned if `oidField.name` is `undefined` doesn't matter because it will not happen.
+ */
+export declare function getObjectIdField(layerFieldsInfo: IField[]): string;
+/**
+ * Checks whether the given field has a valid numeric type.
+ * Fields descriptions are [here](http://resources.esri.com/help/9.3/ArcGISEngine/ArcObjects/esriGeoDatabase/esriFieldType.htm).
+ * @param field
+ */
+export declare function isNumericField(field: IField): boolean;
+/**
+ * Checks whether the given field has a valid date type.
+ * Fields descriptions are [here](http://resources.esri.com/help/9.3/ArcGISEngine/ArcObjects/esriGeoDatabase/esriFieldType.htm).
+ * @param field
+ */
+export declare function isDateField(field: IField): boolean;
+/**
+ * Checks whether the given field has a valid integer type.
+ * Fields descriptions are [here](http://resources.esri.com/help/9.3/ArcGISEngine/ArcObjects/esriGeoDatabase/esriFieldType.htm).
+ * @param field
+ */
+export declare function isIntegerField(field: IField): boolean;
+/**
+ * Returns list of date field names from an array of fields of type IField
+ * @param fieldsInfo
+ */
+export declare function getLayerDateFields(fieldsInfo: IField[]): string[];
+/**
+ * Returns list of numeric field names from an array of fields of type IField
+ * @param fieldsInfo
+ */
+export declare function getLayerNumericFields(fieldsInfo: IField[]): string[];
+/**
+ * Retrieve subtype information from the query object.
+ * @param queryObject The query object from which to retrieve the feature layer.
+ * @returns subtype info like typeIdField and the subtypes, if defined; otherwise undefined.
+ * //TODO: may need to revise regrading the typeIdField property (See https://devtopia.esri.com/WebGIS/arcgis-js-api/issues/42555)
+ */
+export declare function getLayerSubtypeInfo(queryObject: QueryObject): SubtypeInfo | undefined;
+/**
+ * Get the field description if the field contains subtype or domain value.
+ * This field description is mainly for displaying purpose (while its id is used in queries).
+ * @param props.fieldName the name of the field
+ * @param props.fieldValueToMatch the value to search for a match in the subtypes or domains; if the field contains subtype or domain it's likely the id.
+ * @param props.subtypeInfo the subtype information, which includes typeIdField and types.
+ * @param props.fieldList the list of fields
+ * @returns The field description if available; otherwise undefined.
+ */
+export declare function getFieldDescription(props: {
+    fieldName: string;
+    fieldValueToMatch: number | string;
+    subtypeInfo?: SubtypeInfo;
+    fieldList?: IField[];
+}): string | undefined;
+/**
+ * Returns feature layer field names used in its renderer.
+ * @param {FeatureLayer} layer
+ * @returns {Promise<string[]>}
+ */
+export declare function getRendererFieldNames(layer: SupportedLayer): Promise<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
+ * @param {FeatureLayer} layer
+ * @returns {Promise<boolean>}
+ */
+export declare function isStandardLayer(layer: SupportedLayer): Promise<boolean>;
+/**
+ * Finds the matching field name for a given layer based on the fieldToMatch parameter.
+ * @param {QueryObject} props.queryObject
+ * @param {string} props.fieldToMatch
+ * @param {boolean} props.returnUndefinedIfNotFound
+ * @returns {Promise<string>}
+ */
+export declare function findMatchingLayerFieldName(props: {
+    queryObject: QueryObject;
+    fieldToMatch: string;
+    returnUndefinedIfNotFound?: boolean;
+}): Promise<string>;
+/**
+ * Finds the matching layer fields for a list of fields.
+ *
+ * @param {(string[] | undefined)} props.fields
+ * @param {SupportedLayer} props.queryObject
+ * @param {boolean} props.returnUndefinedIfNotFound
+ * @returns
+ */
+export declare function matchFieldsList(props: {
+    fieldsList: string[] | undefined;
+    queryObject: SupportedLayer;
+    returnUndefinedIfNotFound?: boolean;
+}): Promise<string[] | undefined>;
+/**
+ * Builds a WebChartQuery based on information coming from the runtime filters (chart options), the config and the data source.
+ * The filters by attributes from all sources are all combined together (using the AND operator).
+ * Regarding the other filters (by geometry, gdb version and time extent) only one of each can be applied. The runtime
+ * filters are chosen over the config filters.
+ * @param props.queryObject The query object (feature layer or feature layer view)
+ * @param props.chartConfig The chart's config
+ * @param props.runtimeDataFilters The runtime data filters
+ * @param props.ignoreViewExtent Whether to ignore the view extent
+ */
+export declare function buildQueryConfig(props: {
+    queryObject?: QueryObject;
+    chartConfig: WebChart;
+    runtimeDataFilters?: WebChartDataFilters;
+    ignoreViewExtent?: boolean;
+}): WebChartQuery;
+/**
+ * Ger the list of the fields used in the charts
+ * @category Public
+ *
+ *
+ * @param {WebChart[] | undefined} layer - the supported layer
+ * @param {WebChart[] | undefined} chartList - List of charts stored in the layer
+ *
+ * @returns {Promise<string[]>} - The list of fields used in the charts
+ */
+export declare function getFieldsUsedInCharts(layer: SupportedLayer): Promise<string[]>;
+/**
+ * Fetches the fields used in the chart configuration and returns the matching fields from the feature layer.
+ * @param {ChartConfig} config The chart configuration
+ * @param {SupportedLayer} layer The feature layer
+ *
+ * @returns {Promise<string[]>} The list of matching fields
+ */
+export declare function extractFieldsUsedInConfig(config: WebChart, layer: SupportedLayer | undefined): Promise<string[]>;
+/**
+ * Get the list of layer fields from the series list of the chart config.
+ * @param {SupportedLayer} layer The layer
+ *
+ * @returns {string[]} The list of layer fields
+ */
+export declare function extractFieldsFromConfigList(layer: SupportedLayer): Promise<string[]>;

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

@@ -0,0 +1,49 @@
+import { IFeatureLayer, WebChartDataTypes, WebChart } from '@arcgis/charts-spec';
+import { default as FeatureLayer } from '@arcgis/core/layers/FeatureLayer';
+import { WebChartConfigFields } from './interfaces';
+/**
+ * Creates a chart renderer based on the provided config fields and inline data
+ * @param props.categoryField The category field
+ * @param props.numericFields The numeric fields
+ * @param props.configFields The config fields
+ * @param props.inlineData The data to convert
+ */
+export declare function convertConfigFieldsToChartRenderer(props: {
+    categoryField: string;
+    numericFields: string[];
+    configFields?: WebChartConfigFields;
+    inlineData: WebChartDataTypes;
+}): WebChart["chartRenderer"];
+/**
+ * Converts an array of inline data to a feature set and returns an IFeatureLayer
+ * @param props.categoryField The category field
+ * @param props.categoryType The category type
+ * @param props.numericFields The numeric fields
+ * @param props.inlineData The inline data to convert
+ */
+export declare function convertInlineDataToLayerDefinition(props: {
+    categoryField: string;
+    categoryType: "date" | "number" | "string";
+    numericFields: string[];
+    inlineData: WebChartDataTypes;
+}): IFeatureLayer | undefined;
+/**
+ * Converts an array of inline data into a feature collection.
+ * Also returns a chartRenderer if the configFields are provided.
+ * @param props.categoryField The category field
+ * @param props.categoryType The category type
+ * @param props.numericFields The numeric fields
+ * @param props.configFields The config fields
+ * @param props.inlineData The inline data
+ */
+export declare function convertInlineConfigToLayerConfig(props: {
+    categoryField: string;
+    categoryType: "date" | "number" | "string";
+    numericFields: string[];
+    configFields?: WebChartConfigFields;
+    inlineData: WebChartDataTypes;
+}): Promise<{
+    chartRenderer?: WebChart["chartRenderer"];
+    iLayer?: IFeatureLayer;
+    layer?: FeatureLayer;
+}>;

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

@@ -0,0 +1,19 @@
+/**
+ * Former interface describing the property `configFields` from an inline data source.
+ * Is an object which dictate which data-item field should be used for defining a property of the rendered element (line, point, bars, etc). Used in inline data source mode only.
+ */
+export interface WebChartConfigFields {
+    fillColor?: string;
+    fillOpacity?: string;
+    fillStyle?: string;
+    lineColor?: string;
+    lineOpacity?: string;
+    lineWidth?: string;
+    lineStyle?: string;
+    markerSize?: string;
+    outlineColor?: string;
+    outlineOpacity?: string;
+    outlineWidth?: string;
+    outlineStyle?: string;
+    displayLabel?: string;
+}

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

@@ -0,0 +1,53 @@
+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';
+export interface QueryObjectProps {
+    chartConfig: WebChart;
+    layer?: FeatureLayerView | SupportedLayer;
+    view?: MapView | SceneView;
+}
+export interface RendererInfo {
+    rendererType?: RESTRendererType;
+    rendererField?: string;
+    rendererNormalizationField?: string;
+}
+export interface ServerRestInfo {
+    currentVersion?: string;
+    fullVersion?: string;
+    owningSystemUrl?: string;
+    owningTenant?: string;
+    authInfo?: {
+        isTokenBasedSecurity: boolean;
+        tokenServicesUrl: string;
+    };
+}
+/**
+ * Store information about coded-value domains in the subtype
+ */
+export interface ICodedValueDomain {
+    fieldName: string;
+    name: string;
+    codedValues?: ICodedValue[];
+}
+/**
+ * Store information about featureType
+ */
+export interface IFeatureType {
+    id: number | string;
+    name: string;
+    domains?: ICodedValueDomain[];
+}
+/**
+ * Store information about subtypes from the feature layer, if any, with:
+ * - either the couple typeIdField + types
+ * - or the couple subtypeField + subtypes
+ *  representing the field name and information associating a code with a name
+ */
+export interface SubtypeInfo {
+    typeIdField?: string;
+    types?: IFeatureType[];
+    subtypeField?: string;
+    subtypes?: IFeatureType[];
+}
+export type QueryObject = FeatureLayerView | SupportedLayer | undefined;