@dunguel/expo-geo-parser 0.1.0

package/.eslintrc.js

@@ -0,0 +1,5 @@
+module.exports = {
+  root: true,
+  extends: ['universe/native', 'universe/web'],
+  ignorePatterns: ['build'],
+};

package/README.md

@@ -0,0 +1,35 @@
+# expo-geo-parser
+
+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.
+
+# API documentation
+
+- [Documentation for the latest stable release](https://docs.expo.dev/versions/latest/sdk/geo-parser/)
+- [Documentation for the main branch](https://docs.expo.dev/versions/unversioned/sdk/geo-parser/)
+
+# Installation in managed Expo projects
+
+For [managed](https://docs.expo.dev/archive/managed-vs-bare/) Expo projects, please follow the installation instructions in the [API documentation for the latest stable release](#api-documentation). If you follow the link and there is no documentation available then this library is not yet usable within managed projects — it is likely to be included in an upcoming Expo SDK release.
+
+# Installation in bare React Native projects
+
+For bare React Native projects, you must ensure that you have [installed and configured the `expo` package](https://docs.expo.dev/bare/installing-expo-modules/) before continuing.
+
+### Add the package to your npm dependencies
+
+```
+npm install expo-geo-parser
+```
+
+### Configure for Android
+
+
+
+
+### Configure for iOS
+
+Run `npx pod-install` after installing the npm package.
+
+# Contributing
+
+Contributions are very welcome! Please refer to guidelines described in the [contributing guide]( https://github.com/expo/expo#contributing).

package/android/build.gradle

@@ -0,0 +1,18 @@
+plugins {
+  id 'com.android.library'
+  id 'kotlin-android'
+  id 'expo-module-gradle-plugin'
+}
+
+group = 'expo.modules.geoparser'
+version = '0.1.0'
+
+android {
+  namespace "expo.modules.geoparser"
+  defaultConfig {
+    versionCode 1
+    versionName "0.1.0"
+  }
+}
+
+dependencies {}

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android" />

package/android/src/main/java/expo/modules/geoparser/ExpoGeoParserModule.kt

@@ -0,0 +1,134 @@
+package expo.modules.geoparser
+
+import android.net.Uri
+import expo.modules.geoparser.parsers.GeoJSONParser
+import expo.modules.geoparser.parsers.KMLParser
+import expo.modules.kotlin.modules.Module
+import expo.modules.kotlin.modules.ModuleDefinition
+import java.io.File
+import java.io.InputStream
+import java.util.UUID
+import java.util.zip.ZipInputStream
+
+class ExpoGeoParserModule : Module() {
+    override fun definition() = ModuleDefinition {
+        Name("ExpoGeoParser")
+        Events("onParseFeatures")
+
+        Function("detectFileType") { uri: String ->
+            detectFileType(uri)
+        }
+
+        AsyncFunction("parseFile") { uri: String ->
+            parseGeoFile(uri) { batch, isLast ->
+                sendEvent("onParseFeatures", mapOf(
+                    "features" to batch,
+                    "isLast" to isLast
+                ))
+            }
+        }
+    }
+
+    private fun detectFileType(uri: String): Map<String, Any?> {
+        val parsed = Uri.parse(uri)
+        val fileName = parsed.lastPathSegment
+        val ext = fileName?.substringAfterLast('.', "")?.lowercase()?.takeIf { it.isNotEmpty() }
+        val type = when (ext) {
+            "kml"     -> "kml"
+            "kmz"     -> "kmz"
+            "zip"     -> "zip"
+            "geojson" -> "geojson"
+            "json"    -> "json"
+            else      -> "unknown"
+        }
+        return mapOf("uri" to uri, "fileName" to fileName, "extension" to ext, "type" to type, "uti" to null)
+    }
+
+    private fun openStream(uri: String): InputStream {
+        val parsed = Uri.parse(uri)
+        if (parsed.scheme == "file") {
+            return File(parsed.path ?: throw GeoParserError.InvalidURI(uri)).inputStream()
+        }
+        val context = appContext.reactContext ?: throw GeoParserError.InvalidURI(uri)
+        return context.contentResolver.openInputStream(parsed) ?: throw GeoParserError.InvalidURI(uri)
+    }
+
+    private fun parseGeoFile(uri: String, onFeatures: (List<Map<String, Any?>>, Boolean) -> Unit): Map<String, Any?> {
+        val parsed = Uri.parse(uri)
+        val ext = parsed.lastPathSegment?.substringAfterLast('.', "")?.lowercase() ?: ""
+
+        if (ext == "kmz" || ext == "zip") return parseArchive(uri, ext, onFeatures)
+
+        return openStream(uri).use { stream ->
+            when (ext) {
+                "kml"             -> KMLParser.parse(stream, "kml", onFeatures)
+                "geojson", "json" -> GeoJSONParser.parse(stream, ext, onFeatures)
+                else              -> sniffAndParse(stream, "unknown", onFeatures)
+            }
+        }
+    }
+
+    private fun parseArchive(uri: String, sourceType: String, onFeatures: (List<Map<String, Any?>>, Boolean) -> Unit): Map<String, Any?> {
+        val context = appContext.reactContext ?: throw GeoParserError.InvalidURI(uri)
+        val tmpDir = File(context.cacheDir, UUID.randomUUID().toString()).also { it.mkdirs() }
+        try {
+            var bestKmlFile: File? = null
+            var firstGeoJsonFile: File? = null
+
+            openStream(uri).use { raw ->
+                ZipInputStream(raw).use { zip ->
+                    var entry = zip.nextEntry
+                    while (entry != null) {
+                        val entryExt = entry.name.substringAfterLast('.', "").lowercase()
+                        if (!entry.isDirectory) {
+                            when (entryExt) {
+                                "kml" -> {
+                                    val outFile = File(tmpDir, entry.name.substringAfterLast('/'))
+                                    outFile.parentFile?.mkdirs()
+                                    outFile.outputStream().use { zip.copyTo(it) }
+                                    if (bestKmlFile == null || entry.name.lowercase().endsWith("doc.kml")) {
+                                        bestKmlFile = outFile
+                                    }
+                                }
+                                "geojson", "json" -> {
+                                    if (firstGeoJsonFile == null) {
+                                        val outFile = File(tmpDir, entry.name.substringAfterLast('/'))
+                                        outFile.outputStream().use { zip.copyTo(it) }
+                                        firstGeoJsonFile = outFile
+                                    }
+                                }
+                            }
+                        }
+                        zip.closeEntry()
+                        entry = zip.nextEntry
+                    }
+                }
+            }
+
+            bestKmlFile?.let { file ->
+                return file.inputStream().use { KMLParser.parse(it, sourceType, onFeatures) }
+            }
+            firstGeoJsonFile?.let { file ->
+                return file.inputStream().use { GeoJSONParser.parse(it, sourceType, onFeatures) }
+            }
+
+            throw GeoParserError.NoGeoDataFound
+        } finally {
+            tmpDir.deleteRecursively()
+        }
+    }
+
+    private fun sniffAndParse(stream: InputStream, sourceType: String, onFeatures: (List<Map<String, Any?>>, Boolean) -> Unit): Map<String, Any?> {
+        val buffered = stream.buffered()
+        buffered.mark(512)
+        val peek = ByteArray(256)
+        val n = buffered.read(peek)
+        buffered.reset()
+        val prefix = if (n > 0) String(peek, 0, n, Charsets.UTF_8) else ""
+        return when {
+            prefix.trimStart().startsWith("{")                                               -> GeoJSONParser.parse(buffered, sourceType, onFeatures)
+            "<kml" in prefix || "<Placemark" in prefix || "<Document" in prefix -> KMLParser.parse(buffered, sourceType, onFeatures)
+            else -> throw GeoParserError.UnsupportedFormat
+        }
+    }
+}

package/android/src/main/java/expo/modules/geoparser/GeoParserError.kt

@@ -0,0 +1,9 @@
+package expo.modules.geoparser
+
+sealed class GeoParserError(message: String) : Exception(message) {
+    class InvalidURI(uri: String) : GeoParserError("Invalid URI: $uri")
+    object ExtractionFailed       : GeoParserError("Failed to extract archive")
+    object NoGeoDataFound         : GeoParserError("No supported geo data found in archive")
+    object UnsupportedFormat      : GeoParserError("Unsupported or unrecognised file format")
+    class ParseError(msg: String) : GeoParserError("Parse error: $msg")
+}

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

@@ -0,0 +1,100 @@
+package expo.modules.geoparser.parsers
+
+import expo.modules.geoparser.GeoParserError
+import org.json.JSONArray
+import org.json.JSONObject
+import java.io.InputStream
+
+object GeoJSONParser {
+
+    fun parse(input: InputStream, sourceType: String, onFeatures: (List<Map<String, Any?>>, isLast: Boolean) -> Unit): Map<String, Any?> {
+        val json = try {
+            JSONObject(input.reader(Charsets.UTF_8).readText())
+        } catch (e: Exception) {
+            throw GeoParserError.ParseError("Invalid JSON")
+        }
+
+        val features = extractFeatures(json)
+        val batchSize = 200
+        if (features.isEmpty()) {
+            onFeatures(emptyList(), true)
+        } else {
+            var idx = 0
+            while (idx < features.size) {
+                val end = minOf(idx + batchSize, features.size)
+                onFeatures(features.subList(idx, end), end >= features.size)
+                idx = end
+            }
+        }
+
+        val result = mutableMapOf<String, Any?>(
+            "type" to "FeatureCollection",
+            "sourceType" to sourceType
+        )
+        json.optString("name").takeIf { it.isNotEmpty() }?.let { result["name"] = it }
+        json.optJSONObject("properties")?.let { props ->
+            props.optString("name").takeIf { it.isNotEmpty() }?.let { result["name"] = it }
+            props.optString("description").takeIf { it.isNotEmpty() }?.let { result["description"] = it }
+        }
+
+        return result
+    }
+
+    private fun extractFeatures(json: JSONObject): List<Map<String, Any?>> {
+        return when (val type = json.optString("type")) {
+            "FeatureCollection" -> {
+                val arr = json.optJSONArray("features") ?: return emptyList()
+                (0 until arr.length()).mapNotNull { parseFeature(arr.getJSONObject(it)) }
+            }
+            "Feature" -> listOfNotNull(parseFeature(json))
+            else -> {
+                if (isGeometryType(type)) listOfNotNull(bareGeometryToFeature(json))
+                else emptyList()
+            }
+        }
+    }
+
+    private fun parseFeature(json: JSONObject): Map<String, Any?>? {
+        if (json.optString("type") != "Feature") return null
+        val geometry = json.optJSONObject("geometry") ?: return null
+        val properties = json.optJSONObject("properties") ?: JSONObject()
+        val feature = mutableMapOf<String, Any?>(
+            "type" to "Feature",
+            "geometry" to toMap(geometry),
+            "properties" to toMap(properties)
+        )
+        json.opt("id")?.takeIf { it != JSONObject.NULL }?.let { feature["id"] = it.toString() }
+        return feature
+    }
+
+    private fun bareGeometryToFeature(json: JSONObject): Map<String, Any?>? {
+        if (json.optString("type").isEmpty()) return null
+        return mapOf(
+            "type" to "Feature",
+            "geometry" to toMap(json),
+            "properties" to emptyMap<String, Any?>()
+        )
+    }
+
+    private fun isGeometryType(type: String): Boolean = type in setOf(
+        "Point", "LineString", "Polygon",
+        "MultiPoint", "MultiLineString", "MultiPolygon",
+        "GeometryCollection"
+    )
+
+    fun toMap(obj: JSONObject): Map<String, Any?> {
+        val map = mutableMapOf<String, Any?>()
+        for (key in obj.keys()) map[key] = toKotlin(obj.get(key))
+        return map
+    }
+
+    private fun toList(arr: JSONArray): List<Any?> =
+        (0 until arr.length()).map { toKotlin(arr.get(it)) }
+
+    private fun toKotlin(value: Any?): Any? = when (value) {
+        is JSONObject -> toMap(value)
+        is JSONArray -> toList(value)
+        JSONObject.NULL -> null
+        else -> value
+    }
+}

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

@@ -0,0 +1,283 @@
+package expo.modules.geoparser.parsers
+
+import expo.modules.geoparser.GeoParserError
+import org.xml.sax.Attributes
+import org.xml.sax.helpers.DefaultHandler
+import java.io.InputStream
+import javax.xml.parsers.SAXParserFactory
+
+class KMLParser(
+    private val batchSize: Int = 200,
+    private val onFeatures: (List<Map<String, Any?>>, isLast: Boolean) -> Unit
+) : DefaultHandler() {
+
+    private val featureBuffer = mutableListOf<Map<String, Any?>>()
+    var documentName = ""
+    var documentDescription = ""
+    private val styles = mutableMapOf<String, StyleInfo>()
+    private val styleMaps = mutableMapOf<String, String>()
+
+    private val elementStack = mutableListOf<String>()
+    private val textBuffer = StringBuilder()
+
+    private var documentDepth = 0
+    private var documentMetaCaptured = false
+
+    private var inPlacemark = false
+    private var currentFeatureId: String? = null
+    private var currentFeatureName = ""
+    private var currentFeatureDescription = ""
+    private var currentFeatureStyleUrl = ""
+    private var currentGeometryType: String? = null
+
+    private var pointCoord = listOf<Double>()
+    private var lineCoords = listOf<List<Double>>()
+    private var currentRing = listOf<List<Double>>()
+    private var outerRing = listOf<List<Double>>()
+    private var innerRings = mutableListOf<List<List<Double>>>()
+    private var inOuterBoundary = false
+    private var inInnerBoundary = false
+
+    private var inMultiGeometry = false
+    private var multiGeometries = mutableListOf<Map<String, Any?>>()
+
+    private var currentStyleId: String? = null
+    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? = null
+    private var inPair = false
+    private var currentPairKey = ""
+    private var currentPairStyleUrl = ""
+
+    companion object {
+        fun parse(input: InputStream, sourceType: String, onFeatures: (List<Map<String, Any?>>, Boolean) -> Unit): Map<String, Any?> {
+            val handler = KMLParser(onFeatures = onFeatures)
+            val factory = SAXParserFactory.newInstance().apply { isNamespaceAware = true }
+            try {
+                factory.newSAXParser().parse(input, handler)
+            } catch (e: Exception) {
+                throw GeoParserError.ParseError(e.message ?: "XML parse error")
+            }
+            val result = mutableMapOf<String, Any?>(
+                "type" to "FeatureCollection",
+                "sourceType" to sourceType
+            )
+            if (handler.documentName.isNotEmpty()) result["name"] = handler.documentName
+            if (handler.documentDescription.isNotEmpty()) result["description"] = handler.documentDescription
+            return result
+        }
+    }
+
+    override fun startElement(uri: String?, localName: String?, qName: String?, attrs: Attributes?) {
+        val name = stripped(localName ?: qName ?: "")
+        elementStack.add(name)
+        textBuffer.clear()
+
+        when (name) {
+            "Document"       -> documentDepth++
+            "Style"          -> { currentStyleId = attrs?.getValue("id"); buildingStyle = StyleInfo() }
+            "StyleMap"       -> { inStyleMap = true; currentStyleMapId = attrs?.getValue("id") }
+            "Pair"           -> if (inStyleMap) { inPair = true; currentPairKey = ""; currentPairStyleUrl = "" }
+            "LineStyle"      -> inLineStyle = true
+            "PolyStyle"      -> inPolyStyle = true
+            "IconStyle"      -> inIconStyle = true
+            "Icon"           -> if (inIconStyle) inIconHref = true
+            "Placemark"      -> {
+                inPlacemark = true
+                currentFeatureId = attrs?.getValue("id")
+                currentFeatureName = ""
+                currentFeatureDescription = ""
+                currentFeatureStyleUrl = ""
+                currentGeometryType = null
+                multiGeometries = mutableListOf()
+            }
+            "Point"          -> { currentGeometryType = "Point";      pointCoord = listOf() }
+            "LineString"     -> { currentGeometryType = "LineString"; lineCoords = listOf() }
+            "LinearRing"     -> currentRing = listOf()
+            "Polygon"        -> {
+                currentGeometryType = "Polygon"
+                outerRing = listOf(); innerRings = mutableListOf()
+                inOuterBoundary = false; inInnerBoundary = false
+            }
+            "MultiGeometry"  -> { inMultiGeometry = true; multiGeometries = mutableListOf() }
+            "outerBoundaryIs" -> { inOuterBoundary = true;  inInnerBoundary = false }
+            "innerBoundaryIs" -> { inInnerBoundary = true; inOuterBoundary = false }
+        }
+    }
+
+    override fun characters(ch: CharArray?, start: Int, length: Int) {
+        if (ch != null) textBuffer.append(ch, start, length)
+    }
+
+    override fun endElement(uri: String?, localName: String?, qName: String?) {
+        val name = stripped(localName ?: qName ?: "")
+        val text = textBuffer.toString().trim()
+        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 }
+            }
+            "description" -> when {
+                inPlacemark -> currentFeatureDescription = text
+                documentDepth > 0 && documentDescription.isEmpty() -> documentDescription = text
+            }
+            "Style"      -> { currentStyleId?.let { styles[it] = buildingStyle }; currentStyleId = null }
+            "StyleMap"   -> { inStyleMap = false; currentStyleMapId = null }
+            "Pair"       -> {
+                if (inStyleMap && currentPairKey == "normal") currentStyleMapId?.let { styleMaps[it] = currentPairStyleUrl }
+                inPair = false
+            }
+            "key"        -> if (inStyleMap && inPair) currentPairKey = text
+            "styleUrl"   -> when {
+                inPlacemark -> currentFeatureStyleUrl = text
+                inStyleMap && inPair -> currentPairStyleUrl = text
+            }
+            "LineStyle"  -> inLineStyle = false
+            "PolyStyle"  -> inPolyStyle = false
+            "IconStyle"  -> inIconStyle = false
+            "Icon"       -> inIconHref = false
+            "color"      -> {
+                val hex = kmlColorToCSS(text)
+                when {
+                    inLineStyle -> buildingStyle.strokeColor = hex
+                    inPolyStyle -> buildingStyle.fillColor = hex
+                }
+            }
+            "width"      -> if (inLineStyle) text.toDoubleOrNull()?.let { buildingStyle.strokeWidth = it }
+            "fill"       -> if (inPolyStyle) buildingStyle.fillEnabled = text != "0"
+            "href"       -> if (inIconHref) buildingStyle.iconUrl = text
+            "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
+                    "LinearRing" -> currentRing = coords
+                }
+            }
+            "LinearRing"      -> when {
+                inOuterBoundary -> outerRing = currentRing
+                inInnerBoundary -> innerRings.add(currentRing)
+            }
+            "outerBoundaryIs" -> inOuterBoundary = false
+            "innerBoundaryIs" -> inInnerBoundary = false
+            "Point", "LineString", "Polygon" -> {
+                if (inMultiGeometry) {
+                    buildGeometry(name)?.let {
+                        multiGeometries.add(it)
+                        pointCoord = listOf(); lineCoords = listOf()
+                        outerRing = listOf(); innerRings = mutableListOf()
+                    }
+                }
+            }
+            "MultiGeometry" -> { inMultiGeometry = false; currentGeometryType = "MultiGeometry" }
+            "Placemark"     -> { finalizeFeature(); inPlacemark = false }
+        }
+    }
+
+    override fun endDocument() {
+        onFeatures(featureBuffer.toList(), true)
+        featureBuffer.clear()
+    }
+
+    private fun stripped(name: String): String {
+        val idx = name.lastIndexOf(':')
+        return if (idx >= 0) name.substring(idx + 1) else name
+    }
+
+    private fun kmlColorToCSS(kml: String): String {
+        val s = kml.trim().lowercase()
+        if (s.length != 8) return "#000000"
+        return "#${s.substring(6, 8)}${s.substring(4, 6)}${s.substring(2, 4)}"
+    }
+
+    private fun parseCoordinates(text: String): List<List<Double>> =
+        text.trim().split(Regex("\\s+"))
+            .filter { it.isNotEmpty() }
+            .mapNotNull { tuple ->
+                val parts = tuple.split(",").mapNotNull { it.toDoubleOrNull() }
+                if (parts.size >= 2) parts else null
+            }
+
+    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
+        "Polygon"    -> if (outerRing.isNotEmpty()) mapOf("type" to "Polygon", "coordinates" to (listOf(outerRing) + innerRings)) else null
+        else         -> null
+    }
+
+    private fun resolveStyle(url: String): StyleInfo? {
+        val id = if (url.startsWith("#")) url.drop(1) else url
+        styles[id]?.let { return it }
+        styleMaps[id]?.let { normalUrl ->
+            val nid = if (normalUrl.startsWith("#")) normalUrl.drop(1) else normalUrl
+            return styles[nid]
+        }
+        return null
+    }
+
+    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
+        if (currentFeatureStyleUrl.isNotEmpty()) {
+            properties["styleId"] = currentFeatureStyleUrl
+            resolveStyle(currentFeatureStyleUrl)?.takeIf { !it.isEmpty }?.let {
+                properties["style"] = it.asDictionary()
+            }
+        }
+
+        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()
+        }
+    }
+}
+
+private data class StyleInfo(
+    var strokeColor: String? = null,
+    var strokeWidth: Double? = null,
+    var fillColor: String? = null,
+    var fillEnabled: Boolean = true,
+    var iconUrl: String? = null,
+    var iconScale: Double? = null
+) {
+    val isEmpty: Boolean get() = strokeColor == null && fillColor == null && iconUrl == null
+
+    fun asDictionary(): Map<String, Any?> {
+        val d = mutableMapOf<String, Any?>()
+        strokeColor?.let { d["strokeColor"] = it }
+        strokeWidth?.let { d["strokeWidth"] = it }
+        fillColor?.let { d["fillColor"] = it }
+        if (!fillEnabled) d["fillEnabled"] = false
+        iconUrl?.let { d["iconUrl"] = it }
+        iconScale?.let { d["iconScale"] = it }
+        return d
+    }
+}

