@rural-environmental-registry/map_component 1.0.0 → 1.2.0

package/src/utils/geometryCalculator.ts

@@ -0,0 +1,62 @@
+import L, { Layer } from 'leaflet'
+import { area, length } from '@turf/turf'
+import { DrawnArea } from '../types'
+
+export function isClosedPolygonLayer(layer: Layer): boolean {
+  if (layer instanceof L.Polygon || layer instanceof L.Rectangle) return true
+
+  const geo = (layer as L.Polyline).toGeoJSON() as GeoJSON.Feature
+  const geomType = geo.geometry?.type
+  return geomType === 'Polygon' || geomType === 'MultiPolygon'
+}
+
+export function calculateLayerArea(layer: Layer): DrawnArea {
+  if (isClosedPolygonLayer(layer)) {
+    const drawnArea = area((layer as L.Polygon).toGeoJSON())
+
+    return {
+      m2: drawnArea,
+      km2: drawnArea / 1_000_000,
+      ha: drawnArea / 10_000
+    }
+  }
+
+  return { m2: 0, km2: 0, ha: 0 }
+}
+
+export function calculateLayerLength(layer: Layer): { m: number; km: number } {
+  const geo = (layer as L.Polyline).toGeoJSON() as GeoJSON.Feature
+  const geomType = geo.geometry?.type
+
+  if (
+    geomType === 'LineString' ||
+    geomType === 'MultiLineString' ||
+    geomType === 'Polygon' ||
+    geomType === 'MultiPolygon'
+  ) {
+    const km = length(geo, { units: 'kilometers' })
+    return { m: km * 1000, km }
+  }
+
+  return { m: 0, km: 0 }
+}
+
+export function formatLengthKm(km: number): string {
+  return `${km.toLocaleString(undefined, { maximumFractionDigits: 4 })} km`
+}
+
+export function formatAreaKm2(km2: number): string {
+  return `${km2.toLocaleString(undefined, { maximumFractionDigits: 6 })} km²`
+}
+
+export function formatAreaHa(value: number): string {
+  return `${value.toLocaleString(undefined, { maximumFractionDigits: 4 })} ha`
+}
+
+export function formatLengthValue(value: number, unit: 'm' | 'km'): string {
+  const decimals = unit === 'm' ? 2 : 4
+  const suffix = unit === 'km' ? ' km' : ' m'
+  return `${value.toLocaleString(undefined, { maximumFractionDigits: decimals })}${suffix}`
+}
+
+export { formatAreaHa as formatAreaValue }

package/src/utils/geometryFileParseResult.ts

@@ -0,0 +1,5 @@
+import type { Feature } from 'geojson'
+
+export type GeometryFileParseResult =
+  | { ok: true; features: Feature[] }
+  | { ok: false; error: string }

package/src/utils/memorialLayer.ts

@@ -0,0 +1,7 @@
+import type L from 'leaflet'
+
+export const MEMORIAL_KEY = 'memorial'
+
+export function isMemorialLayer(layer: L.Layer): boolean {
+  return (layer as L.Layer & { options?: { memorialKey?: string } }).options?.memorialKey === MEMORIAL_KEY
+}

package/src/utils/menuHistory.ts

@@ -0,0 +1,71 @@
+import { LayerData } from '../types'
+
+const MENU_HISTORY_KEY = 'menuHistory'
+
+const readHistory = (): Record<string, boolean> => {
+  try {
+    const raw = window.sessionStorage.getItem(MENU_HISTORY_KEY)
+    if (!raw) return {}
+
+    const parsed: unknown = JSON.parse(raw)
+    if (typeof parsed !== 'object' || parsed === null || Array.isArray(parsed)) {
+      return {}
+    }
+
+    return parsed as Record<string, boolean>
+  } catch {
+    return {}
+  }
+}
+
+export const setHistory = (layer: LayerData): void => {
+  try {
+    const history = readHistory()
+    window.sessionStorage.setItem(
+      MENU_HISTORY_KEY,
+      JSON.stringify({ ...history, [layer.key]: layer.active })
+    )
+  } catch {
+    // sessionStorage indisponível ou JSON inválido — ignora persistência
+  }
+}
+
+/** Retorna o estado salvo da camada ou `undefined` se não houver histórico. */
+export const getHistory = (layerKey: string): boolean | undefined => {
+  try {
+    const history = readHistory()
+    const isActive = history[layerKey]
+
+    return isActive !== undefined ? isActive : undefined
+  } catch {
+    return undefined
+  }
+}
+
+/** Resolve `active`/`activeDefault` sem mutar o objeto original (mesma regra do fluxo legado). */
+export const resolveLayerActiveState = (layer: LayerData, persist: boolean): LayerData => {
+  const savedActive = persist ? getHistory(layer.key) : undefined
+
+  let active = layer.active ?? false
+  let activeDefault = layer.activeDefault
+
+  if (savedActive !== undefined) {
+    active = savedActive
+    activeDefault = savedActive
+  }
+
+  if (activeDefault) {
+    active = activeDefault
+  }
+
+  return { ...layer, active, activeDefault }
+}
+
+/** Indica se a camada deve ser aplicada ao mapa na inicialização. */
+export const shouldInitLayerOnMap = (layer: LayerData, persist: boolean): boolean => {
+  const resolved = resolveLayerActiveState(layer, persist)
+
+  if (resolved.activeDefault) return true
+
+  return persist && getHistory(layer.key) !== undefined
+}

