front: reorder and redefine map layer groups

front/src/common/Map/DefaultBaseMap.tsx

@@ -109,7 +109,7 @@ const DefaultBaseMap = ({
         showOSM
       >
         <ItineraryLayer
-          layerOrder={LAYER_GROUPS_ORDER[LAYERS.ITINERARY.GROUP]}
+          layerOrder={LAYER_GROUPS_ORDER[LAYERS.PATH.GROUP]}
           geometry={geometry}
           isFeasible={isFeasible}
           showStdcmAssets

front/src/common/Map/Layers/InfraObjectLayers/InfraObjectLayers.tsx

@@ -28,7 +28,7 @@ const InfraObjectLayers = ({
   <>
     <TracksGeographic
       colors={colors[mapStyle]}
-      layerOrder={LAYER_GROUPS_ORDER[LAYERS.TRACKS_GEOGRAPHIC.GROUP]}
+      layerOrder={LAYER_GROUPS_ORDER[LAYERS.TRACKS.GROUP]}
       infraID={infraId}
     />
 
@@ -78,12 +78,14 @@ const InfraObjectLayers = ({
     <SpeedLimits
       colors={colors[mapStyle]}
       layerOrder={LAYER_GROUPS_ORDER[LAYERS.SPEED_LIMITS.GROUP]}
+      punctualLayerOrder={LAYER_GROUPS_ORDER[LAYERS.SPEED_LIMITS_PUNCTUAL.GROUP]}
       infraID={infraId}
     />
 
     <SNCF_PSL
       colors={colors[mapStyle]}
       layerOrder={LAYER_GROUPS_ORDER[LAYERS.SPEED_LIMITS.GROUP]}
+      punctualLayerOrder={LAYER_GROUPS_ORDER[LAYERS.SPEED_LIMITS_PUNCTUAL.GROUP]}
       infraID={infraId}
     />
 

front/src/common/Map/Layers/InfraObjectLayers/SpeedLimits.tsx

@@ -13,7 +13,8 @@ import type { Theme, OmitLayer } from 'types';
 interface SpeedLimitsProps {
   colors: Theme;
   layerOrder: number;
-  infraID: number | undefined;
+  punctualLayerOrder: number;
+  infraID?: number;
 }
 
 export function getSpeedSectionsTag({ speedlimittag }: MapState['layersSettings']): string {
@@ -167,7 +168,12 @@ export function getSpeedSectionsTextLayerProps({
   return res;
 }
 
-export default function SpeedLimits({ colors, layerOrder, infraID }: SpeedLimitsProps) {
+export default function SpeedLimits({
+  colors,
+  layerOrder,
+  punctualLayerOrder,
+  infraID,
+}: SpeedLimitsProps) {
   const { layersSettings } = useSelector((state: RootState) => state.map);
 
   const filter = getFilterBySpeedSectionsTag(layersSettings);
@@ -211,7 +217,7 @@ export default function SpeedLimits({ colors, layerOrder, infraID }: SpeedLimits
       <OrderedLayer
         {...pointProps}
         id="chartis/osrd_speed_limit_points/geo"
-        layerOrder={layerOrder}
+        layerOrder={punctualLayerOrder}
       />
       <OrderedLayer
         {...textProps}

front/src/common/Map/Layers/InfraObjectLayers/extensions/SNCF/PSL.tsx

@@ -20,8 +20,9 @@ import SNCF_PSL_Signs from './PSLSigns';
 
 interface SNCF_PSLProps {
   colors: Theme;
-  layerOrder?: number;
-  infraID?: number | undefined;
+  layerOrder: number;
+  punctualLayerOrder: number;
+  infraID?: number;
 }
 
 export function getPSLSpeedValueLayerProps({
@@ -153,7 +154,7 @@ export function getPSLSpeedLineLayerProps({
   return res;
 }
 
-const SNCF_PSL = ({ colors, layerOrder, infraID }: SNCF_PSLProps) => {
+const SNCF_PSL = ({ colors, layerOrder, punctualLayerOrder, infraID }: SNCF_PSLProps) => {
   const { t } = useTranslation('map-settings');
   const { layersSettings } = useSelector((state: RootState) => state.map);
 
@@ -211,7 +212,7 @@ const SNCF_PSL = ({ colors, layerOrder, infraID }: SNCF_PSLProps) => {
           layerOrder={layerOrder}
         />
       </Source>
-      <SNCF_PSL_Signs colors={colors} layerOrder={layerOrder} filter={speedSectionFilter} />
+      <SNCF_PSL_Signs colors={colors} layerOrder={punctualLayerOrder} filter={speedSectionFilter} />
     </>
   );
 };

front/src/common/Map/WarpedMap/WarpedMap.tsx

@@ -173,7 +173,7 @@ const WarpedMap = ({
       {itinerary && (
         <RenderItinerary
           geojsonPath={itinerary}
-          layerOrder={LAYER_GROUPS_ORDER[LAYERS.ITINERARY.GROUP]}
+          layerOrder={LAYER_GROUPS_ORDER[LAYERS.PATH.GROUP]}
         />
       )}
       {itinerary &&

front/src/config/layerOrder.ts

@@ -3,23 +3,31 @@ import type { Layer } from 'applications/editor/consts';
 export const LAYER_GROUPS = Object.freeze({
   MAP_BACKGROUND: Symbol('MAP_BACKGROUND'),
   TOPOGRAPHY: Symbol('TOPOGRAPHY'),
+  EXTERNAL_TRACKS: Symbol('EXTERNAL_TRACKS'),
   TRACKS: Symbol('TRACKS'),
-  INFRA: Symbol('INFRA'),
-  SIGNALS: Symbol('SIGNALS'),
-  DYN_SIGNALS: Symbol('DYN_SIGNALS'),
+  ELECTRIFICATIONS: Symbol('ELECTRIFICATIONS'),
+  OVER_ELECTRIFICATION: Symbol('OVER_ELECTRIFICATION'),
+  SPEED_LIMITS: Symbol('SPEED_LIMITS'),
+  PATHFINDING: Symbol('PATHFINDING'),
+  SPEED_LIMITS_PUNCTUAL: Symbol('SPEED_LIMITS_PUNCTUAL'),
+  PUNCTUAL: Symbol('PUNCTUAL'),
   TRAIN: Symbol('TRAIN'),
   ERRORS: Symbol('ERRORS'),
 });
 
 export const LAYER_GROUPS_ORDER = Object.freeze({
   [LAYER_GROUPS.MAP_BACKGROUND]: 0,
   [LAYER_GROUPS.TOPOGRAPHY]: 1,
-  [LAYER_GROUPS.TRACKS]: 2,
-  [LAYER_GROUPS.INFRA]: 3,
-  [LAYER_GROUPS.SIGNALS]: 4,
-  [LAYER_GROUPS.DYN_SIGNALS]: 5,
-  [LAYER_GROUPS.TRAIN]: 6,
-  [LAYER_GROUPS.ERRORS]: 7,
+  [LAYER_GROUPS.EXTERNAL_TRACKS]: 2,
+  [LAYER_GROUPS.TRACKS]: 3,
+  [LAYER_GROUPS.ELECTRIFICATIONS]: 4,
+  [LAYER_GROUPS.OVER_ELECTRIFICATION]: 5,
+  [LAYER_GROUPS.SPEED_LIMITS]: 6,
+  [LAYER_GROUPS.PATHFINDING]: 7,
+  [LAYER_GROUPS.SPEED_LIMITS_PUNCTUAL]: 8,
+  [LAYER_GROUPS.PUNCTUAL]: 9,
+  [LAYER_GROUPS.TRAIN]: 10,
+  [LAYER_GROUPS.ERRORS]: 11,
 });
 
 /**
@@ -30,30 +38,35 @@ export const LAYER_GROUPS_ORDER = Object.freeze({
  * etc
  */
 export const LAYERS = Object.freeze({
-  // 0
+  // 0 BACKGROUND
   BACKGROUND: { GROUP: LAYER_GROUPS.MAP_BACKGROUND },
-  // 1
+  // 1 PLATFORMS
   PLATFORMS: { GROUP: LAYER_GROUPS.TOPOGRAPHY },
-  // 2
-  TRACKS_GEOGRAPHIC: { GROUP: LAYER_GROUPS.TRACKS },
-  TRACKS_OSM: { GROUP: LAYER_GROUPS.TRACKS },
-  ELECTRIFICATIONS: { GROUP: LAYER_GROUPS.TRACKS },
-  ITINERARY: { GROUP: LAYER_GROUPS.TRACKS },
-  // 3
-  ROUTES: { GROUP: LAYER_GROUPS.INFRA },
-  OPERATIONAL_POINTS: { GROUP: LAYER_GROUPS.INFRA },
-  DEAD_SECTIONS: { GROUP: LAYER_GROUPS.INFRA },
-  BUFFER_STOPS: { GROUP: LAYER_GROUPS.INFRA },
-  DETECTORS: { GROUP: LAYER_GROUPS.INFRA },
-  SWITCHES: { GROUP: LAYER_GROUPS.INFRA },
-  LINE_SEARCH: { GROUP: LAYER_GROUPS.INFRA },
-  // 4
-  SPEED_LIMITS: { GROUP: LAYER_GROUPS.SIGNALS },
-  // 5
-  SIGNALS: { GROUP: LAYER_GROUPS.DYN_SIGNALS },
-  // 6
+  // 2 EXTERNAL TRACKS
+  TRACKS_OSM: { GROUP: LAYER_GROUPS.EXTERNAL_TRACKS },
+  // 3 TRACKS
+  TRACKS: { GROUP: LAYER_GROUPS.TRACKS },
+  // 4 ELECTRIFICATIONS
+  ELECTRIFICATIONS: { GROUP: LAYER_GROUPS.ELECTRIFICATIONS },
+  // 5 OVER_ELECTRIFICATION
+  DEAD_SECTIONS: { GROUP: LAYER_GROUPS.OVER_ELECTRIFICATION },
+  // 6 SPEED_LIMITS
+  SPEED_LIMITS: { GROUP: LAYER_GROUPS.SPEED_LIMITS },
+  // 7 PATHFINDING
+  ROUTES: { GROUP: LAYER_GROUPS.PATHFINDING },
+  PATH: { GROUP: LAYER_GROUPS.PATHFINDING }, // TODO : decide between "path" and "itinerary" here and in all names in itinerary layer and beyond
+  LINE_SEARCH: { GROUP: LAYER_GROUPS.PATHFINDING },
+  // 8 SPEEDLIMIT PUNCTUAL
+  SPEED_LIMITS_PUNCTUAL: { GROUP: LAYER_GROUPS.SPEED_LIMITS_PUNCTUAL }, // Used for psl_signs in all maps, and speed limits points signs in standard map but not infra editor/warped map
+  // 9 PUNCTUAL
+  OPERATIONAL_POINTS: { GROUP: LAYER_GROUPS.PUNCTUAL },
+  BUFFER_STOPS: { GROUP: LAYER_GROUPS.PUNCTUAL },
+  DETECTORS: { GROUP: LAYER_GROUPS.PUNCTUAL },
+  SWITCHES: { GROUP: LAYER_GROUPS.PUNCTUAL },
+  SIGNALS: { GROUP: LAYER_GROUPS.PUNCTUAL },
+  // 10 TRAIN
   TRAIN: { GROUP: LAYER_GROUPS.TRAIN },
-  // 7
+  // 11 ERRORS
   ERRORS: { GROUP: LAYER_GROUPS.ERRORS },
 });
 
@@ -62,12 +75,12 @@ export const LAYER_ENTITIES_ORDERS: Record<Layer, number> = Object.freeze({
   detectors: LAYER_GROUPS_ORDER[LAYERS.DETECTORS.GROUP],
   signals: LAYER_GROUPS_ORDER[LAYERS.SIGNALS.GROUP],
   switches: LAYER_GROUPS_ORDER[LAYERS.SWITCHES.GROUP],
-  track_sections: LAYER_GROUPS_ORDER[LAYERS.TRACKS_GEOGRAPHIC.GROUP],
+  track_sections: LAYER_GROUPS_ORDER[LAYERS.TRACKS.GROUP],
   electrifications: LAYER_GROUPS_ORDER[LAYERS.ELECTRIFICATIONS.GROUP],
   speed_sections: LAYER_GROUPS_ORDER[LAYERS.SPEED_LIMITS.GROUP],
   routes: LAYER_GROUPS_ORDER[LAYERS.ROUTES.GROUP],
-  psl: LAYER_GROUPS_ORDER[LAYERS.SIGNALS.GROUP],
-  psl_signs: LAYER_GROUPS_ORDER[LAYERS.SIGNALS.GROUP],
+  psl: LAYER_GROUPS_ORDER[LAYERS.SPEED_LIMITS.GROUP],
+  psl_signs: LAYER_GROUPS_ORDER[LAYERS.SPEED_LIMITS_PUNCTUAL.GROUP],
   neutral_signs: LAYER_GROUPS_ORDER[LAYERS.SIGNALS.GROUP],
   errors: LAYER_GROUPS_ORDER[LAYERS.ERRORS.GROUP],
   platforms: LAYER_GROUPS_ORDER[LAYERS.PLATFORMS.GROUP],

front/src/modules/simulationResult/components/SimulationResultsMap/SimulationResultsMap.tsx

@@ -201,10 +201,7 @@ const SimulationResultMap = ({
         terrain3DExaggeration={terrain3DExaggeration}
       >
         {geojsonPath && (
-          <Itinerary
-            geojsonPath={geojsonPath}
-            layerOrder={LAYER_GROUPS_ORDER[LAYERS.ITINERARY.GROUP]}
-          />
+          <Itinerary geojsonPath={geojsonPath} layerOrder={LAYER_GROUPS_ORDER[LAYERS.PATH.GROUP]} />
         )}
 
         <MapMarkers markers={mapMarkers} />

front/src/modules/simulationResult/components/SimulationResultsMap/VirtualLayers.tsx

@@ -1,7 +1,9 @@
 import { range } from 'lodash';
 import { Layer } from 'react-map-gl/maplibre';
 
-export const VIRTUAL_LAYERS = 8;
+import { LAYER_GROUPS_ORDER } from 'config/layerOrder';
+
+export const VIRTUAL_LAYERS = Object.getOwnPropertySymbols(LAYER_GROUPS_ORDER).length;
 
 export default function VirtualLayers() {
   const layers = range(0, VIRTUAL_LAYERS)

front/src/modules/trainschedule/components/ManageTrainSchedule/Map.tsx

@@ -220,7 +220,7 @@ const Map = ({
         )}
 
         <ItineraryLayer
-          layerOrder={LAYER_GROUPS_ORDER[LAYERS.ITINERARY.GROUP]}
+          layerOrder={LAYER_GROUPS_ORDER[LAYERS.PATH.GROUP]}
           geometry={pathGeometry}
           hideItineraryLine={hideItinerary}
           showStdcmAssets={showStdcmAssets}