package/build/ExpoGeoParser.types.d.ts

@@ -0,0 +1,2 @@
+export type ExpoGeoParserEvents = {};
+//# sourceMappingURL=ExpoGeoParser.types.d.ts.map

package/build/ExpoGeoParser.types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ExpoGeoParser.types.d.ts","sourceRoot":"","sources":["../src/ExpoGeoParser.types.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,mBAAmB,GAAG,EAAE,CAAC"}

package/build/ExpoGeoParser.types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=ExpoGeoParser.types.js.map

package/build/ExpoGeoParser.types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ExpoGeoParser.types.js","sourceRoot":"","sources":["../src/ExpoGeoParser.types.ts"],"names":[],"mappings":"","sourcesContent":["export type ExpoGeoParserEvents = {};\n"]}

package/build/ExpoGeoParserModule.d.ts

@@ -0,0 +1,41 @@
+import { NativeModule } 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;
+    };
+}
+declare const _default: ExpoGeoParserModule;
+export default _default;
+//# sourceMappingURL=ExpoGeoParserModule.d.ts.map

package/build/ExpoGeoParserModule.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ExpoGeoParserModule.d.ts","sourceRoot":"","sources":["../src/ExpoGeoParserModule.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAuB,MAAM,MAAM,CAAC;AAEzD,MAAM,MAAM,WAAW,GAAG,KAAK,GAAG,KAAK,GAAG,KAAK,GAAG,SAAS,GAAG,MAAM,GAAG,SAAS,CAAC;AAEjF,MAAM,MAAM,gBAAgB,GAAG;IAC7B,GAAG,EAAE,MAAM,CAAC;IACZ,QAAQ,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACzB,SAAS,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1B,IAAI,EAAE,WAAW,CAAC;IAClB,GAAG,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CACrB,CAAC;AAEF,MAAM,MAAM,eAAe,GAAG;IAC5B,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,UAAU,CAAC,EAAE,eAAe,EAAE,CAAC;CAChC,CAAC;AAEF,MAAM,MAAM,cAAc,GAAG;IAC3B,IAAI,EAAE,SAAS,CAAC;IAChB,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IACrB,QAAQ,EAAE,eAAe,CAAC;IAC1B,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACrC,CAAC;AAEF,MAAM,MAAM,wBAAwB,GAAG;IACrC,IAAI,EAAE,mBAAmB,CAAC;IAC1B,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,UAAU,CAAC,EAAE,WAAW,CAAC;IACzB,QAAQ,EAAE,cAAc,EAAE,CAAC;CAC5B,CAAC;AAEF,MAAM,MAAM,kBAAkB,GAAG;IAC/B,QAAQ,EAAE,cAAc,EAAE,CAAC;IAC3B,MAAM,EAAE,OAAO,CAAC;CACjB,CAAC;AAEF,OAAO,OAAO,mBAAoB,SAAQ,YAAY;IACpD,cAAc,CAAC,GAAG,EAAE,MAAM,GAAG,gBAAgB;IAC7C,SAAS,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,wBAAwB,EAAE,UAAU,CAAC,CAAC;IAC3E,WAAW,CACT,KAAK,EAAE,iBAAiB,EACxB,QAAQ,EAAE,CAAC,KAAK,EAAE,kBAAkB,KAAK,IAAI,GAC5C;QAAE,MAAM,EAAE,MAAM,IAAI,CAAA;KAAE;CAC1B;;AAED,wBAAyE"}