package/src/utils/normalizeGeoJsonToFeatures.ts

@@ -0,0 +1,52 @@
+import type { Feature, FeatureCollection, Geometry } from 'geojson'
+
+function isFeatureCollection(value: unknown): value is FeatureCollection {
+  return (
+    typeof value === 'object' &&
+    value !== null &&
+    'type' in value &&
+    (value as FeatureCollection).type === 'FeatureCollection' &&
+    'features' in value &&
+    Array.isArray(value.features)
+  )
+}
+
+function isFeature(value: unknown): value is Feature {
+  return (
+    typeof value === 'object' &&
+    value !== null &&
+    'type' in value &&
+    (value as Feature).type === 'Feature' &&
+    'geometry' in value
+  )
+}
+
+function isGeometry(value: unknown): value is Geometry {
+  return (
+    typeof value === 'object' &&
+    value !== null &&
+    'type' in value &&
+    !('features' in value) &&
+    (value as { type: string }).type !== 'Feature'
+  )
+}
+
+export function normalizeGeoJsonToFeatures(geojson: unknown): Feature[] {
+  if (Array.isArray(geojson)) {
+    return geojson.flatMap(item => normalizeGeoJsonToFeatures(item))
+  }
+
+  if (isFeatureCollection(geojson)) {
+    return geojson.features
+  }
+
+  if (isFeature(geojson)) {
+    return [geojson]
+  }
+
+  if (isGeometry(geojson)) {
+    return [{ type: 'Feature', properties: null, geometry: geojson }]
+  }
+
+  return []
+}

package/src/utils/parseGeoJsonFile.ts

@@ -0,0 +1,23 @@
+import { normalizeGeoJsonToFeatures } from './normalizeGeoJsonToFeatures'
+import type { GeometryFileParseResult } from './geometryFileParseResult'
+
+export async function parseGeoJsonFile(file: File): Promise<GeometryFileParseResult> {
+  const fileName = file.name.toLowerCase()
+  if (!fileName.endsWith('.geojson') && !fileName.endsWith('.json')) {
+    return { ok: false, error: 'The file must be a .geojson or .json file' }
+  }
+
+  try {
+    const content = await file.text()
+    const parsed = JSON.parse(content) as unknown
+    const features = normalizeGeoJsonToFeatures(parsed)
+
+    if (features.length === 0) {
+      return { ok: false, error: 'The GeoJSON file contains no geometries' }
+    }
+
+    return { ok: true, features }
+  } catch {
+    return { ok: false, error: 'Could not read the file. Check that it contains valid GeoJSON' }
+  }
+}

package/src/utils/parseKmlFile.ts

@@ -0,0 +1,31 @@
+import { kml } from '@tmcw/togeojson'
+import { normalizeGeoJsonToFeatures } from './normalizeGeoJsonToFeatures'
+import type { GeometryFileParseResult } from './geometryFileParseResult'
+
+export async function parseKmlFile(file: File): Promise<GeometryFileParseResult> {
+  const fileName = file.name.toLowerCase()
+  if (!fileName.endsWith('.kml')) {
+    return { ok: false, error: 'The file must be a .kml file' }
+  }
+
+  try {
+    const content = await file.text()
+    const xmlDoc = new DOMParser().parseFromString(content, 'text/xml')
+    const parserError = xmlDoc.querySelector('parsererror')
+
+    if (parserError) {
+      return { ok: false, error: 'Could not read the file. Check that it contains valid KML' }
+    }
+
+    const geojson = kml(xmlDoc)
+    const features = normalizeGeoJsonToFeatures(geojson)
+
+    if (features.length === 0) {
+      return { ok: false, error: 'The KML file contains no geometries' }
+    }
+
+    return { ok: true, features }
+  } catch {
+    return { ok: false, error: 'Could not read the file. Check that it contains valid KML' }
+  }
+}

package/src/utils/parseShapefileZip.ts

@@ -0,0 +1,29 @@
+import shp from 'shpjs'
+import { normalizeGeoJsonToFeatures } from './normalizeGeoJsonToFeatures'
+import type { GeometryFileParseResult } from './geometryFileParseResult'
+
+export type ShapefileParseResult = GeometryFileParseResult
+
+export async function parseShapefileZip(file: File): Promise<ShapefileParseResult> {
+  const fileName = file.name.toLowerCase()
+  if (!fileName.endsWith('.zip')) {
+    return { ok: false, error: 'The file must be a .zip containing the shapefile' }
+  }
+
+  try {
+    const buffer = await file.arrayBuffer()
+    const geojson = await shp(buffer)
+    const features = normalizeGeoJsonToFeatures(geojson)
+
+    if (features.length === 0) {
+      return { ok: false, error: 'The shapefile contains no geometries' }
+    }
+
+    return { ok: true, features }
+  } catch {
+    return {
+      ok: false,
+      error: 'Could not read the file. Check that the .zip contains valid .shp, .shx and .dbf files'
+    }
+  }
+}

