@arcgis/charts-components 5.0.0-next.14 → 5.0.0-next.141

package/dist/utils/index.d.ts

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

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

@@ -1,208 +1,246 @@
-import { IFeatureLayer, IField, SupportedLayer, WebChart, WebChartDataFilters, WebChartQuery } from '../../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 { IFeatureType, QueryObject, QueryObjectProps, RendererInfo, SubtypeInfo } from './interfaces';
+import type FeatureLayer from "@arcgis/core/layers/FeatureLayer.js";
+import type Renderer from "@arcgis/core/renderers/Renderer";
+import type FeatureLayerView from "@arcgis/core/views/layers/FeatureLayerView";
+import type MapView from "@arcgis/core/views/MapView.js";
+import type SceneView from "@arcgis/core/views/SceneView.js";
+import type { SupportedLayer } from "../../interfaces.js";
+import type { QueryObject, QueryObjectProps, RendererInfo, SubtypeInfo } from "./interfaces.js";
+import type { IFeatureLayer, IField } from "../../spec/rest-js-types.js";
+import type { WebChart, WebChartDataFilters, WebChartQuery } from "../../spec/web-chart.js";
+
 /**
  * Returns the renderer type and the field and normalization field if applicable.
+ *
  * @param layerRenderer
  */
-export declare function getRendererInfo(layerRenderer?: Renderer): RendererInfo;
+export 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>;
+export 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>;
+export 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
+ * @param usePopupTemplateFieldsInfo - whether to use the aliases from the popupTemplate
  */
-export declare function fetchLayerFieldsInfo(queryObject: QueryObject, usePopupTemplateFieldsInfo?: boolean): Promise<IField[]>;
+export 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
+ *
+ * @param fieldName - The list of fields containing all the information regarding the fields, including the name
+ * @param fields
+ */
+export function getFieldFromName(fieldName: string, fields?: IField[]): IField | undefined;
+
+/**
+ * Returns the unique ID fields or the object ID field of the given layer.
+ * Also return a boolean indicating whether the returned ID field is a traditional Object ID field.
+ *
+ * @param layer - The layer
+ * @returns An object containing the unique ID fields or the object ID field and a boolean indicating if it is a traditional Object ID field
+ * When the layer is undefined, returns undefined ID fields and false for the boolean.
  */
-export declare function getFieldFromName(fieldName: string, fields?: IField[]): IField | undefined;
+export function getLayerUniqueIdOrObjectIdFields(layer?: SupportedLayer): {
+    idFields: string[] | undefined;
+    isTraditionalTypeOID: boolean;
+};
+
 /**
- * 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.
+ * Returns the object ID field of the given layer and a boolean indicating whether it is a traditional Object ID field.
+ * If the layer has unique ID fields defined, the first field is returned.
+ *
+ * @param layer - The layer
  */
-export declare function getObjectIdField(layerFieldsInfo: IField[]): string;
+export function getObjectIdField(layer?: SupportedLayer): {
+    idField: string;
+    isTraditionalTypeOID: boolean;
+};
+
 /**
  * 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;
+export 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;
+export 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;
+export 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[];
+export 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 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;
+export function getLayerNumericFields(fieldsInfo: IField[]): string[];
+
 /**
  * Retrieve subtype information from the query object.
- * @param queryObject The query object from which to retrieve the feature layer.
+ *
+ * @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;
+export 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
+ *
+ * @param props - the name of the field
  * @returns The field description if available; otherwise undefined.
  */
-export declare function getFieldDescription(props: {
+export 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 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}
+ *
+ * @param layer
  */
-declare function getServerRestInfo(resUrl: string): string;
+export 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>}
+ *
+ * @param layer
  */
-export declare function isStandardLayer(layer: SupportedLayer): Promise<boolean>;
+export 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>}
+ *
+ * @param props
  */