package/build/ExpoGeoParserModule.js

@@ -0,0 +1,3 @@
+import { requireNativeModule } from "expo";
+export default requireNativeModule("ExpoGeoParser");
+//# sourceMappingURL=ExpoGeoParserModule.js.map

package/build/ExpoGeoParserModule.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ExpoGeoParserModule.js","sourceRoot":"","sources":["../src/ExpoGeoParserModule.ts"],"names":[],"mappings":"AAAA,OAAO,EAAgB,mBAAmB,EAAE,MAAM,MAAM,CAAC;AA+CzD,eAAe,mBAAmB,CAAsB,eAAe,CAAC,CAAC","sourcesContent":["import { NativeModule, requireNativeModule } from \"expo\";\n\nexport type GeoFileType = \"kml\" | \"kmz\" | \"zip\" | \"geojson\" | \"json\" | \"unknown\";\n\nexport type DetectedFileType = {\n  uri: string;\n  fileName?: string | null;\n  extension?: string | null;\n  type: GeoFileType;\n  uti?: string | null;\n};\n\nexport type GeoJSONGeometry = {\n  type: string;\n  coordinates?: unknown;\n  geometries?: GeoJSONGeometry[];\n};\n\nexport type GeoJSONFeature = {\n  type: \"Feature\";\n  id?: string | number;\n  geometry: GeoJSONGeometry;\n  properties: Record<string, unknown>;\n};\n\nexport type GeoJSONFeatureCollection = {\n  type: \"FeatureCollection\";\n  name?: string;\n  description?: string;\n  sourceType?: GeoFileType;\n  features: GeoJSONFeature[];\n};\n\nexport type ParseFeaturesEvent = {\n  features: GeoJSONFeature[];\n  isLast: boolean;\n};\n\ndeclare class ExpoGeoParserModule extends NativeModule {\n  detectFileType(uri: string): DetectedFileType;\n  parseFile(uri: string): Promise<Omit<GeoJSONFeatureCollection, \"features\">>;\n  addListener(\n    event: \"onParseFeatures\",\n    listener: (event: ParseFeaturesEvent) => void\n  ): { remove: () => void };\n}\n\nexport default requireNativeModule<ExpoGeoParserModule>(\"ExpoGeoParser\");\n"]}