@osimatic/helpers-js 1.4.13 → 1.4.15

package/location.js

@@ -429,9 +429,7 @@ class PostalAddress {
 
 class Polygon {
 	static format(geoJsonPolygon) {
-		if (typeof geoJsonPolygon == 'string') {
-			geoJsonPolygon = JSON.parse(geoJsonPolygon);
-		}
+		geoJsonPolygon = typeof geoJsonPolygon == 'string' ? JSON.parse(geoJsonPolygon) : geoJsonPolygon;
 
 		const rings = geoJsonPolygon.coordinates || [];
 		const ring0 = rings[0] || [];
@@ -452,6 +450,19 @@ class Polygon {
 		};
 	}
 
+	static getStartCoordinates(geoJsonPolygon, asString=false) {
+		geoJsonPolygon = typeof geoJsonPolygon == 'string' ? JSON.parse(geoJsonPolygon) : geoJsonPolygon;
+
+		const rings = geoJsonPolygon.coordinates || [];
+		const ring0 = rings[0] || [];
+		if (ring0.length === 0) {
+			return null;
+		}
+
+		const [firstLon, firstLat] = ring0[0];
+		return asString ? str.join(',') : [firstLat, firstLon];
+	}
+
 	static convertToGeoJson(latlngs) {
 		let rings = [];
 		if (Array.isArray(latlngs) && Array.isArray(latlngs[0])) {
@@ -475,6 +486,38 @@ class Polygon {
 		return { type: 'Polygon', coordinates: rings };
 	}
 
+	static toLatLngRings(geoJsonPolygon) {
+		geoJsonPolygon = typeof geoJsonPolygon == 'string' ? JSON.parse(geoJsonPolygon) : geoJsonPolygon;
+
+		const polygonCoords = geoJsonPolygon.coordinates;
+		if (!Array.isArray(polygonCoords) || polygonCoords.length === 0) {
+			return false;
+		}
+
+		// polygonCoords: [ [ [lon,lat], ... ] , ... ]
+		const rings = [];
+		for (const ring of polygonCoords) {
+			const latlngRing = [];
+			for (const coord of ring) {
+				if (!Array.isArray(coord) || coord.length < 2) {
+					continue;
+				}
+				const [lon, lat] = coord;
+				latlngRing.push([lat, lon]);
+			}
+			if (latlngRing.length > 0) {
+				// Fermer l'anneau si nécessaire (Leaflet accepte ouvert/fermé, on nettoie par sécurité)
+				const first = latlngRing[0];
+				const last = latlngRing[latlngRing.length - 1];
+				if (first[0] !== last[0] || first[1] !== last[1]) {
+					latlngRing.push([first[0], first[1]]);
+				}
+				rings.push(latlngRing);
+			}
+		}
+		return rings;
+	}
+
 
 	// Test "sur le segment" en degrés (plan local) — suffisant pour le bord du polygone
 	static isPointOnSegmentDeg(lat, lon, A, B, EPS = 1e-12) {
@@ -545,6 +588,7 @@ class Polygon {
 
 		return true;
 	}
+
 }
 
 class GeographicCoordinates {
@@ -581,11 +625,7 @@ class GeographicCoordinates {
 	}
 
 	static formatPoint(geoJsonPoint, fractionDigit=6) {
-		if (typeof geoJsonPoint == 'string') {
-			geoJsonPoint = JSON.parse(geoJsonPoint);
-		}
-
-		const [long, lat] = geoJsonPoint.coordinates || [];
+		const [long, lat] = GeographicCoordinates.parseFromGeoJson(geoJsonPoint);
 		if (typeof long == 'undefined' || typeof lat == 'undefined') {
 			return '';
 		}
@@ -596,11 +636,20 @@ class GeographicCoordinates {
 		return { type: 'Point', coordinates: [Number(long), Number(lat)] };
 	}
 
-	static getAllLatLongsFromGeoJsonList(geoJsonList) {
-		if (typeof geoJsonList == 'string') {
-			geoJsonList = JSON.parse(geoJsonList);
+	static parseFromGeoJson(geoJsonPoint, asString=false) {
+		geoJsonPoint = typeof geoJsonPoint == 'string' ? JSON.parse(geoJsonPoint) : geoJsonPoint;
+
+		const [long, lat] = geoJsonPoint.coordinates || [];
+		if (typeof long == 'undefined' || typeof lat == 'undefined') {
+			return null;
 		}
 
+		return asString ? str.join(',') : [lat, lon];
+	}
+
+	static getAllLatLongsFromGeoJsonList(geoJsonList) {
+		geoJsonList = typeof geoJsonList == 'string' ? JSON.parse(geoJsonList) : geoJsonList;
+
 		const arr = [];
 		for (const geoJsonItem of geoJsonList) {
 			if (!geoJsonItem) {

package/open_street_map.js

@@ -77,7 +77,7 @@ class OpenStreetMap {
 		listLocations.forEach(location => this.addMarker(location, icon));
 	}
 
-	addMarker(coordinates, options) {
+	addMarker(geoJson, options) {
 		let locationCoordinates = coordinates.split(',');
 		let latitude = parseFloat(locationCoordinates[0]);
 		let longitude = parseFloat(locationCoordinates[1]);
@@ -105,6 +105,111 @@ class OpenStreetMap {
 		this.locations.push([latitude, longitude]);
 	}
 
+	addGeoJson(geoJson, options) {
+		OpenStreetMap.displayGeoJSONOnMap(this.map, geoJson, options);
+	}
+
+	/**
+	 * Affiche un GeoJSON (string) sur une carte Leaflet (OSM).
+	 * Gère: Point, Polygon, et Feature/FeatureCollection contenant ces types.
+	 *
+	 * @param {L.Map} map - instance Leaflet déjà créée
+	 * @param {string} geoJson - GeoJSON en texte
+	 * @param {object} [opts]
+	 *  - layerGroup: L.LayerGroup | L.FeatureGroup (facultatif, cible d'ajout)
+	 *  - pointMarker: options Leaflet pour le marker (ex: { draggable:false })
+	 *  - polygonStyle: options Leaflet pour le polygon (ex: { color:'#007bff' })
+	 *  - fit: boolean (par défaut true) → adapte la vue à la géométrie
+	 *  - pointZoom: number (zoom si Point et fit=true, défaut 16)
+	 *  - popup: string (facultatif) → bindPopup commun pour l'entité
+	 * @returns {L.Layer | null} couche ajoutée (marker ou polygon), sinon null
+	 */
+	static displayGeoJSONOnMap(map, geoJson, opts = {}) {
+		if (!map) {
+			console.warn('displayGeoJSONOnMap: paramètres invalides');
+			return null;
+		}
+
+		if (typeof geoJson == 'string') {
+			geoJson = JSON.parse(geoJson);
+		}
+
+		const {
+			layerGroup = null,
+			polygonStyle = { color: '#3388ff', weight: 3, opacity: 0.9, fillOpacity: 0.2 },
+			fit = true,
+			pointZoom = 16,
+			icon = null,
+			title = null,
+			popup = null
+		} = opts;
+
+		function addLayer(layer) {
+			layer.on('popupopen', () => {
+				//console.log('popupopen');
+				if (typeof opts['on_click'] == 'function') {
+					opts['on_click']();
+				}
+				return false;
+			});
+
+			if (layerGroup && typeof layerGroup.addLayer === 'function') {
+				layerGroup.addLayer(layer);
+			}
+			else {
+				layer.addTo(map);
+			}
+			if (popup) {
+				layer.bindPopup(popup);
+			}
+			return layer;
+		}
+
+		if (geoJson.type === 'Point') {
+			const coords = geoJson.coordinates;
+			if (!Array.isArray(coords) || coords.length < 2) {
+				console.warn('displayGeoJSONOnMap: Point invalide');
+				return null;
+			}
+			const [lon, lat] = coords;
+			const marker = L.marker([lat, lon], {
+				icon: L.icon({
+					iconUrl: icon,
+					iconSize: [22, 32],
+				}),
+				title: title,
+			});
+			addLayer(marker);
+
+			if (fit) {
+				map.setView([lat, lon], pointZoom);
+				setTimeout(function() { map.invalidateSize(true); }, 30);
+			}
+			return marker;
+		}
+
+		if (geoJson.type === 'Polygon') {
+			const rings = Polygon.toLatLngRings(geoJson.coordinates);
+			if (!rings.length) {
+				console.warn('displayGeoJSONOnMap: Polygon invalide');
+				return null;
+			}
+			// Leaflet accepte un tableau d’anneaux pour L.polygon
+			const poly = L.polygon(rings, polygonStyle);
+			addLayer(poly);
+
+			if (fit) {
+				const b = poly.getBounds();
+				map.fitBounds(b, { padding: [20, 20] });
+				setTimeout(function() { map.invalidateSize(true); }, 30);
+			}
+			return poly;
+		}
+
+		console.warn('displayGeoJSONOnMap: type non géré');
+		return null;
+	}
+
 	setView(location, zoom) {
 		this.map.setView(location, zoom);
 	}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@osimatic/helpers-js",
-  "version": "1.4.13",
+  "version": "1.4.15",
   "main": "main.js",
   "scripts": {
     "test": "echo \"Error: no test specified\" && exit 1"