@dunguel/expo-geo-parser 0.1.0

package/build/index.d.ts

@@ -0,0 +1,5 @@
+import type { GeoJSONFeatureCollection } from "./ExpoGeoParserModule";
+export { default } from "./ExpoGeoParserModule";
+export * from "./ExpoGeoParserModule";
+export declare function parseFile(uri: string): Promise<GeoJSONFeatureCollection>;
+//# sourceMappingURL=index.d.ts.map

package/build/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAkB,wBAAwB,EAAsB,MAAM,uBAAuB,CAAC;AAE1G,OAAO,EAAE,OAAO,EAAE,MAAM,uBAAuB,CAAC;AAChD,cAAc,uBAAuB,CAAC;AAEtC,wBAAsB,SAAS,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,wBAAwB,CAAC,CAqB9E"}

package/build/index.js

@@ -0,0 +1,23 @@
+import NativeModule from "./ExpoGeoParserModule";
+export { default } from "./ExpoGeoParserModule";
+export * from "./ExpoGeoParserModule";
+export async function parseFile(uri) {
+    const features = [];
+    let resolveDone;
+    const allReceived = new Promise(r => { resolveDone = r; });
+    const sub = NativeModule.addListener("onParseFeatures", (e) => {
+        for (const f of e.features)
+            features.push(f);
+        if (e.isLast)
+            resolveDone();
+    });
+    try {
+        const meta = await NativeModule.parseFile(uri);
+        await allReceived;
+        return { ...meta, features };
+    }
+    finally {
+        sub.remove();
+    }
+}
+//# sourceMappingURL=index.js.map

package/build/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,YAAY,MAAM,uBAAuB,CAAC;AAGjD,OAAO,EAAE,OAAO,EAAE,MAAM,uBAAuB,CAAC;AAChD,cAAc,uBAAuB,CAAC;AAEtC,MAAM,CAAC,KAAK,UAAU,SAAS,CAAC,GAAW;IACzC,MAAM,QAAQ,GAAqB,EAAE,CAAC;IAEtC,IAAI,WAAwB,CAAC;IAC7B,MAAM,WAAW,GAAG,IAAI,OAAO,CAAO,CAAC,CAAC,EAAE,GAAG,WAAW,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;IAEjE,MAAM,GAAG,GAAG,YAAY,CAAC,WAAW,CAClC,iBAAiB,EACjB,CAAC,CAAqB,EAAE,EAAE;QACxB,KAAK,MAAM,CAAC,IAAI,CAAC,CAAC,QAAQ;YAAE,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;QAC7C,IAAI,CAAC,CAAC,MAAM;YAAE,WAAW,EAAE,CAAC;IAC9B,CAAC,CACF,CAAC;IAEF,IAAI,CAAC;QACH,MAAM,IAAI,GAAG,MAAM,YAAY,CAAC,SAAS,CAAC,GAAG,CAAC,CAAC;QAC/C,MAAM,WAAW,CAAC;QAClB,OAAO,EAAE,GAAG,IAAI,EAAE,QAAQ,EAAE,CAAC;IAC/B,CAAC;YAAS,CAAC;QACT,GAAG,CAAC,MAAM,EAAE,CAAC;IACf,CAAC;AACH,CAAC","sourcesContent":["import NativeModule from \"./ExpoGeoParserModule\";\nimport type { GeoJSONFeature, GeoJSONFeatureCollection, ParseFeaturesEvent } from \"./ExpoGeoParserModule\";\n\nexport { default } from \"./ExpoGeoParserModule\";\nexport * from \"./ExpoGeoParserModule\";\n\nexport async function parseFile(uri: string): Promise<GeoJSONFeatureCollection> {\n  const features: GeoJSONFeature[] = [];\n\n  let resolveDone!: () => void;\n  const allReceived = new Promise<void>(r => { resolveDone = r; });\n\n  const sub = NativeModule.addListener(\n    \"onParseFeatures\",\n    (e: ParseFeaturesEvent) => {\n      for (const f of e.features) features.push(f);\n      if (e.isLast) resolveDone();\n    }\n  );\n\n  try {\n    const meta = await NativeModule.parseFile(uri);\n    await allReceived;\n    return { ...meta, features };\n  } finally {\n    sub.remove();\n  }\n}\n"]}

