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

Author: Alex-NRCan

packages/geoview-core/src/api/config/reader/geopackage-reader.ts

@@ -576,7 +576,6 @@ export class GeoPackageReader {
         name: fieldEntryKey,
         alias: fieldEntryKey,
         type: fieldType as 'string' | 'number' | 'date',
-        domain: null,
       };
 
       outfields.push(newOutfield);

packages/geoview-core/src/api/event-processors/event-processor-children/feature-info-event-processor.ts

@@ -356,11 +356,11 @@ export class FeatureInfoEventProcessor extends AbstractEventProcessor {
           {
             uid: 'coordinate-info-feature',
             fieldInfo: {
-              latitude: { value: lat.toFixed(6), fieldKey: 0, dataType: 'number', alias: 'Latitude', domain: null },
-              longitude: { value: lng.toFixed(6), fieldKey: 1, dataType: 'number', alias: 'Longitude', domain: null },
-              utmZone: { value: utmIdentifier, fieldKey: 2, dataType: 'string', alias: 'UTM Identifier', domain: null },
-              easting: { value: easting?.toFixed(2), fieldKey: 3, dataType: 'number', alias: 'Easting', domain: null },
-              northing: { value: northing?.toFixed(2), fieldKey: 4, dataType: 'number', alias: 'Northing', domain: null },
+              latitude: { value: lat.toFixed(6), fieldKey: 0, dataType: 'number', alias: 'Latitude' },
+              longitude: { value: lng.toFixed(6), fieldKey: 1, dataType: 'number', alias: 'Longitude' },
+              utmZone: { value: utmIdentifier, fieldKey: 2, dataType: 'string', alias: 'UTM Identifier' },
+              easting: { value: easting?.toFixed(2), fieldKey: 3, dataType: 'number', alias: 'Easting' },
+              northing: { value: northing?.toFixed(2), fieldKey: 4, dataType: 'number', alias: 'Northing' },
               ntsMapsheet: {
                 value: ntsData?.features
                   .filter((f) => f.properties.name !== '')
@@ -373,14 +373,12 @@ export class FeatureInfoEventProcessor extends AbstractEventProcessor {
                 fieldKey: 5,
                 dataType: 'string',
                 alias: 'NTS Mapsheets',
-                domain: null,
               },
               elevation: {
                 value: elevationData?.altitude ? `${elevationData.altitude} m` : undefined,
                 fieldKey: 6,
                 dataType: 'string',
                 alias: 'Elevation',
-                domain: null,
               },
             },
             extent: undefined,

packages/geoview-core/src/api/types/map-schema-types.ts

@@ -581,7 +581,7 @@ export type TypeOutfields = {
   name: string;
   alias: string;
   type: TypeOutfieldsType;
-  domain?: null | codedValueType | rangeDomainType;
+  domain?: codedValueType | rangeDomainType;
 };
 
 /** The types supported by the outfields object. */
@@ -610,7 +610,7 @@ export type TypeFieldEntry = {
   value: unknown;
   dataType: TypeOutfieldsType;
   alias: string;
-  domain: null | codedValueType | rangeDomainType;
+  domain?: codedValueType | rangeDomainType;
 };
 
 // Definition of the alias lookup for matching field names to aliases

packages/geoview-core/src/core/components/details/feature-detail-modal.tsx

@@ -56,7 +56,6 @@ export default function FeatureDetailModal(): JSX.Element {
         value: feature.fieldInfo[fieldName]!.value,
         dataType: feature.fieldInfo[fieldName]!.dataType,
         alias: feature.fieldInfo[fieldName]!.alias ? feature.fieldInfo[fieldName]!.alias : fieldName,
-        domain: null,
       };
     });
 

packages/geoview-core/src/core/components/details/feature-info.tsx

@@ -217,7 +217,6 @@ export function FeatureInfo({ feature, containerType }: FeatureInfoProps): JSX.E
           feature.geoviewLayerType !== 'ogcWms' && feature.geoviewLayerType !== 'ogcWfs'
             ? field!.alias || fieldName
             : (field!.alias || fieldName).split('.').pop() || '',
-        domain: null,
       }));
   }, [feature]);
 

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,14 +456,15 @@ 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
             layerConfig.setGeometryField({
               name: fieldEntry.name,
               alias: fieldEntry.alias || fieldEntry.name,
-              type: layerMetadataEsriDynamicLayer.geometryType as TypeOutfieldsType, // Force the typing, because the type doesn't include all geometry type values
+              // TODO: CHECK - Mismatch of TypeOutfieldsType and geometryType as string. This seems wrong, should the TypeOutfieldsType be enhanced to include geometry types?
+              type: layerMetadataEsriDynamicLayer.geometryType as TypeOutfieldsType,
             });
 
             // Skip that geometry field
