@dunguel/expo-geo-parser 0.1.1 → 0.4.0

package/android/src/main/java/expo/modules/geoparser/parsers/KMLParser.kt

@@ -28,6 +28,9 @@ class KMLParser(
     private var currentFeatureName = ""
     private var currentFeatureDescription = ""
     private var currentFeatureStyleUrl = ""
+    private var currentExtendedData = linkedMapOf<String, Any?>()
+    private var currentExtendedDataName = ""
+    private var inExtendedData = false
     private var currentGeometryType: String? = null
 
     private var pointCoord = listOf<Double>()
@@ -93,9 +96,14 @@ class KMLParser(
                 currentFeatureName = ""
                 currentFeatureDescription = ""
                 currentFeatureStyleUrl = ""
+                currentExtendedData = linkedMapOf()
+                currentExtendedDataName = ""
+                inExtendedData = false
                 currentGeometryType = null
                 multiGeometries = mutableListOf()
             }
+            "ExtendedData"   -> if (inPlacemark) inExtendedData = true
+            "Data", "SimpleData" -> if (inPlacemark && inExtendedData) currentExtendedDataName = attrs?.getValue("name") ?: ""
             "Point"          -> { currentGeometryType = "Point";      pointCoord = listOf() }
             "LineString"     -> { currentGeometryType = "LineString"; lineCoords = listOf() }
             "LinearRing"     -> currentRing = listOf()
@@ -117,18 +125,33 @@ class KMLParser(
     override fun endElement(uri: String?, localName: String?, qName: String?) {
         val name = stripped(localName ?: qName ?: "")
         val text = textBuffer.toString().trim()
+        val parent = elementStack.dropLast(1).lastOrNull() ?: ""
         textBuffer.clear()
         if (elementStack.isNotEmpty()) elementStack.removeAt(elementStack.lastIndex)
 
         when (name) {
             "Document"   -> documentDepth--
             "name"       -> when {
-                inPlacemark -> currentFeatureName = text
-                documentDepth > 0 && !documentMetaCaptured -> { documentName = text; documentMetaCaptured = true }
+                inPlacemark && parent == "Placemark" -> currentFeatureName = text
+                isCollectionContainer(parent) && !documentMetaCaptured -> {
+                    documentName = text
+                    documentMetaCaptured = true
+                }
             }
             "description" -> when {
-                inPlacemark -> currentFeatureDescription = text
-                documentDepth > 0 && documentDescription.isEmpty() -> documentDescription = text
+                inPlacemark && parent == "Placemark" -> currentFeatureDescription = text
+                isCollectionContainer(parent) && documentDescription.isEmpty() -> documentDescription = text
+            }
+            "ExtendedData" -> inExtendedData = false
+            "Data" -> currentExtendedDataName = ""
+            "value" -> if (inPlacemark && inExtendedData && currentExtendedDataName.isNotEmpty()) {
+                currentExtendedData[currentExtendedDataName] = parsePropertyValue(text)
+            }
+            "SimpleData" -> {
+                if (inPlacemark && inExtendedData && currentExtendedDataName.isNotEmpty()) {
+                    currentExtendedData[currentExtendedDataName] = parsePropertyValue(text)
+                }
+                currentExtendedDataName = ""
             }
             "Style"      -> { currentStyleId?.let { styles[it] = buildingStyle }; currentStyleId = null }
             "StyleMap"   -> { inStyleMap = false; currentStyleMapId = null }
@@ -158,7 +181,6 @@ class KMLParser(
             "scale"      -> if (inIconStyle) text.toDoubleOrNull()?.let { buildingStyle.iconScale = it }
             "coordinates" -> {
                 val coords = parseCoordinates(text)
-                val parent = elementStack.lastOrNull() ?: ""
                 when (parent) {
                     "Point"      -> pointCoord = coords.firstOrNull() ?: listOf()
                     "LineString" -> lineCoords = coords
@@ -195,6 +217,9 @@ class KMLParser(
         return if (idx >= 0) name.substring(idx + 1) else name
     }
 
+    private fun isCollectionContainer(name: String): Boolean =
+        name == "Document" || name == "Folder"
+
     private fun kmlColorToCSS(kml: String): String {
         val s = kml.trim().lowercase()
         if (s.length != 8) return "#000000"
@@ -209,6 +234,16 @@ class KMLParser(
                 if (parts.size >= 2) parts else null
             }
 
+    private fun parsePropertyValue(text: String): Any {
+        val trimmed = text.trim()
+        return when {
+            trimmed.equals("true", ignoreCase = true) -> true
+            trimmed.equals("false", ignoreCase = true) -> false
+            NUMERIC_SCALAR.matches(trimmed) -> trimmed.toDouble()
+            else -> trimmed
+        }
+    }
+
     private fun buildGeometry(type: String): Map<String, Any?>? = when (type) {
         "Point"      -> if (pointCoord.isNotEmpty()) mapOf("type" to "Point", "coordinates" to pointCoord) else null
         "LineString" -> if (lineCoords.isNotEmpty()) mapOf("type" to "LineString", "coordinates" to lineCoords) else null
@@ -227,17 +262,14 @@ class KMLParser(
     }
 
     private fun finalizeFeature() {
-        val geometry: Map<String, Any?> = if (currentGeometryType == "MultiGeometry") {
-            if (multiGeometries.isEmpty()) return
-            mapOf("type" to "GeometryCollection", "geometries" to multiGeometries.toList())
-        } else {
-            val gType = currentGeometryType ?: return
-            buildGeometry(gType) ?: return
-        }
-
         val properties = mutableMapOf<String, Any?>()
         if (currentFeatureName.isNotEmpty()) properties["name"] = currentFeatureName
-        if (currentFeatureDescription.isNotEmpty()) properties["description"] = currentFeatureDescription
+        properties.putAll(currentExtendedData)
+        if (currentFeatureDescription.isNotEmpty()) {
+            val extracted = extractDescriptionAttributes(currentFeatureDescription)
+            extracted.attributes.forEach { (key, value) -> properties.putIfAbsent(key, value) }
+            extracted.description?.let { properties["description"] = it }
+        }
         if (currentFeatureStyleUrl.isNotEmpty()) {
             properties["styleId"] = currentFeatureStyleUrl
             resolveStyle(currentFeatureStyleUrl)?.takeIf { !it.isEmpty }?.let {
@@ -245,19 +277,76 @@ class KMLParser(
             }
         }
 
-        val feature = mutableMapOf<String, Any?>(
-            "type" to "Feature",
-            "geometry" to geometry,
-            "properties" to properties
-        )
-        currentFeatureId?.takeIf { it.isNotEmpty() }?.let { feature["id"] = it }
-
-        featureBuffer.add(feature)
-        if (featureBuffer.size >= batchSize) {
-            onFeatures(featureBuffer.toList(), false)
-            featureBuffer.clear()
+        val geometries: List<Map<String, Any?>> = if (currentGeometryType == "MultiGeometry") {
+            if (multiGeometries.isEmpty()) return
+            multiGeometries.toList()
+        } else {
+            val gType = currentGeometryType ?: return
+            listOf(buildGeometry(gType) ?: return)
+        }
+
+        geometries.forEachIndexed { index, geometry ->
+            val feature = mutableMapOf<String, Any?>(
+                "type" to "Feature",
+                "geometry" to geometry,
+                "properties" to properties
+            )
+            splitFeatureId(currentFeatureId, index, geometries.size)?.let { feature["id"] = it }
+
+            featureBuffer.add(feature)
+            if (featureBuffer.size >= batchSize) {
+                onFeatures(featureBuffer.toList(), false)
+                featureBuffer.clear()
+            }
         }
     }
+
+    private fun splitFeatureId(baseId: String?, index: Int, total: Int): String? {
+        if (baseId.isNullOrEmpty()) return null
+        if (total <= 1) return baseId
+        return "${baseId}_${index + 1}"
+    }
+
+    private fun extractDescriptionAttributes(description: String): ExtractedDescription {
+        val textDescription = stripHtml(description)
+        if (!description.contains("<table") || !description.contains("<th") || !description.contains("<td")) {
+            return ExtractedDescription(linkedMapOf(), textDescription.ifEmpty { null })
+        }
+
+        val attributes = linkedMapOf<String, Any?>()
+        for (match in HTML_ATTRIBUTE_ROW.findAll(description)) {
+            val key = stripHtml(match.groupValues[1])
+            if (key.isEmpty()) continue
+            val value = stripHtml(match.groupValues[2])
+            attributes[key] = parsePropertyValue(value)
+        }
+
+        val cleanedDescription =
+            if (textDescription.isNotEmpty() && !(attributes.isNotEmpty() && textDescription == "Attributes")) {
+                textDescription
+            } else {
+                null
+            }
+
+        return ExtractedDescription(attributes, cleanedDescription)
+    }
+
+    private fun stripHtml(value: String): String =
+        value
+            .replace(HTML_TAG, " ")
+            .replace("&nbsp;", " ")
+            .replace("&amp;", "&")
+            .replace("&lt;", "<")
+            .replace("&gt;", ">")
+            .replace("&quot;", "\"")
+            .replace("&#39;", "'")
+            .replace(WHITESPACE, " ")
+            .trim()
+
+    private data class ExtractedDescription(
+        val attributes: LinkedHashMap<String, Any?>,
+        val description: String?
+    )
 }
 
 private data class StyleInfo(
@@ -281,3 +370,11 @@ private data class StyleInfo(
         return d
     }
 }
+
+private val HTML_TAG = Regex("<[^>]+>")
+private val HTML_ATTRIBUTE_ROW = Regex(
+    "<th[^>]*>\\s*(.*?)\\s*</th>\\s*<td[^>]*>\\s*(.*?)\\s*</td>",
+    setOf(RegexOption.IGNORE_CASE, RegexOption.DOT_MATCHES_ALL)
+)
+private val WHITESPACE = Regex("\\s+")
+private val NUMERIC_SCALAR = Regex("^-?(0|[1-9]\\d*)(\\.\\d+)?$")

package/ios/Parsers/KMLParser.swift

@@ -19,6 +19,9 @@ final class KMLParser: NSObject, XMLParserDelegate {
   private var currentFeatureName = ""
   private var currentFeatureDescription = ""
   private var currentFeatureStyleUrl = ""
+  private var currentExtendedData: [String: Any] = [:]
+  private var currentExtendedDataName = ""
+  private var inExtendedData = false
   private var currentGeometryType: String?
 
   private var pointCoord: [Double] = []
@@ -92,8 +95,15 @@ final class KMLParser: NSObject, XMLParserDelegate {
       currentFeatureName = ""
       currentFeatureDescription = ""
       currentFeatureStyleUrl = ""
+      currentExtendedData = [:]
+      currentExtendedDataName = ""
+      inExtendedData = false
       currentGeometryType = nil
       multiGeometries = []
+    case "ExtendedData":
+      if inPlacemark { inExtendedData = true }
+    case "Data", "SimpleData":
+      if inPlacemark && inExtendedData { currentExtendedDataName = attributeDict["name"] ?? "" }
     case "Point":           currentGeometryType = "Point";      pointCoord = []
     case "LineString":      currentGeometryType = "LineString"; lineCoords = []
     case "LinearRing":      currentRing = []
@@ -124,16 +134,30 @@ final class KMLParser: NSObject, XMLParserDelegate {
   ) {
     let name = stripped(elementName)
     let text = textBuffer.trimmingCharacters(in: .whitespacesAndNewlines)
+    let parent = elementStack.dropLast().last ?? ""
     defer { textBuffer = ""; if !elementStack.isEmpty { elementStack.removeLast() } }
 
     switch name {
     case "Document":    documentDepth -= 1
     case "name":
-      if inPlacemark { currentFeatureName = text }
-      else if documentDepth > 0 && !documentMetaCaptured { documentName = text; documentMetaCaptured = true }
+      if inPlacemark && parent == "Placemark" { currentFeatureName = text }
+      else if isCollectionContainer(parent) && !documentMetaCaptured { documentName = text; documentMetaCaptured = true }
     case "description":
-      if inPlacemark { currentFeatureDescription = text }
-      else if documentDepth > 0 && documentDescription.isEmpty { documentDescription = text }
+      if inPlacemark && parent == "Placemark" { currentFeatureDescription = text }
+      else if isCollectionContainer(parent) && documentDescription.isEmpty { documentDescription = text }
+    case "ExtendedData":
+      inExtendedData = false
+    case "Data":
+      currentExtendedDataName = ""
+    case "value":
+      if inPlacemark && inExtendedData && !currentExtendedDataName.isEmpty {
+        currentExtendedData[currentExtendedDataName] = parsePropertyValue(text)
+      }
+    case "SimpleData":
+      if inPlacemark && inExtendedData && !currentExtendedDataName.isEmpty {
+        currentExtendedData[currentExtendedDataName] = parsePropertyValue(text)
+      }
+      currentExtendedDataName = ""
     case "Style":
       if let id = currentStyleId { styles[id] = buildingStyle }
       currentStyleId = nil
@@ -161,7 +185,6 @@ final class KMLParser: NSObject, XMLParserDelegate {
     case "scale":       if inIconStyle, let s = Double(text) { buildingStyle.iconScale = s }
     case "coordinates":
       let coords = parseCoordinates(text)
-      let parent = elementStack.dropLast().last ?? ""
       switch parent {
       case "Point":      pointCoord = coords.first ?? []
       case "LineString": lineCoords = coords
@@ -189,6 +212,10 @@ final class KMLParser: NSObject, XMLParserDelegate {
     return name
   }
 
+  private func isCollectionContainer(_ name: String) -> Bool {
+    name == "Document" || name == "Folder"
+  }
+
   private func kmlColorToCSS(_ kml: String) -> String {
     let s = kml.trimmingCharacters(in: .whitespacesAndNewlines).lowercased()
     guard s.count == 8 else { return "#000000" }
@@ -205,6 +232,24 @@ final class KMLParser: NSObject, XMLParserDelegate {
       }
   }
 
+  private func parsePropertyValue(_ text: String) -> Any {
+    let trimmed = text.trimmingCharacters(in: .whitespacesAndNewlines)
+    let lowercased = trimmed.lowercased()
+
+    if lowercased == "true" { return true }
+    if lowercased == "false" { return false }
+    if isNumericScalar(trimmed), let number = Double(trimmed) {
+      return number
+    }
+
+    return trimmed
+  }
+
+  private func isNumericScalar(_ text: String) -> Bool {
+    guard !text.isEmpty else { return false }
+    return text.range(of: #"^-?(0|[1-9]\d*)(\.\d+)?$"#, options: .regularExpression) != nil
+  }
+
   private func buildGeometry(type: String) -> [String: Any]? {
     switch type {
     case "Point":
@@ -232,29 +277,99 @@ final class KMLParser: NSObject, XMLParserDelegate {
   }
 
   private func finalizeFeature() {
-    let geometry: [String: Any]
+    var properties: [String: Any] = [:]
+    if !currentFeatureName.isEmpty { properties["name"] = currentFeatureName }
+    for (key, value) in currentExtendedData {
+      properties[key] = value
+    }
+
+    if !currentFeatureDescription.isEmpty {
+      let extracted = extractDescriptionAttributes(from: currentFeatureDescription)
+      for (key, value) in extracted.attributes where properties[key] == nil {
+        properties[key] = value
+      }
+      if let description = extracted.description {
+        properties["description"] = description
+      }
+    }
+
+    if !currentFeatureStyleUrl.isEmpty {
+      properties["styleId"] = currentFeatureStyleUrl
+      if let style = resolveStyle(url: currentFeatureStyleUrl), !style.isEmpty {
+        properties["style"] = style.asDictionary()
+      }
+    }
+
+    let geometries: [[String: Any]]
     if currentGeometryType == "MultiGeometry" {
       guard !multiGeometries.isEmpty else { return }
-      geometry = ["type": "GeometryCollection", "geometries": multiGeometries]
+      geometries = multiGeometries
     } else if let gType = currentGeometryType, let geom = buildGeometry(type: gType) {
-      geometry = geom
+      geometries = [geom]
     } else {
       return
     }
 
-    var properties: [String: Any] = [:]
-    if !currentFeatureName.isEmpty        { properties["name"]        = currentFeatureName }
-    if !currentFeatureDescription.isEmpty { properties["description"] = currentFeatureDescription }
-    if !currentFeatureStyleUrl.isEmpty {
-      properties["styleId"] = currentFeatureStyleUrl
-      if let style = resolveStyle(url: currentFeatureStyleUrl), !style.isEmpty {
-        properties["style"] = style.asDictionary()
+    for (index, geometry) in geometries.enumerated() {
+      var feature: [String: Any] = ["type": "Feature", "geometry": geometry, "properties": properties]
+      if let id = splitFeatureId(baseId: currentFeatureId, index: index, total: geometries.count) {
+        feature["id"] = id
       }
+      features.append(feature)
+    }
+  }
+
+  private func splitFeatureId(baseId: String?, index: Int, total: Int) -> String? {
+    guard let baseId, !baseId.isEmpty else { return nil }
+    guard total > 1 else { return baseId }
+    return "\(baseId)_\(index + 1)"
+  }
+
+  private func extractDescriptionAttributes(from description: String) -> (attributes: [String: Any], description: String?) {
+    let textDescription = stripHTML(description)
+    guard description.contains("<table"), description.contains("<th"), description.contains("<td") else {
+      return ([:], textDescription.isEmpty ? nil : textDescription)
+    }
+
+    guard let regex = try? NSRegularExpression(
+      pattern: #"<th[^>]*>\s*(.*?)\s*</th>\s*<td[^>]*>\s*(.*?)\s*</td>"#,
+      options: [.caseInsensitive, .dotMatchesLineSeparators]
+    ) else {
+      return ([:], textDescription.isEmpty ? nil : textDescription)
+    }
+
+    let nsDescription = description as NSString
+    let matches = regex.matches(in: description, range: NSRange(location: 0, length: nsDescription.length))
+
+    var attributes: [String: Any] = [:]
+    for match in matches where match.numberOfRanges >= 3 {
+      let key = stripHTML(nsDescription.substring(with: match.range(at: 1)))
+      if key.isEmpty { continue }
+      let value = stripHTML(nsDescription.substring(with: match.range(at: 2)))
+      attributes[key] = parsePropertyValue(value)
     }
 
-    var feature: [String: Any] = ["type": "Feature", "geometry": geometry, "properties": properties]
-    if let id = currentFeatureId, !id.isEmpty { feature["id"] = id }
-    features.append(feature)
+    let cleanedDescription: String?
+    if !textDescription.isEmpty && !(matches.isEmpty == false && textDescription == "Attributes") {
+      cleanedDescription = textDescription
+    } else {
+      cleanedDescription = nil
+    }
+
+    return (attributes, cleanedDescription)
+  }
+
+  private func stripHTML(_ value: String) -> String {
+    value
+      .replacingOccurrences(of: #"<[^>]+>"#, with: " ", options: .regularExpression)
+      .replacingOccurrences(of: "&nbsp;", with: " ")
+      .replacingOccurrences(of: "&amp;", with: "&")
+      .replacingOccurrences(of: "&lt;", with: "<")
+      .replacingOccurrences(of: "&gt;", with: ">")
+      .replacingOccurrences(of: "&quot;", with: "\"")
+      .replacingOccurrences(of: "&#39;", with: "'")
+      .replacingOccurrences(of: #"\s+"#, with: " ", options: .regularExpression)
+      .trimmingCharacters(in: .whitespacesAndNewlines)
   }
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dunguel/expo-geo-parser",
-  "version": "0.1.1",
+  "version": "0.4.0",
   "description": "A high-performance Expo native module for parsing geospatial files like KML, KMZ, and other formats, extracting polygons, markers, and spatial data efficiently on iOS and Android.",
   "main": "build/index.js",
   "types": "build/index.d.ts",