package/src/utils/stableMarker.ts

@@ -0,0 +1,52 @@
+import type { FeatureGroup, LatLngExpression, Map, Marker, MarkerOptions } from 'leaflet'
+import type { default as LeafletType } from 'leaflet'
+
+export type StableMarkerOptions = MarkerOptions & Record<string, unknown>
+
+/** Opções padrão para evitar drift de divIcon durante zoom no Leaflet. */
+export const STABLE_MARKER_DEFAULTS: StableMarkerOptions = {
+  pane: 'markerPane',
+  riseOnHover: false,
+  zoomAnimation: false
+}
+
+/**
+ * Cria marcador com opções estáveis para ícones customizados (divIcon).
+ * Consumidores podem passar `icon` e metadados de domínio (ex.: layerCode, rules).
+ */
+export function createStableMarker(
+  leaflet: typeof LeafletType,
+  latlng: LatLngExpression,
+  options: StableMarkerOptions = {}
+): Marker {
+  return leaflet.marker(latlng, {
+    ...STABLE_MARKER_DEFAULTS,
+    ...options
+  })
+}
+
+/**
+ * Reposiciona marcadores após zoom (workaround para desalinhamento de divIcon).
+ * Retorna função de cleanup para remover o listener.
+ */
+export function bindMarkerZoomStability(map: Map, layerGroup: FeatureGroup): () => void {
+  const handler = (): void => {
+    const stabilize = (layer: any): void => {
+      if (typeof layer.getLatLng === 'function' && typeof layer.setLatLng === 'function') {
+        const latlng = layer.getLatLng()
+        if (latlng) {
+          layer.setLatLng(latlng)
+        }
+      } else if (typeof layer.eachLayer === 'function') {
+        layer.eachLayer(stabilize)
+      }
+    }
+    layerGroup.eachLayer(stabilize)
+  }
+
+  map.on('zoomend', handler)
+
+  return () => {
+    map.off('zoomend', handler)
+  }
+}

package/src/utils/validateImportedPolygonGeometry.ts

@@ -0,0 +1,62 @@
+import { area, booleanValid, kinks } from '@turf/turf'
+import type { Feature, MultiPolygon, Polygon, Position } from 'geojson'
+
+export type ImportedPolygonValidationResult =
+  | { ok: true; feature: Feature<Polygon | MultiPolygon> }
+  | { ok: false; error: string }
+
+const COORD_TOLERANCE = 1e-9
+
+function coordsEqual(a: Position, b: Position): boolean {
+  return Math.abs(a[0] - b[0]) <= COORD_TOLERANCE && Math.abs(a[1] - b[1]) <= COORD_TOLERANCE
+}
+
+function isRingClosed(ring: Position[]): boolean {
+  if (ring.length < 4) return false
+  return coordsEqual(ring[0], ring[ring.length - 1])
+}
+
+function validateRingsClosed(geometry: Polygon | MultiPolygon): boolean {
+  if (!Array.isArray(geometry?.coordinates)) return false
+  const polygons = geometry.type === 'Polygon' ? [geometry.coordinates] : geometry.coordinates
+  return polygons.every(polygon => polygon.every(ring => isRingClosed(ring)))
+}
+
+export function validateImportedPolygonGeometry(features: Feature[]): ImportedPolygonValidationResult {
+  try {
+    if (features.length !== 1) {
+      return { ok: false, error: 'The file must contain exactly one geometry' }
+    }
+
+    const feature = features[0]
+    const geometry = feature.geometry
+
+    if (!geometry || (geometry.type !== 'Polygon' && geometry.type !== 'MultiPolygon')) {
+      return { ok: false, error: 'Geometry must be Polygon or MultiPolygon' }
+    }
+
+    if (!validateRingsClosed(geometry)) {
+      return { ok: false, error: 'Polygon ring is not closed or is invalid' }
+    }
+
+    if (!booleanValid(geometry)) {
+      return { ok: false, error: 'Invalid geometry' }
+    }
+
+    if (kinks(geometry).features.length > 0) {
+      return { ok: false, error: 'Geometry has self-intersection' }
+    }
+
+    if (area(geometry) <= 0) {
+      return { ok: false, error: 'Polygon has zero area' }
+    }
+
+    return { ok: true, feature: feature as Feature<Polygon | MultiPolygon> }
+  } catch {
+    return {
+      ok: false,
+      error:
+        'An error occurred while validating the geometry. Ensure the file contains valid coordinates.'
+    }
+  }
+}