formatting

Author: AlexianMasson

packages/openlayers/lib/map/create-context.test.ts

@@ -145,7 +145,9 @@ describe("createContextFromMap", () => {
       });
 
       it("extracts the style", () => {
-        expect((extractedLayerModel as MapContextLayerWms).style).toBe("default");
+        expect((extractedLayerModel as MapContextLayerWms).style).toBe(
+          "default",
+        );
       });
 
       it("extracts layer properties", () => {
@@ -169,12 +171,15 @@ describe("createContextFromMap", () => {
         const map = new Map({});
         map.addLayer(layer);
         // Wait for the promise chain to complete (mock resolves immediately but .then is async)
-        await vi.waitFor(() => {
-          const source = layer.getSource();
-          if (!source) {
-            throw new Error("Source not ready yet");
-          }
-        }, { timeout: 1000, interval: 10 });
+        await vi.waitFor(
+          () => {
+            const source = layer.getSource();
+            if (!source) {
+              throw new Error("Source not ready yet");
+            }
+          },
+          { timeout: 1000, interval: 10 },
+        );
         const context = createContextFromMap(map);
         extractedLayerModel = context.layers[0];
       });
@@ -258,7 +263,9 @@ describe("createContextFromMap", () => {
       });
 
       it("does not have inline data", () => {
-        expect((extractedLayerModel as MapContextLayerGeojson).data).toBeUndefined();
+        expect(
+          (extractedLayerModel as MapContextLayerGeojson).data,
+        ).toBeUndefined();
       });
 
       it("extracts layer properties", () => {
@@ -293,7 +300,9 @@ describe("createContextFromMap", () => {
       });
 
       it("extracts the layer name", () => {
-        expect((extractedLayerModel as MapContextLayerWmts)?.name).toBeDefined();
+        expect(
+          (extractedLayerModel as MapContextLayerWmts)?.name,
+        ).toBeDefined();
       });
 
       it("extracts layer properties", () => {
@@ -452,7 +461,9 @@ describe("createContextFromMap", () => {
       it("extracts the view", () => {
         expect(extractedContext.view).toBeTruthy();
         expect((extractedContext.view as any)?.center).toBeDefined();
-        expect((extractedContext.view as any)?.zoom).toBe((originalContext.view as any)?.zoom);
+        expect((extractedContext.view as any)?.zoom).toBe(
+          (originalContext.view as any)?.zoom,
+        );
       });
     });
 
@@ -517,7 +528,9 @@ describe("createContextFromMap", () => {
         );
 
         // Compare view zoom
-        expect((extractedContext2.view as any)?.zoom).toBe((extractedContext.view as any)?.zoom);
+        expect((extractedContext2.view as any)?.zoom).toBe(
+          (extractedContext.view as any)?.zoom,
+        );
 
         // Compare view center with tolerance
         expect((extractedContext2.view as any)?.center[0]).toBeCloseTo(

packages/openlayers/lib/map/create-context.ts

@@ -1,5 +1,9 @@
 import Map from "ol/Map";
-import { MapContext, MapContextLayer, MapContextLayerXyz, MapContextView } from "@geospatial-sdk/core";
+import {
+  MapContext,
+  MapContextLayer,
+  MapContextView,
+} from "@geospatial-sdk/core";
 import { toLonLat, get as getProjection } from "ol/proj";
 import Layer from "ol/layer/Layer";
 import TileLayer from "ol/layer/Tile";
@@ -22,20 +26,20 @@ const GEOJSON = new GeoJSON();
  */
 function extractLayerModel(layer: Layer): MapContextLayer | null {
   const source = layer.getSource();
-  
+
   if (!source) {
     return null;
   }
 
   // Common properties
   const attributionsFn = source.getAttributions();
   let attributionsString: string | undefined = undefined;
-  
+
   if (attributionsFn) {
     // @ts-expect-error- OpenLayers AttributionLike can be called without arguments
     const attributionsResult = attributionsFn();
     if (attributionsResult) {
-      attributionsString = Array.isArray(attributionsResult) 
+      attributionsString = Array.isArray(attributionsResult)
         ? attributionsResult.join(", ")
         : attributionsResult;
     }
@@ -143,29 +147,28 @@ function extractLayerModel(layer: Layer): MapContextLayer | null {
   }
 
   // Vector layers (GeoJSON, WFS)
-  if (layer instanceof VectorLayer && source instanceof VectorSource) {    
+  if (layer instanceof VectorLayer && source instanceof VectorSource) {
     const getStyle = layer.getStyle();
     let style: string | undefined = undefined;
     if (getStyle && typeof getStyle === "string") {
       style = getStyle;
-    }
-    else {
-        style = undefined;
+    } else {
+      style = undefined;
     }
 
     const url = source.getUrl();
-    
+
     // WFS layers have a function URL, not a string
     if (url && typeof url === "function") {
       // Call the function with dummy parameters to get the actual URL
       const dummyExtent: [number, number, number, number] = [0, 0, 1, 1];
       const dummyResolution = 1;
       const dummyProjection = getProjection("EPSG:3857")!;
       const urlString = url(dummyExtent, dummyResolution, dummyProjection);
-      
+
       // Extract the base URL (before the ?)
       const baseUrl = urlString.split("?")[0];
-      
+
       return {
         type: "wfs",
         url: baseUrl,
@@ -174,7 +177,7 @@ function extractLayerModel(layer: Layer): MapContextLayer | null {
         ...baseProperties,
       };
     }
-    
+
     if (url && typeof url === "string") {
       // Check if it's a WFS layer by looking at the URL
       if (url.includes("wfs") || url.includes("WFS")) {
@@ -207,8 +210,7 @@ function extractLayerModel(layer: Layer): MapContextLayer | null {
         data: featureCollection,
         ...baseProperties,
       };
-    }
-    else {
+    } else {
       return null;
     }
   }
@@ -234,7 +236,7 @@ function extractViewModel(map: Map): MapContextView | null {
   }
 
   const centerLonLat = toLonLat(center, view.getProjection());
-  
+
   return {
     center: centerLonLat as [number, number],
     zoom,
@@ -247,11 +249,11 @@ function extractViewModel(map: Map): MapContextView | null {
  */
 export function createContextFromMap(map: Map): MapContext {
   const layers: MapContextLayer[] = [];
-  
+
   map.getLayers().forEach((layer) => {
     const layerModel = extractLayerModel(layer as Layer);
     if (layerModel) {
-    layers.push(layerModel);
+      layers.push(layerModel);
     }
   });