@rural-environmental-registry/map_component 1.0.0 → 1.1.0

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/parseShapefileZip.ts

@@ -0,0 +1,56 @@
+import shp from 'shpjs'
+import type { Feature, FeatureCollection } from 'geojson'
+
+export type ShapefileParseResult =
+  | { ok: true; features: Feature[] }
+  | { ok: false; error: string }
+
+function isFeatureCollection(value: unknown): value is FeatureCollection {
+  return (
+    typeof value === 'object' &&
+    value !== null &&
+    'type' in value &&
+    (value as FeatureCollection).type === 'FeatureCollection'
+  )
+}
+
+function normalizeToFeatures(geojson: FeatureCollection | Feature | Feature[] | FeatureCollection[]): Feature[] {
+  if (Array.isArray(geojson)) {
+    return geojson.flatMap((item) => {
+      if (isFeatureCollection(item)) {
+        return item.features
+      }
+      return [item as Feature]
+    })
+  }
+
+  if (isFeatureCollection(geojson)) {
+    return geojson.features
+  }
+
+  return [geojson as Feature]
+}
+
+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 = normalizeToFeatures(geojson as FeatureCollection | Feature | Feature[] | FeatureCollection[])
+
+    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/validateShapefileGeometry.ts

@@ -0,0 +1,54 @@
+import { area, booleanValid, kinks } from '@turf/turf'
+import type { Feature, MultiPolygon, Polygon, Position } from 'geojson'
+
+export type ShapefileValidationResult =
+  | { 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 validateShapefileGeometry(features: Feature[]): ShapefileValidationResult {
+  if (features.length !== 1) {
+    return { ok: false, error: 'The shapefile 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> }
+}