package/expo-module.config.json

@@ -0,0 +1,9 @@
+{
+  "platforms": ["apple", "android"],
+  "apple": {
+    "modules": ["ExpoGeoParserModule"]
+  },
+  "android": {
+    "modules": ["expo.modules.geoparser.ExpoGeoParserModule"]
+  }
+}

package/ios/ExpoGeoParser.podspec

@@ -0,0 +1,30 @@
+require 'json'
+
+package = JSON.parse(File.read(File.join(__dir__, '..', 'package.json')))
+
+Pod::Spec.new do |s|
+  s.name           = 'ExpoGeoParser'
+  s.version        = package['version']
+  s.summary        = package['description']
+  s.description    = package['description']
+  s.license        = package['license']
+  s.author         = package['author']
+  s.homepage       = package['homepage']
+  s.platforms      = {
+    :ios => '15.1',
+    :tvos => '15.1'
+  }
+  s.swift_version  = '5.9'
+  s.source         = { git: 'https://github.com/guilhermedunguel/expo-geo-parser' }
+  s.static_framework = true
+
+  s.dependency 'ExpoModulesCore'
+  s.dependency 'SSZipArchive'
+
+  # Swift/Objective-C compatibility
+  s.pod_target_xcconfig = {
+    'DEFINES_MODULE' => 'YES',
+  }
+
+  s.source_files = "**/*.{h,m,mm,swift,hpp,cpp}"
+end

package/ios/ExpoGeoParserModule.swift