@@ -472,8 +475,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 +785,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 +825,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 | undefined {
+    // Find the field definition in the provided fields array
+    return fields?.find((metadataEntry) => metadataEntry.name === fieldName)?.domain;
   }
 
   // #endregion PARSING METHODS

packages/geoview-core/src/geo/layer/geoview-layers/vector/abstract-geoview-vector.ts

@@ -6,7 +6,7 @@ import type { Extent } from 'ol/extent';
 import { getUid } from 'ol/util';
 import type { ReadOptions } from 'ol/format/Feature';
 
-import type { TypeOutfields } from '@/api/types/map-schema-types';
+import type { TypeOutfields, TypeOutfieldsType } from '@/api/types/map-schema-types';
 import type { TypePostSettings } from '@/api/types/layer-schema-types';
 import type { VectorLayerEntryConfig } from '@/api/config/validation-classes/vector-layer-entry-config';
 import { AbstractGeoViewLayer } from '@/geo/layer/geoview-layers/abstract-geoview-layers';
@@ -254,14 +254,13 @@ export abstract class AbstractGeoViewVector extends AbstractGeoViewLayer {
             return;
           }
 
-          let type = 'string';
+          let type = 'string' as TypeOutfieldsType;
           if (firstRow[index] && firstRow[index] !== '' && Number(firstRow[index])) type = 'number';
 
           const newOutfield: TypeOutfields = {
             name: header,
             alias: header,
-            type: type as 'string' | 'number',
-            domain: null,
+            type: type,
           };
           outfields!.push(newOutfield);
         }

packages/geoview-core/src/geo/layer/geoview-layers/vector/ogc-feature.ts

@@ -4,7 +4,7 @@ import type { Options as SourceOptions } from 'ol/source/Vector';
 import type { Projection as OLProjection } from 'ol/proj';
 
 import { AbstractGeoViewVector } from '@/geo/layer/geoview-layers/vector/abstract-geoview-vector';
-import type { DisplayDateMode, TypeOutfields } from '@/api/types/map-schema-types';
+import type { DisplayDateMode, TypeOutfields, TypeOutfieldsType } from '@/api/types/map-schema-types';
 import type {
   TypeGeoviewLayerConfig,
   TypeMetadataOGCFeature,
@@ -292,15 +292,14 @@ export class OgcFeature extends AbstractGeoViewVector {
         const fieldEntry = fields[fieldEntryKey];
         if (fieldEntry.type === 'Geometry') return;
 
-        let fieldType = 'string';
+        let fieldType = 'string' as TypeOutfieldsType;
         if (fieldEntry.type === 'date') fieldType = 'date';
         else if (['bigint', 'number'].includes(typeof fieldEntry)) fieldType = 'number';
 
         const newOutfield: TypeOutfields = {
           name: fieldEntryKey,
           alias: fieldEntryKey,
-          type: fieldType as 'string' | 'number' | 'date',
-          domain: null,
+          type: fieldType,
         };
         outfields!.push(newOutfield);
       });

packages/geoview-core/src/geo/layer/geoview-layers/vector/wfs.ts

@@ -636,7 +636,6 @@ export class WFS extends AbstractGeoViewVector {
           name: fieldEntry.name,
           alias: fieldEntry.alias ?? fieldEntry.name,
           type: WFS.getFieldType(fieldEntry.name, layerConfig),
-          domain: null,
         };
 
         outfields!.push(newOutfield);

packages/geoview-core/src/geo/layer/gv-layers/abstract-gv-layer.ts

@@ -29,6 +29,8 @@ import type {
   TypeOutfields,
   TypeLayerStyleSettings,
   TypeFeatureInfoResult,
+  codedValueType,
+  rangeDomainType,
 } from '@/api/types/map-schema-types';
 import { type TypeLayerMetadataFields, type TypeGeoviewLayerType, type TypeMetadataEsriDynamicLayer } from '@/api/types/layer-schema-types';
 import type { GeoViewError } from '@/core/exceptions/geoview-exceptions';
