Rebvased and removed the getFieldType and getFieldDomain overrides for EsriImage that were recently added

Author: Alex-NRCan

packages/geoview-core/src/geo/layer/geoview-layers/esri-layer-common.ts

@@ -26,6 +26,7 @@ import type {
   TypeMetadataEsriLayerSummary,
   TypeMetadataEsriImage,
   TypeMosaicRule,
+  TypeLayerMetadataFields,
 } from '@/api/types/layer-schema-types';
 import { Fetch } from '@/core/utils/fetch-helper';
 import type { ConfigBaseClass } from '@/api/config/validation-classes/config-base-class';
@@ -377,7 +378,7 @@ export class EsriUtilities {
         throw new LayerServiceMetadataUnableToFetchError(layerConfig.getGeoviewLayerId(), layerConfig.getLayerName(), formatError(error));
       }
     } else {
-      // The layer metadata was alredy queried (same as the service metadata), use that
+      // In the case of an EsriImage, the layer metadata was already queried (same as the service metadata), use that
       layerMetadata = layerConfig.getServiceMetadata()!;
     }
 
@@ -435,7 +436,8 @@ export class EsriUtilities {
 
     // Read variables
     const queryable = layerMetadata.capabilities.includes('Query') || layerMetadata.capabilities.includes('Catalog');
-    const hasFields = !!layerMetadata.fields?.length;
+    const { fields } = layerMetadata;
+    const hasFields = !!fields?.length;
     const isGroupLayer = layerMetadataEsriDynamicLayer.type === 'Group Layer';
     const isMetadataGroup = layerConfig.getIsMetadataLayerGroup();
 
@@ -444,7 +446,7 @@ export class EsriUtilities {
 
     // Initialize the outfields
     // dynamic group layer doesn't have fields definition
-    if (layerMetadata.fields && !isGroupLayer) {
+    if (hasFields && !isGroupLayer) {
       // Get the outfields
       let outfields = layerConfig.getOutfields();
 
@@ -454,7 +456,7 @@ export class EsriUtilities {
         outfields = [];
 
         // Loop
-        layerMetadata.fields.forEach((fieldEntry) => {
+        fields.forEach((fieldEntry) => {
           // If the field is the geometry field
           if (layerMetadataEsriDynamicLayer.geometryField && fieldEntry?.name === layerMetadataEsriDynamicLayer.geometryField?.name) {
             // Keep the geometry field for future use
@@ -472,8 +474,8 @@ export class EsriUtilities {
           const newOutfield: TypeOutfields = {
             name: fieldEntry.name,
             alias: fieldEntry.alias || fieldEntry.name,
-            type: this.esriGetFieldType(layerConfig, fieldEntry.name),
-            domain: this.esriGetFieldDomain(layerConfig, fieldEntry.name),
+            type: this.esriGetFieldType(layerConfig, fields, fieldEntry.name),
+            domain: this.esriGetFieldDomain(fields, fieldEntry.name),
           };
 
           outfields!.push(newOutfield);
@@ -782,18 +784,32 @@ export class EsriUtilities {
 
   /**
    * Returns the type of the specified field.
-   * @param {EsriDynamicLayerEntryConfig | EsriFeatureLayerEntryConfig | EsriImageLayerEntryConfig} layerConfig The ESRI layer config
-   * @param {string} fieldName field name for which we want to get the type.
-   * @returns {TypeOutfieldsType} The type of the field.
-   * @static
+   *
+   * For ESRI Image layers, well-known pixel fields (`PixelValue`, `ProcessedValue`, `Name`)
+   * are short-circuited to `'string'` because they have no metadata entry.
+   *
+   * @param layerConfig - The ESRI layer config, used to detect EsriImage-specific fields.
+   * @param fields - The metadata field definitions to search.
+   * @param fieldName - Field name for which we want to get the type.
+   * @returns The mapped outfield type (`'date'`, `'oid'`, `'number'`, or `'string'`).
    */
   static esriGetFieldType(
     layerConfig: EsriDynamicLayerEntryConfig | EsriFeatureLayerEntryConfig | EsriImageLayerEntryConfig,
+    fields: TypeLayerMetadataFields[],
     fieldName: string
   ): TypeOutfieldsType {
-    const esriFieldDefinitions = layerConfig.getLayerMetadata()?.fields;
-    const fieldDefinition = esriFieldDefinitions?.find((metadataEntry) => metadataEntry.name === fieldName);
+    // For EsriImage layers, handle well-known pixel fields that have no metadata entry
+    if (layerConfig instanceof EsriImageLayerEntryConfig) {
+      const lowerFieldName = fieldName.toLowerCase();
+      if (lowerFieldName === 'pixelvalue' || lowerFieldName === 'processedvalue' || lowerFieldName === 'name') {
+        return 'string';
+      }
+    }
+
+    // Find the field definition in the provided fields array
+    const fieldDefinition = fields?.find((metadataEntry) => metadataEntry.name === fieldName);
     if (!fieldDefinition) return 'string';
+
     const esriFieldType = fieldDefinition.type;
     if (esriFieldType === 'esriFieldTypeDate') return 'date';
     if (esriFieldType === 'esriFieldTypeOID') return 'oid';
@@ -808,20 +824,16 @@ export class EsriUtilities {
 
   /**
    * Returns the domain of the specified field.
-   * @param {EsriDynamicLayerEntryConfig | EsriFeatureLayerEntryConfig | EsriImageLayerEntryConfig} layerConfig The ESRI layer config
-   * @param {string} fieldName field name for which we want to get the domain.
-   * @returns {codedValueType | rangeDomainType | null} The domain of the field.
-   * @static
+   *
+   * @param fields - The metadata field definitions to search.
+   * @param fieldName - Field name for which we want to get the domain.
+   * @returns The domain of the field, or `null` if not found.
    */
   // TODO: ESRI domains are translated to GeoView domains in the configuration. Any GeoView layer that support geoview domains can
   // TO.DOCONT: call a method getFieldDomain that use config.source.featureInfo.outfields to find a field domain.
-  static esriGetFieldDomain(
-    layerConfig: EsriDynamicLayerEntryConfig | EsriFeatureLayerEntryConfig | EsriImageLayerEntryConfig,
-    fieldName: string
-  ): codedValueType | rangeDomainType | null {
-    const esriFieldDefinitions = layerConfig.getLayerMetadata()?.fields;
-    const fieldDefinition = esriFieldDefinitions?.find((metadataEntry) => metadataEntry.name === fieldName);
-    return fieldDefinition ? fieldDefinition.domain : null;
+  static esriGetFieldDomain(fields: TypeLayerMetadataFields[], fieldName: string): codedValueType | rangeDomainType | null {
+    // Find the field definition in the provided fields array
+    return fields?.find((metadataEntry) => metadataEntry.name === fieldName)?.domain ?? null;
   }
 
   // #endregion PARSING METHODS

packages/geoview-core/src/geo/layer/gv-layers/raster/gv-esri-image.ts

@@ -14,16 +14,13 @@ import { logger } from '@/core/utils/logger';
 import { Fetch } from '@/core/utils/fetch-helper';
 import type { EsriImageLayerEntryConfig } from '@/api/config/validation-classes/raster-validation-classes/esri-image-layer-entry-config';
 import type {
-  codedValueType,
-  rangeDomainType,
   TypeFeatureInfoEntry,
   TypeFeatureInfoResult,
   TypeFieldEntry,
   TypeIconSymbolVectorConfig,
   TypeLayerStyleConfig,
   TypeLayerStyleConfigInfo,
   TypeLayerStyleSettings,
-  TypeOutfieldsType,
 } from '@/api/types/map-schema-types';
 import { CONST_LAYER_TYPES } from '@/api/types/layer-schema-types';
 import type { GeometryJson } from '@/geo/layer/gv-layers/utils';
@@ -32,7 +29,7 @@ import { AbstractGVRaster } from '@/geo/layer/gv-layers/raster/abstract-gv-raste
 import type { TypeLegend } from '@/core/stores/store-interface-and-intial-values/layer-state';
 import { GVWMS } from '@/geo/layer/gv-layers/raster/gv-wms';
 import type { LayerFilters } from '@/geo/layer/gv-layers/layer-filters';
-import type { TypeMetadataEsriImage, TypeMetadataEsriRasterFunctionInfos, TypeMosaicRule } from '@/api/types/layer-schema-types';
+import type { TypeMetadataEsriRasterFunctionInfos, TypeMosaicRule } from '@/api/types/layer-schema-types';
 import { GeometryApi } from '@/geo/layer/geometry/geometry';
 import type { TemporalMode } from '@/index';
 
@@ -385,74 +382,6 @@ export class GVEsriImage extends AbstractGVRaster {
     return featureInfoResult;
   }
 
-  /**
-   * Overrides the return of the field type from the metadata. If the type can not be found, return 'string'.
-   * @param {string} fieldName - The field name for which we want to get the type.
-   * @returns {TypeOutfieldsType} The type of the field.
-   * @override
-   */
-  protected override onGetFieldType(fieldName: string): TypeOutfieldsType {
-    // Handle special ESRI Image pixel fields
-    const lowerFieldName = fieldName.toLowerCase();
-
-    // Pixel-specific fields
-    if (lowerFieldName === 'pixelvalue' || lowerFieldName === 'processedvalue') {
-      return 'string';
-    }
-
-    if (lowerFieldName === 'name') {
-      return 'string';
-    }
-
-    // Check catalog item fields from metadata
-    const metadata = this.getLayerConfig().getServiceMetadata() as TypeMetadataEsriImage;
-
-    if (metadata?.fields) {
-      const field = metadata.fields.find((f) => f.name.toLowerCase() === lowerFieldName);
-      if (field) {
-        // Map ESRI field types to our types
-        switch (field.type) {
-          case 'esriFieldTypeSmallInteger':
-          case 'esriFieldTypeInteger':
-          case 'esriFieldTypeOID':
-            return 'number';
-          case 'esriFieldTypeSingle':
-          case 'esriFieldTypeDouble':
-            return 'number';
-          case 'esriFieldTypeDate':
-            return 'date';
-          case 'esriFieldTypeString':
-          case 'esriFieldTypeGeometry':
-          default:
-            return 'string';
-        }
-      }
-    }
-
-    // Default to string for unknown fields
-    return 'string';
-  }
-
-  /**
-   * Overrides the return of the domain of the specified field.
-   * @param {string} fieldName - The field name for which we want to get the domain.
-   * @returns {null | codedValueType | rangeDomainType} The domain of the field.
-   * @override
-   */
-  protected override onGetFieldDomain(fieldName: string): null | codedValueType | rangeDomainType {
-    // Get metadata
-    const metadata = this.getLayerConfig().getServiceMetadata() as TypeMetadataEsriImage;
-
-    // If no fields in metadata, return null
-    if (!metadata?.fields) return null;
-
-    // Find the field
-    const field = metadata.fields.find((f) => f.name.toLowerCase() === fieldName.toLowerCase());
-
-    // Return the domain if found
-    return field?.domain || null;
-  }
-
   /**
    * Overrides the formatting of feature info results to skip icon rendering for pixel-based queries.
    * ESRI Image layers return pixel values, not symbolized features, so we skip the icon source step.