@@ -0,0 +1,164 @@
+import ExpoModulesCore
+import Foundation
+import UniformTypeIdentifiers
+import SSZipArchive
+
+public class ExpoGeoParserModule: Module {
+  public func definition() -> ModuleDefinition {
+    Name("ExpoGeoParser")
+    Events("onParseFeatures")
+
+    Function("detectFileType") { (uri: String) -> [String: Any?] in
+      let info = Self.detectFileType(from: uri)
+      return [
+        "uri": uri,
+        "fileName": info.fileName,
+        "extension": info.fileExtension,
+        "type": info.type,
+        "uti": info.utiIdentifier
+      ]
+    }
+
+    AsyncFunction("parseFile") { (uri: String) throws -> [String: Any] in
+      var result = try Self.parseGeoFile(from: uri)
+      let features = result.removeValue(forKey: "features") as? [[String: Any]] ?? []
+
+      let batchSize = 200
+      var idx = 0
+      repeat {
+        let end = min(idx + batchSize, features.count)
+        self.sendEvent("onParseFeatures", [
+          "features": Array(features[idx..<end]),
+          "isLast": end >= features.count
+        ])
+        idx = end
+      } while idx < features.count
+
+      return result
+    }
+  }
+}
+
+// MARK: - File-type detection
+
+private extension ExpoGeoParserModule {
+  struct DetectedFileInfo {
+    let fileName: String?
+    let fileExtension: String?
+    let type: String
+    let utiIdentifier: String?
+  }
+
+  static func detectFileType(from uri: String) -> DetectedFileInfo {
+    guard let url = URL(string: uri) else {
+      return DetectedFileInfo(fileName: nil, fileExtension: nil, type: "unknown", utiIdentifier: nil)
+    }
+    return detectFileType(from: url)
+  }
+
+  static func detectFileType(from url: URL) -> DetectedFileInfo {
+    let fileName = url.lastPathComponent.isEmpty ? nil : url.lastPathComponent
+    let rawExt = url.pathExtension.trimmingCharacters(in: .whitespacesAndNewlines)
+    let ext = rawExt.isEmpty ? nil : rawExt.lowercased()
+
+    let type: String
+    switch ext {
+    case "kml":     type = "kml"
+    case "kmz":     type = "kmz"
+    case "zip":     type = "zip"
+    case "geojson": type = "geojson"
+    case "json":    type = "json"
+    default:        type = "unknown"
+    }
+
+    let uti = ext.flatMap { UTType(filenameExtension: $0)?.identifier }
+    return DetectedFileInfo(fileName: fileName, fileExtension: ext, type: type, utiIdentifier: uti)
+  }
+}
+
+// MARK: - Parser dispatcher
+
+private extension ExpoGeoParserModule {
+  static func parseGeoFile(from uri: String) throws -> [String: Any] {
+    guard let url = URL(string: uri) else {
+      throw GeoParserError.invalidURI(uri)
+    }
+
+    let info = detectFileType(from: url)
+
+    if info.type == "kmz" || info.type == "zip" {
+      return try parseArchive(at: url, sourceType: info.type)
+    }
+
+    let data = try Data(contentsOf: url)
+
+    switch info.type {
+    case "kml":             return try KMLParser.parse(data: data, sourceType: "kml")
+    case "geojson", "json": return try GeoJSONParser.parse(data: data, sourceType: info.type)
+    default:                return try sniffAndParse(data: data, sourceType: "unknown")
+    }
+  }
+
+  static func parseArchive(at url: URL, sourceType: String) throws -> [String: Any] {
+    let tmpDir = FileManager.default.temporaryDirectory
+      .appendingPathComponent(UUID().uuidString, isDirectory: true)
+    try FileManager.default.createDirectory(at: tmpDir, withIntermediateDirectories: true)
+    defer { try? FileManager.default.removeItem(at: tmpDir) }
+
+    guard SSZipArchive.unzipFile(atPath: url.path, toDestination: tmpDir.path) else {
+      throw GeoParserError.extractionFailed
+    }
+
+    guard let enumerator = FileManager.default.enumerator(at: tmpDir, includingPropertiesForKeys: nil) else {
+      throw GeoParserError.noGeoDataFound
+    }
+
+    var kmlFiles: [URL] = []
+    var geojsonFiles: [URL] = []
+    for case let fileURL as URL in enumerator {
+      let ext = fileURL.pathExtension.lowercased()
+      if ext == "kml"                           { kmlFiles.append(fileURL) }
+      else if ext == "geojson" || ext == "json" { geojsonFiles.append(fileURL) }
+    }
+
+    if let kmlURL = kmlFiles.first(where: { $0.lastPathComponent.lowercased() == "doc.kml" }) ?? kmlFiles.first {
+      return try KMLParser.parse(data: Data(contentsOf: kmlURL), sourceType: sourceType)
+    }
+    if let gjURL = geojsonFiles.first {
+      return try GeoJSONParser.parse(data: Data(contentsOf: gjURL), sourceType: sourceType)
+    }
+
+    throw GeoParserError.noGeoDataFound
+  }
+
+  static func sniffAndParse(data: Data, sourceType: String) throws -> [String: Any] {
+    if data.first == UInt8(ascii: "{") {
+      return try GeoJSONParser.parse(data: data, sourceType: sourceType)
+    }
+    if let prefix = String(data: data.prefix(256), encoding: .utf8),
+       prefix.contains("<kml") || prefix.contains("<Placemark") || prefix.contains("<Document") {
+      return try KMLParser.parse(data: data, sourceType: sourceType)
+    }
+    throw GeoParserError.unsupportedFormat
+  }
+}
+
+// MARK: - Errors
+
+enum GeoParserError: LocalizedError {
+  case invalidURI(String)
+  case extractionFailed
+  case noGeoDataFound
+  case unsupportedFormat
+  case parseError(String)
+
+  var errorDescription: String? {
+    switch self {
+    case .invalidURI(let uri): return "Invalid URI: \(uri)"
+    case .extractionFailed:    return "Failed to extract archive"
+    case .noGeoDataFound:      return "No supported geo data found in archive"
+    case .unsupportedFormat:   return "Unsupported or unrecognised file format"
+    case .parseError(let msg): return "Parse error: \(msg)"
+    }
+  }
+}

package/ios/Parsers/GeoJSONParser.swift

