From 2dffc93e43b4af6d612036747a8a9863fc9df188 Mon Sep 17 00:00:00 2001
From: Johann Levesque <Johann.Levesque@NRCan-RNCan.gc.ca>
Date: Wed, 17 Jul 2024 14:08:19 -0400
Subject: [PATCH 1/5] feat-fix(layers-event): Add getGeoJSON for vector layer,
 patch timing issue with geoCoreLayer, add layerError event, add global 
 layerVisibility event Closes #2338, #2376

---
 .../public/configs/OSDP/function-event.json   |  15 ++
 .../templates/demos/demo-function-event.html  |  22 ++-
 .../geoview-core/src/api/config/config-api.ts |   2 +-
 .../map-event-processor.ts                    |  40 +----
 packages/geoview-core/src/app.tsx             |  25 +--
 .../geoview-layers/abstract-geoview-layers.ts |   3 +-
 .../vector/abstract-geoview-vector.ts         |  19 +++
 .../geo/layer/gv-layers/abstract-gv-layer.ts  |   3 +-
 .../gv-layers/vector/abstract-gv-vector.ts    |  20 +++
 packages/geoview-core/src/geo/layer/layer.ts  | 142 +++++++++++++++++-
 10 files changed, 236 insertions(+), 55 deletions(-)

diff --git a/packages/geoview-core/public/configs/OSDP/function-event.json b/packages/geoview-core/public/configs/OSDP/function-event.json
index a9f777e6daf..0f2f86c1f19 100644
--- a/packages/geoview-core/public/configs/OSDP/function-event.json
+++ b/packages/geoview-core/public/configs/OSDP/function-event.json
@@ -10,6 +10,10 @@
       "labeled": true
     },
     "listOfGeoviewLayerConfig": [
+      {
+        "geoviewLayerType": "geoCore",
+        "geoviewLayerId": "f4c51eaa-a6ca-48b9-a1fc-b0651da20509"
+      },
       {
         "geoviewLayerId": "airborne_radioactivity",
         "geoviewLayerName": {
@@ -25,6 +29,17 @@
           }
         ]
       },
