diff --git a/packages/geoview-core/public/configs/navigator/28-geocore.json b/packages/geoview-core/public/configs/navigator/28-geocore.json index 139ba497d62..1979e869cc2 100644 --- a/packages/geoview-core/public/configs/navigator/28-geocore.json +++ b/packages/geoview-core/public/configs/navigator/28-geocore.json @@ -12,7 +12,7 @@ "listOfGeoviewLayerConfig": [ { "geoviewLayerType": "geoCore", - "geoviewLayerId": "21b821cf-0f1c-40ee-8925-eab12d357668" + "geoviewLayerId": "1dcd28aa-99da-4f62-b157-15631379b170" }, { "geoviewLayerType": "geoCore", diff --git a/packages/geoview-core/public/configs/performance.json b/packages/geoview-core/public/configs/performance.json new file mode 100644 index 00000000000..d5ba9db4fa4 --- /dev/null +++ b/packages/geoview-core/public/configs/performance.json @@ -0,0 +1,50 @@ +{ + "map": { + "interaction": "dynamic", + "viewSettings": { + "projection": 3857 + }, + "basemapOptions": { + "basemapId": "transport", + "shaded": true, + "labeled": false + }, + "listOfGeoviewLayerConfig": [ + { + "geoviewLayerType": "geoCore", + "geoviewLayerId": "1dcd28aa-99da-4f62-b157-15631379b170" + }, + { + "geoviewLayerType": "geoCore", + "geoviewLayerId": "6c343726-1e92-451a-876a-76e17d398a1c" + }, + { + "geoviewLayerType": "geoCore", + "geoviewLayerId": "e2424b6c-db0c-4996-9bc0-2ca2e6714d71" + }, + { + "geoviewLayerType": "geoCore", + "geoviewLayerId": "c5c249c4-dea6-40a6-8fae-188a42030908" + } + ] + }, + "components": [ + "overview-map" + ], + "overviewMap": { + "hideOnZoom": 7 + }, + "footerBar": { + "tabs": { + "core": [ + "legend", + "layers", + "details", + "geochart", + "data-table" + ] + } + }, + "corePackages": [], + "theme": "geo.ca" +} \ No newline at end of file diff --git a/packages/geoview-core/public/templates/outliers/outlier-performance.html b/packages/geoview-core/public/templates/outliers/outlier-performance.html new file mode 100644 index 00000000000..be6944481dd --- /dev/null +++ b/packages/geoview-core/public/templates/outliers/outlier-performance.html @@ -0,0 +1,101 @@ + + + + + + Outlier ESRI Layers - Canadian Geospatial Platform Viewer + + + + + + + + + + + + +
+ + + + + + + +
+

Outlier layers with performace issue

+
+ + + + + + + + + + +
+ Main
+ Outlier Layers
+

This page is used to showcase layers with few layer with bad performance with different original server projection

+
+ +
+

Max Record Count Layers

+ Top +
+ + 

+    

+
+    
+    
+
+    

+
+    

+      Outlier Layers:
+      
+    

+    

+
+    
+    
+  
+
diff --git a/packages/geoview-core/public/templates/outliers/outliers.html b/packages/geoview-core/public/templates/outliers/outliers.html
index e4bc6e5f729..ff52ea7885a 100644
--- a/packages/geoview-core/public/templates/outliers/outliers.html
+++ b/packages/geoview-core/public/templates/outliers/outliers.html
@@ -34,6 +34,7 @@ 
Performance Issue (Huge) Layers

       Max Record Count Layers

       GeoAI

       Elections 2019

+      Many slow layers in different projection

       

     
   
diff --git a/packages/geoview-core/schema.json b/packages/geoview-core/schema.json
index 28bea530eb8..d83d86f3b5e 100644
--- a/packages/geoview-core/schema.json
+++ b/packages/geoview-core/schema.json
@@ -72,7 +72,8 @@
         "string",
         "number",
         "date",
-        "url"
+        "url",
+        "oid"
       ]
     },
     "TypeFeatureInfoNotQueryable": {
diff --git a/packages/geoview-core/src/api/config/types/classes/sub-layer-config/leaf/abstract-base-esri-layer-entry-config.ts b/packages/geoview-core/src/api/config/types/classes/sub-layer-config/leaf/abstract-base-esri-layer-entry-config.ts
index 4c2088ffdd5..111769c0a7f 100644
--- a/packages/geoview-core/src/api/config/types/classes/sub-layer-config/leaf/abstract-base-esri-layer-entry-config.ts
+++ b/packages/geoview-core/src/api/config/types/classes/sub-layer-config/leaf/abstract-base-esri-layer-entry-config.ts
@@ -165,16 +165,13 @@ export abstract class AbstractBaseEsriLayerEntryConfig extends AbstractBaseLayer
    *
    * @param {string} esriFieldType The ESRI field type.
    *
-   * @returns {'string' | 'date' | 'number'} The type of the field.
+   * @returns {'string' | 'date' | 'number' | 'oid'} The type of the field.
    * @static @private
    */
-  static #convertEsriFieldType(esriFieldType: string): 'string' | 'date' | 'number' {
+  static #convertEsriFieldType(esriFieldType: string): 'string' | 'date' | 'number' | 'oid' {
     if (esriFieldType === 'esriFieldTypeDate') return 'date';
-    if (
-      ['esriFieldTypeDouble', 'esriFieldTypeInteger', 'esriFieldTypeSingle', 'esriFieldTypeSmallInteger', 'esriFieldTypeOID'].includes(
-        esriFieldType
-      )
-    )
+    if (esriFieldType === 'esriFieldTypeOID') return 'oid';
+    if (['esriFieldTypeDouble', 'esriFieldTypeInteger', 'esriFieldTypeSingle', 'esriFieldTypeSmallInteger'].includes(esriFieldType))
       return 'number';
     return 'string';
   }
diff --git a/packages/geoview-core/src/api/config/types/config-validation-schema.json b/packages/geoview-core/src/api/config/types/config-validation-schema.json
index 39a79ae5c1f..080ade92b78 100644
--- a/packages/geoview-core/src/api/config/types/config-validation-schema.json
+++ b/packages/geoview-core/src/api/config/types/config-validation-schema.json
@@ -1707,7 +1707,8 @@
         "string",
         "number",
         "date",