@@ -0,0 +1,59 @@
+import Foundation
+
+struct GeoJSONParser {
+
+  static func parse(data: Data, sourceType: String) throws -> [String: Any] {
+    guard let json = try? JSONSerialization.jsonObject(with: data) as? [String: Any] else {
+      throw GeoParserError.parseError("Invalid JSON")
+    }
+
+    let features = extractFeatures(from: json)
+
+    var result: [String: Any] = ["type": "FeatureCollection", "sourceType": sourceType, "features": features]
+    if let name = json["name"] as? String { result["name"] = name }
+    if let props = json["properties"] as? [String: Any] {
+      if let name = props["name"] as? String        { result["name"]        = name }
+      if let desc = props["description"] as? String { result["description"] = desc }
+    }
+    return result
+  }
+
+  private static func extractFeatures(from json: [String: Any]) -> [[String: Any]] {
+    guard let type = json["type"] as? String else { return [] }
+
+    switch type {
+    case "FeatureCollection":
+      return (json["features"] as? [[String: Any]] ?? []).compactMap { parseFeature($0) }
+    case "Feature":
+      return parseFeature(json).map { [$0] } ?? []
+    default:
+      if isGeometryType(type), let feature = bareGeometryToFeature(json) { return [feature] }
+      return []
+    }
+  }
+
+  private static func parseFeature(_ json: [String: Any]) -> [String: Any]? {
+    guard json["type"] as? String == "Feature",
+          let geometry = json["geometry"] as? [String: Any]
+    else { return nil }
+
+    let properties = json["properties"] as? [String: Any] ?? [:]
+    var feature: [String: Any] = ["type": "Feature", "geometry": geometry, "properties": properties]
+    if let id = json["id"] { feature["id"] = "\(id)" }
+    return feature
+  }
+
+  private static func bareGeometryToFeature(_ json: [String: Any]) -> [String: Any]? {
+    guard json["type"] as? String != nil else { return nil }
+    return ["type": "Feature", "geometry": json, "properties": [:] as [String: Any]]
+  }
+
+  private static func isGeometryType(_ type: String) -> Bool {
+    let types: Set<String> = [
+      "Point", "LineString", "Polygon",
+      "MultiPoint", "MultiLineString", "MultiPolygon",
+      "GeometryCollection"
+    ]
+    return types.contains(type)
+  }
+}

package/ios/Parsers/KMLParser.swift