+      {
+        "geoviewLayerId": "errorId",
+        "geoviewLayerName": { "en": "uniqerrorLayerueValue" },
+        "metadataAccessPath": { "en": "https://maps-cartes.ec.gc.ca/arcgis/rest/services/CESI/MapServer1/" },
+        "geoviewLayerType": "esriFeature",
+        "listOfLayerEntryConfig": [
+          {
+            "layerId": "1"
+          }
+        ]
+      },
       {
         "geoviewLayerId": "uniqueValueId",
         "geoviewLayerName": { "en": "uniqueValue" },
diff --git a/packages/geoview-core/public/templates/demos/demo-function-event.html b/packages/geoview-core/public/templates/demos/demo-function-event.html
index 0f8be9facb0..9e1a84a19ee 100644
--- a/packages/geoview-core/public/templates/demos/demo-function-event.html
+++ b/packages/geoview-core/public/templates/demos/demo-function-event.html
@@ -178,7 +178,7 @@ <h3>Events that will generate notifications:</h3>
     <script src="layerlib.js"></script>
     <script>
       // initialize cgpv and api events, a callback is optional, used if calling api's after the rendering is ready
-      cgpv.init((mapId) => {
+      cgpv.init(async (mapId) => {
           listenToLegendLayerSetChanges('HMap1-state', 'Map1');
 
         // Events=====================================================================================================================
@@ -192,6 +192,12 @@ <h3>Events that will generate notifications:</h3>
           cgpv.api.maps.Map1.notifications.addNotificationSuccess(payload.layerPath + ' loaded');
         });
 
+        // listen to layer error events
+        cgpv.api.maps.Map1.layer.onLayerError((sender, payload) => {
+          // NOTE: The event added layer will be trigger first as the layer, even in error, has been added to ui 
+          cgpv.api.maps.Map1.notifications.addNotificationError(payload.layerPath + ' error');
+        });
+
         // listen to individual layer loaded event
         cgpv.api.maps.Map1.layer.getGeoviewLayer('nonmetalmines/5').onIndividualLayerLoaded((sender, payload) => {
           cgpv.api.maps.Map1.notifications.addNotificationSuccess('Nonmetal mines has finished loading');
@@ -203,12 +209,22 @@ <h3>Events that will generate notifications:</h3>
           cgpv.api.maps.Map1.notifications.addNotificationSuccess(payload.layerPath + ' removed');
         });
 
-        // listen to layer visibility changed event
+        // listen to layer visibility changed event (individual geoview layer)
         cgpv.api.maps.Map1.layer.getGeoviewLayer('uniqueValueId/1').onVisibleChanged((sender, payload) => {
           cgpv.api.maps.Map1.notifications.addNotificationSuccess(`uniqueValueId/1 visibility set to ${payload.visible}`);
         });
 
-        // listen to layer item visibility changed event
+        // listen to layer visibility changed event (individual geoview layer)
+        cgpv.api.maps.Map1.layer.getGeoviewLayer('rcs.f4c51eaa-a6ca-48b9-a1fc-b0651da20509.en').onVisibleChanged((sender, payload) => {
+          cgpv.api.maps.Map1.notifications.addNotificationSuccess(`layer ${payload.layerPath} visibility set to ${payload.visible}`);
+        });
+
+        // listen to layer item visibility changed event (any layers)
+        cgpv.api.maps.Map1.layer.onLayerVisibilityToggled((sender, payload) => {
+          cgpv.api.maps.Map1.notifications.addNotificationSuccess(`layer ${payload.layerPath} visibility set to ${payload.visibility}`);
+        });
+
+        // listen to layer item visibility changed event (any layers)
         cgpv.api.maps.Map1.layer.onLayerItemVisibilityToggled((sender, payload) => {
           cgpv.api.maps.Map1.notifications.addNotificationSuccess(`${payload.itemName} on layer ${payload.layerPath} visibility set to ${payload.visibility}`);
         });
diff --git a/packages/geoview-core/src/api/config/config-api.ts b/packages/geoview-core/src/api/config/config-api.ts
index 84b4bd02043..273da05a6a7 100644
--- a/packages/geoview-core/src/api/config/config-api.ts
+++ b/packages/geoview-core/src/api/config/config-api.ts
@@ -32,7 +32,7 @@ export class ConfigApi {
    * @returns {boolean} Returns true if the UUID respect the format.
    * @static
    */
-  static isValidUUID(uuid: string) {
+  static isValidUUID(uuid: string): boolean {
     const regex = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
     return regex.test(uuid);
   }
diff --git a/packages/geoview-core/src/api/event-processors/event-processor-children/map-event-processor.ts b/packages/geoview-core/src/api/event-processors/event-processor-children/map-event-processor.ts
index 8f33e64bf78..fe4034862f6 100644
--- a/packages/geoview-core/src/api/event-processors/event-processor-children/map-event-processor.ts
+++ b/packages/geoview-core/src/api/event-processors/event-processor-children/map-event-processor.ts
@@ -550,43 +550,11 @@ export class MapEventProcessor extends AbstractEventProcessor {
   }
 
   static setOrToggleMapLayerVisibility(mapId: string, layerPath: string, newValue?: boolean): void {
-    // Apply some visibility logic
-    const curOrderedLayerInfo = this.getMapStateProtected(mapId).orderedLayerInfo;
-    const layerVisibility = this.getMapVisibilityFromOrderedLayerInfo(mapId, layerPath);
-    // Determine the outcome of the new visibility based on parameters
-    const newVisibility = newValue !== undefined ? newValue : !layerVisibility;
-    const layerInfos = curOrderedLayerInfo.filter((info) => info.layerPath.startsWith(layerPath));
-    const parentLayerPathArray = layerPath.split('/');
-    parentLayerPathArray.pop();
-    const parentLayerPath = parentLayerPathArray.join('/');
-    const parentLayerInfo = curOrderedLayerInfo.find((info) => info.layerPath === parentLayerPath);
-
-    layerInfos.forEach((layerInfo) => {
-      if (layerInfo) {
-        // If the new visibility is different than before
-        if (newVisibility !== layerVisibility) {
-          // Go for it
-          // eslint-disable-next-line no-param-reassign
-          layerInfo.visible = newVisibility;
-          this.getMapViewerLayerAPI(mapId).getGeoviewLayerHybrid(layerInfo.layerPath)?.setVisible(layerInfo.visible, layerInfo.layerPath);
-        }
-      }
-    });
-
-    if (parentLayerInfo !== undefined) {
-      const parentLayerVisibility = this.getMapVisibilityFromOrderedLayerInfo(mapId, parentLayerPath);
-      if ((!layerVisibility || newValue) && parentLayerVisibility === false) {
-        if (parentLayerInfo) {
-          parentLayerInfo.visible = true;
-          this.getMapViewerLayerAPI(mapId).getGeoviewLayerHybrid(parentLayerPath)?.setVisible(true, parentLayerPath);
-        }
-      }
-      const children = curOrderedLayerInfo.filter(
-        (info) => info.layerPath.startsWith(parentLayerPath) && info.layerPath !== parentLayerPath
-      );
-      if (!children.some((child) => child.visible === true)) this.setOrToggleMapLayerVisibility(mapId, parentLayerPath, false);
-    }
+    // Redirect to layerAPI
+    this.getMapViewerLayerAPI(mapId).setOrToggleLayerVisibility(layerPath, newValue);
+  }
 
+  static setOrToggleMapLayerVisibilityState(mapId: string, curOrderedLayerInfo: TypeOrderedLayerInfo[]): void {
     // Redirect
     this.getMapStateProtected(mapId).setterActions.setOrderedLayerInfo([...curOrderedLayerInfo]);
   }
diff --git a/packages/geoview-core/src/app.tsx b/packages/geoview-core/src/app.tsx
index 809b3c082f7..3436c5a6a70 100644
--- a/packages/geoview-core/src/app.tsx
+++ b/packages/geoview-core/src/app.tsx
@@ -226,17 +226,20 @@ function init(callbackMapInit?: (mapId: string) => void, callbackMapLayersLoaded
           // Log
           logger.logInfo('Map initialized', mapElement.getAttribute('id')!);
 
-          // Callback about it
-          const mapId = mapElement.getAttribute('id')!;
-          callbackMapInit?.(mapId);
-
-          // Register when the map viewer will have loaded layers
-          api.maps[mapId].onMapLayersLoaded((mapViewerLoaded) => {
-            logger.logInfo('Map layers loaded', mapViewerLoaded.mapId);
-
-            // Callback for that particular map
-            callbackMapLayersLoaded?.(mapViewerLoaded.mapId);
-          });
+          // TODO: Fix this timeout issue when geoCore layer are use in config: https://github.com/Canadian-Geospatial-Platform/geoview/issues/2380
+          setTimeout(() => {
+            // Callback about it
+            const mapId = mapElement.getAttribute('id')!;
+            callbackMapInit?.(mapId);
+
+            // Register when the map viewer will have loaded layers
+            api.maps[mapId].onMapLayersLoaded((mapViewerLoaded) => {
+              logger.logInfo('Map layers loaded', mapViewerLoaded.mapId);
+
+              // Callback for that particular map
+              callbackMapLayersLoaded?.(mapViewerLoaded.mapId);
+            });
+          }, 500);
         })
         .catch((error) => {
           // Log
diff --git a/packages/geoview-core/src/geo/layer/geoview-layers/abstract-geoview-layers.ts b/packages/geoview-core/src/geo/layer/geoview-layers/abstract-geoview-layers.ts
index c6ceb7db7d5..06a40fe9fb9 100644
--- a/packages/geoview-core/src/geo/layer/geoview-layers/abstract-geoview-layers.ts
+++ b/packages/geoview-core/src/geo/layer/geoview-layers/abstract-geoview-layers.ts
@@ -1167,7 +1167,7 @@ export abstract class AbstractGeoViewLayer {
       const curVisible = this.getVisible(layerPath);
       olLayer.setVisible(layerVisibility);
       // olLayer.changed();
-      if (layerVisibility !== curVisible) this.#emitVisibleChanged({ visible: layerVisibility });
+      if (layerVisibility !== curVisible) this.#emitVisibleChanged({ layerPath, visible: layerVisibility });
     }
   }
 
@@ -1954,6 +1954,7 @@ type LegendQueriedDelegate = EventDelegateBase<AbstractGeoViewLayer, LegendQueri
  * Define an event for the delegate
  */
 export type VisibleChangedEvent = {
+  layerPath: string;
   visible: boolean;
 };
 
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 ba1e161d34e..f257f06d1bf 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
@@ -5,6 +5,7 @@ import { Vector as VectorSource } from 'ol/source';
 import { Options as SourceOptions } from 'ol/source/Vector';
 import { VectorImage as VectorLayer } from 'ol/layer';
 import { Options as VectorLayerOptions } from 'ol/layer/VectorImage';
+import { GeoJSON as FormatGeoJSON } from 'ol/format';
 import { all, bbox } from 'ol/loadingstrategy';
 import { ReadOptions } from 'ol/format/Feature';
 import BaseLayer from 'ol/layer/Base';
@@ -507,6 +508,24 @@ export abstract class AbstractGeoViewVector extends AbstractGeoViewLayer {
     return Promise.resolve(undefined);
   }
 
+  /**
+   * Return the vector layer as a GeoJSON object
+   * @param {string} layerPath - Layer path to get GeoJSON
+   * @returns {JSON} Layer's features as GeoJSON
+   */
+  getFeaturesAsGeoJSON(layerPath: string): JSON {
+    // Get map projection
+    const mapProjection: ProjectionLike = MapEventProcessor.getMapViewer(this.mapId).getProjection().getCode();
+
+    const format = new FormatGeoJSON();
+    const geoJsonStr = format.writeFeatures((this.getOLLayer(layerPath) as VectorLayer<Feature>).getSource()!.getFeatures(), {
+      dataProjection: 'EPSG:4326', // Output projection,
+      featureProjection: mapProjection,
+    });
+
+    return JSON.parse(geoJsonStr);
+  }
+
   /**
    * Overrides when the layer gets in loaded status.
    */
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 f91ac63ee2d..568454ffdfd 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
@@ -591,7 +591,7 @@ export abstract class AbstractGVLayer {
   setVisible(layerVisibility: boolean): void {
     const curVisible = this.getVisible();
     this.getOLLayer().setVisible(layerVisibility);
-    if (layerVisibility !== curVisible) this.#emitVisibleChanged({ visible: layerVisibility });
+    if (layerVisibility !== curVisible) this.#emitVisibleChanged({ layerPath: this.getLayerPath(), visible: layerVisibility });
   }
 
   /**
@@ -1187,6 +1187,7 @@ type LegendQueriedDelegate = EventDelegateBase<AbstractGVLayer, LegendQueriedEve
  * Define an event for the delegate
  */
 export type VisibleChangedEvent = {
+  layerPath: string;
   visible: boolean;
 };
 
diff --git a/packages/geoview-core/src/geo/layer/gv-layers/vector/abstract-gv-vector.ts b/packages/geoview-core/src/geo/layer/gv-layers/vector/abstract-gv-vector.ts
index 1389c923592..fc266e99a4b 100644
--- a/packages/geoview-core/src/geo/layer/gv-layers/vector/abstract-gv-vector.ts
+++ b/packages/geoview-core/src/geo/layer/gv-layers/vector/abstract-gv-vector.ts
@@ -2,11 +2,13 @@ import BaseLayer from 'ol/layer/Base';
 import VectorLayer from 'ol/layer/Vector';
 import VectorSource from 'ol/source/Vector';
 import { Options as VectorLayerOptions } from 'ol/layer/VectorImage';
+import { GeoJSON as FormatGeoJSON } from 'ol/format';
 import Style from 'ol/style/Style';
 import { Coordinate } from 'ol/coordinate';
 import { Extent } from 'ol/extent';
 import { Pixel } from 'ol/pixel';
 import Feature, { FeatureLike } from 'ol/Feature';
+import { ProjectionLike } from 'ol/proj';
 
 import { getUid } from 'ol/util';
 import { DateMgt } from '@/core/utils/date-mgt';
@@ -21,6 +23,7 @@ import { AbstractGVLayer } from '../abstract-gv-layer';
 import { AbstractGeoViewLayer } from '../../geoview-layers/abstract-geoview-layers';
 import { getLocalizedValue } from '@/core/utils/utilities';
 import { getMinOrMaxExtents } from '@/geo/utils/utilities';
+import { MapEventProcessor } from '@/api/event-processors/event-processor-children/map-event-processor';
 
 /**
  * Abstract Geoview Layer managing an OpenLayer vector type layer.
@@ -286,6 +289,23 @@ export abstract class AbstractGVVector extends AbstractGVLayer {
     return Promise.resolve(undefined);
   }
 
+  /**
+   * Return the vector layer as a GeoJSON object
+   * @returns {JSON} Layer's features as GeoJSON
+   */
+  getFeaturesAsGeoJSON(): JSON {
+    // Get map projection
+    const mapProjection: ProjectionLike = MapEventProcessor.getMapViewer(this.getMapId()).getProjection().getCode();
+
+    const format = new FormatGeoJSON();
+    const geoJsonStr = format.writeFeatures((this.getOLLayer() as VectorLayer<Feature>).getSource()!.getFeatures(), {
+      dataProjection: 'EPSG:4326', // Output projection,
+      featureProjection: mapProjection,
+    });
+
+    return JSON.parse(geoJsonStr);
+  }
+
   /**
    * Calculates a style for the given feature, based on the layer current style and options.
    * @param {AbstractGeoViewLayer | AbstractGVLayer} layer - The layer on which to work for the style.
diff --git a/packages/geoview-core/src/geo/layer/layer.ts b/packages/geoview-core/src/geo/layer/layer.ts
index 158a2714c7f..d34432dd8b1 100644
--- a/packages/geoview-core/src/geo/layer/layer.ts
+++ b/packages/geoview-core/src/geo/layer/layer.ts
@@ -147,9 +147,15 @@ export class LayerApi {
   // Keep all callback delegates references
   #onLayerLoadedHandlers: LayerLoadedDelegate[] = [];
 
+  // Keep all callback delegates references
+  #onLayerErrorHandlers: LayerErrorDelegate[] = [];
+
   // Keep all callback delegates references
   #onLayerRemovedHandlers: LayerRemovedDelegate[] = [];
 
+  // Keep all callback delegates references
+  #onLayerVisibilityToggledHandlers: LayerVisibilityToggledDelegate[] = [];
+
   // Keep all callback delegates references
   #onLayerItemVisibilityToggledHandlers: LayerItemVisibilityToggledDelegate[] = [];
 
@@ -909,6 +915,8 @@ export class LayerApi {
 
         // TODO: find a more centralized way to trap error and display message
         api.maps[this.getMapId()].notifications.showError('validation.layer.loadfailed', [layer, this.getMapId()]);
+
+        this.#emitLayerError({ layerPath: layer });
       });
     }
 
@@ -1386,8 +1394,55 @@ export class LayerApi {
    * @param {boolean} newValue - The new value of visibility.
    */
   setOrToggleLayerVisibility(layerPath: string, newValue?: boolean): void {
-    // Redirect to processor
-    MapEventProcessor.setOrToggleMapLayerVisibility(this.getMapId(), layerPath, newValue);
+    // Apply some visibility logic
+    const curOrderedLayerInfo = MapEventProcessor.getMapLayerOrder(this.getMapId());
+    const layerVisibility = MapEventProcessor.getMapVisibilityFromOrderedLayerInfo(this.getMapId(), layerPath);
+    // Determine the outcome of the new visibility based on parameters
+    const newVisibility = newValue !== undefined ? newValue : !layerVisibility;
+    const layerInfos = curOrderedLayerInfo.filter((info: { layerPath: string }) => info.layerPath.startsWith(layerPath));
+    const parentLayerPathArray = layerPath.split('/');
+    parentLayerPathArray.pop();
+    const parentLayerPath = parentLayerPathArray.join('/');
+    const parentLayerInfo = curOrderedLayerInfo.find((info: { layerPath: string }) => info.layerPath === parentLayerPath);
+
+    layerInfos.forEach((layerInfo: { visible: boolean; layerPath: string }) => {
+      if (layerInfo) {
+        // If the new visibility is different than before
+        if (newVisibility !== layerVisibility) {
+          // Go for it
+          // eslint-disable-next-line no-param-reassign
+          layerInfo.visible = newVisibility;
+          this.getGeoviewLayerHybrid(layerInfo.layerPath)?.setVisible(layerInfo.visible, layerInfo.layerPath);
+          // Emit event
+          this.#emitLayerVisibilityToggled({ layerPath: layerInfo.layerPath, visibility: layerInfo.visible });
+        }
+      }
+    });
+
+    if (parentLayerInfo !== undefined) {
+      const parentLayerVisibility = MapEventProcessor.getMapVisibilityFromOrderedLayerInfo(this.getMapId(), parentLayerPath);
+      if ((!layerVisibility || newValue) && parentLayerVisibility === false) {
+        if (parentLayerInfo) {
+          parentLayerInfo.visible = true;
+          this.getGeoviewLayerHybrid(parentLayerPath)?.setVisible(true, parentLayerPath);
+
+          // Emit event
+          this.#emitLayerVisibilityToggled({ layerPath: parentLayerPath, visibility: true });
+        }
+      }
+      const children = curOrderedLayerInfo.filter(
+        (info: { layerPath: string }) => info.layerPath.startsWith(parentLayerPath) && info.layerPath !== parentLayerPath
+      );
+      if (!children.some((child: { visible: boolean }) => child.visible === true)) {
+        this.setOrToggleLayerVisibility(parentLayerPath, false);
+
+        // Emit event
+        this.#emitLayerVisibilityToggled({ layerPath, visibility: false });
+      }
+    }
+
+    // Redirect to processor so we can update the store with setterActions
+    MapEventProcessor.setOrToggleMapLayerVisibilityState(this.getMapId(), curOrderedLayerInfo);
   }
 
   /**
@@ -1528,6 +1583,34 @@ export class LayerApi {
     EventHelper.offEvent(this.#onLayerLoadedHandlers, callback);
   }
 
+  /**
+   * Emits an event to all handlers when the layer's features have been flag as error on the map.
+   * @param {LayerErrorEvent} event - The event to emit
+   * @private
+   */
+  #emitLayerError(event: LayerErrorEvent): void {
+    // Emit the event for all handlers
+    EventHelper.emitEvent(this, this.#onLayerErrorHandlers, event);
+  }
+
+  /**
+   * Registers a layer error event handler.
+   * @param {LayerErrorDelegate} callback - The callback to be executed whenever the event is emitted
+   */
+  onLayerError(callback: LayerErrorDelegate): void {
+    // Register the event handler
+    EventHelper.onEvent(this.#onLayerErrorHandlers, callback);
+  }
+
+  /**
+   * Unregisters a layer error event handler.
+   * @param {LayerErrorDelegate} callback - The callback to stop being called whenever the event is emitted
+   */
+  offLayerError(callback: LayerErrorDelegate): void {
+    // Unregister the event handler
+    EventHelper.offEvent(this.#onLayerErrorHandlers, callback);
+  }
+
   /**
    * Emits an event to all handlers.
    * @param {LayerRemovedEvent} event - The event to emit
@@ -1556,6 +1639,33 @@ export class LayerApi {
     EventHelper.offEvent(this.#onLayerRemovedHandlers, callback);
   }
 
+  /**
+   * Emits layer visibility toggled event.
+   * @param {LayerVisibilityToggledEvent} event - The event to emit
+   */
+  #emitLayerVisibilityToggled(event: LayerVisibilityToggledEvent): void {
+    // Emit the event for all handlers
+    EventHelper.emitEvent(this, this.#onLayerVisibilityToggledHandlers, event);
+  }
+
+  /**
+   * Registers a layer visibility toggled event handler.
+   * @param {LayerVisibilityToggledDelegate} callback - The callback to be executed whenever the event is emitted
+   */
+  onLayerVisibilityToggled(callback: LayerVisibilityToggledDelegate): void {
+    // Register the event handler
+    EventHelper.onEvent(this.#onLayerVisibilityToggledHandlers, callback);
+  }
+
+  /**
+   * Unregisters a layer  visibility toggled event handler.
+   * @param {LayerVisibilityToggledDelegate} callback - The callback to stop being called whenever the event is emitted
+   */
+  offLayerVisibilityToggled(callback: LayerVisibilityToggledDelegate): void {
+    // Unregister the event handler
+    EventHelper.offEvent(this.#onLayerVisibilityToggledHandlers, callback);
+  }
+
   /**
    * Emits layer item visibility toggled event.
    * @param {LayerItemVisibilityToggledEvent} event - The event to emit
@@ -1612,6 +1722,19 @@ export type LayerLoadedEvent = {
   layerPath: string;
 };
 
+/**
+ * Define a delegate for the event handler function signature
+ */
+type LayerErrorDelegate = EventDelegateBase<LayerApi, LayerErrorEvent, void>;
+
+/**
+ * Define an event for the delegate
+ */
+export type LayerErrorEvent = {
+  // The error layer
+  layerPath: string;
+};
+
 /**
  * Define a delegate for the event handler function signature
  */
@@ -1625,6 +1748,21 @@ export type LayerRemovedEvent = {
   layerPath: string;
 };
 
+/**
+ * Define a delegate for the event handler function signature
+ */
+type LayerVisibilityToggledDelegate = EventDelegateBase<LayerApi, LayerVisibilityToggledEvent, void>;
+
+/**
+ * Define an event for the delegate
+ */
+export type LayerVisibilityToggledEvent = {
+  // The layer path of the affected layer
+  layerPath: string;
+  // The new visibility
+  visibility: boolean;
+};
+
 /**
  * Define a delegate for the event handler function signature
  */

From 8dacf21d21fd8c08f096db11e6b9a3ca85669b6b Mon Sep 17 00:00:00 2001
From: Johann Levesque <Johann.Levesque@NRCan-RNCan.gc.ca>
Date: Wed, 17 Jul 2024 15:09:56 -0400
Subject: [PATCH 2/5] fix comments

---
 .../public/templates/demos/demo-function-event.html    |  8 ++++----
 .../event-processor-children/map-event-processor.ts    |  2 +-
 packages/geoview-core/src/app.tsx                      | 10 ++++++++--
 .../geoview-layers/vector/abstract-geoview-vector.ts   |  2 +-
 .../geo/layer/gv-layers/vector/abstract-gv-vector.ts   |  3 +--
 packages/geoview-core/src/geo/layer/layer.ts           |  4 ++--
 6 files changed, 17 insertions(+), 12 deletions(-)

diff --git a/packages/geoview-core/public/templates/demos/demo-function-event.html b/packages/geoview-core/public/templates/demos/demo-function-event.html
index 9e1a84a19ee..13393f696c3 100644
--- a/packages/geoview-core/public/templates/demos/demo-function-event.html
+++ b/packages/geoview-core/public/templates/demos/demo-function-event.html
@@ -211,22 +211,22 @@ <h3>Events that will generate notifications:</h3>
 
         // listen to layer visibility changed event (individual geoview layer)
         cgpv.api.maps.Map1.layer.getGeoviewLayer('uniqueValueId/1').onVisibleChanged((sender, payload) => {
-          cgpv.api.maps.Map1.notifications.addNotificationSuccess(`uniqueValueId/1 visibility set to ${payload.visible}`);
+          cgpv.api.maps.Map1.notifications.addNotificationSuccess(`uniqueValueId/1 visibility set to ${payload.visible} - individual`);
         });
 
         // listen to layer visibility changed event (individual geoview layer)
         cgpv.api.maps.Map1.layer.getGeoviewLayer('rcs.f4c51eaa-a6ca-48b9-a1fc-b0651da20509.en').onVisibleChanged((sender, payload) => {
-          cgpv.api.maps.Map1.notifications.addNotificationSuccess(`layer ${payload.layerPath} visibility set to ${payload.visible}`);
+          cgpv.api.maps.Map1.notifications.addNotificationSuccess(`layer ${payload.layerPath} visibility set to ${payload.visible} - individual`);
         });
 
         // listen to layer item visibility changed event (any layers)
         cgpv.api.maps.Map1.layer.onLayerVisibilityToggled((sender, payload) => {
-          cgpv.api.maps.Map1.notifications.addNotificationSuccess(`layer ${payload.layerPath} visibility set to ${payload.visibility}`);
+          cgpv.api.maps.Map1.notifications.addNotificationSuccess(`layer ${payload.layerPath} visibility set to ${payload.visibility} - global`);
         });
 
         // listen to layer item visibility changed event (any layers)
         cgpv.api.maps.Map1.layer.onLayerItemVisibilityToggled((sender, payload) => {
-          cgpv.api.maps.Map1.notifications.addNotificationSuccess(`${payload.itemName} on layer ${payload.layerPath} visibility set to ${payload.visibility}`);
+          cgpv.api.maps.Map1.notifications.addNotificationSuccess(`${payload.itemName} on layer ${payload.layerPath} visibility set to ${payload.visibility} - global`);
         });
 
         // listen to map zoom event
diff --git a/packages/geoview-core/src/api/event-processors/event-processor-children/map-event-processor.ts b/packages/geoview-core/src/api/event-processors/event-processor-children/map-event-processor.ts
index fe4034862f6..edc37b2558c 100644
--- a/packages/geoview-core/src/api/event-processors/event-processor-children/map-event-processor.ts
+++ b/packages/geoview-core/src/api/event-processors/event-processor-children/map-event-processor.ts
@@ -554,7 +554,7 @@ export class MapEventProcessor extends AbstractEventProcessor {
     this.getMapViewerLayerAPI(mapId).setOrToggleLayerVisibility(layerPath, newValue);
   }
 
-  static setOrToggleMapLayerVisibilityState(mapId: string, curOrderedLayerInfo: TypeOrderedLayerInfo[]): void {
+  static setOrderedLayerInfoWithNoOrderChangeState(mapId: string, curOrderedLayerInfo: TypeOrderedLayerInfo[]): void {
     // Redirect
     this.getMapStateProtected(mapId).setterActions.setOrderedLayerInfo([...curOrderedLayerInfo]);
   }
diff --git a/packages/geoview-core/src/app.tsx b/packages/geoview-core/src/app.tsx
index 3436c5a6a70..43dc660d147 100644
--- a/packages/geoview-core/src/app.tsx
+++ b/packages/geoview-core/src/app.tsx
@@ -226,10 +226,16 @@ function init(callbackMapInit?: (mapId: string) => void, callbackMapLayersLoaded
           // Log
           logger.logInfo('Map initialized', mapElement.getAttribute('id')!);
 
+          // TODO: Fix this timeout issue when geoCore layer are use in config: https://github.com/Canadian-Geospatial-Platform/geoview/issues/2380
+          // Set a timeout value if one of thelaeyrs is a geoCore type
+          const mapId = mapElement.getAttribute('id')!;
+          const layerTypes = api.maps[mapId].mapFeaturesConfig.map.listOfGeoviewLayerConfig?.map((item) => item.geoviewLayerType) || [];
+          const geoCoreTimeout = layerTypes.includes('geoCore') ? 500 : 0;
+
           // TODO: Fix this timeout issue when geoCore layer are use in config: https://github.com/Canadian-Geospatial-Platform/geoview/issues/2380
           setTimeout(() => {
             // Callback about it
-            const mapId = mapElement.getAttribute('id')!;
+            // const mapId = mapElement.getAttribute('id')!;
             callbackMapInit?.(mapId);
 
             // Register when the map viewer will have loaded layers
@@ -239,7 +245,7 @@ function init(callbackMapInit?: (mapId: string) => void, callbackMapLayersLoaded
               // Callback for that particular map
               callbackMapLayersLoaded?.(mapViewerLoaded.mapId);
             });
-          }, 500);
+          }, geoCoreTimeout);
         })
         .catch((error) => {
           // Log
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 f257f06d1bf..3eeaa069ed8 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
@@ -515,7 +515,7 @@ export abstract class AbstractGeoViewVector extends AbstractGeoViewLayer {
    */
   getFeaturesAsGeoJSON(layerPath: string): JSON {
     // Get map projection
-    const mapProjection: ProjectionLike = MapEventProcessor.getMapViewer(this.mapId).getProjection().getCode();
+    const mapProjection: ProjectionLike = this.getMapViewer().getProjection().getCode();
 
     const format = new FormatGeoJSON();
     const geoJsonStr = format.writeFeatures((this.getOLLayer(layerPath) as VectorLayer<Feature>).getSource()!.getFeatures(), {
diff --git a/packages/geoview-core/src/geo/layer/gv-layers/vector/abstract-gv-vector.ts b/packages/geoview-core/src/geo/layer/gv-layers/vector/abstract-gv-vector.ts
index fc266e99a4b..e0005c47ae6 100644
--- a/packages/geoview-core/src/geo/layer/gv-layers/vector/abstract-gv-vector.ts
+++ b/packages/geoview-core/src/geo/layer/gv-layers/vector/abstract-gv-vector.ts
@@ -23,7 +23,6 @@ import { AbstractGVLayer } from '../abstract-gv-layer';
 import { AbstractGeoViewLayer } from '../../geoview-layers/abstract-geoview-layers';
 import { getLocalizedValue } from '@/core/utils/utilities';
 import { getMinOrMaxExtents } from '@/geo/utils/utilities';
-import { MapEventProcessor } from '@/api/event-processors/event-processor-children/map-event-processor';
 
 /**
  * Abstract Geoview Layer managing an OpenLayer vector type layer.
@@ -295,7 +294,7 @@ export abstract class AbstractGVVector extends AbstractGVLayer {
    */
   getFeaturesAsGeoJSON(): JSON {
     // Get map projection
-    const mapProjection: ProjectionLike = MapEventProcessor.getMapViewer(this.getMapId()).getProjection().getCode();
+    const mapProjection: ProjectionLike = this.getMapViewer().getProjection().getCode();
 
     const format = new FormatGeoJSON();
     const geoJsonStr = format.writeFeatures((this.getOLLayer() as VectorLayer<Feature>).getSource()!.getFeatures(), {
diff --git a/packages/geoview-core/src/geo/layer/layer.ts b/packages/geoview-core/src/geo/layer/layer.ts
index d34432dd8b1..7c0624e65eb 100644
--- a/packages/geoview-core/src/geo/layer/layer.ts
+++ b/packages/geoview-core/src/geo/layer/layer.ts
@@ -1442,7 +1442,7 @@ export class LayerApi {
     }
 
     // Redirect to processor so we can update the store with setterActions
-    MapEventProcessor.setOrToggleMapLayerVisibilityState(this.getMapId(), curOrderedLayerInfo);
+    MapEventProcessor.setOrderedLayerInfoWithNoOrderChangeState(this.getMapId(), curOrderedLayerInfo);
   }
 
   /**
@@ -1744,7 +1744,7 @@ type LayerRemovedDelegate = EventDelegateBase<LayerApi, LayerRemovedEvent, void>
  * Define an event for the delegate
  */
 export type LayerRemovedEvent = {
-  // The added layer
+  // The remove layer
   layerPath: string;
 };
 

From ff819a408fabf8d7fa5b643101cb3b463c266b18 Mon Sep 17 00:00:00 2001
From: Johann Levesque <Johann.Levesque@NRCan-RNCan.gc.ca>
Date: Thu, 18 Jul 2024 08:49:00 -0400
Subject: [PATCH 3/5] comments 2

---
 .../geoview-core/src/geo/layer/gv-layers/abstract-gv-layer.ts    | 1 +
 1 file changed, 1 insertion(+)

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 568454ffdfd..cc2d657c6be 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
@@ -1187,6 +1187,7 @@ type LegendQueriedDelegate = EventDelegateBase<AbstractGVLayer, LegendQueriedEve
  * Define an event for the delegate
  */
 export type VisibleChangedEvent = {
+  // TODO: Refactor - Layers refactoring. Remove the layerPath parameter once hybrid work is done
   layerPath: string;
   visible: boolean;
 };

From 5b715ec0471844e27f4c5a8484c972ba0047a488 Mon Sep 17 00:00:00 2001
From: Johann Levesque <Johann.Levesque@NRCan-RNCan.gc.ca>
Date: Thu, 18 Jul 2024 08:51:15 -0400
Subject: [PATCH 4/5] comments 3

---
 packages/geoview-core/src/app.tsx | 1 -
 1 file changed, 1 deletion(-)

diff --git a/packages/geoview-core/src/app.tsx b/packages/geoview-core/src/app.tsx
index 43dc660d147..40a2ef27dc6 100644
--- a/packages/geoview-core/src/app.tsx
+++ b/packages/geoview-core/src/app.tsx
@@ -235,7 +235,6 @@ function init(callbackMapInit?: (mapId: string) => void, callbackMapLayersLoaded
           // TODO: Fix this timeout issue when geoCore layer are use in config: https://github.com/Canadian-Geospatial-Platform/geoview/issues/2380
           setTimeout(() => {
             // Callback about it
-            // const mapId = mapElement.getAttribute('id')!;
             callbackMapInit?.(mapId);
 
             // Register when the map viewer will have loaded layers

From 0fe720d6521c6af7547c65376dcc2328ea86088d Mon Sep 17 00:00:00 2001
From: Johann Levesque <Johann.Levesque@NRCan-RNCan.gc.ca>
Date: Thu, 18 Jul 2024 09:10:04 -0400
Subject: [PATCH 5/5] commetn 4

---
 packages/geoview-core/src/geo/layer/layer.ts | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/packages/geoview-core/src/geo/layer/layer.ts b/packages/geoview-core/src/geo/layer/layer.ts
index 7c0624e65eb..251289286f9 100644
--- a/packages/geoview-core/src/geo/layer/layer.ts
+++ b/packages/geoview-core/src/geo/layer/layer.ts
@@ -916,7 +916,7 @@ export class LayerApi {
         // TODO: find a more centralized way to trap error and display message
         api.maps[this.getMapId()].notifications.showError('validation.layer.loadfailed', [layer, this.getMapId()]);
 
-        this.#emitLayerError({ layerPath: layer });
+        this.#emitLayerError({ layerPath: layer, errorMessage: loggerMessage });
       });
     }
 
@@ -1733,6 +1733,8 @@ type LayerErrorDelegate = EventDelegateBase<LayerApi, LayerErrorEvent, void>;
 export type LayerErrorEvent = {
   // The error layer
   layerPath: string;
+
+  errorMessage: string;
 };
 
 /**