-        "url"
+        "url",
+        "oid"
       ]
     },
     "codedValueType": {
diff --git a/packages/geoview-core/src/api/config/types/map-schema-types.ts b/packages/geoview-core/src/api/config/types/map-schema-types.ts
index 03cc6cc5b26..ae092d24f01 100644
--- a/packages/geoview-core/src/api/config/types/map-schema-types.ts
+++ b/packages/geoview-core/src/api/config/types/map-schema-types.ts
@@ -500,7 +500,7 @@ export type TypeOutfields = {
 };
 
 /** The types supported by the outfields object. */
-export type TypeOutfieldsType = 'string' | 'date' | 'number' | 'url';
+export type TypeOutfieldsType = 'string' | 'date' | 'number' | 'url' | 'oid';
 
 export type codedValueType = {
   type: 'codedValue';
diff --git a/packages/geoview-core/src/api/event-processors/event-processor-children/legend-event-processor.ts b/packages/geoview-core/src/api/event-processors/event-processor-children/legend-event-processor.ts
index e09dbe98e4b..498a7dce273 100644
--- a/packages/geoview-core/src/api/event-processors/event-processor-children/legend-event-processor.ts
+++ b/packages/geoview-core/src/api/event-processors/event-processor-children/legend-event-processor.ts
@@ -639,6 +639,11 @@ export class LegendEventProcessor extends AbstractEventProcessor {
     const visibleValues = new Set(styleUnique.filter((style) => style.visible).map((style) => style.values.join(';')));
     const unvisibleValues = new Set(styleUnique.filter((style) => !style.visible).map((style) => style.values.join(';')));
 
+    // GV: Some esri layer has uniqueValue renderer but there is no field define in their metadata (i.e. e2424b6c-db0c-4996-9bc0-2ca2e6714d71).
+    // TODO: The fields contain undefined, it should be empty. Check in new config api
+    // TODO: This is a workaround
+    if (uniqueValueStyle.fields[0] === undefined) uniqueValueStyle.fields.pop();
+
     // Filter features based on visibility
     return features.filter((feature) => {
       const fieldValues = uniqueValueStyle.fields.map((field) => feature.fieldInfo[field]!.value).join(';');
diff --git a/packages/geoview-core/src/core/components/data-table/data-table.tsx b/packages/geoview-core/src/core/components/data-table/data-table.tsx
index 50041520ad9..29c412cedbb 100644
--- a/packages/geoview-core/src/core/components/data-table/data-table.tsx
+++ b/packages/geoview-core/src/core/components/data-table/data-table.tsx
@@ -226,7 +226,7 @@ function DataTable({ data, layerPath, tableHeight = '500px' }: DataTableProps):
         header: value.alias,
         filterFn: 'contains',
         columnFilterModeOptions: ['contains', 'startsWith', 'endsWith', 'empty', 'notEmpty'],
-        ...(value.dataType === 'number' && {
+        ...((value.dataType === 'number' || value.dataType === 'oid') && {
           filterFn: 'between',
           columnFilterModeOptions: [
             'equals',
@@ -299,13 +299,15 @@ function DataTable({ data, layerPath, tableHeight = '500px' }: DataTableProps):
     async (feature: TypeFeatureInfoEntry) => {
       let { extent } = feature;
 
-      // If there is no extent, the layer is ESRI Dynamic, get the feature extent using its OBJECTID
-      // GV: Some layers do not use OBJECTID, these are the other values seen so far.
-      // TODO: Update field info types to include esriFieldTypeOID to identify the ID field.
-      const idFields = ['OBJECTID', 'OBJECTID_1', 'FID', 'STATION_NUMBER'];
-      const idField = idFields.find((fieldName) => feature.fieldInfo[fieldName]?.value !== undefined);
-      if (!extent && idField !== undefined)
-        extent = await getExtentFromFeatures(layerPath, [feature.fieldInfo[idField]!.value as string], idField);
+      // Get oid field
+      const oidField =
+        feature && feature.fieldInfo
+          ? Object.keys(feature.fieldInfo).find((key) => feature.fieldInfo[key]!.dataType === 'oid') || undefined
+          : undefined;
+
+      // If there is no extent, the layer is ESRI Dynamic, get the feature extent using its oid field
+      if (!extent && oidField !== undefined)
+        extent = await getExtentFromFeatures(layerPath, [feature.fieldInfo[oidField]!.value as string], oidField);
 
       if (extent) {
         // Project
diff --git a/packages/geoview-core/src/core/components/data-table/json-export-button.tsx b/packages/geoview-core/src/core/components/data-table/json-export-button.tsx
index 9f983084103..b7dd34e4411 100644
--- a/packages/geoview-core/src/core/components/data-table/json-export-button.tsx
+++ b/packages/geoview-core/src/core/components/data-table/json-export-button.tsx
@@ -72,9 +72,14 @@ function JSONExportButton({ rows, features, layerPath }: JSONExportButtonProps):
       try {
         // Create a new promise that will resolved when features have been updated with their geometries
         return new Promise((resolve, reject) => {
+          // Get oid field
+          const oidField = chunk[0].fieldInfo
+            ? Object.keys(chunk[0].fieldInfo).find((key) => chunk[0].fieldInfo[key]!.dataType === 'oid') || 'OBJECTID'
+            : 'OBJECTID';
+
           // Get the ids
           const objectids = chunk.map((record) => {
-            return record.geometry?.get('OBJECTID') as number;
+            return record.geometry?.get(oidField) as number;
           });
 
           // Query
@@ -83,7 +88,7 @@ function JSONExportButton({ rows, features, layerPath }: JSONExportButtonProps):
               // For each result
               results.forEach((result) => {
                 // Filter
-                const recFound = chunk.filter((record) => record.geometry?.get('OBJECTID') === result.fieldInfo?.OBJECTID?.value);
+                const recFound = chunk.filter((record) => record.geometry?.get(oidField) === result.fieldInfo[oidField]?.value);
 
                 // If found it
                 if (recFound && recFound.length === 1) {
diff --git a/packages/geoview-core/src/core/components/details/feature-info.tsx b/packages/geoview-core/src/core/components/details/feature-info.tsx
index 5a76c3147b2..c952f8af1b4 100644
--- a/packages/geoview-core/src/core/components/details/feature-info.tsx
+++ b/packages/geoview-core/src/core/components/details/feature-info.tsx
@@ -69,7 +69,7 @@ const FeatureHeader = memo(function FeatureHeader({ iconSrc, name, hasGeometry,
         
           
         
-        
+        
           
             
           
@@ -80,7 +80,7 @@ const FeatureHeader = memo(function FeatureHeader({ iconSrc, name, hasGeometry,
 });
 
 export function FeatureInfo({ feature }: FeatureInfoProps): JSX.Element | null {
-  logger.logTraceRender('components/details/feature-info');
+  logger.logTraceRender('components/details/feature-info', feature);
 
   // Hooks
   const theme = useTheme();
@@ -186,7 +186,7 @@ export function FeatureInfo({ feature }: FeatureInfoProps): JSX.Element | null {
       ();
   const theme = useTheme();
 
-  const { CSV, ESRI_DYNAMIC, ESRI_FEATURE, ESRI_IMAGE, GEOJSON, GEOPACKAGE, WMS, WFS, OGC_FEATURE, XYZ_TILES } = CONST_LAYER_TYPES;
+  // TODO: refactor - add the Geopacakges when refactor is done GEOPACKAGE
+  const { CSV, ESRI_DYNAMIC, ESRI_FEATURE, ESRI_IMAGE, GEOJSON, WMS, WFS, OGC_FEATURE, XYZ_TILES } = CONST_LAYER_TYPES;
   const { GEOCORE } = CONST_LAYER_ENTRY_TYPES;
 
   const [geoviewLayerInstance, setGeoviewLayerInstance] = useState();
@@ -104,7 +103,6 @@ export function AddNewLayer(): JSX.Element {
     [ESRI_FEATURE, 'ESRI Feature Service'],
     [ESRI_IMAGE, 'ESRI Image Service'],
     [GEOJSON, 'GeoJSON'],
-    [GEOPACKAGE, 'GeoPackage'],
     [WMS, 'OGC Web Map Service (WMS)'],
     [WFS, 'OGC Web Feature Service (WFS)'],
     [OGC_FEATURE, 'OGC API Features'],
@@ -712,43 +710,44 @@ export function AddNewLayer(): JSX.Element {
     return true;
   };
 
+  // TODO: refactor - add the Geopacakges when refactor is done. We keep code for reference
   /**
    * Using the layerURL state object, check whether URL is a valid GeoPackage.
    *
    * @returns {boolean} True if layer passes validation
    */
-  const geoPackageValidation = (): boolean => {
-    try {
-      // We assume a single GeoPackage file is present
-      setHasMetadata(false);
-      const geoPackageGeoviewLayerConfig = {
-        geoviewLayerType: GEOPACKAGE,
-        listOfLayerEntryConfig: [] as GeoPackageLayerEntryConfig[],
-      } as TypeGeoPackageLayerConfig;
-      const geopackageGeoviewLayerInstance = new GeoPackage(mapId, geoPackageGeoviewLayerConfig);
-      // Synchronize the geoviewLayerId.
-      geoPackageGeoviewLayerConfig.geoviewLayerId = geopackageGeoviewLayerInstance.geoviewLayerId;
-      setGeoviewLayerInstance(geopackageGeoviewLayerInstance);
-      const layers = [
-        new GeoPackageLayerEntryConfig({
-          geoviewLayerConfig: geoPackageGeoviewLayerConfig,
-          layerId: geoPackageGeoviewLayerConfig.geoviewLayerId,
-          layerName: '',
-          source: {
-            dataAccessPath: layerURL,
-          },
-        } as GeoPackageLayerEntryConfig),
-      ];
-      setLayerName(layers[0].layerName!);
-      setLayerEntries([layers[0]]);
-    } catch (error) {
-      emitErrorServer('GeoPackage');
-      // Log error
-      logger.logError(error);
-      return false;
-    }
-    return true;
-  };
+  // const geoPackageValidation = (): boolean => {
+  // try {
+  //   // We assume a single GeoPackage file is present
+  //   setHasMetadata(false);
+  //   const geoPackageGeoviewLayerConfig = {
+  //     geoviewLayerType: GEOPACKAGE,
+  //     listOfLayerEntryConfig: [] as GeoPackageLayerEntryConfig[],
+  //   } as TypeGeoPackageLayerConfig;
+  //   const geopackageGeoviewLayerInstance = new GeoPackage(mapId, geoPackageGeoviewLayerConfig);
+  //   // Synchronize the geoviewLayerId.
+  //   geoPackageGeoviewLayerConfig.geoviewLayerId = geopackageGeoviewLayerInstance.geoviewLayerId;
+  //   setGeoviewLayerInstance(geopackageGeoviewLayerInstance);
+  //   const layers = [
+  //     new GeoPackageLayerEntryConfig({
+  //       geoviewLayerConfig: geoPackageGeoviewLayerConfig,
+  //       layerId: geoPackageGeoviewLayerConfig.geoviewLayerId,
+  //       layerName: '',
+  //       source: {
+  //         dataAccessPath: layerURL,
+  //       },
+  //     } as GeoPackageLayerEntryConfig),
+  //   ];
+  //   setLayerName(layers[0].layerName!);
+  //   setLayerEntries([layers[0]]);
+  // } catch (error) {
+  //   emitErrorServer('GeoPackage');
+  //   // Log error
+  //   logger.logError(error);
+  //   return false;
+  // }
+  // return true;
+  // };
 
   /**
    * Attempt to determine the layer type based on the URL format
@@ -769,8 +768,6 @@ export function AddNewLayer(): JSX.Element {
       setLayerType(WFS);
     } else if (displayURL.toUpperCase().endsWith('.JSON') || displayURL.toUpperCase().endsWith('.GEOJSON')) {
       setLayerType(GEOJSON);
-    } else if (displayURL.toUpperCase().endsWith('.GPKG')) {
-      setLayerType(GEOPACKAGE);
     } else if (displayURL.toUpperCase().indexOf('{Z}/{X}/{Y}') !== -1 || displayURL.toUpperCase().indexOf('{Z}/{Y}/{X}') !== -1) {
       setLayerType(XYZ_TILES);
     } else if (displayURL.indexOf('/') === -1 && displayURL.replaceAll('-', '').length === 32) {
@@ -818,7 +815,6 @@ export function AddNewLayer(): JSX.Element {
     else if (layerType === ESRI_FEATURE) promise = esriValidation(ESRI_FEATURE);
     else if (layerType === ESRI_IMAGE) promise = esriImageValidation();
     else if (layerType === GEOJSON) promise = geoJSONValidation();
-    else if (layerType === GEOPACKAGE) promise = Promise.resolve(geoPackageValidation());
     else if (layerType === GEOCORE) promise = geocoreValidation();
     else if (layerType === CSV) promise = csvValidation();
 
diff --git a/packages/geoview-core/src/core/components/layers/right-panel/layer-details.tsx b/packages/geoview-core/src/core/components/layers/right-panel/layer-details.tsx
index b576bc3824e..734c85b67ea 100644
--- a/packages/geoview-core/src/core/components/layers/right-panel/layer-details.tsx
+++ b/packages/geoview-core/src/core/components/layers/right-panel/layer-details.tsx
@@ -123,17 +123,18 @@ export function LayerDetails(props: LayerDetailsProps): JSX.Element {
   };
 
   function renderItemCheckbox(item: TypeLegendItem): JSX.Element | null {
-    // no checkbox for simple style layers
-    if (
-      layerDetails.styleConfig?.LineString?.type === 'simple' ||
-      layerDetails.styleConfig?.MultiLineString?.type === 'simple' ||
-      layerDetails.styleConfig?.Point?.type === 'simple' ||
-      layerDetails.styleConfig?.MultiPoint?.type === 'simple' ||
-      layerDetails.styleConfig?.Polygon?.type === 'simple' ||
-      layerDetails.styleConfig?.MultiPolygon?.type === 'simple'
-    ) {
+    // First check if styleConfig exists
+    if (!layerDetails.styleConfig) {
       return null;
     }
+
+    // No checkbox for simple style layers
+    if (layerDetails.styleConfig[item.geometryType]?.type === 'simple') return null;
+
+    // GV: Some esri layer has uniqueValue renderer but there is no field define in their metadata (i.e. e2424b6c-db0c-4996-9bc0-2ca2e6714d71).
+    // For these layers, we need to disable checkboxes
+    if (layerDetails.styleConfig[item.geometryType]?.fields[0] === undefined) return null;
+
     if (!layerDetails.canToggle) {
       return (
         
@@ -177,6 +178,7 @@ export function LayerDetails(props: LayerDetailsProps): JSX.Element {
             key={`${item.name}/${layerDetails.items.indexOf(item)}`}
             alignItems="center"
             justifyItems="stretch"
+            sx={{ display: 'flex', flexWrap: 'nowrap' }}
           >
             {renderItemCheckbox(item)}
             
diff --git a/packages/geoview-core/src/core/stores/store-interface-and-intial-values/layer-state.ts b/packages/geoview-core/src/core/stores/store-interface-and-intial-values/layer-state.ts
index e64addf4f2b..065eabcb4ac 100644
--- a/packages/geoview-core/src/core/stores/store-interface-and-intial-values/layer-state.ts
+++ b/packages/geoview-core/src/core/stores/store-interface-and-intial-values/layer-state.ts
@@ -115,6 +115,12 @@ export function initializeLayerState(set: TypeSetStore, get: TypeGetStore): ILay
 
         // Check if EsriDynamic config
         if (layerConfig && layerEntryIsEsriDynamic(layerConfig)) {
+          // Get oid field
+          const oidField =
+            layerConfig.source.featureInfo && layerConfig.source.featureInfo.outfields
+              ? layerConfig.source.featureInfo.outfields.filter((field) => field.type === 'oid')[0].name
+              : 'OBJECTID';
+
           // Query for the specific object ids
           // TODO: Put the server original projection in the config metadata (add a new optional param in source for esri)
           // TO.DOCONT: When we get the projection we can get the projection in original server (will solve error trying to reproject https://maps-cartes.ec.gc.ca/arcgis/rest/services/CESI/MapServer/7 in 3857)
@@ -123,7 +129,7 @@ export function initializeLayerState(set: TypeSetStore, get: TypeGetStore): ILay
             `${layerConfig.source?.dataAccessPath}/${layerConfig.layerId}`,
             geometryType,
             objectIDs,
-            'OBJECTID',
+            oidField,
             true,
             MapEventProcessor.getMapState(get().mapId).currentProjection
           );
diff --git a/packages/geoview-core/src/core/workers/abstract-worker-pool.ts b/packages/geoview-core/src/core/workers/abstract-worker-pool.ts
new file mode 100644
index 00000000000..fa32159c924
--- /dev/null
+++ b/packages/geoview-core/src/core/workers/abstract-worker-pool.ts
@@ -0,0 +1,58 @@
+import { AbstractWorker } from './abstract-worker';
+
+/**
+ * Abstract base class for managing a pool of workers.
+ * Provides common functionality for worker pool management.
+ * @template T - The type of worker being managed
+ */
+export abstract class AbstractWorkerPool {
+  /** Array of worker instances in the pool */
+  protected workers: AbstractWorker[] = [];
+
+  /** Set of currently busy workers */
+  protected busyWorkers = new Set>();
+
+  /** Constructor function for creating new worker instances */
+  protected WorkerClass: new () => AbstractWorker;
+
+  /** Name identifier for the worker pool */
+  protected name: string;
+
+  /**
+   * Creates an instance of AbstractWorkerPool.
+   * @param {string} name - Name identifier for the worker pool
+   * @param {new () => AbstractWorker} workerClass - Constructor for creating worker instances
+   * @param {number} numWorkers - Number of workers to initialize in the pool
+   */
+  constructor(name: string, workerClass: new () => AbstractWorker, numWorkers = navigator.hardwareConcurrency || 4) {
+    this.name = name;
+    this.WorkerClass = workerClass;
+    this.initializeWorkers(numWorkers);
+  }
+
+  /**
+   * Initializes the specified number of workers in the pool.
+   * @param {number} numWorkers - Number of workers to create
+   * @returns {void}
+   */
+  protected initializeWorkers(numWorkers: number): void {
+    for (let i = 0; i < numWorkers; i++) {
+      const worker = new this.WorkerClass();
+      this.workers.push(worker);
+    }
+  }
+
+  /**
+   * Gets an available worker from the pool.
+   * @returns {AbstractWorker | undefined}
+   */
+  protected getAvailableWorker(): AbstractWorker | undefined {
+    return this.workers.find((w) => !this.busyWorkers.has(w));
+  }
+
+  public terminate(): void {
+    this.workers.forEach((worker) => worker.terminate());
+    this.workers = [];
+    this.busyWorkers.clear();
+  }
+}
diff --git a/packages/geoview-core/src/core/workers/abstract-worker.ts b/packages/geoview-core/src/core/workers/abstract-worker.ts
index 26369a7ec48..7a9312abc08 100644
--- a/packages/geoview-core/src/core/workers/abstract-worker.ts
+++ b/packages/geoview-core/src/core/workers/abstract-worker.ts
@@ -83,14 +83,14 @@ export abstract class AbstractWorker {
    * @param args - Arguments to pass to the worker for initialization.
    * @returns A promise that resolves when the worker is initialized.
    */
-  protected abstract init(...args: unknown[]): Promise;
+  public abstract init(...args: unknown[]): Promise;
 
   /**
    * Process the worker. This method should be implemented by subclasses.
    * @param args - Arguments to pass to the worker for process.
    * @returns A promise that resolves when the worker is processed.
    */
-  protected abstract process(...args: unknown[]): Promise;
+  public abstract process(...args: unknown[]): Promise;
 
   /**
    * Terminates the worker.
diff --git a/packages/geoview-core/src/core/workers/fetch-esri-worker-pool.ts b/packages/geoview-core/src/core/workers/fetch-esri-worker-pool.ts
new file mode 100644
index 00000000000..adc4ce91a31
--- /dev/null
+++ b/packages/geoview-core/src/core/workers/fetch-esri-worker-pool.ts
@@ -0,0 +1,64 @@
+import { AbstractWorkerPool } from './abstract-worker-pool';
+import { FetchEsriWorker, FetchEsriWorkerType } from './fetch-esri-worker';
+import { QueryParams } from './fetch-esri-worker-script';
+import { createWorkerLogger } from './helper/logger-worker';
+
+import { TypeJsonObject } from '@/api/config/types/config-types';
+
+/**
+ * Worker pool for managing ESRI fetch operations.
+ * Extends AbstractWorkerPool to handle concurrent ESRI service requests.
+ *
+ * @class FetchEsriWorkerPool
+ * @extends {AbstractWorkerPool}
+ */
+export class FetchEsriWorkerPool extends AbstractWorkerPool {
+  // Logger instance for the fetch ESRI worker pool
+  #logger = createWorkerLogger('FetchEsriWorkerPool');
+
+  /**
+   * Creates an instance of FetchEsriWorkerPool.
+   * @param {number} [numWorkers=navigator.hardwareConcurrency || 4] - Number of workers to create in the pool
+   */
+  constructor(numWorkers = navigator.hardwareConcurrency || 4) {
+    super('FetchEsriWorkerPool', FetchEsriWorker, numWorkers);
+    this.#logger.logInfo('Worker pool created', `Number of workers: ${numWorkers}`);
+  }
+
+  /**
+   * Initializes all workers in the pool.
+   * @async
+   * @returns {Promise}
+   * @throws {Error} When worker initialization fails
+   */
+  public async init(): Promise {
+    try {
+      await Promise.all(this.workers.map((worker) => worker.init()));
+      this.#logger.logTrace('Worker pool initialized');
+    } catch (error) {
+      this.#logger.logError('Worker pool initialization failed', error);
+      throw error;
+    }
+  }
+
+  /**
+   * Processes an ESRI query using an available worker from the pool.
+   * @param {QueryParams} params - Parameters for the ESRI query
+   * @returns {Promise} The query results
+   * @throws {Error} When no workers are available or query processing fails
+   */
+  public async process(params: QueryParams): Promise {
+    const availableWorker = this.workers.find((w) => !this.busyWorkers.has(w));
+    if (!availableWorker) {
+      throw new Error('No available workers');
+    }
+
+    try {
+      this.busyWorkers.add(availableWorker);
+      const result = await availableWorker.process(params);
+      return result as TypeJsonObject;
+    } finally {
+      this.busyWorkers.delete(availableWorker);
+    }
+  }
+}
diff --git a/packages/geoview-core/src/core/workers/fetch-esri-worker-script.ts b/packages/geoview-core/src/core/workers/fetch-esri-worker-script.ts
new file mode 100644
index 00000000000..b229e5db2dd
--- /dev/null
+++ b/packages/geoview-core/src/core/workers/fetch-esri-worker-script.ts
@@ -0,0 +1,90 @@
+import { expose } from 'comlink';
+
+import { createWorkerLogger } from './helper/logger-worker';
+import { TypeJsonObject } from '@/api/config/types/config-types';
+
+/**
+ * This worker script is designed to be used with the FetchEsriWorker class.
+ * It handles the transformation of fetch of features from ArcGIS server.
+ *
+ * The main operations are:
+ * 1. Initialization: Set up the worker, empty for now.
+ * 2. Processing: Fetch the server and return the JSON.
+ */
+
+/**
+ * Interface for ESRI query parameters
+ * @interface QueryParams
+ * @property {string} url - The URL of the ESRI service endpoint
+ * @property {string} geometryType - The type of geometry being queried
+ * @property {number[]} objectIds - Array of object IDs to query
+ * @property {boolean} queryGeometry - Whether to include geometry in the query
+ * @property {number} projection - The spatial reference ID for the output
+ * @property {number} maxAllowableOffset - The maximum allowable offset for geometry simplification
+ */
+export interface QueryParams {
+  url: string;
+  geometryType: string;
+  objectIds: number[];
+  queryGeometry: boolean;
+  projection: number;
+  maxAllowableOffset: number;
+}
+
+// Initialize the worker logger
+const logger = createWorkerLogger('FetchEsriWorker');
+
+/**
+ * Queries features from an ESRI service
+ * @async
+ * @param {QueryParams} params - The parameters for the ESRI query
+ * @returns {Promise} A promise that resolves to the query results
+ * @throws {Error} When the HTTP request fails
+ */
+async function queryEsriFeatures(params: QueryParams): Promise {
+  // Move the ESRI query function directly into the worker to avoid circular dependencies
+  const urlParam = `?objectIds=${params.objectIds}&outFields=*&returnGeometry=${params.queryGeometry}&outSR=${params.projection}&geometryPrecision=1&maxAllowableOffset=${params.maxAllowableOffset}&f=json`;
+
+  const identifyResponse = await fetch(`${params.url}/query${urlParam}`);
+  const identifyJsonResponse = await identifyResponse.json();
+
+  return identifyJsonResponse;
+}
+
+/**
+ * The main worker object containing methods for initialization and processing.
+ */
+const worker = {
+  /**
+   * Initializes the worker.
+   */
+  init(): void {
+    try {
+      logger.logTrace('FetchEsriWorker initialized');
+    } catch {
+      logger.logError('FetchEsriWorker failed to initialize');
+    }
+  },
+
+  /**
+   * Processes an ESRI query request
+   * @param {QueryParams} params - The parameters for the ESRI query
+   * @returns {Promise} A promise that resolves to the query results
+   * @throws {Error} When the query processing fails
+   */
+  process(params: QueryParams): Promise {
+    try {
+      logger.logTrace('Starting query processing', JSON.stringify(params));
+      const response = queryEsriFeatures(params);
+      logger.logTrace('Query completed');
+      return response;
+    } catch (error) {
+      logger.logError('Query processing failed', error);
+      throw error;
+    }
+  },
+};
+
+// Expose the worker methods to be accessible from the main thread
+expose(worker);
+export default {} as typeof Worker & { new (): Worker };
diff --git a/packages/geoview-core/src/core/workers/fetch-esri-worker.ts b/packages/geoview-core/src/core/workers/fetch-esri-worker.ts
new file mode 100644
index 00000000000..309a07c1c75
--- /dev/null
+++ b/packages/geoview-core/src/core/workers/fetch-esri-worker.ts
@@ -0,0 +1,63 @@
+import { AbstractWorker } from './abstract-worker';
+import { QueryParams } from './fetch-esri-worker-script';
+import { TypeJsonObject } from '@/api/config/types/config-types';
+
+/**
+ * How to create a new worker:
+ *
+ * 1. Define an interface for your worker's exposed methods (init, process and other is needed)
+ * 2. Create a new class extending AbstractWorker (e.g. export class MyWorker extends AbstractWorker)
+ * 3. Create the actual worker script (my-worker-script.ts):
+ * 4. Use your new worker in the main application:
+ *    const myWorker = new MyWorker();
+ *    const result1 = await myWorker.init('test');
+ *    const result2 = await myWorker.process(42, true);
+ */
+
+/**
+ * Interface defining the methods exposed by the fetch ESRI worker.
+ */
+export interface FetchEsriWorkerType {
+  /**
+   * Initializes the worker - empty for now.
+   */
+  init: () => Promise;
+
+  /**
+   * Processes an ESRI query JSON export.
+   * @param {QueryParams} queryParams - The query parameters for the fetch.
+   * @returns {TypeJsonObject} A promise that resolves to the response fetch as JSON string.
+   */
+  process: (queryParams: QueryParams) => Promise;
+}
+
+/**
+ * Class representing a fetch ESRI worker.
+ * Extends AbstractWorker to handle fetch operations on ESRI ArcGIS server in a separate thread.
+ */
+export class FetchEsriWorker extends AbstractWorker {
+  /**
+   * Creates an instance of FetchEsriWorker.
+   * Initializes the worker with the 'fetch-esri' script.
+   */
+  constructor() {
+    super('FetchEsriWorker', new Worker(new URL('./fetch-esri-worker-script.ts', import.meta.url)));
+  }
+
+  /**
+   * Initializes the worker - empty for now.
+   * @returns A promise that resolves when initialization is complete.
+   */
+  public init(): Promise {
+    return this.proxy.init();
+  }
+
+  /**
+   * Processes a JSON fetch for an esri query.
+   * @param {QueryParams} queryParams - The query parameters for the fetch.
+   * @returns A promise that resolves to the processed JSON string.
+   */
+  public process(queryParams: QueryParams): Promise {
+    return this.proxy.process(queryParams);
+  }
+}
diff --git a/packages/geoview-core/src/core/workers/json-export-script.ts b/packages/geoview-core/src/core/workers/json-export-script.ts
index 2b82b8952bd..0d869aa9eef 100644
--- a/packages/geoview-core/src/core/workers/json-export-script.ts
+++ b/packages/geoview-core/src/core/workers/json-export-script.ts
@@ -137,9 +137,9 @@ const worker = {
     try {
       sourceCRS = projectionInfo.sourceCRS;
       targetCRS = projectionInfo.targetCRS;
-      logger.logTrace('init', `Worker initialized with sourceCRS: ${sourceCRS}, targetCRS: ${targetCRS}`);
+      logger.logTrace('init worker', `Worker initialized with sourceCRS: ${sourceCRS}, targetCRS: ${targetCRS}`);
     } catch (error) {
-      logger.logError('init', error);
+      logger.logError('init worker', error);
     }
   },
 
@@ -151,7 +151,7 @@ const worker = {
    */
   process(chunk: TypeWorkerExportChunk[], isFirst: boolean): string {
     try {
-      logger.logTrace('process', `Processing chunk of ${chunk.length} items`);
+      logger.logTrace('process worker', `Processing chunk of ${chunk.length} items`);
       let result = '';
       if (isFirst) {
         result += '{"type":"FeatureCollection","features":[';
@@ -171,10 +171,10 @@ const worker = {
 
       result += processedChunk.join(',');
 
-      logger.logTrace('process', `Finished processing`);
+      logger.logTrace('process worker', `Finished processing`);
       return result;
     } catch (error) {
-      logger.logError('process', error);
+      logger.logError('process worker', error);
       return '';
     }
   },
diff --git a/packages/geoview-core/src/geo/layer/geoview-layers/esri-layer-common.ts b/packages/geoview-core/src/geo/layer/geoview-layers/esri-layer-common.ts
index 057064a45c6..a1660e794c4 100644
--- a/packages/geoview-core/src/geo/layer/geoview-layers/esri-layer-common.ts
+++ b/packages/geoview-core/src/geo/layer/geoview-layers/esri-layer-common.ts
@@ -201,6 +201,7 @@ export function commonGetFieldType(
   if (!fieldDefinition) return 'string';
   const esriFieldType = fieldDefinition.type as string;
   if (esriFieldType === 'esriFieldTypeDate') return 'date';
+  if (esriFieldType === 'esriFieldTypeOID') return 'oid';
   if (
     ['esriFieldTypeDouble', 'esriFieldTypeInteger', 'esriFieldTypeSingle', 'esriFieldTypeSmallInteger', 'esriFieldTypeOID'].includes(
       esriFieldType
diff --git a/packages/geoview-core/src/geo/layer/geoview-layers/vector/abstract-geoview-vector.ts b/packages/geoview-core/src/geo/layer/geoview-layers/vector/abstract-geoview-vector.ts
index 712af4be75b..8e6bee1dd02 100644
--- a/packages/geoview-core/src/geo/layer/geoview-layers/vector/abstract-geoview-vector.ts
+++ b/packages/geoview-core/src/geo/layer/geoview-layers/vector/abstract-geoview-vector.ts
@@ -13,7 +13,7 @@ import { ProjectionLike } from 'ol/proj';
 import { Geometry, Point } from 'ol/geom';
 import { getUid } from 'ol/util';
 
-import { TypeOutfields } from '@config/types/map-schema-types';
+import { TypeFeatureInfoLayerConfig, TypeOutfields } from '@config/types/map-schema-types';
 
 import { api } from '@/app';
 import { AbstractGeoViewLayer, CONST_LAYER_TYPES } from '@/geo/layer/geoview-layers/abstract-geoview-layers';
@@ -147,11 +147,15 @@ export abstract class AbstractGeoViewVector extends AbstractGeoViewLayer {
             // Convert the CSV to features
             features = AbstractGeoViewVector.convertCsv(this.mapId, xhr.responseText, layerConfig as VectorLayerEntryConfig);
           } else if (layerConfig.schemaTag === CONST_LAYER_TYPES.ESRI_FEATURE) {
+            // Get oid field
+            const oidField = AbstractGeoViewVector.#getEsriOidField(layerConfig);
+
             // Fetch the features text array
             const esriFeaturesArray = await AbstractGeoViewVector.getEsriFeatures(
               layerConfig.layerPath,
               url as string,
               JSON.parse(xhr.responseText).count,
+              oidField,
               this.getLayerMetadata(layerConfig.layerPath)?.maxRecordCount as number | undefined
             );
 
@@ -178,8 +182,11 @@ export abstract class AbstractGeoViewVector extends AbstractGeoViewLayer {
                is not a number, we assume it is provided as an ISO UTC string. If not, the result is unpredictable.
             */
           if (features) {
+            // Get oid field
+            const oidField = AbstractGeoViewVector.#getEsriOidField(layerConfig);
+
             features.forEach((feature) => {
-              const featureId = feature.get('OBJECTID') ? feature.get('OBJECTID') : getUid(feature);
+              const featureId = feature.get(oidField) ? feature.get(oidField) : getUid(feature);
               feature.setId(featureId);
             });
             // If there's no feature info, build it from features
@@ -239,6 +246,7 @@ export abstract class AbstractGeoViewVector extends AbstractGeoViewLayer {
    * @param {string} layerPath - The layer path of the layer.
    * @param {string} url - The base url for the service.
    * @param {number} featureCount - The number of features in the layer.
+   * @param {string} oidField - The unique identifier field name.
    * @param {number} maxRecordCount - The max features per query from the service.
    * @param {number} featureLimit - The maximum number of features to fetch per query.
    * @param {number} queryLimit - The maximum number of queries to run at once.
@@ -252,18 +260,21 @@ export abstract class AbstractGeoViewVector extends AbstractGeoViewLayer {
     layerPath: string,
     url: string,
     featureCount: number,
+    oidField: string,
     maxRecordCount?: number,
     featureLimit: number = 500,
     queryLimit: number = 10
   ): Promise {
     // Update url
+    // TODO: Performance - Check if we should add &maxAllowableOffset=10 to the url. It creates small sliver but download size if 18mb compare to 50mb for outlier-election-2019
+    // TODO.CONT: Download time is 90 seconds compare to 130 seconds. It may worth the loss of precision...
     const baseUrl = url.replace('&where=1%3D1&returnCountOnly=true', `&outfields=*&geometryPrecision=1`);
     const featureFetchLimit = maxRecordCount && maxRecordCount < featureLimit ? maxRecordCount : featureLimit;
 
     // Create array of url's to call
     const urlArray: string[] = [];
     for (let i = 0; i < featureCount; i += featureFetchLimit) {
-      urlArray.push(`${baseUrl}&where=OBJECTID+<=+${i + featureFetchLimit}&resultOffset=${i}`);
+      urlArray.push(`${baseUrl}&where=${oidField}+<=+${i + featureFetchLimit}&resultOffset=${i}`);
     }
 
     const promises: Promise[] = [];
@@ -497,4 +508,23 @@ export abstract class AbstractGeoViewVector extends AbstractGeoViewLayer {
     if (!layerConfig.source.featureInfo.nameField)
       layerConfig.source.featureInfo.nameField = layerConfig.source.featureInfo!.outfields[0].name;
   }
+
+  /**
+   * Gets the Object ID field name from the layer configuration
+   * @param {AbstractBaseLayerEntryConfig} layerConfig - The layer configuration object
+   * @returns {string} The name of the OID field if found, otherwise returns 'OBJECTID' as default
+   * @description Extracts the Object ID field name from the layer configuration. An OID (Object ID) is a
+   * standardized identifier used to uniquely identify features in a layer. If no OID field is specified
+   * in the configuration, it defaults to 'OBJECTID'.
+   * @private
+   */
+  // TODO: We should have this function in abstract-base-layer to be called like layerConfig.getEsriOidField() - issue 2699
+  // TODO.CONT: This should be rename without the esri. The oid type should be mandatory and if not present, we should crate one.
+  // TODO.CONT: We already create the internalGeoviewId but we should make this more officiel by assigning a type of oid
+  static #getEsriOidField(layerConfig: AbstractBaseLayerEntryConfig): string {
+    // Get oid field
+    return layerConfig.source?.featureInfo && (layerConfig.source.featureInfo as TypeFeatureInfoLayerConfig).outfields !== undefined
+      ? (layerConfig.source.featureInfo as TypeFeatureInfoLayerConfig).outfields.filter((field) => field.type === 'oid')[0]?.name
+      : 'OBJECTID';
+  }
 }
diff --git a/packages/geoview-core/src/geo/layer/gv-layers/abstract-gv-layer.ts b/packages/geoview-core/src/geo/layer/gv-layers/abstract-gv-layer.ts
index 947c01b2398..a70e300f316 100644
--- a/packages/geoview-core/src/geo/layer/gv-layers/abstract-gv-layer.ts
+++ b/packages/geoview-core/src/geo/layer/gv-layers/abstract-gv-layer.ts
@@ -236,12 +236,13 @@ export abstract class AbstractGVLayer extends AbstractBaseLayer {
    * Returns feature information for the layer specified.
    * @param {QueryType} queryType - The type of query to perform.
    * @param {TypeLocation} location - An optionsl pixel, coordinate or polygon that will be used by the query.
+   * @param {boolean} queryGeometry - The query geometry boolean
    * @returns {Promise} The feature info table.
    */
   async getFeatureInfo(
     queryType: QueryType,
-    layerPath: string,
-    location: TypeLocation = null
+    location: TypeLocation = null,
+    queryGeometry: boolean = true
   ): Promise {
     // TODO: Refactor - After layers refactoring, remove the layerPath parameter here (gotta keep it in the signature for now for the layers-set active switch)
     try {
@@ -266,19 +267,19 @@ export abstract class AbstractGVLayer extends AbstractBaseLayer {
           promiseGetFeature = this.getAllFeatureInfo();
           break;
         case 'at_pixel':
-          promiseGetFeature = this.getFeatureInfoAtPixel(location as Pixel);
+          promiseGetFeature = this.getFeatureInfoAtPixel(location as Pixel, queryGeometry);
           break;
         case 'at_coordinate':
-          promiseGetFeature = this.getFeatureInfoAtCoordinate(location as Coordinate);
+          promiseGetFeature = this.getFeatureInfoAtCoordinate(location as Coordinate, queryGeometry);
           break;
         case 'at_long_lat':
-          promiseGetFeature = this.getFeatureInfoAtLongLat(location as Coordinate);
+          promiseGetFeature = this.getFeatureInfoAtLongLat(location as Coordinate, queryGeometry);
           break;
         case 'using_a_bounding_box':
-          promiseGetFeature = this.getFeatureInfoUsingBBox(location as Coordinate[]);
+          promiseGetFeature = this.getFeatureInfoUsingBBox(location as Coordinate[], queryGeometry);
           break;
         case 'using_a_polygon':
-          promiseGetFeature = this.getFeatureInfoUsingPolygon(location as Coordinate[]);
+          promiseGetFeature = this.getFeatureInfoUsingPolygon(location as Coordinate[], queryGeometry);
           break;
         default:
           // Default is empty array
@@ -315,10 +316,11 @@ export abstract class AbstractGVLayer extends AbstractBaseLayer {
   /**
    * Overridable function to return of feature information at a given pixel location.
    * @param {Coordinate} location - The pixel coordinate that will be used by the query.
+   * @param {boolean} queryGeometry - The query geometry boolean.
    * @returns {Promise} A promise of an array of TypeFeatureInfoEntry[].
    */
   // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  protected getFeatureInfoAtPixel(location: Pixel): Promise {
+  protected getFeatureInfoAtPixel(location: Pixel, queryGeometry: boolean): Promise {
     // Crash on purpose
     throw new Error(`Not implemented exception for getFeatureInfoAtPixel on layer path ${this.getLayerPath()}`);
   }
@@ -326,10 +328,11 @@ export abstract class AbstractGVLayer extends AbstractBaseLayer {
   /**
    * Overridable function to return of feature information at a given coordinate.
    * @param {Coordinate} location - The coordinate that will be used by the query.
+   * @param {boolean} queryGeometry - The query geometry boolean.
    * @returns {Promise} A promise of an array of TypeFeatureInfoEntry[].
    */
   // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  protected getFeatureInfoAtCoordinate(location: Coordinate): Promise {
+  protected getFeatureInfoAtCoordinate(location: Coordinate, queryGeometry: boolean): Promise {
     // Crash on purpose
     throw new Error(`Not implemented exception for getFeatureInfoAtCoordinate on layer path ${this.getLayerPath()}`);
   }
@@ -337,10 +340,11 @@ export abstract class AbstractGVLayer extends AbstractBaseLayer {
   /**
    * Overridable function to return of feature information at the provided long lat coordinate.
    * @param {Coordinate} lnglat - The coordinate that will be used by the query.
+   * @param {boolean} queryGeometry - The query geometry boolean
    * @returns {Promise} A promise of an array of TypeFeatureInfoEntry[].
    */
   // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  protected getFeatureInfoAtLongLat(location: Coordinate): Promise {
+  protected getFeatureInfoAtLongLat(location: Coordinate, queryGeometry: boolean): Promise {
     // Crash on purpose
     throw new Error(`Not implemented exception for getFeatureInfoAtLongLat on layer path ${this.getLayerPath()}`);
   }
@@ -348,10 +352,11 @@ export abstract class AbstractGVLayer extends AbstractBaseLayer {
   /**
    * Overridable function to return of feature information at the provided bounding box.
    * @param {Coordinate} location - The bounding box that will be used by the query.
+   * @param {boolean} queryGeometry - The query geometry boolean.
    * @returns {Promise} A promise of an array of TypeFeatureInfoEntry[].
    */
   // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  protected getFeatureInfoUsingBBox(location: Coordinate[]): Promise {
+  protected getFeatureInfoUsingBBox(location: Coordinate[], queryGeometry: boolean): Promise {
     // Crash on purpose
     throw new Error(`Not implemented exception for getFeatureInfoUsingBBox on layer path ${this.getLayerPath()}`);
   }
@@ -359,10 +364,11 @@ export abstract class AbstractGVLayer extends AbstractBaseLayer {
   /**
    * Overridable function to return of feature information at the provided polygon.
    * @param {Coordinate} location - The polygon that will be used by the query.
+   * @param {boolean} queryGeometry - The query geometry boolean.
    * @returns {Promise} A promise of an array of TypeFeatureInfoEntry[].
    */
   // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  protected getFeatureInfoUsingPolygon(location: Coordinate[]): Promise {
+  protected getFeatureInfoUsingPolygon(location: Coordinate[], queryGeometry: boolean): Promise {
     // Crash on purpose
     throw new Error(`Not implemented exception for getFeatureInfoUsingPolygon on layer path ${this.getLayerPath()}`);
   }
diff --git a/packages/geoview-core/src/geo/layer/gv-layers/raster/gv-esri-dynamic.ts b/packages/geoview-core/src/geo/layer/gv-layers/raster/gv-esri-dynamic.ts
index a2014201b40..7a3815254f8 100644
--- a/packages/geoview-core/src/geo/layer/gv-layers/raster/gv-esri-dynamic.ts
+++ b/packages/geoview-core/src/geo/layer/gv-layers/raster/gv-esri-dynamic.ts
@@ -8,7 +8,7 @@ import { Extent } from 'ol/extent';
 import Feature from 'ol/Feature';
 import Geometry from 'ol/geom/Geometry';
 
-import { validateExtent } from '@/geo/utils/utilities';
+import { getMetersPerPixel, validateExtent } from '@/geo/utils/utilities';
 import { Projection } from '@/geo/utils/projection';
 import { logger } from '@/core/utils/logger';
 import { DateMgt } from '@/core/utils/date-mgt';
@@ -24,11 +24,15 @@ import {
 } from '@/geo/map/map-schema-types';
 import { esriGetFieldType, esriGetFieldDomain } from '../utils';
 import { AbstractGVRaster } from './abstract-gv-raster';
-import { TypeOutfieldsType } from '@/api/config/types/map-schema-types';
+import { TypeOutfieldsType, TypeStyleGeometry, TypeValidMapProjectionCodes } from '@/api/config/types/map-schema-types';
 import { getLegendStyles } from '@/geo/utils/renderer/geoview-renderer';
 import { CONST_LAYER_TYPES } from '../../geoview-layers/abstract-geoview-layers';
 import { TypeLegend } from '@/core/stores/store-interface-and-intial-values/layer-state';
 import { TypeEsriImageLayerLegend } from './gv-esri-image';
+import { TypeJsonObject } from '@/api/config/types/config-types';
+import { FetchEsriWorkerPool } from '@/core/workers/fetch-esri-worker-pool';
+import { QueryParams } from '@/core/workers/fetch-esri-worker-script';
+import { GeometryApi } from '../../geometry/geometry';
 
 type TypeFieldOfTheSameValue = { value: string | number | Date; nbOccurence: number };
 type TypeQueryTree = { fieldValue: string | number | Date; nextField: TypeQueryTree }[];
@@ -40,6 +44,8 @@ type TypeQueryTree = { fieldValue: string | number | Date; nextField: TypeQueryT
  * @class GVEsriDynamic
  */
 export class GVEsriDynamic extends AbstractGVRaster {
+  #fetchWorkerPool: FetchEsriWorkerPool;
+
   // The default hit tolerance the query should be using
   static override DEFAULT_HIT_TOLERANCE: number = 7;
 
@@ -55,12 +61,38 @@ export class GVEsriDynamic extends AbstractGVRaster {
   public constructor(mapId: string, olSource: ImageArcGISRest, layerConfig: EsriDynamicLayerEntryConfig) {
     super(mapId, olSource, layerConfig);
 
+    // TODO: Performance - Do we need worker pool or one worker per layer is enough. If a worker is already working we should terminate it
+    // TODO.CONT: and use the abort controller to cancel the fetch and start a new one. So every esriDynamic layer has it's own worker.
+    // Setup the worker pool
+    this.#fetchWorkerPool = new FetchEsriWorkerPool();
+    this.#fetchWorkerPool
+      .init()
+      .then(() => logger.logTraceCore('Worker pool for fetch ESRI initialized'))
+      .catch((err) => logger.logError('Worker pool error', err));
+
+    // TODO: Performance - Investigate to see if we can call the export map for the whole service at once instead of making many call
+    // TODO.CONT: We can use the layers and layersDef parameters to set what should be visible.
+    // TODO.CONT: layers=show:layerId ; layerDefs={ "layerId": "layer def" }
+    // TODO.CONT: There is no allowableOffset on esri dynamic to speed up. We will need to see what can be done for layers in wrong projection
+    // TODO.CONT: We may try to use the service projection imageLayerOptions.source?.updateParams({ imageSR: 3978 }); and let OL project on the fly
+    // TODO.CONT: from some test, it reduce time by half
     // Create the image layer options.
     const imageLayerOptions: ImageOptions = {
       source: olSource,
       properties: { layerConfig },
     };
 
+    // TODO: Performance - For testing purpose on projection and performance
+    if (layerConfig.geoviewLayerConfig.geoviewLayerId === '6c343726-1e92-451a-876a-76e17d398a1c') {
+      imageLayerOptions.source?.updateParams({ imageSR: 3978 });
+    }
+    if (layerConfig.geoviewLayerConfig.geoviewLayerId === 'e2424b6c-db0c-4996-9bc0-2ca2e6714d71') {
+      imageLayerOptions.source?.updateParams({ imageSR: 3857 });
+    }
+    if (layerConfig.geoviewLayerConfig.geoviewLayerId === '1dcd28aa-99da-4f62-b157-15631379b170') {
+      imageLayerOptions.source?.updateParams({ imageSR: 4269 });
+    }
+
     // Init the layer options with initial settings
     AbstractGVRaster.initOptionsWithInitialSettings(imageLayerOptions, layerConfig);
 
@@ -221,32 +253,77 @@ export class GVEsriDynamic extends AbstractGVRaster {
   /**
    * Overrides the return of feature information at a given pixel location.
    * @param {Coordinate} location - The pixel coordinate that will be used by the query.
+   * @param {boolean} queryGeometry - The query geometry boolean.
    * @returns {Promise} A promise of an array of TypeFeatureInfoEntry[].
    */
-  protected override getFeatureInfoAtPixel(location: Pixel): Promise {
+  protected override getFeatureInfoAtPixel(
+    location: Pixel,
+    queryGeometry: boolean = true
+  ): Promise {
     // Redirect to getFeatureInfoAtCoordinate
-    return this.getFeatureInfoAtCoordinate(this.getMapViewer().map.getCoordinateFromPixel(location));
+    return this.getFeatureInfoAtCoordinate(this.getMapViewer().map.getCoordinateFromPixel(location), queryGeometry);
   }
 
   /**
    * Overrides the return of feature information at a given coordinate.
    * @param {Coordinate} location - The coordinate that will be used by the query.
+   * @param {boolean} queryGeometry - The query geometry boolean.
    * @returns {Promise} A promise of an array of TypeFeatureInfoEntry[].
    */
-  protected override getFeatureInfoAtCoordinate(location: Coordinate): Promise {
+  protected override getFeatureInfoAtCoordinate(
+    location: Coordinate,
+    queryGeometry: boolean = true
+  ): Promise {
     // Transform coordinate from map project to lntlat
     const projCoordinate = this.getMapViewer().convertCoordinateMapProjToLngLat(location);
 
     // Redirect to getFeatureInfoAtLongLat
-    return this.getFeatureInfoAtLongLat(projCoordinate);
+    return this.getFeatureInfoAtLongLat(projCoordinate, queryGeometry);
+  }
+
+  /**
+   * Query the features geometry with a web worker
+   * @param {EsriDynamicLayerEntryConfig} layerConfig - The layer config
+   * @param {number[]} objectIds - Array of object IDs to query
+   * @param {boolean} queryGeometry - Whether to include geometry in the query
+   * @param {number} projection - The spatial reference ID for the output
+   * @param {number} maxAllowableOffset - The maximum allowable offset for geometry simplification
+   * @returns {TypeJsonObject} A promise of esri response for query.
+   */
+  async fetchFeatureInfoGeometryWithWorker(
+    layerConfig: EsriDynamicLayerEntryConfig,
+    objectIds: number[],
+    queryGeometry: boolean,
+    projection: number,
+    maxAllowableOffset: number
+  ): Promise {
+    try {
+      const params: QueryParams = {
+        url: layerConfig.source.dataAccessPath + layerConfig.layerId,
+        geometryType: (layerConfig.getLayerMetadata()!.geometryType as string).replace('esriGeometry', ''),
+        objectIds,
+        queryGeometry,
+        projection,
+        maxAllowableOffset,
+      };
+
+      return await this.#fetchWorkerPool.process(params);
+    } catch (error) {
+      logger.logError('Query processing failed:', error);
+      throw error;
+    }
   }
 
   /**
    * Overrides the return of feature information at the provided long lat coordinate.
    * @param {Coordinate} lnglat - The coordinate that will be used by the query.
+   * @param {boolean} queryGeometry - The query geometry boolean.
    * @returns {Promise} A promise of an array of TypeFeatureInfoEntry[].
    */
-  protected override async getFeatureInfoAtLongLat(lnglat: Coordinate): Promise {
+  protected override async getFeatureInfoAtLongLat(
+    lnglat: Coordinate,
+    queryGeometry: boolean = true
+  ): Promise {
     try {
       // If invisible
       if (!this.getVisible()) return [];
@@ -254,7 +331,7 @@ export class GVEsriDynamic extends AbstractGVRaster {
       // Get the layer config in a loaded phase
       const layerConfig = this.getLayerConfig();
 
-      // If not queryable
+      // If not queryable or there no url access path to query return []
       if (!layerConfig.source.featureInfo?.queryable) return [];
 
       let identifyUrl = layerConfig.source.dataAccessPath;
@@ -263,37 +340,116 @@ export class GVEsriDynamic extends AbstractGVRaster {
       identifyUrl = identifyUrl.endsWith('/') ? identifyUrl : `${identifyUrl}/`;
 
       // GV: We cannot directly use the view extent and reproject. If we do so some layers (issue #2413) identify will return empty resultset
-      // GV-CONT: This happen with max extent as initial extent and 3978 projection. If we use only the LL and UP corners for the repojection it works
+      // GV.CONT: This happen with max extent as initial extent and 3978 projection. If we use only the LL and UP corners for the repojection it works
       const mapViewer = this.getMapViewer();
       const mapExtent = mapViewer.getView().calculateExtent();
       const boundsLL = mapViewer.convertCoordinateMapProjToLngLat([mapExtent[0], mapExtent[1]]);
       const boundsUR = mapViewer.convertCoordinateMapProjToLngLat([mapExtent[2], mapExtent[3]]);
       const extent = { xmin: boundsLL[0], ymin: boundsLL[1], xmax: boundsUR[0], ymax: boundsUR[1] };
-
       const layerDefs = this.getOLSource()?.getParams()?.layerDefs || '';
       const size = mapViewer.map.getSize()!;
 
+      // Identify query to get oid features value and attributes, at this point we do not query geometry
       identifyUrl =
         `${identifyUrl}identify?f=json&tolerance=${this.hitTolerance}` +
         `&mapExtent=${extent.xmin},${extent.ymin},${extent.xmax},${extent.ymax}` +
         `&imageDisplay=${size[0]},${size[1]},96` +
         `&layers=visible:${layerConfig.layerId}` +
         `&layerDefs=${layerDefs}` +
-        `&returnFieldName=true&sr=4326&returnGeometry=true` +
-        `&geometryType=esriGeometryPoint&geometry=${lnglat[0]},${lnglat[1]}`;
+        `&geometryType=esriGeometryPoint&geometry=${lnglat[0]},${lnglat[1]}` +
+        `&returnGeometry=false&sr=4326&returnFieldName=true`;
 
-      const response = await fetch(identifyUrl);
-      const jsonResponse = await response.json();
-      if (jsonResponse.error) {
+      const identifyResponse = await fetch(identifyUrl);
+      const identifyJsonResponse = await identifyResponse.json();
+      if (identifyJsonResponse.error) {
         logger.logInfo('There is a problem with this query: ', identifyUrl);
-        throw new Error(`Error code = ${jsonResponse.error.code} ${jsonResponse.error.message}` || '');
+        throw new Error(`Error code = ${identifyJsonResponse.error.code} ${identifyJsonResponse.error.message}` || '');
       }
 
-      const features = new EsriJSON().readFeatures(
-        { features: jsonResponse.results },
-        { dataProjection: Projection.PROJECTION_NAMES.LNGLAT, featureProjection: mapViewer.getProjection().getCode() }
-      ) as Feature[];
+      // If no features identified return []
+      if (identifyJsonResponse.results.length === 0) return [];
+
+      // Extract OBJECTIDs
+      const oidField = layerConfig.source.featureInfo.outfields
+        ? layerConfig.source.featureInfo.outfields.filter((field) => field.type === 'oid')[0].name
+        : 'OBJECTID';
+      const objectIds = identifyJsonResponse.results.map((result: TypeJsonObject) => String(result.attributes[oidField]).replace(',', ''));
+
+      // Get meters per pixel to set the maxAllowableOffset to simplify return geometry
+      const maxAllowableOffset = queryGeometry
+        ? getMetersPerPixel(
+            mapViewer.getMapState().currentProjection as TypeValidMapProjectionCodes,
+            mapViewer.getView().getResolution() || 7000,
+            lnglat[1]
+          )
+        : 0;
+
+      // TODO: Performance - We need to separate the query attribute from geometry. We can use the attributes returned by identify to show details panel
+      // TODO.CONT: or create 2 distinc query one for attributes and one for geometry. This way we can display the panel faster and wait later for geometry
+      // TODO.CONT: We need to see if we can fetch in async mode without freezing the ui. If not we will need a web worker for the fetch.
+      // TODO.CONT: If we go with web worker, we need a reusable approach so we can use with all our queries
+      // Get features
+      // const response = await esriQueryRecordsByUrlObjectIds(
+      //   layerConfig.source.dataAccessPath + layerConfig.layerId,
+      //   (layerConfig.getLayerMetadata()!.geometryType as string).replace('esriGeometry', '') as TypeStyleGeometry,
+      //   objectIds,
+      //   '*',
+      //   false,
+      //   mapViewer.getMapState().currentProjection,
+      //   maxAllowableOffset,
+      //   false
+      // );
+
+      // TODO: Performance - This is also time consuming, the creation of the feature can take several seconds, check web worker
+      // TODO.CONT: Because web worker can only use sereialize date and not object with function it may be difficult for this...
+      // TODO.CONT: For the moment, the feature is created without a geometry. This should be added by web worker
+      // TODO.CONT: Splitting the query will help avoid layer details error when geometry is big anf let ui not frezze. The Web worker
+      // TODO.CONT: geometry assignement must not be in an async function.
+      // Transform the features in an OL feature - at this point, there is no geometry associated with the feature
+      const features = new EsriJSON().readFeatures({ features: identifyJsonResponse.results }) as Feature[];
       const arrayOfFeatureInfoEntries = await this.formatFeatureInfoResult(features, layerConfig);
+
+      // If geometry is needed, use web worker to query and assign geometry later
+      if (queryGeometry)
+        // TODO: Performance - We may need to use chunk and process 50 geom at a time. When we query 500 features (points) we have CORS issue with
+        // TODO.CONT: the esri query (was working with identify). But identify was failing on huge geometry...
+        this.fetchFeatureInfoGeometryWithWorker(layerConfig, objectIds, true, mapViewer.getMapState().currentProjection, maxAllowableOffset)
+          .then((featuresJSON) => {
+            (featuresJSON.features as TypeJsonObject[]).forEach((feat: TypeJsonObject, index: number) => {
+              // TODO: Performance - There is still a problem when we create the feature with new EsriJSON().readFeature. It goes trought a loop and take minutes on the deflate function
+              // TODO.CONT: 1dcd28aa-99da-4f62-b157-15631379b170, ocean biology layer has huge amount of verticies and when zoomed in we require more
+              // TODO.CONT: more definition so the feature creation take more time. Investigate if we can create the geometry instead
+              // TODO.CONT: Investigate using this approach in esri-feature.ts
+              // const geom = new EsriJSON().readFeature(feat, {
+              //   dataProjection: `EPSG:${mapViewer.getMapState().currentProjection}`,
+              //   featureProjection: `EPSG:${mapViewer.getMapState().currentProjection}`,
+              // }) as Feature;
+
+              // TODO: Performance - Relying on style to get geometry is not good. We shold extract it from metadata and keep it in dedicated attribute
+              const geomType = Object.keys(layerConfig?.layerStyle || []);
+
+              // Get coordinates in right format and create geometry
+              const coordinates = (feat.geometry?.points ||
+                feat.geometry?.paths ||
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                feat.geometry?.rings || [feat.geometry?.x, feat.geometry?.y]) as any; // MultiPoint or Line or Polygon or Point schema
+              const newGeom: Geometry | null =
+                geomType.length > 0
+                  ? (GeometryApi.createGeometryFromType(geomType[0] as TypeStyleGeometry, coordinates) as unknown as Geometry)
+                  : null;
+
+              // TODO: Perfromance - We will need a trigger to refresh the higight and detaiils panel (for zoom button) when extent and
+              // TODO.CONT: is applied. Sometime the delay is too big so we need to change tab or layer in layer list to trigger the refresh
+              // We assume order of arrayOfFeatureInfoEntries is the same as featuresJSON.features as they are process in same order
+              const entry = arrayOfFeatureInfoEntries![index];
+              if (newGeom !== null && entry.geometry && entry.geometry instanceof Feature) {
+                entry.extent = newGeom.getExtent();
+                entry.geometry.setGeometry(newGeom);
+              }
+            });
+          })
+          .catch((err) => logger.logError('Features worker', err));
+
       return arrayOfFeatureInfoEntries;
     } catch (error) {
       // Log
diff --git a/packages/geoview-core/src/geo/layer/gv-layers/utils.ts b/packages/geoview-core/src/geo/layer/gv-layers/utils.ts
index 5afd261026b..755da694f64 100644
--- a/packages/geoview-core/src/geo/layer/gv-layers/utils.ts
+++ b/packages/geoview-core/src/geo/layer/gv-layers/utils.ts
@@ -43,6 +43,7 @@ export function esriGetFieldType(
   if (!fieldDefinition) return 'string';
   const esriFieldType = fieldDefinition.type as string;
   if (esriFieldType === 'esriFieldTypeDate') return 'date';
+  if (esriFieldType === 'esriFieldTypeOID') return 'oid';
   if (
     ['esriFieldTypeDouble', 'esriFieldTypeInteger', 'esriFieldTypeSingle', 'esriFieldTypeSmallInteger', 'esriFieldTypeOID'].includes(
       esriFieldType
@@ -105,10 +106,15 @@ export function esriParseFeatureInfoEntries(records: TypeJsonObject[], geometryT
  * Asynchronously queries an Esri feature layer given the url and returns an array of `TypeFeatureInfoEntryPartial` records.
  * @param {string} url - An Esri url indicating a feature layer to query
  * @param {TypeStyleGeometry?} geometryType - The geometry type for the geometries in the layer being queried (used when geometries are returned)
+ * @param {boolean} parseFeatureInfoEntries - A boolean to indicate if we use the raw esri output or if we parse it
  * @returns {TypeFeatureInfoEntryPartial[] | null} An array of relared records of type TypeFeatureInfoEntryPartial, or an empty array.
  */
-export async function esriQueryRecordsByUrl(url: string, geometryType?: TypeStyleGeometry): Promise {
-  // TODO: Refactor - Suggestion to rework this function and the one in EsriDynamic.getFeatureInfoAtLongLat(), making
+export async function esriQueryRecordsByUrl(
+  url: string,
+  geometryType?: TypeStyleGeometry,
+  parseFeatureInfoEntries = true
+): Promise {
+  // TODO: Performance - Refactor - Suggestion to rework this function and the one in EsriDynamic.getFeatureInfoAtLongLat(), making
   // TO.DO.CONT: the latter redirect to this one here and merge some logic between the 2 functions ideally making this
   // TO.DO.CONT: one here return a TypeFeatureInfoEntry[] with options to have returnGeometry=true or false and such.
   // Query the data
@@ -120,8 +126,8 @@ export async function esriQueryRecordsByUrl(url: string, geometryType?: TypeStyl
       throw new Error(`Error code = ${respJson.error.code} ${respJson.error.message}` || '');
     }
 
-    // Return the array of TypeFeatureInfoEntryPartial
-    return esriParseFeatureInfoEntries(respJson.features, geometryType);
+    // Return the array of TypeFeatureInfoEntryPartial or the raw response features array
+    return parseFeatureInfoEntries ? esriParseFeatureInfoEntries(respJson.features, geometryType) : respJson.features;
   } catch (error) {
     // Log
     logger.logError('There is a problem with this query: ', url, error);
@@ -137,6 +143,8 @@ export async function esriQueryRecordsByUrl(url: string, geometryType?: TypeStyl
  * @param {string} fields - The list of field names to include in the output
  * @param {boolean} geometry - True to return the geometries in the output
  * @param {number} outSR - The spatial reference of the output geometries from the query
+ * @param {number} maxOffset - The max allowable offset value to simplify geometry
+ * @param {boolean} parseFeatureInfoEntries - A boolean to indicate if we use the raw esri output or if we parse it
  * @returns {TypeFeatureInfoEntryPartial[] | null} An array of relared records of type TypeFeatureInfoEntryPartial, or an empty array.
  */
 export function esriQueryRecordsByUrlObjectIds(
@@ -145,14 +153,19 @@ export function esriQueryRecordsByUrlObjectIds(
   objectIds: number[],
   fields: string,
   geometry: boolean,
-  outSR?: number
+  outSR?: number,
+  maxOffset?: number,
+  parseFeatureInfoEntries = true
 ): Promise {
+  // Offset
+  const offset = maxOffset !== undefined ? `&maxAllowableOffset=${maxOffset}` : '';
+
   // Query
   const oids = objectIds.join(',');
-  const url = `${layerUrl}/query?where=&objectIds=${oids}&outFields=${fields}&returnGeometry=${geometry}&outSR=${outSR}&geometryPrecision=1&f=json`;
+  const url = `${layerUrl}/query?&objectIds=${oids}&outFields=${fields}&returnGeometry=${geometry}&outSR=${outSR}&geometryPrecision=1${offset}&f=json`;
 
   // Redirect
-  return esriQueryRecordsByUrl(url, geometryType);
+  return esriQueryRecordsByUrl(url, geometryType, parseFeatureInfoEntries);
 }
 
 /**
diff --git a/packages/geoview-core/src/geo/layer/layer-sets/abstract-layer-set.ts b/packages/geoview-core/src/geo/layer/layer-sets/abstract-layer-set.ts
index 6f8b2142ef5..376cbb870cf 100644
--- a/packages/geoview-core/src/geo/layer/layer-sets/abstract-layer-set.ts
+++ b/packages/geoview-core/src/geo/layer/layer-sets/abstract-layer-set.ts
@@ -393,16 +393,18 @@ export abstract class AbstractLayerSet {
    * @param {AbstractGVLayer} geoviewLayer - The geoview layer
    * @param {QueryType} queryType - The query type
    * @param {TypeLocation} location - The location for the query
+   * @param {boolean} queryGeometry - The query geometry boolean
    * @returns {Promise} A promise resolving to the query results
    */
   protected static queryLayerFeatures(
     data: TypeFeatureInfoResultSetEntry | TypeAllFeatureInfoResultSetEntry | TypeHoverResultSetEntry,
     geoviewLayer: AbstractGVLayer,
     queryType: QueryType,
-    location: TypeLocation
+    location: TypeLocation,
+    queryGeometry: boolean = true
   ): Promise {
     // Get Feature Info
-    return geoviewLayer.getFeatureInfo(queryType, data.layerPath, location);
+    return geoviewLayer.getFeatureInfo(queryType, location, queryGeometry);
   }
 
   /**
diff --git a/packages/geoview-core/src/geo/layer/layer-sets/feature-info-layer-set.ts b/packages/geoview-core/src/geo/layer/layer-sets/feature-info-layer-set.ts
index a17eadb3272..e23f28db064 100644
--- a/packages/geoview-core/src/geo/layer/layer-sets/feature-info-layer-set.ts
+++ b/packages/geoview-core/src/geo/layer/layer-sets/feature-info-layer-set.ts
@@ -110,6 +110,13 @@ export class FeatureInfoLayerSet extends AbstractLayerSet {
     // GV Each query should be distinct as far as the resultSet goes! The 'reinitialization' below isn't sufficient.
     // GV As it is (and was like this before events refactor), the this.resultSet is mutating between async calls.
 
+    // TODO: Use the AbortController and kill the active query if there is one in progress. The query layer here call the getFeatureInfoAtLongLat
+    // TODO.CONT: in gv-esri-dynamic. It is for this particular format we need check because identify are slow and many can be sent at the same time
+    // Create an AbortController instance
+    // const controller = new AbortController();
+    // const signal = controller.signal;
+    // controller.abort(); // Cancels the fetch request
+
     // Prepare to hold all promises of features in the loop below
     const allPromises: Promise[] = [];
 
diff --git a/packages/geoview-core/src/geo/layer/layer-sets/hover-feature-info-layer-set.ts b/packages/geoview-core/src/geo/layer/layer-sets/hover-feature-info-layer-set.ts
index 8005db6bd38..9662e2051a4 100644
--- a/packages/geoview-core/src/geo/layer/layer-sets/hover-feature-info-layer-set.ts
+++ b/packages/geoview-core/src/geo/layer/layer-sets/hover-feature-info-layer-set.ts
@@ -117,7 +117,7 @@ export class HoverFeatureInfoLayerSet extends AbstractLayerSet {
         MapEventProcessor.setMapHoverFeatureInfo(this.getMapId(), this.resultSet[layerPath].feature);
 
         // Process query on results data
-        AbstractLayerSet.queryLayerFeatures(this.resultSet[layerPath], layer, queryType, pixelCoordinate)
+        AbstractLayerSet.queryLayerFeatures(this.resultSet[layerPath], layer, queryType, pixelCoordinate, false)
           .then((arrayOfRecords) => {
             if (arrayOfRecords === null) {
               this.resultSet[layerPath].queryStatus = 'error';
@@ -146,13 +146,12 @@ export class HoverFeatureInfoLayerSet extends AbstractLayerSet {
             // Log
             logger.logPromiseFailed('queryLayerFeatures in queryLayers in hoverFeatureInfoLayerSet', error);
           });
-      } else {
-        this.resultSet[layerPath].feature = null;
-        this.resultSet[layerPath].queryStatus = 'error';
-
-        // Propagate to the store
-        MapEventProcessor.setMapHoverFeatureInfo(this.getMapId(), this.resultSet[layerPath].feature);
       }
+      this.resultSet[layerPath].feature = null;
+      this.resultSet[layerPath].queryStatus = 'error';
+
+      // Propagate to the store
+      MapEventProcessor.setMapHoverFeatureInfo(this.getMapId(), this.resultSet[layerPath].feature);
     });
   }
 
diff --git a/packages/geoview-core/src/geo/utils/renderer/geoview-renderer.ts b/packages/geoview-core/src/geo/utils/renderer/geoview-renderer.ts
index eacb599a997..ba47e10f51d 100644
--- a/packages/geoview-core/src/geo/utils/renderer/geoview-renderer.ts
+++ b/packages/geoview-core/src/geo/utils/renderer/geoview-renderer.ts
@@ -1580,6 +1580,23 @@ export async function getFeatureCanvas(
     if (style[geometryType]) {
       const styleSettings = style[geometryType]!;
       const { type } = styleSettings;
+
+      // TODO: Performance #2688 - Wrap the style processing in a Promise to prevent blocking, Use requestAnimationFrame to process style during next frame
+      // Wrap the style processing in a Promise to prevent blocking
+      // return new Promise((resolve) => {
+      //   // Use requestAnimationFrame to process style during next frame
+      //   requestAnimationFrame(() => {
+      //     const processedStyle = processStyle[type][geometryType].call(
+      //       '',
+      //       styleSettings,
+      //       feature as Feature,
+      //       filterEquation,
+      //       legendFilterIsOff
+      //     );
+      //     resolve(processedStyle);
+      //   });
+      // });
+
       const featureStyle = processStyle[type][geometryType](styleSettings, feature, filterEquation, legendFilterIsOff);
       if (featureStyle) {
         if (geometryType === 'Point') {
diff --git a/packages/geoview-core/src/geo/utils/utilities.ts b/packages/geoview-core/src/geo/utils/utilities.ts
index 39dae427b5b..c32a0422097 100644
--- a/packages/geoview-core/src/geo/utils/utilities.ts
+++ b/packages/geoview-core/src/geo/utils/utilities.ts
@@ -22,6 +22,7 @@ import { getLegendStyles } from '@/geo/utils/renderer/geoview-renderer';
 import { TypeLayerStyleConfig } from '@/geo/map/map-schema-types';
 
 import { TypeBasemapLayer } from '../layer/basemap/basemap-types';
+import { TypeValidMapProjectionCodes } from '@/api/config/types/map-schema-types';
 
 /**
  * Interface used for css style declarations
@@ -308,6 +309,7 @@ export function convertTypeFeatureStyleToOpenLayersStyle(style?: TypeFeatureStyl
   return getDefaultDrawingStyle(style?.strokeColor, style?.strokeWidth, style?.fillColor);
 }
 
+// #region EXTENT
 /**
  * Returns the union of 2 extents.
  * @param {Extent | undefined} extentA First extent
@@ -432,6 +434,7 @@ export function validateExtentWhenDefined(extent: Extent | undefined, code: stri
   if (extent) return validateExtent(extent, code);
   return undefined;
 }
+// #endregion EXTENT
 
 /**
  * Gets the area of a given geometry
@@ -475,3 +478,24 @@ export function calculateDistance(coordinates: Coordinate[], inProj: string, out
 
   return { total: Math.round((getLength(geom) / 1000) * 100) / 100, sections };
 }
+
+/**
+ * Get meters per pixel for different projections
+ * @param {TypeValidMapProjectionCodes} projection - The projection of the map
+ * @param {number} resolution - The resolution of the map
+ * @param {number?} lat - The latitude, only needed for Web Mercator
+ * @returns {number} Number representing meters per pixel
+ */
+export function getMetersPerPixel(projection: TypeValidMapProjectionCodes, resolution: number, lat?: number): number {
+  if (!resolution) return 0;
+
+  // Web Mercator needs latitude correction because of severe distortion at high latitudes
+  // At latitude 60°N, the scale distortion factor is about 2:1
+  if (projection === 3857 && lat !== undefined) {
+    const latitudeCorrection = Math.cos((lat * Math.PI) / 180);
+    return resolution * latitudeCorrection;
+  }
+
+  // LCC (and other meter-based projections) can use resolution directly
+  return resolution;
+}