@@ -0,0 +1,281 @@
+import Foundation
+
+final class KMLParser: NSObject, XMLParserDelegate {
+
+  private var features: [[String: Any]] = []
+  private var documentName = ""
+  private var documentDescription = ""
+  private var styles: [String: StyleInfo] = [:]
+  private var styleMaps: [String: String] = [:]
+
+  private var elementStack: [String] = []
+  private var textBuffer = ""
+
+  private var documentDepth = 0
+  private var documentMetaCaptured = false
+
+  private var inPlacemark = false
+  private var currentFeatureId: String?
+  private var currentFeatureName = ""
+  private var currentFeatureDescription = ""
+  private var currentFeatureStyleUrl = ""
+  private var currentGeometryType: String?
+
+  private var pointCoord: [Double] = []
+  private var lineCoords: [[Double]] = []
+  private var currentRing: [[Double]] = []
+  private var outerRing: [[Double]] = []
+  private var innerRings: [[[Double]]] = []
+  private var inOuterBoundary = false
+  private var inInnerBoundary = false
+
+  private var inMultiGeometry = false
+  private var multiGeometries: [[String: Any]] = []
+
+  private var currentStyleId: String?
+  private var buildingStyle = StyleInfo()
+  private var inLineStyle = false
+  private var inPolyStyle = false
+  private var inIconStyle = false
+  private var inIconHref = false
+
+  private var inStyleMap = false
+  private var currentStyleMapId: String?
+  private var inPair = false
+  private var currentPairKey = ""
+  private var currentPairStyleUrl = ""
+
+  static func parse(data: Data, sourceType: String) throws -> [String: Any] {
+    let delegate = KMLParser()
+    let xmlParser = XMLParser(data: data)
+    xmlParser.delegate = delegate
+    xmlParser.shouldProcessNamespaces = true
+    xmlParser.shouldReportNamespacePrefixes = false
+
+    guard xmlParser.parse() else {
+      throw GeoParserError.parseError(xmlParser.parserError?.localizedDescription ?? "XML parse error")
+    }
+
+    var result: [String: Any] = [
+      "type": "FeatureCollection",
+      "sourceType": sourceType,
+      "features": delegate.features
+    ]
+    if !delegate.documentName.isEmpty        { result["name"]        = delegate.documentName }
+    if !delegate.documentDescription.isEmpty { result["description"] = delegate.documentDescription }
+    return result
+  }
+
+  func parser(
+    _ parser: XMLParser,
+    didStartElement elementName: String,
+    namespaceURI: String?,
+    qualifiedName _: String?,
+    attributes attributeDict: [String: String]
+  ) {
+    let name = stripped(elementName)
+    elementStack.append(name)
+    textBuffer = ""
+
+    switch name {
+    case "Document":        documentDepth += 1
+    case "Style":           currentStyleId = attributeDict["id"]; buildingStyle = StyleInfo()
+    case "StyleMap":        inStyleMap = true; currentStyleMapId = attributeDict["id"]
+    case "Pair":            if inStyleMap { inPair = true; currentPairKey = ""; currentPairStyleUrl = "" }
+    case "LineStyle":       inLineStyle = true
+    case "PolyStyle":       inPolyStyle = true
+    case "IconStyle":       inIconStyle = true
+    case "Icon":            if inIconStyle { inIconHref = true }
+    case "Placemark":
+      inPlacemark = true
+      currentFeatureId = attributeDict["id"]
+      currentFeatureName = ""
+      currentFeatureDescription = ""
+      currentFeatureStyleUrl = ""
+      currentGeometryType = nil
+      multiGeometries = []
+    case "Point":           currentGeometryType = "Point";      pointCoord = []
+    case "LineString":      currentGeometryType = "LineString"; lineCoords = []
+    case "LinearRing":      currentRing = []
+    case "Polygon":
+      currentGeometryType = "Polygon"
+      outerRing = []; innerRings = []
+      inOuterBoundary = false; inInnerBoundary = false
+    case "MultiGeometry":   inMultiGeometry = true; multiGeometries = []
+    case "outerBoundaryIs": inOuterBoundary = true;  inInnerBoundary = false
+    case "innerBoundaryIs": inInnerBoundary = true; inOuterBoundary = false
+    default: break
+    }
+  }
+
+  func parser(_ parser: XMLParser, foundCharacters string: String) {
+    textBuffer += string
+  }
+
+  func parser(_ parser: XMLParser, foundCDATA block: Data) {
+    if let s = String(data: block, encoding: .utf8) { textBuffer += s }
+  }
+
+  func parser(
+    _ parser: XMLParser,
+    didEndElement elementName: String,
+    namespaceURI: String?,
+    qualifiedName _: String?
+  ) {
+    let name = stripped(elementName)
+    let text = textBuffer.trimmingCharacters(in: .whitespacesAndNewlines)
+    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 }
+    case "description":
+      if inPlacemark { currentFeatureDescription = text }
+      else if documentDepth > 0 && documentDescription.isEmpty { documentDescription = text }
+    case "Style":
+      if let id = currentStyleId { styles[id] = buildingStyle }
+      currentStyleId = nil
+    case "StyleMap":    inStyleMap = false; currentStyleMapId = nil
+    case "Pair":
+      if inStyleMap && currentPairKey == "normal", let mapId = currentStyleMapId {
+        styleMaps[mapId] = currentPairStyleUrl
+      }
+      inPair = false
+    case "key":         if inStyleMap && inPair { currentPairKey = text }
+    case "styleUrl":
+      if inPlacemark { currentFeatureStyleUrl = text }
+      else if inStyleMap && inPair { currentPairStyleUrl = text }
+    case "LineStyle":   inLineStyle = false
+    case "PolyStyle":   inPolyStyle = false
+    case "IconStyle":   inIconStyle = false
+    case "Icon":        inIconHref = false
+    case "color":
+      let hex = kmlColorToCSS(text)
+      if inLineStyle { buildingStyle.strokeColor = hex }
+      else if inPolyStyle { buildingStyle.fillColor = hex }
+    case "width":       if inLineStyle, let w = Double(text) { buildingStyle.strokeWidth = w }
+    case "fill":        if inPolyStyle { buildingStyle.fillEnabled = (text != "0") }
+    case "href":        if inIconHref { buildingStyle.iconUrl = text }
+    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
+      case "LinearRing": currentRing = coords
+      default: break
+      }
+    case "LinearRing":
+      if inOuterBoundary { outerRing = currentRing }
+      else if inInnerBoundary { innerRings.append(currentRing) }
+    case "outerBoundaryIs": inOuterBoundary = false
+    case "innerBoundaryIs": inInnerBoundary = false
+    case "Point", "LineString", "Polygon":
+      if inMultiGeometry, let geom = buildGeometry(type: name) {
+        multiGeometries.append(geom)
+        pointCoord = []; lineCoords = []; outerRing = []; innerRings = []
+      }
+    case "MultiGeometry":   inMultiGeometry = false; currentGeometryType = "MultiGeometry"
+    case "Placemark":       finalizeFeature(); inPlacemark = false
+    default: break
+    }
+  }
+
+  private func stripped(_ name: String) -> String {
+    if let r = name.range(of: ":", options: .backwards) { return String(name[r.upperBound...]) }
+    return name
+  }
+
+  private func kmlColorToCSS(_ kml: String) -> String {
+    let s = kml.trimmingCharacters(in: .whitespacesAndNewlines).lowercased()
+    guard s.count == 8 else { return "#000000" }
+    return "#\(s.dropFirst(6).prefix(2))\(s.dropFirst(4).prefix(2))\(s.dropFirst(2).prefix(2))"
+  }
+
+  private func parseCoordinates(_ text: String) -> [[Double]] {
+    text
+      .components(separatedBy: .whitespacesAndNewlines)
+      .filter { !$0.isEmpty }
+      .compactMap { tuple -> [Double]? in
+        let parts = tuple.split(separator: ",").compactMap { Double($0) }
+        return parts.count >= 2 ? Array(parts) : nil
+      }
+  }
+
+  private func buildGeometry(type: String) -> [String: Any]? {
+    switch type {
+    case "Point":
+      guard !pointCoord.isEmpty else { return nil }
+      return ["type": "Point", "coordinates": pointCoord]
+    case "LineString":
+      guard !lineCoords.isEmpty else { return nil }
+      return ["type": "LineString", "coordinates": lineCoords]
+    case "Polygon":
+      guard !outerRing.isEmpty else { return nil }
+      return ["type": "Polygon", "coordinates": [outerRing] + innerRings]
+    default:
+      return nil
+    }
+  }
+
+  private func resolveStyle(url: String) -> StyleInfo? {
+    let id = url.hasPrefix("#") ? String(url.dropFirst()) : url
+    if let style = styles[id] { return style }
+    if let normalUrl = styleMaps[id] {
+      let nid = normalUrl.hasPrefix("#") ? String(normalUrl.dropFirst()) : normalUrl
+      return styles[nid]
+    }
+    return nil
+  }
+
+  private func finalizeFeature() {
+    let geometry: [String: Any]
+    if currentGeometryType == "MultiGeometry" {
+      guard !multiGeometries.isEmpty else { return }
+      geometry = ["type": "GeometryCollection", "geometries": multiGeometries]
+    } else if let gType = currentGeometryType, let geom = buildGeometry(type: gType) {
+      geometry = 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()
+      }
+    }
+
+    var feature: [String: Any] = ["type": "Feature", "geometry": geometry, "properties": properties]
+    if let id = currentFeatureId, !id.isEmpty { feature["id"] = id }
+    features.append(feature)
+  }
+}
+
+private struct StyleInfo {
+  var strokeColor: String?
+  var strokeWidth: Double?
+  var fillColor: String?
+  var fillEnabled: Bool = true
+  var iconUrl: String?
+  var iconScale: Double?
+
+  var isEmpty: Bool { strokeColor == nil && fillColor == nil && iconUrl == nil }
+
+  func asDictionary() -> [String: Any] {
+    var d: [String: Any] = [:]
+    if let v = strokeColor { d["strokeColor"] = v }
+    if let v = strokeWidth { d["strokeWidth"] = v }
+    if let v = fillColor   { d["fillColor"]   = v }
+    if !fillEnabled        { d["fillEnabled"] = false }
+    if let v = iconUrl     { d["iconUrl"]     = v }
+    if let v = iconScale   { d["iconScale"]   = v }
+    return d
+  }
+}

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "@dunguel/expo-geo-parser",
+  "version": "0.1.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",
+  "scripts": {
+    "build": "expo-module build",
+    "clean": "expo-module clean",
+    "lint": "expo-module lint",
+    "test": "expo-module test",
+    "prepare": "expo-module prepare",
+    "prepublishOnly": "expo-module prepublishOnly",
+    "expo-module": "expo-module",
+    "open:ios": "xed example/ios",
+    "open:android": "open -a \"Android Studio\" example/android"
+  },
+  "keywords": [
+    "react-native",
+    "expo",
+    "expo-geo-parser",
+    "ExpoGeoParser"
+  ],
+  "repository": "https://github.com/guilhermedunguel/expo-geo-parser",
+  "bugs": {
+    "url": "https://github.com/guilhermedunguel/expo-geo-parser/issues"
+  },
+  "author": "Guilherme Dunguel <guilhermedunguel@gmail.com> (https://github.com/guilhermedunguel)",
+  "license": "MIT",
+  "homepage": "https://github.com/guilhermedunguel/expo-geo-parser#readme",
+  "dependencies": {},
+  "devDependencies": {
+    "@types/react": "~19.1.1",
+    "expo-module-scripts": "^55.0.2",
+    "expo": "^55.0.5",
+    "react-native": "0.82.1"
+  },
+  "peerDependencies": {
+    "expo": "*",
+    "react": "*",
+    "react-native": "*"
+  }
+}