@@ -1816,10 +1818,18 @@ export abstract class AbstractGVLayer extends AbstractBaseGVLayer {
         // eslint-disable-next-line no-param-reassign
         featureInfoEntry.fieldInfo[fieldEntry.name] = {
           fieldKey: fieldKeyCounter++,
-          value: callbackGetFieldValue(feature, fieldEntry.name, fieldEntry.type, inputFormat, inputTimezone, inputTemporalMode),
+          value: callbackGetFieldValue(
+            feature,
+            fieldEntry.name,
+            fieldEntry.type,
+            fieldEntry.domain,
+            inputFormat,
+            inputTimezone,
+            inputTemporalMode
+          ),
           dataType: fieldEntry.type,
           alias: fieldEntry.alias,
-          domain: fieldEntry.domain ?? null,
+          domain: fieldEntry.domain,
         };
       }
     }
@@ -1830,22 +1840,29 @@ export abstract class AbstractGVLayer extends AbstractBaseGVLayer {
 
   /**
    * Retrieves and formats the value of a field from an OpenLayers feature.
-   * For fields of type `date`, the value is normalized and formatted using the
-   * date management utilities. Date values may be provided as epoch milliseconds
-   * or as date strings and are converted to a short ISO-like string.
-   * @param {Feature} feature - The OpenLayers feature containing the field values.
-   * @param {string} fieldName - The name of the field to retrieve.
-   * @param {TypeOutfieldsType} fieldType - The type of the field (e.g. `'string'`, `'number'`, `'date'`).
-   * @param {string | string[] | undefined} [inputFormat] - The format(s) to prioritize for string inputs. Defaults to an ISO-like format.
-   * @param {TimeIANA | undefined} [inputTimezone] - The IANA timezone to assume when interpreting input date values.
-   * @param {TemporalMode | undefined} [inputTemporalMode] - When `calendar`, treats the input as a calendar-date-only value (no timezones). When 'instant', treats the input as moment in time (timezones aware).
-   * @returns {unknown} The formatted field value. For date fields, this is a
-   * formatted date string; for other field types, the raw field value is returned.
+   * - For `date` fields, the raw value (epoch ms or date string) is normalized
+   *   via the date management utilities.
+   * - For fields with a `codedValue` domain, the raw code is resolved to its
+   *   human-readable name. If no matching code is found, the raw value is returned.
+   * - For all other fields, the raw value is returned as-is.
+   *
+   * @param feature - The OpenLayers feature containing the field values.
+   * @param fieldName - The name of the field to retrieve.
+   * @param fieldType - The data type of the field (e.g. `'string'`, `'number'`, `'date'`, `'oid'`).
+   * @param fieldDomain - Optional domain metadata. When present and of type `codedValue`,
+   * the raw field value is mapped to the corresponding coded-value name.
+   * @param inputFormat - Optional format(s) to prioritize when parsing date string inputs.
+   * @param inputTimezone - Optional IANA timezone to assume when interpreting date values.
+   * @param inputTemporalMode - Optional temporal mode. `'calendar'` treats dates as
+   * timezone-agnostic calendar dates; `'instant'` treats them as timezone-aware moments.
+   * @returns The processed field value: a formatted date for date fields, the decoded
+   * name for coded-value domains, or the raw value otherwise.
    */
   static helperGetFieldValue(
     feature: Feature,
     fieldName: string,
     fieldType: TypeOutfieldsType,
+    fieldDomain: codedValueType | rangeDomainType | undefined,
     inputFormat: string | string[] | undefined,
     inputTimezone: TimeIANA | undefined,
     inputTemporalMode: TemporalMode | undefined
@@ -1855,6 +1872,16 @@ export abstract class AbstractGVLayer extends AbstractBaseGVLayer {
       // Read the date
       return DateMgt.createDate(fieldValue, inputFormat, inputTimezone, inputTemporalMode);
     }
+
+    // If the field has a domain
+    if (fieldDomain && fieldDomain.type === 'codedValue') {
+      // Find the coded value corresponding to the value
+      const codedValue = fieldDomain.codedValues.find((cv) => cv.code === fieldValue);
+
+      // Read the value from the domain
+      return codedValue ? codedValue.name : fieldValue;
+    }
+
     return fieldValue;
   }
 
@@ -1867,6 +1894,7 @@ export type GetFieldValueDelegate = (
   feature: Feature,
   fieldName: string,
   fieldType: TypeOutfieldsType,
+  fieldDomain: codedValueType | rangeDomainType | undefined,
   inputFormat: string | string[] | undefined,
   inputTimezone: TimeIANA | undefined,
   inputTemporalMode: TemporalMode | undefined