-export declare function findMatchingLayerFieldName(props: {
+export function findMatchingLayerFieldName(props: {
     queryObject: QueryObject;
     fieldToMatch: string;
     returnUndefinedIfNotFound?: boolean;
 }): Promise<string>;
+
+/**
+ * Find the matching field in a list of fields based on the fieldToMatch parameter.
+ * It first looks for a perfect match (case-sensitive), then for an approximate match (case-insensitive).
+ *
+ * We look for a match in 2 steps:
+ *
+ * 1. Perfect match: the case of the fields is exactly the same. This helps when the layer has fields with the same name but with a
+ *    different case (e.g. "field" and "FiElD"). Refer to https://devtopia.esri.com/WebGIS/arcgis-charts/issues/8305
+ *
+ * 2: Approximate match: we upper-case the fields to compare them
+ *
+ * @param layerFieldList - The list of fields to search in.
+ * @param fieldToMatch - The field name to match.
+ * @returns The matching field if found, otherwise undefined.
+ */
+export function findMatchingField(layerFieldList: IField[], fieldToMatch: string): IField | undefined;
+
 /**
  * Finds the matching layer fields for a list of fields.
  *
- * @param {(string[] | undefined)} props.fields
- * @param {SupportedLayer} props.queryObject
- * @param {boolean} props.returnUndefinedIfNotFound
- * @returns
+ * @param props
  */
-export declare function matchFieldsList(props: {
+export 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: {
+ * 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 - The query object (feature layer or feature layer view)
+ */
+export 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
+ * @param layer - the supported layer
+ * @returns The list of fields used in the charts
  */
-export declare function getFieldsUsedInCharts(layer: SupportedLayer): Promise<string[]>;
+export 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
+ * @param config - The chart configuration
+ * @param layer - The feature layer
+ * @returns The list of matching fields
  */
-export declare function extractFieldsUsedInConfig(config: WebChart, layer: SupportedLayer | undefined): Promise<string[]>;
+export 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
+ * @param layer - The layer
+ * @returns 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 {};
+export function extractFieldsFromConfigList(layer: SupportedLayer): Promise<string[]>;
+
+/**
+ * Finds the matching layer in the view based on the provided layer's portal item id.
+ * - The matching is done based on the portalItem id.
+ * - If no matching layer is found, returns `undefined`.
+ *
+ * @param props - The map or scene view
+ * @returns The matching layer in the view or undefined if not found
+ * @example
+ * ```ts
+ * const matchingLayer = findMatchingLayerFromView({ view, portalItemId: 'abc123' });
+ * ```
+ * @requires
+ * - view
+ * - portalItemId
+ */
+export function findMatchingLayerFromView(props: {
+    view?: MapView | SceneView;
+    portalItemId: string;
+}): FeatureLayerView | SupportedLayer | undefined;

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

@@ -1,64 +1,40 @@
-import { Color, IFeatureLayer, WebChart, WebChartDataItemValue, WebChartDataTypes } from '../../../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;
+import type FeatureLayer from "@arcgis/core/layers/FeatureLayer";
+import type { WebChartConfigFields } from "./interfaces.js";
+import type { IFeatureLayer } from "../../../spec/rest-js-types.js";
+import type { WebChartDataTypes } from "../../../spec/data-source.js";
+import type { WebChart } from "../../../spec/web-chart.js";
+
 /**
  * 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
+ *
+ * @param props - The category field
  */
-export declare function convertConfigFieldsToChartRenderer(props: {
+export function convertConfigFieldsToChartRenderer(props: {
     categoryField: string;
     numericFields: string[];
     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
- * @param props.categoryType The category type
- * @param props.numericFields The numeric fields
- * @param props.inlineData The inline data to convert
+ *
+ * @param props - The category field
  */
-export declare function convertInlineDataToLayerDefinition(props: {
+export function convertInlineDataToLayerDefinition(props: {
     categoryField: string;
     categoryType: "date" | "dateOnly" | "number" | "string" | "timeStampOffset";
     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
+ *
+ * @param props - The category field
  */
-export declare function convertInlineConfigToLayerConfig(props: {
+export function convertInlineConfigToLayerConfig(props: {
     categoryField: string;
     categoryType: "date" | "dateOnly" | "number" | "string" | "timeStampOffset";
     numericFields: string[];
@@ -68,10 +44,4 @@ export declare function convertInlineConfigToLayerConfig(props: {
     chartRenderer?: WebChart["chartRenderer"];
     iLayer?: IFeatureLayer;
     layer?: FeatureLayer;
-}>;
-export declare const inlineConversionPrivateFunctions: {
-    hexToRGB: typeof hexToRGB;
-    convertColor: typeof convertColor;
-    removeConfigFieldsFromData: typeof removeConfigFieldsFromData;
-};
-export {};
+}>;

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

@@ -3,17 +3,17 @@
  * 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;
-}
+  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

@@ -1,43 +1,49 @@
-import { RESTRendererType, WebChart, ICodedValue, SupportedLayer } from '../../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 type MapView from "@arcgis/core/views/MapView";
+import type SceneView from "@arcgis/core/views/SceneView";
+import type FeatureLayerView from "@arcgis/core/views/layers/FeatureLayerView";
+import type { SupportedLayer } from "../../interfaces.js";
+import type { WebChart } from "../../spec/web-chart.js";
+import type { RESTRendererType } from "../../spec/rest-js-object-literals.js";
+import type { ICodedValue } from "../../spec/rest-js-types.js";
+
 export interface QueryObjectProps {
-    chartConfig: WebChart;
-    layer?: FeatureLayerView | SupportedLayer;
-    view?: MapView | SceneView;
+  chartConfig: WebChart;
+  layer?: FeatureLayerView | SupportedLayer;
+  view?: MapView | SceneView;
+  filterByExtent?: boolean;
 }
+
 export interface RendererInfo {
-    rendererType?: RESTRendererType;
-    rendererField?: string;
-    rendererNormalizationField?: string;
+  rendererType?: RESTRendererType;
+  rendererField?: string;
+  rendererNormalizationField?: string;
 }
+
 export interface ServerRestInfo {
-    currentVersion?: string;
-    fullVersion?: string;
-    owningSystemUrl?: string;
-    owningTenant?: string;
-    authInfo?: {
-        isTokenBasedSecurity: boolean;
-        tokenServicesUrl: string;
-    };
+  currentVersion?: string;
+  fullVersion?: string;
+  owningSystemUrl?: string;
+  owningTenant?: string;
+  authInfo?: {
+      isTokenBasedSecurity: boolean;
+      tokenServicesUrl: string;
+  };
 }
-/**
- * Store information about coded-value domains in the subtype
- */
+
+/** Store information about coded-value domains in the subtype */
 export interface ICodedValueDomain {
-    fieldName: string;
-    name: string;
-    codedValues?: ICodedValue[];
+  fieldName: string;
+  name: string;
+  codedValues?: ICodedValue[];
 }
-/**
- * Store information about featureType
- */
+
+/** Store information about featureType */
 export interface IFeatureType {
-    id: number | string;
-    name: string;
-    domains?: ICodedValueDomain[];
+  id: number | string;
+  name: string;
+  domains?: ICodedValueDomain[];
 }
+
 /**
  * Store information about subtypes from the feature layer, if any, with:
  * - either the couple typeIdField + types
@@ -45,9 +51,10 @@ export interface IFeatureType {
  *  representing the field name and information associating a code with a name
  */
 export interface SubtypeInfo {
-    typeIdField?: string;
-    types?: IFeatureType[];
-    subtypeField?: string;
-    subtypes?: IFeatureType[];
+  typeIdField?: string;
+  types?: IFeatureType[];
+  subtypeField?: string;
+  subtypes?: IFeatureType[];
 }
-export type QueryObject = FeatureLayerView | SupportedLayer | undefined;
+
+export type QueryObject = FeatureLayerView | SupportedLayer | undefined;