package/src/ExpoGeoParser.types.ts

@@ -0,0 +1 @@
+export type ExpoGeoParserEvents = {};

package/src/ExpoGeoParserModule.ts

@@ -0,0 +1,48 @@
+import { NativeModule, requireNativeModule } from "expo";
+
+export type GeoFileType = "kml" | "kmz" | "zip" | "geojson" | "json" | "unknown";
+
+export type DetectedFileType = {
+  uri: string;
+  fileName?: string | null;
+  extension?: string | null;
+  type: GeoFileType;
+  uti?: string | null;
+};
+
+export type GeoJSONGeometry = {
+  type: string;
+  coordinates?: unknown;
+  geometries?: GeoJSONGeometry[];
+};
+
+export type GeoJSONFeature = {
+  type: "Feature";
+  id?: string | number;
+  geometry: GeoJSONGeometry;
+  properties: Record<string, unknown>;
+};
+
+export type GeoJSONFeatureCollection = {
+  type: "FeatureCollection";
+  name?: string;
+  description?: string;
+  sourceType?: GeoFileType;
+  features: GeoJSONFeature[];
+};
+
+export type ParseFeaturesEvent = {
+  features: GeoJSONFeature[];
+  isLast: boolean;
+};
+
+declare class ExpoGeoParserModule extends NativeModule {
+  detectFileType(uri: string): DetectedFileType;
+  parseFile(uri: string): Promise<Omit<GeoJSONFeatureCollection, "features">>;
+  addListener(
+    event: "onParseFeatures",
+    listener: (event: ParseFeaturesEvent) => void
+  ): { remove: () => void };
+}
+
+export default requireNativeModule<ExpoGeoParserModule>("ExpoGeoParser");