From ed4e362ea1c9893a084468af7174790e75ef49c9 Mon Sep 17 00:00:00 2001 From: Cursor Agent Date: Thu, 1 Oct 2026 00:08:13 +0000 Subject: [PATCH 01/42] feat: initial @capgo/capacitor-native-map plugin scaffold Unified NativeMap JS API with Google Maps on Android, MapKit on iOS, and Google Maps JS on web. Includes example app, CI workflows, and third-party license notices for ported MIT sources. Co-authored-by: Martin DONADIEU --- .eslintignore | 4 + .github/FUNDING.yml | 1 + .github/ISSUE_TEMPLATE/bug-report.md | 84 ++ .github/ISSUE_TEMPLATE/feature-request.md | 41 + .github/scripts/verify-packed-example.sh | 59 + .github/workflows/build.yml | 89 ++ .github/workflows/bump_version.yml | 63 + .../workflows/github-releases-to-discord.yml | 25 + .github/workflows/pr_beta_prompt.yml | 86 ++ .github/workflows/pr_beta_publish.yml | 324 +++++ .github/workflows/test.yml | 105 ++ .gitignore | 78 ++ .maestro/android/basic-features.yaml | 5 + .maestro/flows/basic-local-music.yaml | 47 + .maestro/ios/basic-features.yaml | 5 + .npmignore | 60 + .prettierignore | 1 + AGENTS.md | 130 ++ CHANGELOG.md | 5 + CapgoCapacitorNativeMap.podspec | 16 + NOTICE | 8 + Package.swift | 31 + README.md | 933 ++++++++++++- THIRD_PARTY_LICENSES | 8 + android/.gitignore | 1 + android/build.gradle | 103 ++ android/gradle.properties | 22 + android/gradle/wrapper/gradle-wrapper.jar | Bin 0 -> 43764 bytes .../gradle/wrapper/gradle-wrapper.properties | 7 + android/gradlew | 251 ++++ android/gradlew.bat | 94 ++ android/proguard-rules.pro | 21 + android/settings.gradle | 2 + android/src/main/AndroidManifest.xml | 2 + .../CapacitorClusterManagerRenderer.kt | 37 + .../plugins/nativemap/CapacitorGoogleMap.kt | 1190 +++++++++++++++++ .../nativemap/CapacitorGoogleMapMarker.kt | 93 ++ .../nativemap/CapacitorGoogleMapPolyline.kt | 78 ++ .../CapacitorGoogleMapTileOverlay.kt | 28 + .../nativemap/CapacitorGoogleMapsBounds.kt | 33 + .../nativemap/CapacitorGoogleMapsCircle.kt | 63 + .../nativemap/CapacitorGoogleMapsPlugin.kt | 1139 ++++++++++++++++ .../nativemap/CapacitorGoogleMapsPoint.kt | 23 + .../nativemap/CapacitorGoogleMapsPolygon.kt | 80 ++ .../nativemap/CapacitorGoogleMapsStyleSpan.kt | 5 + .../nativemap/GoogleMapCameraConfig.kt | 50 + .../plugins/nativemap/GoogleMapConfig.kt | 165 +++ .../plugins/nativemap/GoogleMapErrors.kt | 114 ++ .../plugins/nativemap/GoogleMapPadding.kt | 28 + android/src/main/res/.gitkeep | 0 assets/github-social-preview.png | Bin 0 -> 109623 bytes assets/github-social-template.svg | 78 ++ bun.lock | 837 ++++++++++++ example-app/README.md | 34 + example-app/android/.gitignore | 101 ++ example-app/android/app/.gitignore | 2 + example-app/android/app/build.gradle | 54 + .../android/app/capacitor.build.gradle | 19 + example-app/android/app/proguard-rules.pro | 21 + .../myapp/ExampleInstrumentedTest.java | 26 + .../android/app/src/main/AndroidManifest.xml | 42 + .../app/capgo/nativeaudio/MainActivity.java | 5 + .../main/res/drawable-land-hdpi/splash.png | Bin 0 -> 7705 bytes .../main/res/drawable-land-mdpi/splash.png | Bin 0 -> 4040 bytes .../main/res/drawable-land-xhdpi/splash.png | Bin 0 -> 9251 bytes .../main/res/drawable-land-xxhdpi/splash.png | Bin 0 -> 13984 bytes .../main/res/drawable-land-xxxhdpi/splash.png | Bin 0 -> 17683 bytes .../main/res/drawable-port-hdpi/splash.png | Bin 0 -> 7934 bytes .../main/res/drawable-port-mdpi/splash.png | Bin 0 -> 4096 bytes .../main/res/drawable-port-xhdpi/splash.png | Bin 0 -> 9875 bytes .../main/res/drawable-port-xxhdpi/splash.png | Bin 0 -> 13346 bytes .../main/res/drawable-port-xxxhdpi/splash.png | Bin 0 -> 17489 bytes .../drawable-v24/ic_launcher_foreground.xml | 34 + .../res/drawable/ic_launcher_background.xml | 170 +++ .../app/src/main/res/drawable/splash.png | Bin 0 -> 4040 bytes .../app/src/main/res/layout/activity_main.xml | 12 + .../res/mipmap-anydpi-v26/ic_launcher.xml | 5 + .../mipmap-anydpi-v26/ic_launcher_round.xml | 5 + .../src/main/res/mipmap-hdpi/ic_launcher.png | Bin 0 -> 2786 bytes .../mipmap-hdpi/ic_launcher_foreground.png | Bin 0 -> 3450 bytes .../res/mipmap-hdpi/ic_launcher_round.png | Bin 0 -> 4341 bytes .../src/main/res/mipmap-mdpi/ic_launcher.png | Bin 0 -> 1869 bytes .../mipmap-mdpi/ic_launcher_foreground.png | Bin 0 -> 2110 bytes .../res/mipmap-mdpi/ic_launcher_round.png | Bin 0 -> 2725 bytes .../src/main/res/mipmap-xhdpi/ic_launcher.png | Bin 0 -> 3981 bytes .../mipmap-xhdpi/ic_launcher_foreground.png | Bin 0 -> 5036 bytes .../res/mipmap-xhdpi/ic_launcher_round.png | Bin 0 -> 6593 bytes .../main/res/mipmap-xxhdpi/ic_launcher.png | Bin 0 -> 6644 bytes .../mipmap-xxhdpi/ic_launcher_foreground.png | Bin 0 -> 9793 bytes .../res/mipmap-xxhdpi/ic_launcher_round.png | Bin 0 -> 10455 bytes .../main/res/mipmap-xxxhdpi/ic_launcher.png | Bin 0 -> 9441 bytes .../mipmap-xxxhdpi/ic_launcher_foreground.png | Bin 0 -> 15529 bytes .../res/mipmap-xxxhdpi/ic_launcher_round.png | Bin 0 -> 15916 bytes .../res/values/ic_launcher_background.xml | 4 + .../app/src/main/res/values/strings.xml | 7 + .../app/src/main/res/values/styles.xml | 22 + .../app/src/main/res/xml/file_paths.xml | 5 + .../getcapacitor/myapp/ExampleUnitTest.java | 18 + example-app/android/build.gradle | 29 + example-app/android/capacitor.settings.gradle | 6 + example-app/android/gradle.properties | 22 + .../android/gradle/wrapper/gradle-wrapper.jar | Bin 0 -> 43764 bytes .../gradle/wrapper/gradle-wrapper.properties | 7 + example-app/android/gradlew | 251 ++++ example-app/android/gradlew.bat | 94 ++ example-app/android/settings.gradle | 5 + example-app/android/variables.gradle | 16 + example-app/bun.lock | 908 +++++++++++++ example-app/bunfig.toml | 2 + example-app/capacitor.config.ts | 13 + example-app/index.html | 19 + example-app/ios/.gitignore | 13 + .../ios/App/App.xcodeproj/project.pbxproj | 380 ++++++ .../xcshareddata/IDEWorkspaceChecks.plist | 8 + example-app/ios/App/App/AppDelegate.swift | 58 + .../AppIcon.appiconset/AppIcon-512@2x.png | Bin 0 -> 110522 bytes .../AppIcon.appiconset/Contents.json | 14 + .../ios/App/App/Assets.xcassets/Contents.json | 6 + .../Splash.imageset/Contents.json | 23 + .../Splash.imageset/splash-2732x2732-1.png | Bin 0 -> 41273 bytes .../Splash.imageset/splash-2732x2732-2.png | Bin 0 -> 41273 bytes .../Splash.imageset/splash-2732x2732.png | Bin 0 -> 41273 bytes .../App/Base.lproj/LaunchScreen.storyboard | 32 + .../ios/App/App/Base.lproj/Main.storyboard | 19 + example-app/ios/App/App/Info.plist | 70 + example-app/ios/App/App/SceneDelegate.swift | 24 + example-app/ios/App/CapApp-SPM/.gitignore | 9 + example-app/ios/App/CapApp-SPM/Package.swift | 27 + example-app/ios/App/CapApp-SPM/README.md | 5 + .../Sources/CapApp-SPM/CapApp-SPM.swift | 1 + example-app/ios/debug.xcconfig | 1 + example-app/package.json | 32 + example-app/public/audio/beep.wav | Bin 0 -> 52964 bytes example-app/public/audio/music.mp3 | Bin 0 -> 296934 bytes example-app/src/App.css | 27 + example-app/src/App.tsx | 83 ++ example-app/src/index.css | 37 + example-app/src/main.tsx | 10 + example-app/src/vite-env.d.ts | 1 + .../supabase/.branches/_current_branch | 1 + example-app/supabase/.temp/cli-latest | 1 + example-app/tsconfig.json | 24 + example-app/tsconfig.node.json | 10 + example-app/vite.config.ts | 9 + ios/.gitignore | 8 + ios/Sources/NativeMapPlugin/Appearance.swift | 234 ++++ .../NativeMapPlugin/AppleMapMarker.swift | 94 ++ ios/Sources/NativeMapPlugin/Callout.swift | 133 ++ .../NativeMapPlugin/CameraEvents.swift | 70 + .../NativeMapPlugin/CapacitorAppleMaps.swift | 487 +++++++ .../CapacitorAppleMapsPlugin.swift | 293 ++++ .../NativeMapPlugin/ControlsBridge.swift | 84 ++ ios/Sources/NativeMapPlugin/Geocode.swift | 112 ++ .../NativeMapPlugin/GoogleMapsBridge.swift | 91 ++ ios/Sources/NativeMapPlugin/MainThread.swift | 17 + .../NativeMapPlugin/MapAnnotations.swift | 124 ++ ios/Sources/NativeMapPlugin/MapControls.swift | 101 ++ ios/Sources/NativeMapPlugin/MapMounting.swift | 150 +++ ios/Sources/NativeMapPlugin/MapReadback.swift | 66 + .../NativeMapPlugin/MarkerBridge.swift | 98 ++ ios/Sources/NativeMapPlugin/MarkerIcons.swift | 92 ++ ios/Sources/NativeMapPlugin/Overlays.swift | 427 ++++++ ios/Sources/NativeMapPlugin/Permissions.swift | 66 + ios/Sources/NativeMapPlugin/PluginError.swift | 21 + ios/Sources/NativeMapPlugin/Search.swift | 246 ++++ ios/Sources/NativeMapPlugin/Snapshot.swift | 153 +++ ios/Sources/NativeMapPlugin/ViewHelpers.swift | 68 + .../CapacitorAppleMapsTests.swift | 490 +++++++ .../NativeMapPluginTests/GeocodeTests.swift | 32 + .../NativeMapPluginTests/MapStateTests.swift | 210 +++ .../MarkerAnchorTests.swift | 76 ++ .../MarkerStyleTests.swift | 80 ++ legal/MIT-capacitor-google-maps.txt | 21 + legal/MIT-capacitor-plugin-apple-maps.txt | 21 + package.json | 103 ++ renovate.json | 93 ++ rollup.config.mjs | 22 + scripts/check-cap9-deprecated.mjs | 304 +++++ scripts/check-capacitor-plugin-wiring.mjs | 254 ++++ scripts/generate-ai-changelog.mjs | 135 ++ scripts/tsconfig.json | 19 + src/definitions.ts | 534 ++++++++ src/implementation.ts | 238 ++++ src/index.ts | 13 + src/map.ts | 1113 +++++++++++++++ src/web.ts | 726 ++++++++++ swiftlint.config.js | 25 + tsconfig.json | 21 + 188 files changed, 17398 insertions(+), 2 deletions(-) create mode 100644 .eslintignore create mode 100644 .github/FUNDING.yml create mode 100644 .github/ISSUE_TEMPLATE/bug-report.md create mode 100644 .github/ISSUE_TEMPLATE/feature-request.md create mode 100755 .github/scripts/verify-packed-example.sh create mode 100644 .github/workflows/build.yml create mode 100644 .github/workflows/bump_version.yml create mode 100644 .github/workflows/github-releases-to-discord.yml create mode 100644 .github/workflows/pr_beta_prompt.yml create mode 100644 .github/workflows/pr_beta_publish.yml create mode 100644 .github/workflows/test.yml create mode 100644 .gitignore create mode 100644 .maestro/android/basic-features.yaml create mode 100644 .maestro/flows/basic-local-music.yaml create mode 100644 .maestro/ios/basic-features.yaml create mode 100644 .npmignore create mode 100644 .prettierignore create mode 100644 AGENTS.md create mode 100644 CHANGELOG.md create mode 100644 CapgoCapacitorNativeMap.podspec create mode 100644 NOTICE create mode 100644 Package.swift create mode 100644 THIRD_PARTY_LICENSES create mode 100644 android/.gitignore create mode 100644 android/build.gradle create mode 100644 android/gradle.properties create mode 100644 android/gradle/wrapper/gradle-wrapper.jar create mode 100644 android/gradle/wrapper/gradle-wrapper.properties create mode 100755 android/gradlew create mode 100644 android/gradlew.bat create mode 100644 android/proguard-rules.pro create mode 100644 android/settings.gradle create mode 100644 android/src/main/AndroidManifest.xml create mode 100644 android/src/main/java/com/capgo/plugins/nativemap/CapacitorClusterManagerRenderer.kt create mode 100644 android/src/main/java/com/capgo/plugins/nativemap/CapacitorGoogleMap.kt create mode 100644 android/src/main/java/com/capgo/plugins/nativemap/CapacitorGoogleMapMarker.kt create mode 100644 android/src/main/java/com/capgo/plugins/nativemap/CapacitorGoogleMapPolyline.kt create mode 100644 android/src/main/java/com/capgo/plugins/nativemap/CapacitorGoogleMapTileOverlay.kt create mode 100644 android/src/main/java/com/capgo/plugins/nativemap/CapacitorGoogleMapsBounds.kt create mode 100644 android/src/main/java/com/capgo/plugins/nativemap/CapacitorGoogleMapsCircle.kt create mode 100644 android/src/main/java/com/capgo/plugins/nativemap/CapacitorGoogleMapsPlugin.kt create mode 100644 android/src/main/java/com/capgo/plugins/nativemap/CapacitorGoogleMapsPoint.kt create mode 100644 android/src/main/java/com/capgo/plugins/nativemap/CapacitorGoogleMapsPolygon.kt create mode 100644 android/src/main/java/com/capgo/plugins/nativemap/CapacitorGoogleMapsStyleSpan.kt create mode 100644 android/src/main/java/com/capgo/plugins/nativemap/GoogleMapCameraConfig.kt create mode 100644 android/src/main/java/com/capgo/plugins/nativemap/GoogleMapConfig.kt create mode 100644 android/src/main/java/com/capgo/plugins/nativemap/GoogleMapErrors.kt create mode 100644 android/src/main/java/com/capgo/plugins/nativemap/GoogleMapPadding.kt create mode 100644 android/src/main/res/.gitkeep create mode 100644 assets/github-social-preview.png create mode 100644 assets/github-social-template.svg create mode 100644 bun.lock create mode 100644 example-app/README.md create mode 100644 example-app/android/.gitignore create mode 100644 example-app/android/app/.gitignore create mode 100644 example-app/android/app/build.gradle create mode 100644 example-app/android/app/capacitor.build.gradle create mode 100644 example-app/android/app/proguard-rules.pro create mode 100644 example-app/android/app/src/androidTest/java/com/getcapacitor/myapp/ExampleInstrumentedTest.java create mode 100644 example-app/android/app/src/main/AndroidManifest.xml create mode 100644 example-app/android/app/src/main/java/app/capgo/nativeaudio/MainActivity.java create mode 100644 example-app/android/app/src/main/res/drawable-land-hdpi/splash.png create mode 100644 example-app/android/app/src/main/res/drawable-land-mdpi/splash.png create mode 100644 example-app/android/app/src/main/res/drawable-land-xhdpi/splash.png create mode 100644 example-app/android/app/src/main/res/drawable-land-xxhdpi/splash.png create mode 100644 example-app/android/app/src/main/res/drawable-land-xxxhdpi/splash.png create mode 100644 example-app/android/app/src/main/res/drawable-port-hdpi/splash.png create mode 100644 example-app/android/app/src/main/res/drawable-port-mdpi/splash.png create mode 100644 example-app/android/app/src/main/res/drawable-port-xhdpi/splash.png create mode 100644 example-app/android/app/src/main/res/drawable-port-xxhdpi/splash.png create mode 100644 example-app/android/app/src/main/res/drawable-port-xxxhdpi/splash.png create mode 100644 example-app/android/app/src/main/res/drawable-v24/ic_launcher_foreground.xml create mode 100644 example-app/android/app/src/main/res/drawable/ic_launcher_background.xml create mode 100644 example-app/android/app/src/main/res/drawable/splash.png create mode 100644 example-app/android/app/src/main/res/layout/activity_main.xml create mode 100644 example-app/android/app/src/main/res/mipmap-anydpi-v26/ic_launcher.xml create mode 100644 example-app/android/app/src/main/res/mipmap-anydpi-v26/ic_launcher_round.xml create mode 100644 example-app/android/app/src/main/res/mipmap-hdpi/ic_launcher.png create mode 100644 example-app/android/app/src/main/res/mipmap-hdpi/ic_launcher_foreground.png create mode 100644 example-app/android/app/src/main/res/mipmap-hdpi/ic_launcher_round.png create mode 100644 example-app/android/app/src/main/res/mipmap-mdpi/ic_launcher.png create mode 100644 example-app/android/app/src/main/res/mipmap-mdpi/ic_launcher_foreground.png create mode 100644 example-app/android/app/src/main/res/mipmap-mdpi/ic_launcher_round.png create mode 100644 example-app/android/app/src/main/res/mipmap-xhdpi/ic_launcher.png create mode 100644 example-app/android/app/src/main/res/mipmap-xhdpi/ic_launcher_foreground.png create mode 100644 example-app/android/app/src/main/res/mipmap-xhdpi/ic_launcher_round.png create mode 100644 example-app/android/app/src/main/res/mipmap-xxhdpi/ic_launcher.png create mode 100644 example-app/android/app/src/main/res/mipmap-xxhdpi/ic_launcher_foreground.png create mode 100644 example-app/android/app/src/main/res/mipmap-xxhdpi/ic_launcher_round.png create mode 100644 example-app/android/app/src/main/res/mipmap-xxxhdpi/ic_launcher.png create mode 100644 example-app/android/app/src/main/res/mipmap-xxxhdpi/ic_launcher_foreground.png create mode 100644 example-app/android/app/src/main/res/mipmap-xxxhdpi/ic_launcher_round.png create mode 100644 example-app/android/app/src/main/res/values/ic_launcher_background.xml create mode 100644 example-app/android/app/src/main/res/values/strings.xml create mode 100644 example-app/android/app/src/main/res/values/styles.xml create mode 100644 example-app/android/app/src/main/res/xml/file_paths.xml create mode 100644 example-app/android/app/src/test/java/com/getcapacitor/myapp/ExampleUnitTest.java create mode 100644 example-app/android/build.gradle create mode 100644 example-app/android/capacitor.settings.gradle create mode 100644 example-app/android/gradle.properties create mode 100644 example-app/android/gradle/wrapper/gradle-wrapper.jar create mode 100644 example-app/android/gradle/wrapper/gradle-wrapper.properties create mode 100755 example-app/android/gradlew create mode 100644 example-app/android/gradlew.bat create mode 100644 example-app/android/settings.gradle create mode 100644 example-app/android/variables.gradle create mode 100644 example-app/bun.lock create mode 100644 example-app/bunfig.toml create mode 100644 example-app/capacitor.config.ts create mode 100644 example-app/index.html create mode 100644 example-app/ios/.gitignore create mode 100644 example-app/ios/App/App.xcodeproj/project.pbxproj create mode 100644 example-app/ios/App/App.xcodeproj/project.xcworkspace/xcshareddata/IDEWorkspaceChecks.plist create mode 100644 example-app/ios/App/App/AppDelegate.swift create mode 100644 example-app/ios/App/App/Assets.xcassets/AppIcon.appiconset/AppIcon-512@2x.png create mode 100644 example-app/ios/App/App/Assets.xcassets/AppIcon.appiconset/Contents.json create mode 100644 example-app/ios/App/App/Assets.xcassets/Contents.json create mode 100644 example-app/ios/App/App/Assets.xcassets/Splash.imageset/Contents.json create mode 100644 example-app/ios/App/App/Assets.xcassets/Splash.imageset/splash-2732x2732-1.png create mode 100644 example-app/ios/App/App/Assets.xcassets/Splash.imageset/splash-2732x2732-2.png create mode 100644 example-app/ios/App/App/Assets.xcassets/Splash.imageset/splash-2732x2732.png create mode 100644 example-app/ios/App/App/Base.lproj/LaunchScreen.storyboard create mode 100644 example-app/ios/App/App/Base.lproj/Main.storyboard create mode 100644 example-app/ios/App/App/Info.plist create mode 100644 example-app/ios/App/App/SceneDelegate.swift create mode 100644 example-app/ios/App/CapApp-SPM/.gitignore create mode 100644 example-app/ios/App/CapApp-SPM/Package.swift create mode 100644 example-app/ios/App/CapApp-SPM/README.md create mode 100644 example-app/ios/App/CapApp-SPM/Sources/CapApp-SPM/CapApp-SPM.swift create mode 100644 example-app/ios/debug.xcconfig create mode 100644 example-app/package.json create mode 100644 example-app/public/audio/beep.wav create mode 100644 example-app/public/audio/music.mp3 create mode 100644 example-app/src/App.css create mode 100644 example-app/src/App.tsx create mode 100644 example-app/src/index.css create mode 100644 example-app/src/main.tsx create mode 100644 example-app/src/vite-env.d.ts create mode 100644 example-app/supabase/.branches/_current_branch create mode 100644 example-app/supabase/.temp/cli-latest create mode 100644 example-app/tsconfig.json create mode 100644 example-app/tsconfig.node.json create mode 100644 example-app/vite.config.ts create mode 100644 ios/.gitignore create mode 100644 ios/Sources/NativeMapPlugin/Appearance.swift create mode 100644 ios/Sources/NativeMapPlugin/AppleMapMarker.swift create mode 100644 ios/Sources/NativeMapPlugin/Callout.swift create mode 100644 ios/Sources/NativeMapPlugin/CameraEvents.swift create mode 100644 ios/Sources/NativeMapPlugin/CapacitorAppleMaps.swift create mode 100644 ios/Sources/NativeMapPlugin/CapacitorAppleMapsPlugin.swift create mode 100644 ios/Sources/NativeMapPlugin/ControlsBridge.swift create mode 100644 ios/Sources/NativeMapPlugin/Geocode.swift create mode 100644 ios/Sources/NativeMapPlugin/GoogleMapsBridge.swift create mode 100644 ios/Sources/NativeMapPlugin/MainThread.swift create mode 100644 ios/Sources/NativeMapPlugin/MapAnnotations.swift create mode 100644 ios/Sources/NativeMapPlugin/MapControls.swift create mode 100644 ios/Sources/NativeMapPlugin/MapMounting.swift create mode 100644 ios/Sources/NativeMapPlugin/MapReadback.swift create mode 100644 ios/Sources/NativeMapPlugin/MarkerBridge.swift create mode 100644 ios/Sources/NativeMapPlugin/MarkerIcons.swift create mode 100644 ios/Sources/NativeMapPlugin/Overlays.swift create mode 100644 ios/Sources/NativeMapPlugin/Permissions.swift create mode 100644 ios/Sources/NativeMapPlugin/PluginError.swift create mode 100644 ios/Sources/NativeMapPlugin/Search.swift create mode 100644 ios/Sources/NativeMapPlugin/Snapshot.swift create mode 100644 ios/Sources/NativeMapPlugin/ViewHelpers.swift create mode 100644 ios/Tests/NativeMapPluginTests/CapacitorAppleMapsTests.swift create mode 100644 ios/Tests/NativeMapPluginTests/GeocodeTests.swift create mode 100644 ios/Tests/NativeMapPluginTests/MapStateTests.swift create mode 100644 ios/Tests/NativeMapPluginTests/MarkerAnchorTests.swift create mode 100644 ios/Tests/NativeMapPluginTests/MarkerStyleTests.swift create mode 100644 legal/MIT-capacitor-google-maps.txt create mode 100644 legal/MIT-capacitor-plugin-apple-maps.txt create mode 100644 package.json create mode 100644 renovate.json create mode 100644 rollup.config.mjs create mode 100644 scripts/check-cap9-deprecated.mjs create mode 100644 scripts/check-capacitor-plugin-wiring.mjs create mode 100755 scripts/generate-ai-changelog.mjs create mode 100644 scripts/tsconfig.json create mode 100644 src/definitions.ts create mode 100644 src/implementation.ts create mode 100644 src/index.ts create mode 100644 src/map.ts create mode 100644 src/web.ts create mode 100644 swiftlint.config.js create mode 100644 tsconfig.json diff --git a/.eslintignore b/.eslintignore new file mode 100644 index 0000000..d36e039 --- /dev/null +++ b/.eslintignore @@ -0,0 +1,4 @@ +build +dist +example-app +docs diff --git a/.github/FUNDING.yml b/.github/FUNDING.yml new file mode 100644 index 0000000..436be98 --- /dev/null +++ b/.github/FUNDING.yml @@ -0,0 +1 @@ +github: riderx diff --git a/.github/ISSUE_TEMPLATE/bug-report.md b/.github/ISSUE_TEMPLATE/bug-report.md new file mode 100644 index 0000000..2698e92 --- /dev/null +++ b/.github/ISSUE_TEMPLATE/bug-report.md @@ -0,0 +1,84 @@ +--- +name: 🚨 Bug Report +about: Report something not working +title: 'bug: ' +labels: '' +assignees: '' + +--- + +## Bug Report + +### Capacitor Version + + +``` +PASTE OUTPUT HERE +``` + +### Plugin Version + +``` +PASTE OUTPUT HERE +``` + +### context(s) + +```md +ManualModel: false +AutoMode: false +CapgoCloud: false +OnPremise: false +``` + +### Platform(s) + + + + +### Current Behavior + + + + +### Expected Behavior + + + + +### Code Reproduction + + + + +### Other Technical Details + + +`npm --version` output: + +`node --version` output: + +`pod --version` output (iOS issues only): + +### Additional Context + + diff --git a/.github/ISSUE_TEMPLATE/feature-request.md b/.github/ISSUE_TEMPLATE/feature-request.md new file mode 100644 index 0000000..d898438 --- /dev/null +++ b/.github/ISSUE_TEMPLATE/feature-request.md @@ -0,0 +1,41 @@ +--- +name: ⚡️ Feature Request +about: Request a feature or change +title: 'feat: ' +labels: '' +assignees: '' + +--- + +## Feature Request + +### Description + + + + +### Platform(s) + + + + +### Preferred Solution + + + + +### Alternatives + + + + +### Additional Context + + + diff --git a/.github/scripts/verify-packed-example.sh b/.github/scripts/verify-packed-example.sh new file mode 100755 index 0000000..0c220ad --- /dev/null +++ b/.github/scripts/verify-packed-example.sh @@ -0,0 +1,59 @@ +#!/usr/bin/env bash +set -euo pipefail + +platform="${1:-}" +case "$platform" in + android | ios | web) ;; + *) + echo "Usage: $0 " + exit 1 + ;; +esac + +repo_root="$(cd "$(dirname "${BASH_SOURCE[0]}")/../.." && pwd)" +tmp_root="${RUNNER_TEMP:-$(mktemp -d)}" +pack_dir="$tmp_root/plugin-package" +test_app="$tmp_root/plugin-example-app" + +cd "$repo_root" + +bun run build + +rm -rf "$pack_dir" "$test_app" +mkdir -p "$pack_dir" "$test_app" +bun pm pack --destination "$pack_dir" --quiet + +shopt -s nullglob +packed_packages=("$pack_dir"/*.tgz) +shopt -u nullglob +if [ "${#packed_packages[@]}" -ne 1 ]; then + echo "Expected exactly one package tarball, found ${#packed_packages[@]}" + exit 1 +fi + +plugin_name="$(bun -e 'console.log(require("./package.json").name)')" +cp -R example-app/. "$test_app/" +cd "$test_app" +bun remove "$plugin_name" +bun add "${packed_packages[0]}" +bun run build + +case "$platform" in + android) + if [[ ! -d android ]]; then + bunx cap add android + fi + bunx cap sync android + cd android + ./gradlew build test + ;; + ios) + if [[ ! -d ios ]]; then + bunx cap add ios + fi + bunx cap sync ios + xcodebuild -project ios/App/App.xcodeproj -scheme App -destination generic/platform=iOS CODE_SIGNING_ALLOWED=NO + ;; + web) + ;; +esac diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml new file mode 100644 index 0000000..0a377cb --- /dev/null +++ b/.github/workflows/build.yml @@ -0,0 +1,89 @@ +name: Build and publish + +concurrency: + group: ${{ github.workflow }}-${{ github.ref }} + cancel-in-progress: true + +on: + push: + tags: + - "*" + +jobs: + # Tests already passed before tag was created, so just build and deploy + deploy: + runs-on: ubuntu-latest + # Keep this job capped at 10 minutes; never raise it unless explicitly asked. + timeout-minutes: 10 + name: "Build and publish to npm" + permissions: + contents: write + id-token: write + steps: + - name: Check out + uses: actions/checkout@v6 + with: + fetch-depth: 0 + filter: blob:none + - uses: oven-sh/setup-bun@v2 + - name: Install dependencies + id: install_code + run: bun i + - name: Check plugin wiring + run: bun run check:wiring + - name: Build + id: build_code + run: bun run build + - name: Generate AI changelog + id: changelog + continue-on-error: true + env: + CLOUDFLARE_API_TOKEN: ${{ secrets.CLOUDFLARE_API_TOKEN }} + CLOUDFLARE_ACCOUNT_ID: ${{ secrets.CLOUDFLARE_ACCOUNT_ID }} + run: bun run changelog:ai + - name: Setup Node.js for npm publish + uses: actions/setup-node@v6 + with: + node-version: 24.x + registry-url: 'https://registry.npmjs.org' + - name: Install npm CLI for staged publishing + run: npm install -g npm@^11.15.0 + - name: Stage publish to npm + if: ${{ !contains(github.ref, '-alpha.') }} + env: + NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }} + run: | + npm --version + npm stage publish --provenance --access public --ignore-scripts + - name: Stage publish to npm with next tag + if: ${{ contains(github.ref, '-alpha.') }} + env: + NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }} + run: | + npm --version + npm stage publish --tag next --provenance --access public --ignore-scripts + - name: Request stage approval + continue-on-error: true + env: + GH_TOKEN: ${{ secrets.NPM_STAGE_DISPATCH_TOKEN }} + run: | + gh api --method POST repos/Cap-go/automations/dispatches \ + -f event_type=npm-stage-approve \ + -f "client_payload[repository]=${GITHUB_REPOSITORY}" \ + -f "client_payload[run_id]=${GITHUB_RUN_ID}" \ + -f "client_payload[package]=$(node -p "require('./package.json').name")" + - name: Create GitHub release + id: create_release + uses: softprops/action-gh-release@v2 + with: + body: | + ## 🆕 Changelog + + ${{ steps.changelog.outputs.result || '_Changelog was not generated automatically for this release._' }} + + --- + + 🔗 **Full Changelog**: https://github.com/${{ github.repository }}/compare/${{ steps.changelog.outputs.from_tag || github.ref_name }}...${{ steps.changelog.outputs.to_tag || github.ref_name }} + make_latest: true + token: '${{ secrets.PERSONAL_ACCESS_TOKEN }}' + prerelease: ${{ contains(github.ref, '-alpha.') }} diff --git a/.github/workflows/bump_version.yml b/.github/workflows/bump_version.yml new file mode 100644 index 0000000..c9fcb95 --- /dev/null +++ b/.github/workflows/bump_version.yml @@ -0,0 +1,63 @@ +name: Bump version + +on: + push: + branches: + - main + - development + paths-ignore: + - 'example-app/**' + - '.github/**' + +jobs: + # Run all tests first before creating any tags + test: + if: ${{ !startsWith(github.event.head_commit.message, 'chore(release):') }} + # Called workflow jobs are capped at 10 minutes; never raise that unless explicitly asked. + uses: ./.github/workflows/test.yml + + # Only bump version and create tag if all tests pass + bump-version: + needs: [test] + if: ${{ !startsWith(github.event.head_commit.message, 'chore(release):') }} + runs-on: ubuntu-latest + # Keep this job capped at 10 minutes; never raise it unless explicitly asked. + timeout-minutes: 10 + name: "Bump version and create tag" + steps: + - name: Setup Node.js + uses: actions/setup-node@v6 + with: + node-version: 24.x + - name: Check out + uses: actions/checkout@v6 + with: + fetch-depth: 0 + filter: blob:none + token: '${{ secrets.PERSONAL_ACCESS_TOKEN }}' + - uses: oven-sh/setup-bun@v2 + - name: Install dependencies + id: install_code + run: bun i + - name: Git config + run: | + git config --local user.name "github-actions[bot]" + git config --local user.email "github-actions[bot]@users.noreply.github.com" + - name: Update Doc + run: bun run docgen + - name: Add doc to github + run: | + git add README.md + git commit --m "docs: update doc" || true + - name: Create version bump main + if: github.ref == 'refs/heads/main' + run: bunx capacitor-plugin-standard-version@latest --skip.changelog + - name: Create version bump development + if: github.ref != 'refs/heads/main' + run: bunx capacitor-plugin-standard-version@latest --prerelease alpha --skip.changelog + - name: Push to origin + run: | + CURRENT_BRANCH=$(git rev-parse --abbrev-ref HEAD) + remote_repo="https://${GITHUB_ACTOR}:${{ secrets.PERSONAL_ACCESS_TOKEN }}@github.com/${GITHUB_REPOSITORY}.git" + git pull $remote_repo $CURRENT_BRANCH + git push $remote_repo HEAD:$CURRENT_BRANCH --follow-tags --tags diff --git a/.github/workflows/github-releases-to-discord.yml b/.github/workflows/github-releases-to-discord.yml new file mode 100644 index 0000000..cae7011 --- /dev/null +++ b/.github/workflows/github-releases-to-discord.yml @@ -0,0 +1,25 @@ +name: GitHub Releases to Discord + +on: + release: + types: [published] + +jobs: + github-releases-to-discord: + runs-on: ubuntu-latest + # Keep this job capped at 10 minutes; never raise it unless explicitly asked. + timeout-minutes: 10 + steps: + - name: Setup Node.js + uses: actions/setup-node@v6 + with: + node-version: 24.x + - name: Checkout + uses: actions/checkout@v6 + - name: GitHub Releases to Discord + uses: SethCohen/github-releases-to-discord@v1 + with: + webhook_url: ${{ secrets.WEBHOOK_DISCORD_RELEASE_URL }} + color: "2105893" + footer_title: "Release @${{ github.repository }}" + reduce_headings: true diff --git a/.github/workflows/pr_beta_prompt.yml b/.github/workflows/pr_beta_prompt.yml new file mode 100644 index 0000000..b918fed --- /dev/null +++ b/.github/workflows/pr_beta_prompt.yml @@ -0,0 +1,86 @@ +name: PR beta publish prompt + +on: + pull_request_target: + types: + - opened + - reopened + - synchronize + - ready_for_review + +permissions: + issues: write + pull-requests: write + +jobs: + comment: + runs-on: ubuntu-latest + # Keep this job capped at 10 minutes; never raise it unless explicitly asked. + timeout-minutes: 10 + steps: + - name: Setup Node.js + uses: actions/setup-node@v6.5.0 + with: + node-version: 24.x + - name: Upsert beta publish comment + uses: actions/github-script@v9.0.0 + env: + IS_SAME_REPO: ${{ github.event.pull_request.head.repo.full_name == github.repository && 'true' || 'false' }} + with: + script: | + const marker = ''; + const sameRepo = process.env.IS_SAME_REPO === 'true'; + const pr = context.payload.pull_request; + const body = sameRepo + ? [ + marker, + '', + '## Beta npm build', + '', + 'Maintainers can publish this PR to npm for fast testing.', + '', + 'Comment `/publish-beta` after the PR checks are green.', + '', + 'The workflow will:', + '- publish a prerelease package on the `beta` tag', + `- add a pinned \`pr-${pr.number}\` dist-tag for this exact PR build`, + '- update this comment with the install command', + '', + 'Security note: beta publish is only enabled for branches inside this repository.', + ].join('\n') + : [ + marker, + '', + '## Beta npm build', + '', + 'This PR comes from a fork, so beta publish is disabled for security.', + '', + 'If you need a beta package, move the branch into this repository first.', + ].join('\n'); + + const { owner, repo } = context.repo; + const comments = await github.paginate(github.rest.issues.listComments, { + owner, + repo, + issue_number: pr.number, + per_page: 100, + }); + + const existing = comments.find((comment) => comment.user.type === 'Bot' && comment.body.includes(marker)); + + if (existing) { + await github.rest.issues.updateComment({ + owner, + repo, + comment_id: existing.id, + body, + }); + return; + } + + await github.rest.issues.createComment({ + owner, + repo, + issue_number: pr.number, + body, + }); diff --git a/.github/workflows/pr_beta_publish.yml b/.github/workflows/pr_beta_publish.yml new file mode 100644 index 0000000..7756366 --- /dev/null +++ b/.github/workflows/pr_beta_publish.yml @@ -0,0 +1,324 @@ +name: Publish PR beta package + +on: + issue_comment: + types: + - created + workflow_dispatch: + inputs: + pr_number: + description: Pull request number to publish + required: true + type: number + +concurrency: + group: pr-beta-${{ github.event.issue.number || inputs.pr_number }} + cancel-in-progress: false + +permissions: + contents: read + id-token: write + issues: write + pull-requests: write + +jobs: + publish: + if: ${{ github.event_name == 'workflow_dispatch' || (github.event.issue.pull_request && contains(github.event.comment.body, '/publish-beta')) }} + runs-on: ubuntu-latest + # Keep this job capped at 10 minutes; never raise it unless explicitly asked. + timeout-minutes: 10 + steps: + - name: Resolve PR and access checks + id: pr + uses: actions/github-script@v9.0.0 + with: + script: | + const prNumber = context.eventName === 'workflow_dispatch' + ? Number(core.getInput('pr_number')) + : context.payload.issue.number; + + const { owner, repo } = context.repo; + const { data: pr } = await github.rest.pulls.get({ + owner, + repo, + pull_number: prNumber, + }); + + const actor = context.eventName === 'issue_comment' + ? context.payload.comment.user.login + : context.actor; + + core.setOutput('actor', actor); + core.setOutput('pr_number', String(prNumber)); + + if (pr.state !== 'open') { + core.setFailed(`PR #${prNumber} is not open.`); + return; + } + + if (pr.head.repo.full_name !== `${owner}/${repo}`) { + core.setFailed('Fork PRs cannot publish beta packages because the workflow needs repository secrets.'); + return; + } + + if (context.eventName === 'issue_comment') { + const actor = context.payload.comment.user.login; + const { data: permission } = await github.rest.repos.getCollaboratorPermissionLevel({ + owner, + repo, + username: actor, + }); + const allowed = ['admin', 'maintain', 'write'].includes(permission.permission); + + if (!allowed) { + core.setFailed(`@${actor} does not have permission to publish beta packages.`); + return; + } + } + + const prState = await github.graphql( + `query($owner: String!, $repo: String!, $prNumber: Int!) { + repository(owner: $owner, name: $repo) { + pullRequest(number: $prNumber) { + commits(last: 1) { + nodes { + commit { + statusCheckRollup { + state + } + } + } + } + } + } + }`, + { + owner, + repo, + prNumber, + }, + ); + + const rollupState = prState.repository.pullRequest.commits.nodes[0]?.commit.statusCheckRollup?.state ?? 'PENDING'; + + if (rollupState !== 'SUCCESS') { + core.setFailed(`PR checks are not green yet (current state: ${rollupState}).`); + return; + } + core.setOutput('head_sha', pr.head.sha); + + - name: Mark publish as running + uses: actions/github-script@v9.0.0 + with: + script: | + const marker = ''; + const prNumber = Number('${{ steps.pr.outputs.pr_number }}'); + const actor = '${{ steps.pr.outputs.actor }}'; + const body = [ + marker, + '', + '## Beta npm build', + '', + 'Status: publishing', + '', + `Requested by @${actor}.`, + '', + `This run will publish the PR head to the \`beta\` npm tag.`, + '', + `Run: ${context.serverUrl}/${context.repo.owner}/${context.repo.repo}/actions/runs/${context.runId}`, + ].join('\n'); + + const comments = await github.paginate(github.rest.issues.listComments, { + owner: context.repo.owner, + repo: context.repo.repo, + issue_number: prNumber, + per_page: 100, + }); + + const existing = comments.find((comment) => comment.user.type === 'Bot' && comment.body.includes(marker)); + + if (existing) { + await github.rest.issues.updateComment({ + owner: context.repo.owner, + repo: context.repo.repo, + comment_id: existing.id, + body, + }); + return; + } + + await github.rest.issues.createComment({ + owner: context.repo.owner, + repo: context.repo.repo, + issue_number: prNumber, + body, + }); + + - name: Check out PR head + uses: actions/checkout@v6.1.0 + with: + ref: ${{ steps.pr.outputs.head_sha }} + fetch-depth: 0 + filter: blob:none + persist-credentials: false + + - uses: oven-sh/setup-bun@v2.2.0 + + - name: Install dependencies + run: bun i + + - name: Check plugin wiring + run: bun run check:wiring + + - name: Set beta package version + id: version + env: + PR_NUMBER: ${{ steps.pr.outputs.pr_number }} + run: | + node <<'NODE' >> "$GITHUB_OUTPUT" + const fs = require('fs'); + const path = 'package.json'; + const pkg = JSON.parse(fs.readFileSync(path, 'utf8')); + const baseVersion = pkg.version.split('-')[0]; + const prNumber = process.env.PR_NUMBER; + const runNumber = process.env.GITHUB_RUN_NUMBER; + const runAttempt = process.env.GITHUB_RUN_ATTEMPT; + const betaVersion = `${baseVersion}-beta.pr${prNumber}.${runNumber}.${runAttempt}`; + + pkg.version = betaVersion; + fs.writeFileSync(path, `${JSON.stringify(pkg, null, 2)}\n`); + + console.log(`package_name=${pkg.name}`); + console.log(`version=${betaVersion}`); + NODE + + - name: Build + run: bun run build + + - name: Setup Node.js for npm publish + uses: actions/setup-node@v6.5.0 + with: + node-version: 24.x + registry-url: 'https://registry.npmjs.org' + + - name: Install npm CLI for staged publishing + run: npm install -g npm@^11.15.0 + + - name: Stage publish to npm beta + env: + NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }} + run: | + npm --version + npm stage publish --tag beta --provenance --access public --ignore-scripts + + + - name: Request stage approval + continue-on-error: true + env: + GH_TOKEN: ${{ secrets.NPM_STAGE_DISPATCH_TOKEN }} + run: | + gh api --method POST repos/Cap-go/automations/dispatches \ + -f event_type=npm-stage-approve \ + -f "client_payload[repository]=${GITHUB_REPOSITORY}" \ + -f "client_payload[run_id]=${GITHUB_RUN_ID}" \ + -f "client_payload[package]=${{ steps.version.outputs.package_name }}" + - name: Publish success comment + if: ${{ success() }} + uses: actions/github-script@v9.0.0 + with: + script: | + const marker = ''; + const prNumber = Number('${{ steps.pr.outputs.pr_number }}'); + const actor = '${{ steps.pr.outputs.actor }}'; + const packageName = '${{ steps.version.outputs.package_name }}'; + const version = '${{ steps.version.outputs.version }}'; + const shortSha = '${{ steps.pr.outputs.head_sha }}'.slice(0, 7); + const body = [ + marker, + '', + '## Beta npm build', + '', + 'Status: staged', + '', + `Version: \`${version}\``, + `Source: \`${shortSha}\``, + `Requested by @${actor}`, + '', + 'Latest beta:', + '```sh', + `bun add ${packageName}@beta`, + `bun add ${packageName}@${version}`, + '```', + '', + `Run: ${context.serverUrl}/${context.repo.owner}/${context.repo.repo}/actions/runs/${context.runId}`, + ].join('\n'); + + const comments = await github.paginate(github.rest.issues.listComments, { + owner: context.repo.owner, + repo: context.repo.repo, + issue_number: prNumber, + per_page: 100, + }); + + const existing = comments.find((comment) => comment.user.type === 'Bot' && comment.body.includes(marker)); + + if (existing) { + await github.rest.issues.updateComment({ + owner: context.repo.owner, + repo: context.repo.repo, + comment_id: existing.id, + body, + }); + return; + } + + await github.rest.issues.createComment({ + owner: context.repo.owner, + repo: context.repo.repo, + issue_number: prNumber, + body, + }); + + - name: Publish failure comment + if: ${{ failure() && steps.pr.outputs.pr_number != '' }} + uses: actions/github-script@v9.0.0 + with: + script: | + const marker = ''; + const prNumber = Number('${{ steps.pr.outputs.pr_number }}'); + const body = [ + marker, + '', + '## Beta npm build', + '', + 'Status: failed', + '', + 'Open the run for details:', + `${context.serverUrl}/${context.repo.owner}/${context.repo.repo}/actions/runs/${context.runId}`, + ].join('\n'); + + const comments = await github.paginate(github.rest.issues.listComments, { + owner: context.repo.owner, + repo: context.repo.repo, + issue_number: prNumber, + per_page: 100, + }); + + const existing = comments.find((comment) => comment.user.type === 'Bot' && comment.body.includes(marker)); + + if (existing) { + await github.rest.issues.updateComment({ + owner: context.repo.owner, + repo: context.repo.repo, + comment_id: existing.id, + body, + }); + return; + } + + await github.rest.issues.createComment({ + owner: context.repo.owner, + repo: context.repo.repo, + issue_number: prNumber, + body, + }); diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml new file mode 100644 index 0000000..3a96939 --- /dev/null +++ b/.github/workflows/test.yml @@ -0,0 +1,105 @@ +name: Build source code and test it + +on: + push: + branches: + - renovate/** + pull_request: + branches: [ main ] + workflow_call: # Allow this workflow to be called by other workflows + +jobs: + guard_swiftpm_version: + runs-on: ubuntu-latest + # Keep this job capped at 10 minutes; never raise it unless explicitly asked. + timeout-minutes: 10 + steps: + - name: Check out + uses: actions/checkout@v6 + - name: Enforce capacitor-swift-pm version + run: | + set -euo pipefail + if ! grep -Eq 'https://github.com/ionic-team/capacitor-swift-pm\.git"[[:space:]]*,[[:space:]]*from:[[:space:]]*"8\.0\.0"' Package.swift; then + echo "Expected capacitor-swift-pm to be pinned to 8.0.0 in Package.swift" + exit 1 + fi + build_android: + runs-on: ubuntu-latest + # Keep this job capped at 10 minutes; never raise it unless explicitly asked. + timeout-minutes: 10 + steps: + - name: Check out + uses: actions/checkout@v6 + - uses: oven-sh/setup-bun@v2 + - name: Setup Node.js + uses: actions/setup-node@v6 + with: + node-version: 24.x + - name: Install dependencies + id: install_code + run: bun i + - name: Check plugin wiring + run: bun run check:wiring + - name: Check Cap 9 deprecated APIs + run: bun run check:cap9-deprecated + - name: Setup java + uses: actions/setup-java@v5 + with: + distribution: 'zulu' + java-version: '21' + - name: Build + id: build_code + run: bun run verify:android + - name: Verify packed package in example app (Android) + shell: bash + run: bash ./.github/scripts/verify-packed-example.sh android + build_ios: + runs-on: macOS-latest + # Keep this job capped at 10 minutes; never raise it unless explicitly asked. + timeout-minutes: 10 + steps: + - name: Check out + uses: actions/checkout@v6 + - uses: oven-sh/setup-bun@v2 + - name: Setup Node.js + uses: actions/setup-node@v6 + with: + node-version: 24.x + - name: Install dependencies + id: install_code + run: bun i + - name: Check plugin wiring + run: bun run check:wiring + - name: Check Cap 9 deprecated APIs + run: bun run check:cap9-deprecated + - name: Build + id: build_code + run: bun run verify:ios + - name: Verify packed package in example app (iOS) + shell: bash + run: bash ./.github/scripts/verify-packed-example.sh ios + web: + runs-on: ubuntu-latest + # Keep this job capped at 10 minutes; never raise it unless explicitly asked. + timeout-minutes: 10 + name: 'Build code and test' + steps: + - name: Check out + uses: actions/checkout@v6 + - uses: oven-sh/setup-bun@v2 + - name: Install dependencies + id: install_code + run: bun i + - name: Check plugin wiring + run: bun run check:wiring + - name: Check Cap 9 deprecated APIs + run: bun run check:cap9-deprecated + - name: Lint + id: lint_code + run: bun run lint + - name: Verify packed package in example app (Web) + shell: bash + run: bash ./.github/scripts/verify-packed-example.sh web + - name: Verify + id: verify_code + run: bun run verify:web diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..0de7761 --- /dev/null +++ b/.gitignore @@ -0,0 +1,78 @@ +# node files +dist +node_modules + +# iOS files +/Packages +xcuserdata/ +DerivedData/ +.swiftpm/configuration/registries.json +.swiftpm/xcode/package.xcworkspace/contents.xcworkspacedata +.netrc +Package.resolved +/.build + + +# macOS files +.DS_Store + + + +# Based on Android gitignore template: https://github.com/github/gitignore/blob/HEAD/Android.gitignore + +# Built application files +*.apk +*.ap_ + +# Files for the ART/Dalvik VM +*.dex + +# Java class files +*.class + +# Generated files +bin +gen +out + +# Gradle files +.gradle +build + +# Local configuration file (sdk path, etc) +local.properties + +# Proguard folder generated by Eclipse +proguard + +# Log Files +*.log + +# Android Studio Navigation editor temp files +.navigation + +# Android Studio captures folder +captures + +# IntelliJ +*.iml +.idea + +# Keystore files +# Uncomment the following line if you do not want to check your keystore files in. +#*.jks + +# External native build folder generated in Android Studio 2.2 and later +.externalNativeBuild + +# Example app build output +example-app/node_modules +example-app/dist +package-lock.json + +# Development artifacts +.swiftpm/ +.maestro/results/ + +# Generated scripts +scripts/configure-dependencies.js diff --git a/.maestro/android/basic-features.yaml b/.maestro/android/basic-features.yaml new file mode 100644 index 0000000..2de34b9 --- /dev/null +++ b/.maestro/android/basic-features.yaml @@ -0,0 +1,5 @@ +appId: app.capgo.nativeaudio +--- +- launchApp: + clearState: true +- runFlow: ../flows/basic-local-music.yaml diff --git a/.maestro/flows/basic-local-music.yaml b/.maestro/flows/basic-local-music.yaml new file mode 100644 index 0000000..603e3d6 --- /dev/null +++ b/.maestro/flows/basic-local-music.yaml @@ -0,0 +1,47 @@ +appId: app.capgo.nativeaudio +name: Basic local music smoke +--- +- assertVisible: "@capgo/native-audio" +- tapOn: + text: "Local Music" + retryTapIfNoChange: true +- extendedWaitUntil: + visible: "Longer local MP3 for testing seek, fades, and delayed playback\\." + timeout: 15000 +- scrollUntilVisible: + element: "Preload" + direction: DOWN + centerElement: true + timeout: 15000 +- tapOn: "Preload" +- extendedWaitUntil: + visible: "Re-preload" + timeout: 15000 +- tapOn: + text: "Play" + enabled: true +- extendedWaitUntil: + visible: + text: "Pause" + enabled: true + timeout: 15000 +- tapOn: + text: "Pause" + enabled: true +- extendedWaitUntil: + visible: ".*Paused Local Music\\." + timeout: 15000 +- tapOn: + text: "Resume" + enabled: true +- tapOn: + text: "Stop" + enabled: true +- extendedWaitUntil: + visible: ".*Stopped Local Music\\." + timeout: 15000 +- tapOn: "Unload" +- extendedWaitUntil: + visible: ".*Local Music unloaded\\." + timeout: 15000 +- assertVisible: "Preload" diff --git a/.maestro/ios/basic-features.yaml b/.maestro/ios/basic-features.yaml new file mode 100644 index 0000000..2de34b9 --- /dev/null +++ b/.maestro/ios/basic-features.yaml @@ -0,0 +1,5 @@ +appId: app.capgo.nativeaudio +--- +- launchApp: + clearState: true +- runFlow: ../flows/basic-local-music.yaml diff --git a/.npmignore b/.npmignore new file mode 100644 index 0000000..f629a7a --- /dev/null +++ b/.npmignore @@ -0,0 +1,60 @@ +# node files +dist/ +node_modules/ + +# iOS files +Pods +Build +xcuserdata + +# macOS files +.DS_Store + + + +# Based on Android gitignore template: https://github.com/github/gitignore/blob/master/Android.gitignore + +# Built application files +*.apk +*.ap_ + +# Files for the ART/Dalvik VM +*.dex + +# Java class files +*.class + +# Generated files +bin/ +gen/ +out/ + +# Gradle files +.gradle/ +build/ + +# Local configuration file (sdk path, etc) +local.properties + +# Proguard folder generated by Eclipse +proguard/ + +# Log Files +*.log + +# Android Studio Navigation editor temp files +.navigation/ + +# Android Studio captures folder +captures/ + +# IntelliJ +*.iml +.idea + +# Keystore files +# Uncomment the following line if you do not want to check your keystore files in. +#*.jks + +# External native build folder generated in Android Studio 2.2 and later +.externalNativeBuild diff --git a/.prettierignore b/.prettierignore new file mode 100644 index 0000000..5ab6e14 --- /dev/null +++ b/.prettierignore @@ -0,0 +1 @@ +example-app diff --git a/AGENTS.md b/AGENTS.md new file mode 100644 index 0000000..1d0df45 --- /dev/null +++ b/AGENTS.md @@ -0,0 +1,130 @@ +# AGENTS.md + +This file provides guidance to AI agents and contributors working on this Capacitor plugin. + +## Quick Start + +```bash +# Install dependencies +bun install + +# Build the plugin (TypeScript + Rollup + docgen) +bun run build + +# Full verification (iOS, Android, Web) +bun run verify + +# Format code (ESLint + Prettier + SwiftLint) +bun run fmt + +# Lint without fixing +bun run lint +``` + +## Development Workflow + +1. **Install** - `bun install` (never use npm) +2. **Build** - `bun run build` compiles TypeScript, generates docs, and bundles with Rollup +3. **Verify** - `bun run verify` builds for iOS, Android, and Web. Always run this before submitting work +4. **Format** - `bun run fmt` auto-fixes ESLint, Prettier, and SwiftLint issues +5. **Lint** - `bun run lint` checks code quality without modifying files + +### Individual Platform Verification + +```bash +bun run verify:ios +bun run verify:android +bun run verify:web +``` + +### Example App + +If an `example-app/` directory exists, you can test the plugin locally: + +```bash +cd example-app +bun install +bun run start +``` + +The example app references the plugin via `file:..`. Use `bunx cap sync ` to sync native platforms. + +## Project Structure + +- `src/definitions.ts` - TypeScript interfaces and types (source of truth for API docs) +- `src/index.ts` - Plugin registration +- `src/web.ts` - Web implementation +- `ios/Sources/` - iOS native code (Swift) +- `android/src/main/` - Android native code (Java/Kotlin) +- `dist/` - Generated output (do not edit manually) +- `Package.swift` - SwiftPM definition +- `*.podspec` - CocoaPods spec + +## iOS Package Management + +We always support both **CocoaPods** and **Swift Package Manager (SPM)**. Every plugin must ship a valid `*.podspec` and `Package.swift`. Do not remove or break either integration — users depend on both. + +## API Documentation + +API docs in the README are auto-generated from JSDoc in `src/definitions.ts`. **Never edit the `` or `` sections in README.md directly.** Instead, update `src/definitions.ts` and run `bun run docgen` (also runs as part of `bun run build`). Document any important default or future-major default candidate in `src/definitions.ts` so the next Capacitor major upgrade can change it deliberately. + +## Versioning + +The plugin major version must always follow the Capacitor major version (e.g., plugin v8 for Capacitor 8). **Do not introduce breaking changes in `src/definitions.ts` unless explicitly asked or the current definition is broken or unusable.** Breaking changes belong to the matching Capacitor major migration, and all other changes must stay backward compatible. + +## Changelog + +`CHANGELOG.md` is managed automatically by CI/CD. Do not edit it manually. + +## Pull Request Guidelines + +We welcome contributions, including AI-generated pull requests. Every PR must include: + +### Required Sections + +1. **What** - What does this PR change? +2. **Why** - What is the reason for this change? +3. **How** - How did you approach the implementation? +4. **Testing** - What did you test? How did you verify it works? +5. **Not Tested** - What is not yet tested or needs further validation? + +### Rules + +- **No breaking changes** unless aligned with a new Capacitor major release. +- Run `bun run verify` and `bun run fmt` before opening a PR. CI will catch failures, but catching them locally saves time. +- If you are an AI agent, that is perfectly fine. Just be transparent about it. We care that the code is correct and helpful, not who wrote it. +- We review PRs on a best-effort basis. We may request changes — you are expected to address them for the PR to be merged. +- We use automated code review tools (CodeRabbit, and others). You will need to respond to their feedback and resolve any issues they raise. +- We have automatic releases. Once merged, your change will ship in the next release cycle. + +### PR Template + +``` +## What +- [Brief description of the change] + +## Why +- [Motivation for this change] + +## How +- [Implementation approach] + +## Testing +- [What was tested and how] + +## Not Tested +- [What still needs testing, if anything] +``` + +## Common Pitfalls + +- Always rename Swift/Java classes and package IDs when creating a new plugin from a template — leftover names cause registration conflicts. +- We only use Java 21 for Android builds. +- Keep temporary files clean: delete or mark with `deleteOnExit` after use. +- `dist/` is fully regenerated on every build — never edit generated files. +- Use Bun for everything. Do not use npm or npx. Use `bunx` if you need to run a package binary. +- Production and PR beta publishes use `npm stage publish`. Plugin CI only has the org `NPM_TOKEN`. + +## Timeout Policy + +- Keep CI, script, and runtime timeouts at 10 minutes or less. Use `timeout-minutes: 10` or lower in GitHub Actions and cap timeout values at `600000` ms, `600` seconds, or `10m` unless explicitly requested. diff --git a/CHANGELOG.md b/CHANGELOG.md new file mode 100644 index 0000000..c9fe824 --- /dev/null +++ b/CHANGELOG.md @@ -0,0 +1,5 @@ +# Changelog + +## 0.0.1 + +Initial release: unified `@capgo/capacitor-native-map` plugin with Google Maps on Android, MapKit on iOS, and Google Maps JS on web. diff --git a/CapgoCapacitorNativeMap.podspec b/CapgoCapacitorNativeMap.podspec new file mode 100644 index 0000000..d82a5e5 --- /dev/null +++ b/CapgoCapacitorNativeMap.podspec @@ -0,0 +1,16 @@ +require 'json' + +package = JSON.parse(File.read(File.join(__dir__, 'package.json'))) + +Pod::Spec.new do |s| + s.name = 'CapgoCapacitorNativeMap' + s.version = package['version'] + s.summary = package['description'] + s.license = package['license'] + s.homepage = package['repository']['url'] + s.author = package['author'] + s.source = { :git => package['repository']['url'], :tag => s.version.to_s } + s.source_files = 'ios/Sources/**/*.{swift,h,m,c,cc,mm,cpp}' + s.ios.deployment_target = '15.0' + s.dependency 'Capacitor' +end diff --git a/NOTICE b/NOTICE new file mode 100644 index 0000000..74f9cab --- /dev/null +++ b/NOTICE @@ -0,0 +1,8 @@ +@capgo/capacitor-native-map +Copyright (c) Capgo + +This product includes software developed by third parties under the MIT License. +See THIRD_PARTY_LICENSES and the legal/ directory for details. + +Ported Android and web map code derives from @capacitor/google-maps (Copyright (c) Ionic). +Ported iOS map code derives from capacitor-plugin-apple-maps (Copyright Katama Labs contributors). diff --git a/Package.swift b/Package.swift new file mode 100644 index 0000000..185b4b6 --- /dev/null +++ b/Package.swift @@ -0,0 +1,31 @@ +// swift-tools-version: 5.9 +import PackageDescription + +let package = Package( + name: "CapgoCapacitorNativeMap", + platforms: [ + .iOS(.v15) + ], + products: [ + .library( + name: "CapgoCapacitorNativeMap", + targets: ["NativeMapPlugin"] + ) + ], + dependencies: [ + .package(url: "https://github.com/ionic-team/capacitor-swift-pm.git", from: "8.0.0") + ], + targets: [ + .target( + name: "NativeMapPlugin", + dependencies: [ + .product(name: "Capacitor", package: "capacitor-swift-pm"), + .product(name: "Cordova", package: "capacitor-swift-pm") + ], + path: "ios/Sources/NativeMapPlugin"), + .testTarget( + name: "NativeMapPluginTests", + dependencies: ["NativeMapPlugin"], + path: "ios/Tests/NativeMapPluginTests") + ] +) diff --git a/README.md b/README.md index 0c08396..3027f9a 100644 --- a/README.md +++ b/README.md @@ -1,5 +1,934 @@ # @capgo/capacitor-native-map -Native maps for Capacitor: Google Maps on Android, Apple MapKit on iOS, and a web fallback. +Native maps for Capacitor with one JavaScript API: -Work in progress. Not published to npm yet. +- **Android**: Google Maps (Maps SDK) +- **iOS**: Apple MapKit +- **Web**: Google Maps JavaScript API (requires an API key) + +Capacitor 8.x. TypeScript 6.x in the example app. + +## Credits + +Portions of this plugin are adapted from: + +- [@capacitor/google-maps](https://github.com/ionic-team/capacitor-google-maps) (MIT) for Android and web +- [capacitor-plugin-apple-maps](https://github.com/katamalabs/capacitor-plugin-apple-maps) (MIT) for iOS + +See [THIRD_PARTY_LICENSES](./THIRD_PARTY_LICENSES) and the [legal/](./legal/) folder. + +## Install + +```bash +npm install @capgo/capacitor-native-map +npx cap sync +``` + +## API + + + + + +### create(...) + +```typescript +create(options: CreateMapArgs) => Promise +``` + +| Param | Type | +| ------------- | ------------------------------------------------------- | +| **`options`** | CreateMapArgs | + +-------------------- + + +### enableTouch(...) + +```typescript +enableTouch(args: { id: string; }) => Promise +``` + +| Param | Type | +| ---------- | ---------------------------- | +| **`args`** | { id: string; } | + +-------------------- + + +### disableTouch(...) + +```typescript +disableTouch(args: { id: string; }) => Promise +``` + +| Param | Type | +| ---------- | ---------------------------- | +| **`args`** | { id: string; } | + +-------------------- + + +### addTileOverlay(...) + +```typescript +addTileOverlay(args: AddTileOverlayArgs) => Promise<{ id: string; }> +``` + +| Param | Type | +| ---------- | ----------------------------------------------------------------- | +| **`args`** | AddTileOverlayArgs | + +**Returns:** Promise<{ id: string; }> + +-------------------- + + +### removeTileOverlay(...) + +```typescript +removeTileOverlay(args: RemoveTileOverlayArgs) => Promise +``` + +| Param | Type | +| ---------- | ----------------------------------------------------------------------- | +| **`args`** | RemoveTileOverlayArgs | + +-------------------- + + +### addMarker(...) + +```typescript +addMarker(args: AddMarkerArgs) => Promise<{ id: string; }> +``` + +| Param | Type | +| ---------- | ------------------------------------------------------- | +| **`args`** | AddMarkerArgs | + +**Returns:** Promise<{ id: string; }> + +-------------------- + + +### addMarkers(...) + +```typescript +addMarkers(args: AddMarkersArgs) => Promise<{ ids: string[]; }> +``` + +| Param | Type | +| ---------- | --------------------------------------------------------- | +| **`args`** | AddMarkersArgs | + +**Returns:** Promise<{ ids: string[]; }> + +-------------------- + + +### removeMarker(...) + +```typescript +removeMarker(args: RemoveMarkerArgs) => Promise +``` + +| Param | Type | +| ---------- | ------------------------------------------------------------- | +| **`args`** | RemoveMarkerArgs | + +-------------------- + + +### removeMarkers(...) + +```typescript +removeMarkers(args: RemoveMarkersArgs) => Promise +``` + +| Param | Type | +| ---------- | --------------------------------------------------------------- | +| **`args`** | RemoveMarkersArgs | + +-------------------- + + +### addPolygons(...) + +```typescript +addPolygons(args: AddPolygonsArgs) => Promise<{ ids: string[]; }> +``` + +| Param | Type | +| ---------- | ----------------------------------------------------------- | +| **`args`** | AddPolygonsArgs | + +**Returns:** Promise<{ ids: string[]; }> + +-------------------- + + +### removePolygons(...) + +```typescript +removePolygons(args: RemovePolygonsArgs) => Promise +``` + +| Param | Type | +| ---------- | ----------------------------------------------------------------- | +| **`args`** | RemovePolygonsArgs | + +-------------------- + + +### addCircles(...) + +```typescript +addCircles(args: AddCirclesArgs) => Promise<{ ids: string[]; }> +``` + +| Param | Type | +| ---------- | --------------------------------------------------------- | +| **`args`** | AddCirclesArgs | + +**Returns:** Promise<{ ids: string[]; }> + +-------------------- + + +### removeCircles(...) + +```typescript +removeCircles(args: RemoveCirclesArgs) => Promise +``` + +| Param | Type | +| ---------- | --------------------------------------------------------------- | +| **`args`** | RemoveCirclesArgs | + +-------------------- + + +### addPolylines(...) + +```typescript +addPolylines(args: AddPolylinesArgs) => Promise<{ ids: string[]; }> +``` + +| Param | Type | +| ---------- | ------------------------------------------------------------- | +| **`args`** | AddPolylinesArgs | + +**Returns:** Promise<{ ids: string[]; }> + +-------------------- + + +### removePolylines(...) + +```typescript +removePolylines(args: RemovePolylinesArgs) => Promise +``` + +| Param | Type | +| ---------- | ------------------------------------------------------------------- | +| **`args`** | RemovePolylinesArgs | + +-------------------- + + +### enableClustering(...) + +```typescript +enableClustering(args: EnableClusteringArgs) => Promise +``` + +| Param | Type | +| ---------- | --------------------------------------------------------------------- | +| **`args`** | EnableClusteringArgs | + +-------------------- + + +### disableClustering(...) + +```typescript +disableClustering(args: { id: string; }) => Promise +``` + +| Param | Type | +| ---------- | ---------------------------- | +| **`args`** | { id: string; } | + +-------------------- + + +### destroy(...) + +```typescript +destroy(args: DestroyMapArgs) => Promise +``` + +| Param | Type | +| ---------- | --------------------------------------------------------- | +| **`args`** | DestroyMapArgs | + +-------------------- + + +### setCamera(...) + +```typescript +setCamera(args: CameraArgs) => Promise +``` + +| Param | Type | +| ---------- | ------------------------------------------------- | +| **`args`** | CameraArgs | + +-------------------- + + +### getMapType(...) + +```typescript +getMapType(args: { id: string; }) => Promise<{ type: string; }> +``` + +| Param | Type | +| ---------- | ---------------------------- | +| **`args`** | { id: string; } | + +**Returns:** Promise<{ type: string; }> + +-------------------- + + +### setMapType(...) + +```typescript +setMapType(args: MapTypeArgs) => Promise +``` + +| Param | Type | +| ---------- | --------------------------------------------------- | +| **`args`** | MapTypeArgs | + +-------------------- + + +### enableIndoorMaps(...) + +```typescript +enableIndoorMaps(args: IndoorMapArgs) => Promise +``` + +| Param | Type | +| ---------- | ------------------------------------------------------- | +| **`args`** | IndoorMapArgs | + +-------------------- + + +### enableTrafficLayer(...) + +```typescript +enableTrafficLayer(args: TrafficLayerArgs) => Promise +``` + +| Param | Type | +| ---------- | ------------------------------------------------------------- | +| **`args`** | TrafficLayerArgs | + +-------------------- + + +### enableAccessibilityElements(...) + +```typescript +enableAccessibilityElements(args: AccElementsArgs) => Promise +``` + +| Param | Type | +| ---------- | ----------------------------------------------------------- | +| **`args`** | AccElementsArgs | + +-------------------- + + +### enableCurrentLocation(...) + +```typescript +enableCurrentLocation(args: CurrentLocArgs) => Promise +``` + +| Param | Type | +| ---------- | --------------------------------------------------------- | +| **`args`** | CurrentLocArgs | + +-------------------- + + +### setPadding(...) + +```typescript +setPadding(args: PaddingArgs) => Promise +``` + +| Param | Type | +| ---------- | --------------------------------------------------- | +| **`args`** | PaddingArgs | + +-------------------- + + +### onScroll(...) + +```typescript +onScroll(args: MapBoundsArgs) => Promise +``` + +| Param | Type | +| ---------- | ------------------------------------------------------- | +| **`args`** | MapBoundsArgs | + +-------------------- + + +### onResize(...) + +```typescript +onResize(args: MapBoundsArgs) => Promise +``` + +| Param | Type | +| ---------- | ------------------------------------------------------- | +| **`args`** | MapBoundsArgs | + +-------------------- + + +### onDisplay(...) + +```typescript +onDisplay(args: MapBoundsArgs) => Promise +``` + +| Param | Type | +| ---------- | ------------------------------------------------------- | +| **`args`** | MapBoundsArgs | + +-------------------- + + +### dispatchMapEvent(...) + +```typescript +dispatchMapEvent(args: { id: string; focus: boolean; }) => Promise +``` + +| Param | Type | +| ---------- | -------------------------------------------- | +| **`args`** | { id: string; focus: boolean; } | + +-------------------- + + +### getMapBounds(...) + +```typescript +getMapBounds(args: { id: string; }) => Promise +``` + +| Param | Type | +| ---------- | ---------------------------- | +| **`args`** | { id: string; } | + +**Returns:** Promise<LatLngBounds> + +-------------------- + + +### fitBounds(...) + +```typescript +fitBounds(args: FitBoundsArgs) => Promise +``` + +| Param | Type | +| ---------- | ------------------------------------------------------- | +| **`args`** | FitBoundsArgs | + +-------------------- + + +### mapBoundsContains(...) + +```typescript +mapBoundsContains(args: MapBoundsContainsArgs) => Promise<{ contains: boolean; }> +``` + +| Param | Type | +| ---------- | ----------------------------------------------------------------------- | +| **`args`** | MapBoundsContainsArgs | + +**Returns:** Promise<{ contains: boolean; }> + +-------------------- + + +### mapBoundsExtend(...) + +```typescript +mapBoundsExtend(args: MapBoundsExtendArgs) => Promise<{ bounds: LatLngBounds; }> +``` + +| Param | Type | +| ---------- | ----------------------------------------------------------------------- | +| **`args`** | MapBoundsContainsArgs | + +**Returns:** Promise<{ bounds: LatLngBounds; }> + +-------------------- + + +### Interfaces + + +#### CreateMapArgs + +An interface containing the options used when creating a map. + +| Prop | Type | Description | Default | +| ----------------- | ----------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------ | +| **`id`** | string | A unique identifier for the map instance. | | +| **`apiKey`** | string | Google Maps API key. Required on Android and web. Not used on iOS (MapKit). | | +| **`config`** | NativeMapConfig | The initial configuration settings for the map. | | +| **`element`** | HTMLElement | The DOM element that the Google Map View will be mounted on which determines size and positioning. | | +| **`forceCreate`** | boolean | Destroy and re-create the map instance if a map with the supplied id already exists | false | +| **`region`** | string | The region parameter alters your application to serve different map tiles or bias the application (such as biasing geocoding results towards the region). Only available for web. | | +| **`language`** | string | The language parameter affects the names of controls, copyright notices, driving directions, and control labels, as well as the responses to service requests. Only available for web. | | + + +#### NativeMapConfig + +For web, all the javascript Google Maps options are available as +NativeMapConfig extends google.maps.MapOptions. +For iOS and Android only the config options declared on NativeMapConfig are available. + +| Prop | Type | Description | Default | Since | +| ---------------------- | ----------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------ | ----- | +| **`width`** | number | Override width for native map. | | | +| **`height`** | number | Override height for native map. | | | +| **`x`** | number | Override absolute x coordinate position for native map. | | | +| **`y`** | number | Override absolute y coordinate position for native map. | | | +| **`center`** | LatLng | Default location on the Earth towards which the camera points. | | | +| **`zoom`** | number | Sets the zoom of the map. | | | +| **`androidLiteMode`** | boolean | Enables image-based lite mode on Android. | false | | +| **`devicePixelRatio`** | number | Override pixel ratio for native map. | | | +| **`styles`** | MapTypeStyle[] \| null | Styles to apply to each of the default map types. Note that for satellite, hybrid and terrain modes, these styles will only apply to labels and geometry. | | 4.3.0 | +| **`mapId`** | string | A map id associated with a specific map style or feature. [Use Map IDs](https://developers.google.com/maps/documentation/get-map-id) Only for Web. | | 5.4.0 | +| **`androidMapId`** | string | A map id associated with a specific map style or feature. [Use Map IDs](https://developers.google.com/maps/documentation/get-map-id) Only for Android. | | 5.4.0 | +| **`iOSMapId`** | string | A map id associated with a specific map style or feature. [Use Map IDs](https://developers.google.com/maps/documentation/get-map-id) Only for iOS. | | 5.4.0 | +| **`maxZoom`** | number \| null | The maximum zoom level which will be displayed on the map. If omitted, or set to <code>null</code>, the maximum zoom from the current map type is used instead. Valid zoom values are numbers from zero up to the supported <a href="https://developers.google.com/maps/documentation/javascript/maxzoom">maximum zoom level</a>. | | | +| **`minZoom`** | number \| null | The minimum zoom level which will be displayed on the map. If omitted, or set to <code>null</code>, the minimum zoom from the current map type is used instead. Valid zoom values are numbers from zero up to the supported <a href="https://developers.google.com/maps/documentation/javascript/maxzoom">maximum zoom level</a>. | | | +| **`mapTypeId`** | string \| null | The initial Map mapTypeId. Defaults to <code>ROADMAP</code>. | | | +| **`heading`** | number \| null | The heading for aerial imagery in degrees measured clockwise from cardinal direction North. Headings are snapped to the nearest available angle for which imagery is available. | | | +| **`restriction`** | MapRestriction \| null | Defines a boundary that restricts the area of the map accessible to users. When set, a user can only pan and zoom while the camera view stays inside the limits of the boundary. | | | + + +#### LatLng + +An interface representing a pair of latitude and longitude coordinates. + +| Prop | Type | Description | +| --------- | ------------------- | ------------------------------------------------------------------------- | +| **`lat`** | number | Coordinate latitude, in degrees. This value is in the range [-90, 90]. | +| **`lng`** | number | Coordinate longitude, in degrees. This value is in the range [-180, 180]. | + + +#### AddTileOverlayArgs + +| Prop | Type | +| ----------------- | --------------------------------------------------- | +| **`id`** | string | +| **`tileOverlay`** | TileOverlay | + + +#### TileOverlay + +A tile overlay is an image placed on top of your map at a specific zoom level. Available on iOS, Android and Web + +| Prop | Type | Description | Default | +| ------------- | -------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------- | +| **`url`** | string | A string representing the tile url. Should contain `{x}`, `{y}` and `{z}` so they can be replaced with actual values for x, y and zoom. Available on iOS, Android and Web | | +| **`opacity`** | number | The opacity of the tile overlay, between 0 (completely transparent) and 1 inclusive. Available on iOS, Android and Web | undefined | +| **`visible`** | boolean | Controls whether this tile overlay should be visible. Available only on Android | undefined | +| **`zIndex`** | number | The zIndex of the tile overlay. Available on iOS and Android | undefined | + + +#### RemoveTileOverlayArgs + +| Prop | Type | +| ------------------- | ------------------- | +| **`id`** | string | +| **`tileOverlayId`** | string | + + +#### AddMarkerArgs + +| Prop | Type | +| ------------ | ----------------------------------------- | +| **`id`** | string | +| **`marker`** | Marker | + + +#### Marker + +A marker is an icon placed at a particular point on the map's surface. + +| Prop | Type | Description | Default | Since | +| ---------------- | ------------------------------------------------------------ | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------ | ----- | +| **`coordinate`** | LatLng | Marker position | | | +| **`opacity`** | number | Sets the opacity of the marker, between 0 (completely transparent) and 1 inclusive. | 1 | | +| **`title`** | string | Title, a short description of the overlay. | | | +| **`snippet`** | string | Snippet text, shown beneath the title in the info window when selected. | | | +| **`isFlat`** | boolean | Controls whether this marker should be flat against the Earth's surface or a billboard facing the camera. | false | | +| **`iconUrl`** | string | Path to a marker icon to render. It can be relative to the web app public directory, or a https url of a remote marker icon. **SVGs are not supported on native platforms.** | | 4.2.0 | +| **`iconSize`** | Size | Controls the scaled size of the marker image set in `iconUrl`. | | 4.2.0 | +| **`iconOrigin`** | Point | The position of the image within a sprite, if any. By default, the origin is located at the top left corner of the image . | | 4.2.0 | +| **`iconAnchor`** | Point | The position at which to anchor an image in correspondence to the location of the marker on the map. By default, the anchor is located along the center point of the bottom of the image. | | 4.2.0 | +| **`tintColor`** | { r: number; g: number; b: number; a: number; } | Customizes the color of the default marker image. Each value must be between 0 and 255. Only for iOS and Android. | | 4.2.0 | +| **`draggable`** | boolean | Controls whether this marker can be dragged interactively | false | | +| **`zIndex`** | number | Specifies the stack order of this marker, relative to other markers on the map. A marker with a high z-index is drawn on top of markers with lower z-indexes | 0 | | + + +#### Size + +| Prop | Type | +| ------------ | ------------------- | +| **`width`** | number | +| **`height`** | number | + + +#### Point + +Point geometry object. +https://tools.ietf.org/html/rfc7946#section-3.1.2 + +| Prop | Type | Description | +| ----------------- | --------------------------------------------- | ------------------------------------- | +| **`type`** | 'Point' | Specifies the type of GeoJSON object. | +| **`coordinates`** | Position | | + + +#### Position + +| Prop | Type | Description | +| ------------ | ------------------- | ----------- | +| **`line`** | number | >= 1 | +| **`column`** | number | >= 0 | + + +#### AddMarkersArgs + +| Prop | Type | +| ------------- | --------------------- | +| **`id`** | string | +| **`markers`** | Marker[] | + + +#### RemoveMarkerArgs + +| Prop | Type | +| -------------- | ------------------- | +| **`id`** | string | +| **`markerId`** | string | + + +#### RemoveMarkersArgs + +| Prop | Type | +| --------------- | --------------------- | +| **`id`** | string | +| **`markerIds`** | string[] | + + +#### AddPolygonsArgs + +| Prop | Type | +| -------------- | ---------------------- | +| **`id`** | string | +| **`polygons`** | Polygon[] | + + +#### Polygon + +Polygon geometry object. +https://tools.ietf.org/html/rfc7946#section-3.1.6 + +| Prop | Type | Description | +| ----------------- | --------------------------------------------- | ------------------------------------- | +| **`type`** | 'Polygon' | Specifies the type of GeoJSON object. | +| **`coordinates`** | Position[][] | | + + +#### RemovePolygonsArgs + +| Prop | Type | +| ---------------- | --------------------- | +| **`id`** | string | +| **`polygonIds`** | string[] | + + +#### AddCirclesArgs + +| Prop | Type | +| ------------- | --------------------- | +| **`id`** | string | +| **`circles`** | Circle[] | + + +#### Circle + +For web, all the javascript Circle options are available as +Circle extends google.maps.CircleOptions. +For iOS and Android only the config options declared on Circle are available. + +| Prop | Type | Description | +| ------------------ | -------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | +| **`fillColor`** | string | The fill color. All CSS3 colors are supported except for extended named colors. | +| **`fillOpacity`** | number | The fill opacity between 0.0 and 1.0. | +| **`strokeColor`** | string | The stroke color. All CSS3 colors are supported except for extended named colors. | +| **`strokeWeight`** | number | The stroke width in pixels. | +| **`geodesic`** | boolean | | +| **`clickable`** | boolean | Indicates whether this <code>Circle</code> handles mouse events. | +| **`title`** | string | Title, a short description of the overlay. Some overlays, such as markers, will display the title on the map. The title is also the default accessibility text. Only available on iOS. | +| **`tag`** | string | | + + +#### RemoveCirclesArgs + +| Prop | Type | +| --------------- | --------------------- | +| **`id`** | string | +| **`circleIds`** | string[] | + + +#### AddPolylinesArgs + +| Prop | Type | +| --------------- | ----------------------- | +| **`id`** | string | +| **`polylines`** | Polyline[] | + + +#### Polyline + +For web, all the javascript Polyline options are available as +Polyline extends google.maps.PolylineOptions. +For iOS and Android only the config options declared on Polyline are available. + +| Prop | Type | Description | +| ------------------- | ------------------------ | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | +| **`strokeColor`** | string | The stroke color. All CSS3 colors are supported except for extended named colors. | +| **`strokeOpacity`** | number | The stroke opacity between 0.0 and 1.0. | +| **`strokeWeight`** | number | The stroke width in pixels. | +| **`geodesic`** | boolean | When <code>true</code>, edges of the polygon are interpreted as geodesic and will follow the curvature of the Earth. When <code>false</code>, edges of the polygon are rendered as straight lines in screen space. Note that the shape of a geodesic polygon may appear to change when dragged, as the dimensions are maintained relative to the surface of the earth. | +| **`clickable`** | boolean | Indicates whether this <code>Polyline</code> handles mouse events. | +| **`tag`** | string | | +| **`styleSpans`** | StyleSpan[] | Used to specify the color of one or more segments of a polyline. The styleSpans property is an array of StyleSpan objects. Setting the spans property is the preferred way to change the color of a polyline. Only on iOS and Android. | + + +#### StyleSpan + +Describes the style for some region of a polyline. + +| Prop | Type | Description | +| -------------- | ------------------- | --------------------------------------------------------------------------------- | +| **`color`** | string | The stroke color. All CSS3 colors are supported except for extended named colors. | +| **`segments`** | number | The length of this span in number of segments. | + + +#### RemovePolylinesArgs + +| Prop | Type | +| ----------------- | --------------------- | +| **`id`** | string | +| **`polylineIds`** | string[] | + + +#### EnableClusteringArgs + +| Prop | Type | +| -------------------- | ------------------- | +| **`id`** | string | +| **`minClusterSize`** | number | + + +#### DestroyMapArgs + +| Prop | Type | +| -------- | ------------------- | +| **`id`** | string | + + +#### CameraArgs + +| Prop | Type | +| ------------ | ----------------------------------------------------- | +| **`id`** | string | +| **`config`** | CameraConfig | + + +#### CameraConfig + +Configuration properties for a Google Map Camera + +| Prop | Type | Description | Default | +| ----------------------- | ----------------------------------------- | ---------------------------------------------------------------------------------------------------------------------- | ------------------ | +| **`coordinate`** | LatLng | Location on the Earth towards which the camera points. | | +| **`zoom`** | number | Sets the zoom of the map. | | +| **`bearing`** | number | Bearing of the camera, in degrees clockwise from true north. | 0 | +| **`angle`** | number | The angle, in degrees, of the camera from the nadir (directly facing the Earth). The only allowed values are 0 and 45. | 0 | +| **`animate`** | boolean | Animate the transition to the new Camera properties. | false | +| **`animationDuration`** | number | This configuration option is not being used. | | + + +#### MapTypeArgs + +| Prop | Type | +| ------------- | ------------------------------------------- | +| **`id`** | string | +| **`mapType`** | MapType | + + +#### IndoorMapArgs + +| Prop | Type | +| ------------- | -------------------- | +| **`id`** | string | +| **`enabled`** | boolean | + + +#### TrafficLayerArgs + +| Prop | Type | +| ------------- | -------------------- | +| **`id`** | string | +| **`enabled`** | boolean | + + +#### AccElementsArgs + +| Prop | Type | +| ------------- | -------------------- | +| **`id`** | string | +| **`enabled`** | boolean | + + +#### CurrentLocArgs + +| Prop | Type | +| ------------- | -------------------- | +| **`id`** | string | +| **`enabled`** | boolean | + + +#### PaddingArgs + +| Prop | Type | +| ------------- | ------------------------------------------------- | +| **`id`** | string | +| **`padding`** | MapPadding | + + +#### MapPadding + +Controls for setting padding on the 'visible' region of the view. + +| Prop | Type | +| ------------ | ------------------- | +| **`top`** | number | +| **`left`** | number | +| **`right`** | number | +| **`bottom`** | number | + + +#### MapBoundsArgs + +| Prop | Type | +| --------------- | --------------------------------------------------------------------- | +| **`id`** | string | +| **`mapBounds`** | { x: number; y: number; width: number; height: number; } | + + +#### FitBoundsArgs + +| Prop | Type | +| ------------- | ------------------------- | +| **`id`** | string | +| **`bounds`** | LatLngBounds | +| **`padding`** | number | + + +#### MapBoundsContainsArgs + +| Prop | Type | +| ------------ | ----------------------------------------- | +| **`bounds`** | LatLngBounds | +| **`point`** | LatLng | + + +### Type Aliases + + +#### Position + +A Position is an array of coordinates. +https://tools.ietf.org/html/rfc7946#section-3.1.1 +Array should contain between two and three elements. +The previous GeoJSON specification allowed more elements (e.g., which could be used to represent M values), +but the current specification only allows X, Y, and (optionally) Z to be defined. + +Note: the type will not be narrowed down to `[number, number] | [number, number, number]` due to +marginal benefits and the large impact of breaking change. + +See previous discussions on the type narrowing: +- {@link https://github.com/DefinitelyTyped/DefinitelyTyped/pull/21590|Nov 2017} +- {@link https://github.com/DefinitelyTyped/DefinitelyTyped/discussions/67773|Dec 2023} +- {@link https://github.com/DefinitelyTyped/DefinitelyTyped/discussions/71441| Dec 2024} + +One can use a +{@link https://www.typescriptlang.org/docs/handbook/2/narrowing.html#using-type-predicates|user-defined type guard that returns a type predicate} +to determine if a position is a 2D or 3D position. + +number[] + + +#### Marker + +Supports markers of either "legacy" or "advanced" types. + +google.maps.Marker | google.maps.marker.AdvancedMarkerElement + + +#### MapBoundsExtendArgs + +MapBoundsContainsArgs + + +### Enums + + +#### MapType + +| Members | Value | Description | +| --------------- | ------------------------ | ---------------------------------------- | +| **`Normal`** | 'Normal' | Basic map. | +| **`Hybrid`** | 'Hybrid' | Satellite imagery with roads and labels. | +| **`Satellite`** | 'Satellite' | Satellite imagery with no labels. | +| **`Terrain`** | 'Terrain' | Topographic data. | +| **`None`** | 'None' | No base map tiles. | + + diff --git a/THIRD_PARTY_LICENSES b/THIRD_PARTY_LICENSES new file mode 100644 index 0000000..661bb1c --- /dev/null +++ b/THIRD_PARTY_LICENSES @@ -0,0 +1,8 @@ +This plugin includes code adapted from the following third-party projects. +See the legal/ directory for full license texts. + +- @capacitor/google-maps (Ionic Team, MIT): Android implementation and web fallback + https://github.com/ionic-team/capacitor-google-maps + +- capacitor-plugin-apple-maps (Katama Labs, MIT): iOS MapKit implementation + https://github.com/katamalabs/capacitor-plugin-apple-maps diff --git a/android/.gitignore b/android/.gitignore new file mode 100644 index 0000000..796b96d --- /dev/null +++ b/android/.gitignore @@ -0,0 +1 @@ +/build diff --git a/android/build.gradle b/android/build.gradle new file mode 100644 index 0000000..9e40e63 --- /dev/null +++ b/android/build.gradle @@ -0,0 +1,103 @@ +ext { + capacitorVersion = System.getenv('CAPACITOR_VERSION') + junitVersion = project.hasProperty('junitVersion') ? rootProject.ext.junitVersion : '4.13.2' + androidxAppCompatVersion = project.hasProperty('androidxAppCompatVersion') ? rootProject.ext.androidxAppCompatVersion : '1.7.1' + androidxJunitVersion = project.hasProperty('androidxJunitVersion') ? rootProject.ext.androidxJunitVersion : '1.3.0' + androidxEspressoCoreVersion = project.hasProperty('androidxEspressoCoreVersion') ? rootProject.ext.androidxEspressoCoreVersion : '3.7.0' + androidxCoreKTXVersion = project.hasProperty('androidxCoreKTXVersion') ? rootProject.ext.androidxCoreKTXVersion : '1.17.0' + googleMapsPlayServicesVersion = project.hasProperty('googleMapsPlayServicesVersion') ? rootProject.ext.googleMapsPlayServicesVersion : '19.2.0' + googleMapsUtilsVersion = project.hasProperty('googleMapsUtilsVersion') ? rootProject.ext.googleMapsUtilsVersion : '3.19.1' + googleMapsKtxVersion = project.hasProperty('googleMapsKtxVersion') ? rootProject.ext.googleMapsKtxVersion : '5.2.1' + googleMapsUtilsKtxVersion = project.hasProperty('googleMapsUtilsKtxVersion') ? rootProject.ext.googleMapsUtilsKtxVersion : '5.2.1' + kotlinxCoroutinesVersion = project.hasProperty('kotlinxCoroutinesVersion') ? rootProject.ext.kotlinxCoroutinesVersion : '1.10.2' +} + +buildscript { + ext.kotlin_version = project.hasProperty("kotlin_version") ? rootProject.ext.kotlin_version : '2.2.20' + repositories { + google() + mavenCentral() + maven { + url = "https://plugins.gradle.org/m2/" + } + } + dependencies { + classpath 'com.android.tools.build:gradle:8.13.0' + classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version" + if (System.getenv("CAP_PLUGIN_PUBLISH") == "true") { + classpath 'io.github.gradle-nexus:publish-plugin:1.3.0' + } + } +} + +apply plugin: 'com.android.library' +apply plugin: 'kotlin-android' +if (System.getenv("CAP_PLUGIN_PUBLISH") == "true") { + apply plugin: 'io.github.gradle-nexus.publish-plugin' + apply from: file('../../scripts/android/publish-root.gradle') + apply from: file('../../scripts/android/publish-module.gradle') +} + +android { + namespace = "com.capgo.plugins.nativemap" + compileSdk = project.hasProperty('compileSdkVersion') ? rootProject.ext.compileSdkVersion : 36 + defaultConfig { + minSdkVersion project.hasProperty('minSdkVersion') ? rootProject.ext.minSdkVersion : 24 + targetSdkVersion project.hasProperty('targetSdkVersion') ? rootProject.ext.targetSdkVersion : 36 + versionCode 1 + versionName "1.0" + testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner" + } + buildTypes { + release { + minifyEnabled false + proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules.pro' + } + } + lintOptions { + abortOnError = false + } + compileOptions { + sourceCompatibility JavaVersion.VERSION_21 + targetCompatibility JavaVersion.VERSION_21 + } + publishing { + singleVariant("release") + } + dependencies { + implementation("org.jetbrains.kotlinx:kotlinx-coroutines-android:$kotlinxCoroutinesVersion") + implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core:$kotlinxCoroutinesVersion") + } +} + +kotlin { + jvmToolchain(21) +} + +repositories { + google() + mavenCentral() +} + + +dependencies { + implementation fileTree(dir: 'libs', include: ['*.jar']) + + if (System.getenv("CAP_PLUGIN_PUBLISH") == "true") { + implementation "com.capacitorjs:core:$capacitorVersion" + } else { + implementation project(':capacitor-android') + } + + implementation "androidx.appcompat:appcompat:$androidxAppCompatVersion" + testImplementation "junit:junit:$junitVersion" + androidTestImplementation "androidx.test.ext:junit:$androidxJunitVersion" + androidTestImplementation "androidx.test.espresso:espresso-core:$androidxEspressoCoreVersion" + implementation "androidx.core:core-ktx:$androidxCoreKTXVersion" + implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version" + + implementation "com.google.maps.android:maps-ktx:$googleMapsKtxVersion" + implementation "com.google.maps.android:maps-utils-ktx:$googleMapsUtilsKtxVersion" + implementation "com.google.maps.android:android-maps-utils:$googleMapsUtilsVersion" + implementation "com.google.android.gms:play-services-maps:$googleMapsPlayServicesVersion" +} diff --git a/android/gradle.properties b/android/gradle.properties new file mode 100644 index 0000000..aa7ea25 --- /dev/null +++ b/android/gradle.properties @@ -0,0 +1,22 @@ +# Project-wide Gradle settings. + +# IDE (e.g. Android Studio) users: +# Gradle settings configured through the IDE *will override* +# any settings specified in this file. + +# For more details on how to configure your build environment visit +# http://www.gradle.org/docs/current/userguide/build_environment.html + +# Specifies the JVM arguments used for the daemon process. +# The setting is particularly useful for tweaking memory settings. +org.gradle.jvmargs=-Xmx2g -XX:MaxMetaspaceSize=2g + +# When configured, Gradle will run in incubating parallel mode. +# This option should only be used with decoupled projects. More details, visit +# http://www.gradle.org/docs/current/userguide/multi_project_builds.html#sec:decoupled_projects +# org.gradle.parallel=true + +# AndroidX package structure to make it clearer which packages are bundled with the +# Android operating system, and which are packaged with your app's APK +# https://developer.android.com/topic/libraries/support-library/androidx-rn +android.useAndroidX=true diff --git a/android/gradle/wrapper/gradle-wrapper.jar b/android/gradle/wrapper/gradle-wrapper.jar new file mode 100644 index 0000000000000000000000000000000000000000..1b33c55baabb587c669f562ae36f953de2481846 GIT binary patch literal 43764 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 '} + case $link in #( + /*) app_path=$link ;; #( + *) app_path=$APP_HOME$link ;; + esac +done + +# This is normally unused +# shellcheck disable=SC2034 +APP_BASE_NAME=${0##*/} +# Discard cd standard output in case $CDPATH is set (https://github.com/gradle/gradle/issues/25036) +APP_HOME=$( cd -P "${APP_HOME:-./}" > /dev/null && printf '%s\n' "$PWD" ) || exit + +# Use the maximum available, or set MAX_FD != -1 to use that value. +MAX_FD=maximum + +warn () { + echo "$*" +} >&2 + +die () { + echo + echo "$*" + echo + exit 1 +} >&2 + +# OS specific support (must be 'true' or 'false'). +cygwin=false +msys=false +darwin=false +nonstop=false +case "$( uname )" in #( + CYGWIN* ) cygwin=true ;; #( + Darwin* ) darwin=true ;; #( + MSYS* | MINGW* ) msys=true ;; #( + NONSTOP* ) nonstop=true ;; +esac + +CLASSPATH="\\\"\\\"" + + +# Determine the Java command to use to start the JVM. +if [ -n "$JAVA_HOME" ] ; then + if [ -x "$JAVA_HOME/jre/sh/java" ] ; then + # IBM's JDK on AIX uses strange locations for the executables + JAVACMD=$JAVA_HOME/jre/sh/java + else + JAVACMD=$JAVA_HOME/bin/java + fi + if [ ! -x "$JAVACMD" ] ; then + die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME + +Please set the JAVA_HOME variable in your environment to match the +location of your Java installation." + fi +else + JAVACMD=java + if ! command -v java >/dev/null 2>&1 + then + die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH. + +Please set the JAVA_HOME variable in your environment to match the +location of your Java installation." + fi +fi + +# Increase the maximum file descriptors if we can. +if ! "$cygwin" && ! "$darwin" && ! "$nonstop" ; then + case $MAX_FD in #( + max*) + # In POSIX sh, ulimit -H is undefined. That's why the result is checked to see if it worked. + # shellcheck disable=SC2039,SC3045 + MAX_FD=$( ulimit -H -n ) || + warn "Could not query maximum file descriptor limit" + esac + case $MAX_FD in #( + '' | soft) :;; #( + *) + # In POSIX sh, ulimit -n is undefined. That's why the result is checked to see if it worked. + # shellcheck disable=SC2039,SC3045 + ulimit -n "$MAX_FD" || + warn "Could not set maximum file descriptor limit to $MAX_FD" + esac +fi + +# Collect all arguments for the java command, stacking in reverse order: +# * args from the command line +# * the main class name +# * -classpath +# * -D...appname settings +# * --module-path (only if needed) +# * DEFAULT_JVM_OPTS, JAVA_OPTS, and GRADLE_OPTS environment variables. + +# For Cygwin or MSYS, switch paths to Windows format before running java +if "$cygwin" || "$msys" ; then + APP_HOME=$( cygpath --path --mixed "$APP_HOME" ) + CLASSPATH=$( cygpath --path --mixed "$CLASSPATH" ) + + JAVACMD=$( cygpath --unix "$JAVACMD" ) + + # Now convert the arguments - kludge to limit ourselves to /bin/sh + for arg do + if + case $arg in #( + -*) false ;; # don't mess with options #( + /?*) t=${arg#/} t=/${t%%/*} # looks like a POSIX filepath + [ -e "$t" ] ;; #( + *) false ;; + esac + then + arg=$( cygpath --path --ignore --mixed "$arg" ) + fi + # Roll the args list around exactly as many times as the number of + # args, so each arg winds up back in the position where it started, but + # possibly modified. + # + # NB: a `for` loop captures its iteration list before it begins, so + # changing the positional parameters here affects neither the number of + # iterations, nor the values presented in `arg`. + shift # remove old arg + set -- "$@" "$arg" # push replacement arg + done +fi + + +# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script. +DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"' + +# Collect all arguments for the java command: +# * DEFAULT_JVM_OPTS, JAVA_OPTS, and optsEnvironmentVar are not allowed to contain shell fragments, +# and any embedded shellness will be escaped. +# * For example: A user cannot expect ${Hostname} to be expanded, as it is an environment variable and will be +# treated as '${Hostname}' itself on the command line. + +set -- \ + "-Dorg.gradle.appname=$APP_BASE_NAME" \ + -classpath "$CLASSPATH" \ + -jar "$APP_HOME/gradle/wrapper/gradle-wrapper.jar" \ + "$@" + +# Stop when "xargs" is not available. +if ! command -v xargs >/dev/null 2>&1 +then + die "xargs is not available" +fi + +# Use "xargs" to parse quoted args. +# +# With -n1 it outputs one arg per line, with the quotes and backslashes removed. +# +# In Bash we could simply go: +# +# readarray ARGS < <( xargs -n1 <<<"$var" ) && +# set -- "${ARGS[@]}" "$@" +# +# but POSIX shell has neither arrays nor command substitution, so instead we +# post-process each arg (as a line of input to sed) to backslash-escape any +# character that might be a shell metacharacter, then use eval to reverse +# that process (while maintaining the separation between arguments), and wrap +# the whole thing up as a single "set" statement. +# +# This will of course break if any of these variables contains a newline or +# an unmatched quote. +# + +eval "set -- $( + printf '%s\n' "$DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS" | + xargs -n1 | + sed ' s~[^-[:alnum:]+,./:=@_]~\\&~g; ' | + tr '\n' ' ' + )" '"$@"' + +exec "$JAVACMD" "$@" diff --git a/android/gradlew.bat b/android/gradlew.bat new file mode 100644 index 0000000..5eed7ee --- /dev/null +++ b/android/gradlew.bat @@ -0,0 +1,94 @@ +@rem +@rem Copyright 2015 the original author or authors. +@rem +@rem Licensed under the Apache License, Version 2.0 (the "License"); +@rem you may not use this file except in compliance with the License. +@rem You may obtain a copy of the License at +@rem +@rem https://www.apache.org/licenses/LICENSE-2.0 +@rem +@rem Unless required by applicable law or agreed to in writing, software +@rem distributed under the License is distributed on an "AS IS" BASIS, +@rem WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +@rem See the License for the specific language governing permissions and +@rem limitations under the License. +@rem +@rem SPDX-License-Identifier: Apache-2.0 +@rem + +@if "%DEBUG%"=="" @echo off +@rem ########################################################################## +@rem +@rem Gradle startup script for Windows +@rem +@rem ########################################################################## + +@rem Set local scope for the variables with windows NT shell +if "%OS%"=="Windows_NT" setlocal + +set DIRNAME=%~dp0 +if "%DIRNAME%"=="" set DIRNAME=. +@rem This is normally unused +set APP_BASE_NAME=%~n0 +set APP_HOME=%DIRNAME% + +@rem Resolve any "." and ".." in APP_HOME to make it shorter. +for %%i in ("%APP_HOME%") do set APP_HOME=%%~fi + +@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script. +set DEFAULT_JVM_OPTS="-Xmx64m" "-Xms64m" + +@rem Find java.exe +if defined JAVA_HOME goto findJavaFromJavaHome + +set JAVA_EXE=java.exe +%JAVA_EXE% -version >NUL 2>&1 +if %ERRORLEVEL% equ 0 goto execute + +echo. 1>&2 +echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH. 1>&2 +echo. 1>&2 +echo Please set the JAVA_HOME variable in your environment to match the 1>&2 +echo location of your Java installation. 1>&2 + +goto fail + +:findJavaFromJavaHome +set JAVA_HOME=%JAVA_HOME:"=% +set JAVA_EXE=%JAVA_HOME%/bin/java.exe + +if exist "%JAVA_EXE%" goto execute + +echo. 1>&2 +echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME% 1>&2 +echo. 1>&2 +echo Please set the JAVA_HOME variable in your environment to match the 1>&2 +echo location of your Java installation. 1>&2 + +goto fail + +:execute +@rem Setup the command line + +set CLASSPATH= + + +@rem Execute Gradle +"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" -jar "%APP_HOME%\gradle\wrapper\gradle-wrapper.jar" %* + +:end +@rem End local scope for the variables with windows NT shell +if %ERRORLEVEL% equ 0 goto mainEnd + +:fail +rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of +rem the _cmd.exe /c_ return code! +set EXIT_CODE=%ERRORLEVEL% +if %EXIT_CODE% equ 0 set EXIT_CODE=1 +if not ""=="%GRADLE_EXIT_CONSOLE%" exit %EXIT_CODE% +exit /b %EXIT_CODE% + +:mainEnd +if "%OS%"=="Windows_NT" endlocal + +:omega diff --git a/android/proguard-rules.pro b/android/proguard-rules.pro new file mode 100644 index 0000000..f1b4245 --- /dev/null +++ b/android/proguard-rules.pro @@ -0,0 +1,21 @@ +# Add project specific ProGuard rules here. +# You can control the set of applied configuration files using the +# proguardFiles setting in build.gradle. +# +# For more details, see +# http://developer.android.com/guide/developing/tools/proguard.html + +# If your project uses WebView with JS, uncomment the following +# and specify the fully qualified class name to the JavaScript interface +# class: +#-keepclassmembers class fqcn.of.javascript.interface.for.webview { +# public *; +#} + +# Uncomment this to preserve the line number information for +# debugging stack traces. +#-keepattributes SourceFile,LineNumberTable + +# If you keep the line number information, uncomment this to +# hide the original source file name. +#-renamesourcefileattribute SourceFile diff --git a/android/settings.gradle b/android/settings.gradle new file mode 100644 index 0000000..1e5b843 --- /dev/null +++ b/android/settings.gradle @@ -0,0 +1,2 @@ +include ':capacitor-android' +project(':capacitor-android').projectDir = new File('../node_modules/@capacitor/android/capacitor') \ No newline at end of file diff --git a/android/src/main/AndroidManifest.xml b/android/src/main/AndroidManifest.xml new file mode 100644 index 0000000..a2f47b6 --- /dev/null +++ b/android/src/main/AndroidManifest.xml @@ -0,0 +1,2 @@ + + diff --git a/android/src/main/java/com/capgo/plugins/nativemap/CapacitorClusterManagerRenderer.kt b/android/src/main/java/com/capgo/plugins/nativemap/CapacitorClusterManagerRenderer.kt new file mode 100644 index 0000000..903056d --- /dev/null +++ b/android/src/main/java/com/capgo/plugins/nativemap/CapacitorClusterManagerRenderer.kt @@ -0,0 +1,37 @@ +package com.capgo.plugins.nativemap + +import android.content.Context +import com.google.android.gms.maps.GoogleMap +import com.google.android.gms.maps.model.MarkerOptions +import com.google.maps.android.clustering.ClusterManager +import com.google.maps.android.clustering.view.DefaultClusterRenderer + +class CapacitorClusterManagerRenderer( + context: Context, + map: NativeMap?, + clusterManager: ClusterManager?, + minClusterSize: Int? +) : DefaultClusterRenderer(context, map, clusterManager) { + + init { + if(minClusterSize != null && minClusterSize > 0) { + super.setMinClusterSize(minClusterSize) + } + } + + override fun onBeforeClusterItemRendered(item: CapacitorNativeMapViewMarker, markerOptions: MarkerOptions) { + super.onBeforeClusterItemRendered(item, markerOptions) + + item.markerOptions?.let { + markerOptions.position(it.position) + markerOptions.title(it.title) + markerOptions.snippet(it.snippet) + markerOptions.alpha(it.alpha) + markerOptions.flat(it.isFlat) + markerOptions.draggable(it.isDraggable) + if(null != it.icon) { + markerOptions.icon(it.icon) + } + } + } +} diff --git a/android/src/main/java/com/capgo/plugins/nativemap/CapacitorGoogleMap.kt b/android/src/main/java/com/capgo/plugins/nativemap/CapacitorGoogleMap.kt new file mode 100644 index 0000000..a13b60a --- /dev/null +++ b/android/src/main/java/com/capgo/plugins/nativemap/CapacitorGoogleMap.kt @@ -0,0 +1,1190 @@ +package com.capgo.plugins.nativemap + +import android.annotation.SuppressLint +import android.graphics.* +import android.location.Location +import android.util.Log +import android.view.MotionEvent +import android.view.View +import android.view.ViewGroup +import android.widget.FrameLayout +import com.getcapacitor.Bridge +import com.getcapacitor.JSArray +import com.getcapacitor.JSObject +import com.google.android.gms.maps.* +import com.google.android.gms.maps.GoogleMap.* +import com.google.android.gms.maps.model.* +import com.google.maps.android.clustering.Cluster +import com.google.maps.android.clustering.ClusterManager +import kotlinx.coroutines.* +import kotlinx.coroutines.channels.Channel +import java.io.InputStream +import java.net.URL + +class CapacitorNativeMapView( + val id: String, + val config: NativeMapConfig, + val delegate: CapacitorNativeMapPlugin +) : + OnCameraIdleListener, + OnCameraMoveStartedListener, + OnCameraMoveListener, + OnMyLocationButtonClickListener, + OnMyLocationClickListener, + OnMapReadyCallback, + OnMapClickListener, + OnMarkerClickListener, + OnMarkerDragListener, + OnInfoWindowClickListener, + OnCircleClickListener, + OnPolylineClickListener, + OnPolygonClickListener { + private var mapView: MapView + private var googleMap: NativeMap? = null + private val markers = HashMap() + private val tileOverlays = HashMap() + private val polygons = HashMap() + private val circles = HashMap() + private val polylines = HashMap() + private val markerIcons = HashMap() + private var clusterManager: ClusterManager? = null + + private val isReadyChannel = Channel() + private var debounceJob: Job? = null + + init { + val bridge = delegate.bridge + + mapView = MapView(bridge.context, config.googleMapOptions) + initMap() + setListeners() + } + + private fun initMap() { + runBlocking { + val job = + CoroutineScope(Dispatchers.Main).launch { + mapView.onCreate(null) + mapView.onStart() + mapView.getMapAsync(this@CapacitorNativeMapView) + mapView.setWillNotDraw(false) + isReadyChannel.receive() + + render() + } + + job.join() + } + } + + private fun render() { + runBlocking { + CoroutineScope(Dispatchers.Main).launch { + val bridge = delegate.bridge + val mapViewParent = FrameLayout(bridge.context) + mapViewParent.minimumHeight = bridge.webView.height + mapViewParent.minimumWidth = bridge.webView.width + + val layoutParams = + FrameLayout.LayoutParams( + getScaledPixels(bridge, config.width), + getScaledPixels(bridge, config.height), + ) + layoutParams.leftMargin = getScaledPixels(bridge, config.x) + layoutParams.topMargin = getScaledPixels(bridge, config.y) + + mapViewParent.tag = id + + mapView.layoutParams = layoutParams + mapViewParent.addView(mapView) + + ((bridge.webView.parent) as ViewGroup).addView(mapViewParent) + + bridge.webView.bringToFront() + bridge.webView.setBackgroundColor(Color.TRANSPARENT) + if (config.styles != null) { + googleMap?.setMapStyle(MapStyleOptions(config.styles!!)) + } + + if (config.maxZoom != null) { + googleMap?.setMaxZoomPreference(config.maxZoom!!.toFloat()) + } + + if (config.minZoom != null) { + googleMap?.setMinZoomPreference((config.minZoom!!.toFloat())) + } + + if (config.mapTypeId != null) { + when (config.mapTypeId!!) { + "hybrid" -> googleMap?.mapType = NativeMap.MAP_TYPE_HYBRID + "roadmap" -> googleMap?.mapType = NativeMap.MAP_TYPE_NORMAL + "satellite" -> googleMap?.mapType = NativeMap.MAP_TYPE_SATELLITE + "terrain" -> googleMap?.mapType = NativeMap.MAP_TYPE_TERRAIN + } + } + + if (config.restriction != null) { + googleMap?.setLatLngBoundsForCameraTarget(config.restriction!!.latLngBounds) + } + + if (config.heading != null) { + googleMap?.cameraPosition?.let { cameraPosition -> + googleMap?.animateCamera( + CameraUpdateFactory.newCameraPosition( + CameraPosition.Builder(cameraPosition) + .bearing(config.heading!!.toFloat()) + .build() + ) + ) + } + } + } + } + } + + fun updateRender(updatedBounds: RectF) { + this.config.x = updatedBounds.left.toInt() + this.config.y = updatedBounds.top.toInt() + this.config.width = updatedBounds.width().toInt() + this.config.height = updatedBounds.height().toInt() + + runBlocking { + CoroutineScope(Dispatchers.Main).launch { + val bridge = delegate.bridge + val mapRect = getScaledRect(bridge, updatedBounds) + val mapView = this@CapacitorNativeMapView.mapView; + mapView.x = mapRect.left + mapView.y = mapRect.top + if (mapView.layoutParams.width != config.width || mapView.layoutParams.height != config.height) { + mapView.layoutParams.width = getScaledPixels(bridge, config.width) + mapView.layoutParams.height = getScaledPixels(bridge, config.height) + mapView.requestLayout() + } + } + } + } + + fun dispatchTouchEvent(event: MotionEvent) { + CoroutineScope(Dispatchers.Main).launch { + val offsetViewBounds = getMapBounds() + + val relativeTop = offsetViewBounds.top + val relativeLeft = offsetViewBounds.left + + event.setLocation(event.x - relativeLeft, event.y - relativeTop) + mapView.dispatchTouchEvent(event) + } + } + + fun bringToFront() { + CoroutineScope(Dispatchers.Main).launch { + val mapViewParent = + ((delegate.bridge.webView.parent) as ViewGroup).findViewWithTag( + this@CapacitorNativeMapView.id + ) + mapViewParent.bringToFront() + } + } + + fun destroy() { + runBlocking { + val job = + CoroutineScope(Dispatchers.Main).launch { + val bridge = delegate.bridge + + val viewToRemove: View? = + ((bridge.webView.parent) as ViewGroup).findViewWithTag(id) + if (null != viewToRemove) { + ((bridge.webView.parent) as ViewGroup).removeView(viewToRemove) + } + mapView.onDestroy() + googleMap = null + clusterManager = null + } + + job.join() + } + } + + fun addTileOverlay( + tileOverlay: CapacitorNativeMapViewTileOverlay, + callback: (Result) -> Unit + ) { + try { + googleMap ?: throw NativeMapNotAvailable() + + CoroutineScope(Dispatchers.Main).launch { + val tileProvider = object : UrlTileProvider(256, 256) { + override fun getTileUrl(x: Int, y: Int, zoom: Int): URL? { + return URL(tileOverlay.url + .replace("{x}", "$x") + .replace("{y}", "$y") + .replace("{z}", "$zoom") + ) + } + } + var tileOverlayOptions = TileOverlayOptions().tileProvider(tileProvider) + if (tileOverlay.zIndex != null) { + tileOverlayOptions.zIndex(tileOverlay.zIndex!!) + } + if (tileOverlay.visible != null) { + tileOverlayOptions.visible(tileOverlay.visible!!) + } + if (tileOverlay.opacity != null) { + tileOverlayOptions.transparency(tileOverlay.opacity!!) + } + + val googleMapTileOverlay = googleMap?.addTileOverlay(tileOverlayOptions) + + tileOverlay.googleMapTileOverlay = googleMapTileOverlay + tileOverlays[googleMapTileOverlay!!.id] = tileOverlay + + callback(Result.success(googleMapTileOverlay.id)) + } + } catch (e: NativeMapsError) { + callback(Result.failure(e)) + } + } + + fun removeTileOverlay(id: String, callback: (error: NativeMapsError?) -> Unit) { + try { + googleMap ?: throw NativeMapNotAvailable() + + val tileOverlay = tileOverlays[id] + tileOverlay ?: throw TileOverlayNotFoundError() + + CoroutineScope(Dispatchers.Main).launch { + tileOverlay.googleMapTileOverlay?.remove() + tileOverlays.remove(id) + + callback(null) + } + } catch (e: NativeMapsError) { + callback(e) + } + } + + fun addMarkers( + newMarkers: List, + callback: (ids: Result>) -> Unit + ) { + try { + googleMap ?: throw NativeMapNotAvailable() + val markerIds: MutableList = mutableListOf() + + CoroutineScope(Dispatchers.Main).launch { + newMarkers.forEach { + val markerOptions: Deferred = + CoroutineScope(Dispatchers.IO).async { + this@CapacitorNativeMapView.buildMarker(it) + } + val googleMapMarker = googleMap?.addMarker(markerOptions.await()) + it.googleMapMarker = googleMapMarker + + if (googleMapMarker != null) { + if (clusterManager != null) { + googleMapMarker.remove() + } + + markers[googleMapMarker.id] = it + markerIds.add(googleMapMarker.id) + } + } + + if (clusterManager != null) { + clusterManager?.addItems(newMarkers) + clusterManager?.cluster() + } + + callback(Result.success(markerIds)) + } + } catch (e: NativeMapsError) { + callback(Result.failure(e)) + } + } + + fun addMarker(marker: CapacitorNativeMapViewMarker, callback: (result: Result) -> Unit) { + try { + googleMap ?: throw NativeMapNotAvailable() + + var markerId: String + + CoroutineScope(Dispatchers.Main).launch { + val markerOptions: Deferred = + CoroutineScope(Dispatchers.IO).async { + this@CapacitorNativeMapView.buildMarker(marker) + } + val googleMapMarker = googleMap?.addMarker(markerOptions.await()) + + marker.googleMapMarker = googleMapMarker + + if (clusterManager != null) { + googleMapMarker?.remove() + clusterManager?.addItem(marker) + clusterManager?.cluster() + } + + markers[googleMapMarker!!.id] = marker + + markerId = googleMapMarker.id + + callback(Result.success(markerId)) + } + } catch (e: NativeMapsError) { + callback(Result.failure(e)) + } + } + + fun addPolygons(newPolygons: List, callback: (ids: Result>) -> Unit) { + try { + googleMap ?: throw NativeMapNotAvailable() + val shapeIds: MutableList = mutableListOf() + + CoroutineScope(Dispatchers.Main).launch { + newPolygons.forEach { + val polygonOptions: Deferred = CoroutineScope(Dispatchers.IO).async { + this@CapacitorNativeMapView.buildPolygon(it) + } + + val googleMapsPolygon = googleMap?.addPolygon(polygonOptions.await()) + googleMapsPolygon?.tag = it.tag + + it.googleMapsPolygon = googleMapsPolygon + + polygons[googleMapsPolygon!!.id] = it + shapeIds.add(googleMapsPolygon.id) + } + + callback(Result.success(shapeIds)) + } + } catch (e: NativeMapsError) { + callback(Result.failure(e)) + } + } + + fun addCircles(newCircles: List,callback: (ids: Result>) -> Unit) { + try { + googleMap ?: throw NativeMapNotAvailable() + val circleIds: MutableList = mutableListOf() + + CoroutineScope(Dispatchers.Main).launch { + newCircles.forEach { + var circleOptions: Deferred = CoroutineScope(Dispatchers.IO).async { + this@CapacitorNativeMapView.buildCircle(it) + } + + val googleMapsCircle = googleMap?.addCircle(circleOptions.await()) + googleMapsCircle?.tag = it.tag + + it.googleMapsCircle = googleMapsCircle + + circles[googleMapsCircle!!.id] = it + circleIds.add(googleMapsCircle.id) + } + + callback(Result.success(circleIds)) + } + } catch (e: NativeMapsError) { + callback(Result.failure(e)) + } + } + + fun addPolylines(newLines: List, callback: (ids: Result>) -> Unit) { + try { + googleMap ?: throw NativeMapNotAvailable() + val lineIds: MutableList = mutableListOf() + + CoroutineScope(Dispatchers.Main).launch { + newLines.forEach { + val polylineOptions: Deferred = CoroutineScope(Dispatchers.IO).async { + this@CapacitorNativeMapView.buildPolyline(it) + } + val googleMapPolyline = googleMap?.addPolyline(polylineOptions.await()) + googleMapPolyline?.tag = it.tag + + it.googleMapsPolyline = googleMapPolyline + + polylines[googleMapPolyline!!.id] = it + lineIds.add(googleMapPolyline.id) + } + + callback(Result.success(lineIds)) + } + } catch (e: NativeMapsError) { + callback(Result.failure(e)) + } + } + + private fun setClusterManagerRenderer(minClusterSize: Int?) { + clusterManager?.renderer = CapacitorClusterManagerRenderer( + delegate.bridge.context, + googleMap, + clusterManager, + minClusterSize + ) + } + + @SuppressLint("PotentialBehaviorOverride") + fun enableClustering(minClusterSize: Int?, callback: (error: NativeMapsError?) -> Unit) { + try { + googleMap ?: throw NativeMapNotAvailable() + + CoroutineScope(Dispatchers.Main).launch { + if (clusterManager != null) { + setClusterManagerRenderer(minClusterSize) + callback(null) + return@launch + } + + val bridge = delegate.bridge + clusterManager = ClusterManager(bridge.context, googleMap) + + setClusterManagerRenderer(minClusterSize) + setClusterListeners() + + // add existing markers to the cluster + if (markers.isNotEmpty()) { + for ((_, marker) in markers) { + marker.googleMapMarker?.remove() + // marker.googleMapMarker = null + } + clusterManager?.addItems(markers.values) + clusterManager?.cluster() + } + + callback(null) + } + } catch (e: NativeMapsError) { + callback(e) + } + } + + @SuppressLint("PotentialBehaviorOverride") + fun disableClustering(callback: (error: NativeMapsError?) -> Unit) { + try { + googleMap ?: throw NativeMapNotAvailable() + + CoroutineScope(Dispatchers.Main).launch { + clusterManager?.clearItems() + clusterManager?.cluster() + clusterManager = null + + googleMap?.setOnMarkerClickListener(this@CapacitorNativeMapView) + + // add existing markers back to the map + if (markers.isNotEmpty()) { + for ((_, marker) in markers) { + val markerOptions: Deferred = + CoroutineScope(Dispatchers.IO).async { + this@CapacitorNativeMapView.buildMarker(marker) + } + val googleMapMarker = googleMap?.addMarker(markerOptions.await()) + marker.googleMapMarker = googleMapMarker + } + } + + callback(null) + } + } catch (e: NativeMapsError) { + callback(e) + } + } + + fun removePolygons(ids: List, callback: (error: NativeMapsError?) -> Unit) { + try { + googleMap ?: throw NativeMapNotAvailable() + + CoroutineScope(Dispatchers.Main).launch { + ids.forEach { + val polygon = polygons[it] + if (polygon != null) { + polygon.googleMapsPolygon?.remove() + polygons.remove(it) + } + } + + callback(null) + } + } catch (e: NativeMapsError) { + callback(e) + } + } + + fun removeMarker(id: String, callback: (error: NativeMapsError?) -> Unit) { + try { + googleMap ?: throw NativeMapNotAvailable() + + val marker = markers[id] + marker ?: throw MarkerNotFoundError() + + CoroutineScope(Dispatchers.Main).launch { + if (clusterManager != null) { + clusterManager?.removeItem(marker) + clusterManager?.cluster() + } + + marker.googleMapMarker?.remove() + markers.remove(id) + + callback(null) + } + } catch (e: NativeMapsError) { + callback(e) + } + } + + fun removeMarkers(ids: List, callback: (error: NativeMapsError?) -> Unit) { + try { + googleMap ?: throw NativeMapNotAvailable() + + CoroutineScope(Dispatchers.Main).launch { + val deletedMarkers: MutableList = mutableListOf() + + ids.forEach { + val marker = markers[it] + if (marker != null) { + marker.googleMapMarker?.remove() + markers.remove(it) + + deletedMarkers.add(marker) + } + } + + if (clusterManager != null) { + clusterManager?.removeItems(deletedMarkers) + clusterManager?.cluster() + } + + callback(null) + } + } catch (e: NativeMapsError) { + callback(e) + } + } + + fun removeCircles(ids: List, callback: (error: NativeMapsError?) -> Unit) { + try { + googleMap ?: throw NativeMapNotAvailable() + + CoroutineScope(Dispatchers.Main).launch { + ids.forEach { + val circle = circles[it] + if (circle != null) { + circle.googleMapsCircle?.remove() + markers.remove(it) + } + } + + callback(null) + } + } catch (e: NativeMapsError) { + callback(e) + } + } + + fun removePolylines(ids: List, callback: (error: NativeMapsError?) -> Unit) { + try { + googleMap ?: throw NativeMapNotAvailable() + + CoroutineScope(Dispatchers.Main).launch { + ids.forEach { + val polyline = polylines[it] + if (polyline != null) { + polyline.googleMapsPolyline?.remove() + polylines.remove(it) + } + } + + callback(null) + } + } catch (e: NativeMapsError) { + callback(e) + } + } + + fun setCamera(config: NativeMapCameraConfig, callback: (error: NativeMapsError?) -> Unit) { + try { + googleMap ?: throw NativeMapNotAvailable() + CoroutineScope(Dispatchers.Main).launch { + val currentPosition = googleMap!!.cameraPosition + + var updatedTarget = config.coordinate + if (updatedTarget == null) { + updatedTarget = currentPosition.target + } + + var zoom = config.zoom + if (zoom == null) { + zoom = currentPosition.zoom.toDouble() + } + + var bearing = config.bearing + if (bearing == null) { + bearing = currentPosition.bearing.toDouble() + } + + var angle = config.angle + if (angle == null) { + angle = currentPosition.tilt.toDouble() + } + + var animate = config.animate + if (animate == null) { + animate = false + } + + val updatedPosition = + CameraPosition.Builder() + .target(updatedTarget) + .zoom(zoom.toFloat()) + .bearing(bearing.toFloat()) + .tilt(angle.toFloat()) + .build() + + if (animate) { + googleMap?.animateCamera(CameraUpdateFactory.newCameraPosition(updatedPosition)) + } else { + googleMap?.moveCamera(CameraUpdateFactory.newCameraPosition(updatedPosition)) + } + callback(null) + } + } catch (e: NativeMapsError) { + callback(e) + } + } + + fun getMapType(callback: (type: String, error: NativeMapsError?) -> Unit) { + try { + googleMap ?: throw NativeMapNotAvailable() + CoroutineScope(Dispatchers.Main).launch { + val mapType: String = when (googleMap?.mapType) { + MAP_TYPE_NORMAL -> "Normal" + MAP_TYPE_HYBRID -> "Hybrid" + MAP_TYPE_SATELLITE -> "Satellite" + MAP_TYPE_TERRAIN -> "Terrain" + MAP_TYPE_NONE -> "None" + else -> { + "Normal" + } + } + callback(mapType, null); + } + } catch (e: NativeMapsError) { + callback("", e) + } + } + + fun setMapType(mapType: String, callback: (error: NativeMapsError?) -> Unit) { + try { + googleMap ?: throw NativeMapNotAvailable() + CoroutineScope(Dispatchers.Main).launch { + val mapTypeInt: Int = + when (mapType) { + "Normal" -> MAP_TYPE_NORMAL + "Hybrid" -> MAP_TYPE_HYBRID + "Satellite" -> MAP_TYPE_SATELLITE + "Terrain" -> MAP_TYPE_TERRAIN + "None" -> MAP_TYPE_NONE + else -> { + Log.w( + "CapacitorNativeMap", + "unknown mapView type '$mapType' Defaulting to normal." + ) + MAP_TYPE_NORMAL + } + } + + googleMap?.mapType = mapTypeInt + callback(null) + } + } catch (e: NativeMapsError) { + callback(e) + } + } + + fun enableIndoorMaps(enabled: Boolean, callback: (error: NativeMapsError?) -> Unit) { + try { + googleMap ?: throw NativeMapNotAvailable() + CoroutineScope(Dispatchers.Main).launch { + googleMap?.isIndoorEnabled = enabled + callback(null) + } + } catch (e: NativeMapsError) { + callback(e) + } + } + + fun enableTrafficLayer(enabled: Boolean, callback: (error: NativeMapsError?) -> Unit) { + try { + googleMap ?: throw NativeMapNotAvailable() + CoroutineScope(Dispatchers.Main).launch { + googleMap?.isTrafficEnabled = enabled + callback(null) + } + } catch (e: NativeMapsError) { + callback(e) + } + } + + @SuppressLint("MissingPermission") + fun enableCurrentLocation(enabled: Boolean, callback: (error: NativeMapsError?) -> Unit) { + try { + googleMap ?: throw NativeMapNotAvailable() + CoroutineScope(Dispatchers.Main).launch { + googleMap?.isMyLocationEnabled = enabled + callback(null) + } + } catch (e: NativeMapsError) { + callback(e) + } + } + + fun setPadding(padding: NativeMapPadding, callback: (error: NativeMapsError?) -> Unit) { + try { + googleMap ?: throw NativeMapNotAvailable() + CoroutineScope(Dispatchers.Main).launch { + googleMap?.setPadding(padding.left, padding.top, padding.right, padding.bottom) + callback(null) + } + } catch (e: NativeMapsError) { + callback(e) + } + } + + fun getMapBounds(): Rect { + return Rect( + getScaledPixels(delegate.bridge, config.x), + getScaledPixels(delegate.bridge, config.y), + getScaledPixels(delegate.bridge, config.x + config.width), + getScaledPixels(delegate.bridge, config.y + config.height) + ) + } + + fun getLatLngBounds(): LatLngBounds { + return googleMap?.projection?.visibleRegion?.latLngBounds ?: throw BoundsNotFoundError() + } + + fun fitBounds(bounds: LatLngBounds, padding: Int) { + val cameraUpdate = CameraUpdateFactory.newLatLngBounds(bounds, padding) + googleMap?.animateCamera(cameraUpdate) + } + + private fun getScaledPixels(bridge: Bridge, pixels: Int): Int { + // Get the screen's density scale + val scale = bridge.activity.resources.displayMetrics.density + // Convert the dps to pixels, based on density scale + return (pixels * scale + 0.5f).toInt() + } + + private fun getScaledPixelsF(bridge: Bridge, pixels: Float): Float { + // Get the screen's density scale + val scale = bridge.activity.resources.displayMetrics.density + // Convert the dps to pixels, based on density scale + return (pixels * scale + 0.5f) + } + + private fun getScaledRect(bridge: Bridge, rectF: RectF): RectF { + return RectF( + getScaledPixelsF(bridge, rectF.left), + getScaledPixelsF(bridge, rectF.top), + getScaledPixelsF(bridge, rectF.right), + getScaledPixelsF(bridge, rectF.bottom) + ) + } + + private fun buildCircle(circle: CapacitorNativeMapCircle): CircleOptions { + val circleOptions = CircleOptions() + circleOptions.fillColor(circle.fillColor) + circleOptions.strokeColor(circle.strokeColor) + circleOptions.strokeWidth(circle.strokeWidth) + circleOptions.zIndex(circle.zIndex) + circleOptions.clickable(circle.clickable) + circleOptions.radius(circle.radius.toDouble()) + circleOptions.center(circle.center) + + return circleOptions + } + + private fun buildPolygon(polygon: CapacitorNativeMapPolygon): PolygonOptions { + val polygonOptions = PolygonOptions() + polygonOptions.fillColor(polygon.fillColor) + polygonOptions.strokeColor(polygon.strokeColor) + polygonOptions.strokeWidth(polygon.strokeWidth) + polygonOptions.zIndex(polygon.zIndex) + polygonOptions.geodesic(polygon.geodesic) + polygonOptions.clickable(polygon.clickable) + + var shapeCounter = 0 + polygon.shapes.forEach { + if (shapeCounter == 0) { + // outer shape + it.forEach { + polygonOptions.add(it) + } + } else { + polygonOptions.addHole(it) + } + + shapeCounter += 1 + } + + return polygonOptions + } + + private fun buildPolyline(line: CapacitorNativeMapViewPolyline): PolylineOptions { + val polylineOptions = PolylineOptions() + polylineOptions.width(line.strokeWidth * this.config.devicePixelRatio) + polylineOptions.color(line.strokeColor) + polylineOptions.clickable(line.clickable) + polylineOptions.zIndex(line.zIndex) + polylineOptions.geodesic(line.geodesic) + + line.path.forEach { + polylineOptions.add(it) + } + + line.styleSpans.forEach { + if (it.segments != null) { + polylineOptions.addSpan(StyleSpan(it.color, it.segments)) + } else { + polylineOptions.addSpan(StyleSpan(it.color)) + } + } + + return polylineOptions + } + + private fun buildMarker(marker: CapacitorNativeMapViewMarker): MarkerOptions { + val markerOptions = MarkerOptions() + markerOptions.position(marker.coordinate) + markerOptions.title(marker.title) + markerOptions.snippet(marker.snippet) + markerOptions.alpha(marker.opacity) + markerOptions.flat(marker.isFlat) + markerOptions.draggable(marker.draggable) + markerOptions.zIndex(marker.zIndex) + if (marker.iconAnchor != null) { + markerOptions.anchor(marker.iconAnchor!!.x, marker.iconAnchor!!.y) + } + + + if (!marker.iconUrl.isNullOrEmpty()) { + if (this.markerIcons.contains(marker.iconUrl)) { + val cachedBitmap = this.markerIcons[marker.iconUrl] + markerOptions.icon(getResizedIcon(cachedBitmap!!, marker)) + } else { + try { + var stream: InputStream? = null + if (marker.iconUrl!!.startsWith("https:")) { + stream = URL(marker.iconUrl).openConnection().getInputStream() + } else { + stream = this.delegate.context.assets.open("public/${marker.iconUrl}") + } + var bitmap = BitmapFactory.decodeStream(stream) + this.markerIcons[marker.iconUrl!!] = bitmap + markerOptions.icon(getResizedIcon(bitmap, marker)) + } catch (e: Exception) { + var detailedMessage = "${e.javaClass} - ${e.localizedMessage}" + if (marker.iconUrl!!.endsWith(".svg")) { + detailedMessage = "SVG not supported" + } + + Log.w( + "CapacitorNativeMap", + "Could not load image '${marker.iconUrl}': ${detailedMessage}. Using default marker icon." + ) + } + } + } else { + if (marker.colorHue != null) { + markerOptions.icon(BitmapDescriptorFactory.defaultMarker(marker.colorHue!!)) + } + } + + marker.markerOptions = markerOptions + + return markerOptions + } + + private fun getResizedIcon( + _bitmap: Bitmap, + marker: CapacitorNativeMapViewMarker + ): BitmapDescriptor { + var bitmap = _bitmap + if (marker.iconSize != null) { + bitmap = + Bitmap.createScaledBitmap( + bitmap, + (marker.iconSize!!.width * this.config.devicePixelRatio).toInt(), + (marker.iconSize!!.height * this.config.devicePixelRatio).toInt(), + false + ) + } + return BitmapDescriptorFactory.fromBitmap(bitmap) + } + + fun onStart() { + mapView.onStart() + } + + fun onResume() { + mapView.onResume() + } + + fun onStop() { + mapView.onStop() + } + + fun onPause() { + mapView.onPause() + } + + fun onDestroy() { + mapView.onDestroy() + } + + override fun onMapReady(map: NativeMap) { + runBlocking { + googleMap = map + + val data = JSObject() + data.put("mapId", this@CapacitorNativeMapView.id) + delegate.notify("onMapReady", data) + + isReadyChannel.send(true) + isReadyChannel.close() + } + } + + @SuppressLint("PotentialBehaviorOverride") + fun setListeners() { + CoroutineScope(Dispatchers.Main).launch { + this@CapacitorNativeMapView.googleMap?.setOnCameraIdleListener(this@CapacitorNativeMapView) + this@CapacitorNativeMapView.googleMap?.setOnCameraMoveStartedListener( + this@CapacitorNativeMapView + ) + this@CapacitorNativeMapView.googleMap?.setOnCameraMoveListener(this@CapacitorNativeMapView) + this@CapacitorNativeMapView.googleMap?.setOnMarkerClickListener(this@CapacitorNativeMapView) + this@CapacitorNativeMapView.googleMap?.setOnPolygonClickListener(this@CapacitorNativeMapView) + this@CapacitorNativeMapView.googleMap?.setOnCircleClickListener(this@CapacitorNativeMapView) + this@CapacitorNativeMapView.googleMap?.setOnMarkerDragListener(this@CapacitorNativeMapView) + this@CapacitorNativeMapView.googleMap?.setOnMapClickListener(this@CapacitorNativeMapView) + this@CapacitorNativeMapView.googleMap?.setOnMyLocationButtonClickListener( + this@CapacitorNativeMapView + ) + this@CapacitorNativeMapView.googleMap?.setOnMyLocationClickListener(this@CapacitorNativeMapView) + this@CapacitorNativeMapView.googleMap?.setOnInfoWindowClickListener(this@CapacitorNativeMapView) + this@CapacitorNativeMapView.googleMap?.setOnPolylineClickListener(this@CapacitorNativeMapView) + } + } + + fun setClusterListeners() { + CoroutineScope(Dispatchers.Main).launch { + clusterManager?.setOnClusterItemClickListener { + if (null == it.googleMapMarker) false + else this@CapacitorNativeMapView.onMarkerClick(it.googleMapMarker!!) + } + + clusterManager?.setOnClusterItemInfoWindowClickListener { + if (null != it.googleMapMarker) { + this@CapacitorNativeMapView.onInfoWindowClick(it.googleMapMarker!!) + } + } + + clusterManager?.setOnClusterInfoWindowClickListener { + val data = this@CapacitorNativeMapView.getClusterData(it) + delegate.notify("onClusterInfoWindowClick", data) + } + + clusterManager?.setOnClusterClickListener { + val data = this@CapacitorNativeMapView.getClusterData(it) + delegate.notify("onClusterClick", data) + false + } + } + } + + private fun getClusterData(it: Cluster): JSObject { + val data = JSObject() + data.put("mapId", this.id) + data.put("latitude", it.position.latitude) + data.put("longitude", it.position.longitude) + data.put("size", it.size) + + val items = JSArray() + for (item in it.items) { + val marker = item.googleMapMarker + + if (marker != null) { + val jsItem = JSObject() + jsItem.put("markerId", marker.id) + jsItem.put("latitude", marker.position.latitude) + jsItem.put("longitude", marker.position.longitude) + jsItem.put("title", marker.title) + jsItem.put("snippet", marker.snippet) + + items.put(jsItem) + } + } + + data.put("items", items) + + return data + } + + override fun onMapClick(point: LatLng) { + val data = JSObject() + data.put("mapId", this@CapacitorNativeMapView.id) + data.put("latitude", point.latitude) + data.put("longitude", point.longitude) + delegate.notify("onMapClick", data) + } + + override fun onMarkerClick(marker: Marker): Boolean { + val data = JSObject() + data.put("mapId", this@CapacitorNativeMapView.id) + data.put("markerId", marker.id) + data.put("latitude", marker.position.latitude) + data.put("longitude", marker.position.longitude) + data.put("title", marker.title) + data.put("snippet", marker.snippet) + delegate.notify("onMarkerClick", data) + return false + } + + override fun onPolylineClick(polyline: Polyline) { + val data = JSObject() + data.put("mapId", this@CapacitorNativeMapView.id) + data.put("polylineId", polyline.id) + data.put("tag", polyline.tag) + delegate.notify("onPolylineClick", data) + } + + override fun onMarkerDrag(marker: Marker) { + val data = JSObject() + data.put("mapId", this@CapacitorNativeMapView.id) + data.put("markerId", marker.id) + data.put("latitude", marker.position.latitude) + data.put("longitude", marker.position.longitude) + data.put("title", marker.title) + data.put("snippet", marker.snippet) + delegate.notify("onMarkerDrag", data) + } + + override fun onMarkerDragStart(marker: Marker) { + val data = JSObject() + data.put("mapId", this@CapacitorNativeMapView.id) + data.put("markerId", marker.id) + data.put("latitude", marker.position.latitude) + data.put("longitude", marker.position.longitude) + data.put("title", marker.title) + data.put("snippet", marker.snippet) + delegate.notify("onMarkerDragStart", data) + } + + override fun onMarkerDragEnd(marker: Marker) { + val data = JSObject() + data.put("mapId", this@CapacitorNativeMapView.id) + data.put("markerId", marker.id) + data.put("latitude", marker.position.latitude) + data.put("longitude", marker.position.longitude) + data.put("title", marker.title) + data.put("snippet", marker.snippet) + delegate.notify("onMarkerDragEnd", data) + } + + override fun onMyLocationButtonClick(): Boolean { + val data = JSObject() + data.put("mapId", this@CapacitorNativeMapView.id) + delegate.notify("onMyLocationButtonClick", data) + return false + } + + override fun onMyLocationClick(location: Location) { + val data = JSObject() + data.put("mapId", this@CapacitorNativeMapView.id) + data.put("latitude", location.latitude) + data.put("longitude", location.longitude) + delegate.notify("onMyLocationClick", data) + } + + override fun onCameraIdle() { + val data = JSObject() + data.put("mapId", this@CapacitorNativeMapView.id) + data.put("bounds", getLatLngBoundsJSObject(getLatLngBounds())) + data.put("bearing", this@CapacitorNativeMapView.googleMap?.cameraPosition?.bearing) + data.put("latitude", this@CapacitorNativeMapView.googleMap?.cameraPosition?.target?.latitude) + data.put("longitude", this@CapacitorNativeMapView.googleMap?.cameraPosition?.target?.longitude) + data.put("tilt", this@CapacitorNativeMapView.googleMap?.cameraPosition?.tilt) + data.put("zoom", this@CapacitorNativeMapView.googleMap?.cameraPosition?.zoom) + delegate.notify("onCameraIdle", data) + delegate.notify("onBoundsChanged", data) + } + + override fun onCameraMoveStarted(reason: Int) { + val data = JSObject() + data.put("mapId", this@CapacitorNativeMapView.id) + data.put("isGesture", reason == 1) + delegate.notify("onCameraMoveStarted", data) + } + + override fun onInfoWindowClick(marker: Marker) { + val data = JSObject() + data.put("mapId", this@CapacitorNativeMapView.id) + data.put("markerId", marker.id) + data.put("latitude", marker.position.latitude) + data.put("longitude", marker.position.longitude) + data.put("title", marker.title) + data.put("snippet", marker.snippet) + delegate.notify("onInfoWindowClick", data) + } + + override fun onCameraMove() { + debounceJob?.cancel() + debounceJob = CoroutineScope(Dispatchers.Main).launch { + delay(100) + clusterManager?.cluster() + } + } + + override fun onPolygonClick(polygon: Polygon) { + val data = JSObject() + data.put("mapId", this@CapacitorNativeMapView.id) + data.put("polygonId", polygon.id) + data.put("tag", polygon.tag) + delegate.notify("onPolygonClick", data) + } + + override fun onCircleClick(circle: Circle) { + val data = JSObject() + data.put("mapId", this@CapacitorNativeMapView.id) + data.put("circleId", circle.id) + data.put("tag", circle.tag) + data.put("latitude", circle.center.latitude) + data.put("longitude", circle.center.longitude) + data.put("radius", circle.radius) + + delegate.notify("onCircleClick", data) + } +} + +fun getLatLngBoundsJSObject(bounds: LatLngBounds): JSObject { + val data = JSObject() + + val southwestJS = JSObject() + val centerJS = JSObject() + val northeastJS = JSObject() + + southwestJS.put("lat", bounds.southwest.latitude) + southwestJS.put("lng", bounds.southwest.longitude) + centerJS.put("lat", bounds.center.latitude) + centerJS.put("lng", bounds.center.longitude) + northeastJS.put("lat", bounds.northeast.latitude) + northeastJS.put("lng", bounds.northeast.longitude) + + data.put("southwest", southwestJS) + data.put("center", centerJS) + data.put("northeast", northeastJS) + + return data +} diff --git a/android/src/main/java/com/capgo/plugins/nativemap/CapacitorGoogleMapMarker.kt b/android/src/main/java/com/capgo/plugins/nativemap/CapacitorGoogleMapMarker.kt new file mode 100644 index 0000000..e5eb016 --- /dev/null +++ b/android/src/main/java/com/capgo/plugins/nativemap/CapacitorGoogleMapMarker.kt @@ -0,0 +1,93 @@ +package com.capgo.plugins.nativemap + +import android.graphics.Color +import android.util.Size +import androidx.core.math.MathUtils +import com.google.android.gms.maps.model.* +import com.google.maps.android.clustering.ClusterItem +import org.json.JSONObject + + +class CapacitorNativeMapViewMarker(fromJSONObject: JSONObject): ClusterItem { + var coordinate: LatLng = LatLng(0.0, 0.0) + var opacity: Float = 1.0f + private var title: String + private var snippet: String + private var zIndex: Float = 0.0f + var isFlat: Boolean = false + var iconUrl: String? = null + var iconSize: Size? = null + var iconAnchor: CapacitorNativeMapPoint? = null + var draggable: Boolean = false + var googleMapMarker: Marker? = null + var colorHue: Float? = null + var markerOptions: MarkerOptions? = null + + init { + if (!fromJSONObject.has("coordinate")) { + throw InvalidArgumentsError("Marker object is missing the required 'coordinate' property") + } + + val latLngObj = fromJSONObject.getJSONObject("coordinate") + if (!latLngObj.has("lat") || !latLngObj.has("lng")) { + throw InvalidArgumentsError("LatLng object is missing the required 'lat' and/or 'lng' property") + } + + coordinate = LatLng(latLngObj.getDouble("lat"), latLngObj.getDouble("lng")) + title = fromJSONObject.optString("title") + opacity = fromJSONObject.optDouble("opacity", 1.0).toFloat() + snippet = fromJSONObject.optString("snippet") + isFlat = fromJSONObject.optBoolean("isFlat", false) + iconUrl = fromJSONObject.optString("iconUrl") + if (fromJSONObject.has("iconSize")) { + val iconSizeObject = fromJSONObject.getJSONObject("iconSize") + iconSize = Size(iconSizeObject.optInt("width", 0), iconSizeObject.optInt("height", 0)) + } + + if (fromJSONObject.has("iconAnchor")) { + val inputAnchorPoint = CapacitorNativeMapPoint(fromJSONObject.getJSONObject("iconAnchor")) + iconAnchor = this.buildIconAnchorPoint(inputAnchorPoint) + } + + if (fromJSONObject.has("tintColor")) { + val tintColorObject = fromJSONObject.getJSONObject("tintColor") + + val r = MathUtils.clamp(tintColorObject.optDouble("r", 0.00), 0.00, 255.0) + val g = MathUtils.clamp(tintColorObject.optDouble("g", 0.00), 0.00, 255.0) + val b = MathUtils.clamp(tintColorObject.optDouble("b", 0.00), 0.00, 255.0) + + val hsl = FloatArray(3) + Color.RGBToHSV(r.toInt(), g.toInt(), b.toInt(), hsl) + + colorHue = hsl[0] + } + + draggable = fromJSONObject.optBoolean("draggable", false) + zIndex = fromJSONObject.optLong("zIndex").toFloat() + } + + override fun getPosition(): LatLng { + return LatLng(coordinate.latitude, coordinate.longitude) + } + + override fun getTitle(): String { + return title + } + + override fun getSnippet(): String { + return snippet + } + + override fun getZIndex(): Float { + return zIndex + } + + private fun buildIconAnchorPoint(iconAnchor: CapacitorNativeMapPoint): CapacitorNativeMapPoint? { + iconSize ?: return null + + val u: Float = iconAnchor.x / iconSize!!.width + val v: Float = iconAnchor.y / iconSize!!.height + + return CapacitorNativeMapPoint(u, v) + } +} \ No newline at end of file diff --git a/android/src/main/java/com/capgo/plugins/nativemap/CapacitorGoogleMapPolyline.kt b/android/src/main/java/com/capgo/plugins/nativemap/CapacitorGoogleMapPolyline.kt new file mode 100644 index 0000000..ad3cfdc --- /dev/null +++ b/android/src/main/java/com/capgo/plugins/nativemap/CapacitorGoogleMapPolyline.kt @@ -0,0 +1,78 @@ +package com.capgo.plugins.nativemap + +import android.graphics.Color +import androidx.core.graphics.toColor +import com.google.android.gms.maps.model.LatLng +import com.google.android.gms.maps.model.Polyline +import org.json.JSONObject + +class CapacitorNativeMapViewPolyline(fromJSONObject: JSONObject) { + var path: MutableList = mutableListOf() + var styleSpans: MutableList = mutableListOf() + var strokeWidth: Float = 1.0f + var strokeColor: Int = Color.BLUE + var clickable: Boolean + var geodesic: Boolean + var zIndex: Float = 0.00f + var tag: String = "" + var googleMapsPolyline: Polyline? = null + + init { + if (!fromJSONObject.has("path")) { + throw InvalidArgumentsError("Polyline object is missing the required 'path' property") + } + + val pathArray = fromJSONObject.getJSONArray("path") + + for (i in 0 until pathArray.length()) { + val obj = pathArray.getJSONObject(i) + if (!obj.has("lat") || !obj.has("lng")) { + throw InvalidArgumentsError("LatLng object is missing the required 'lat' and/or 'lng' property") + } + + val lat = obj.getDouble("lat") + val lng = obj.getDouble("lng") + + path.add(LatLng(lat, lng)) + } + + if (fromJSONObject.has("styleSpans")) { + val styleSpanArray = fromJSONObject.getJSONArray("styleSpans") + for (i in 0 until styleSpanArray.length()) { + val obj = styleSpanArray.getJSONObject(i) + + if (obj.has("color")) { + val color = obj.getString("color") + + if (obj.has("segments")) { + val segments = obj.getDouble("segments") + styleSpans.add(CapacitorNativeMapStyleSpan(Color.parseColor(color), segments)) + } else { + styleSpans.add(CapacitorNativeMapStyleSpan(Color.parseColor(color), null)) + } + } + } + } + + val strokeOpacity = fromJSONObject.optDouble("strokeOpacity", 1.0) + + strokeColor = this.processColor(fromJSONObject.getString("strokeColor"), strokeOpacity) + strokeWidth = fromJSONObject.optDouble("strokeWeight", 1.0).toFloat() + clickable = fromJSONObject.optBoolean("clickable", false) + geodesic = fromJSONObject.optBoolean("geodesic", false) + zIndex = fromJSONObject.optDouble("zIndex", 1.0).toFloat() + tag = fromJSONObject.optString("tag", "") + } + + private fun processColor(hex: String, opacity: Double): Int { + val colorInt = Color.parseColor(hex) + + val alpha = (opacity * 255.0).toInt() + val red = android.graphics.Color.red(colorInt) + val green = android.graphics.Color.green(colorInt) + val blue = android.graphics.Color.blue(colorInt) + + return Color.argb(alpha, red, green, blue) + } + +} \ No newline at end of file diff --git a/android/src/main/java/com/capgo/plugins/nativemap/CapacitorGoogleMapTileOverlay.kt b/android/src/main/java/com/capgo/plugins/nativemap/CapacitorGoogleMapTileOverlay.kt new file mode 100644 index 0000000..0f39405 --- /dev/null +++ b/android/src/main/java/com/capgo/plugins/nativemap/CapacitorGoogleMapTileOverlay.kt @@ -0,0 +1,28 @@ +package com.capgo.plugins.nativemap + +import com.google.android.gms.maps.model.TileOverlay +import org.json.JSONObject + +class CapacitorNativeMapViewTileOverlay(fromJSONObject: JSONObject) { + var url: String + var opacity: Float? = null + var zIndex: Float? = null + var visible: Boolean? = null + var googleMapTileOverlay: TileOverlay? = null + + init { + if (!fromJSONObject.has("url")) { + throw InvalidArgumentsError("TileOverlay object is missing the required 'url' property") + } + url = fromJSONObject.getString("url") + if (fromJSONObject.has("opacity")) { + opacity = fromJSONObject.optDouble("opacity").toFloat() + } + if (fromJSONObject.has("visible")) { + visible = fromJSONObject.optBoolean("visible") + } + if (fromJSONObject.has("zIndex")) { + zIndex = fromJSONObject.optLong("zIndex").toFloat() + } + } +} \ No newline at end of file diff --git a/android/src/main/java/com/capgo/plugins/nativemap/CapacitorGoogleMapsBounds.kt b/android/src/main/java/com/capgo/plugins/nativemap/CapacitorGoogleMapsBounds.kt new file mode 100644 index 0000000..2e4e002 --- /dev/null +++ b/android/src/main/java/com/capgo/plugins/nativemap/CapacitorGoogleMapsBounds.kt @@ -0,0 +1,33 @@ +package com.capgo.plugins.nativemap + +import org.json.JSONObject + +class CapacitorNativeMapBounds(fromJSONObject: JSONObject) { + var width: Int = 0 + var height: Int = 0 + var x: Int = 0 + var y: Int = 0 + + init { + if(!fromJSONObject.has("width")) { + throw InvalidArgumentsError("NativeMapConfig object is missing the required 'width' property") + } + + if(!fromJSONObject.has("height")) { + throw InvalidArgumentsError("NativeMapConfig object is missing the required 'height' property") + } + + if(!fromJSONObject.has("x")) { + throw InvalidArgumentsError("NativeMapConfig object is missing the required 'x' property") + } + + if(!fromJSONObject.has("y")) { + throw InvalidArgumentsError("NativeMapConfig object is missing the required 'y' property") + } + + width = fromJSONObject.getInt("width") + height = fromJSONObject.getInt("height") + x = fromJSONObject.getInt("x") + y = fromJSONObject.getInt("y") + } +} \ No newline at end of file diff --git a/android/src/main/java/com/capgo/plugins/nativemap/CapacitorGoogleMapsCircle.kt b/android/src/main/java/com/capgo/plugins/nativemap/CapacitorGoogleMapsCircle.kt new file mode 100644 index 0000000..6a5344a --- /dev/null +++ b/android/src/main/java/com/capgo/plugins/nativemap/CapacitorGoogleMapsCircle.kt @@ -0,0 +1,63 @@ +package com.capgo.plugins.nativemap + +import android.graphics.Color +import com.google.android.gms.maps.model.Circle +import com.google.android.gms.maps.model.LatLng +import org.json.JSONObject + +class CapacitorNativeMapCircle(fromJSONObject: JSONObject) { + var center: LatLng + var radius: Float + var strokeWidth: Float = 1.0f + var strokeColor: Int = Color.BLUE + var fillColor: Int = Color.BLUE + var clickable: Boolean + var zIndex: Float = 0.00f + var tag: String = "" + var googleMapsCircle: Circle? = null + + init { + if (!fromJSONObject.has("center")) { + throw InvalidArgumentsError("Circle object is missing the required 'center' property") + } + + if (!fromJSONObject.has("radius")) { + throw InvalidArgumentsError("Circle object is missing the required 'radius' property") + } + + val latLng = fromJSONObject.getJSONObject("center") + if (!latLng.has("lat") || !latLng.has("lng")) { + throw InvalidArgumentsError("LatLng object is missing the required 'lat' and/or 'lng' property") + } + + val lat = latLng.getDouble("lat") + val lng = latLng.getDouble("lng") + + center = LatLng(lat, lng) + + radius = fromJSONObject.getDouble("radius").toFloat() + + val strokeOpacity = fromJSONObject.optDouble("strokeOpacity", 1.0) + strokeColor = this.processColor(fromJSONObject.getString("strokeColor"), strokeOpacity) + + val fillOpacity = fromJSONObject.optDouble("fillOpacity", 1.0) + fillColor = this.processColor(fromJSONObject.getString("fillColor"), fillOpacity) + + strokeWidth = fromJSONObject.optDouble("strokeWeight", 1.0).toFloat() + clickable = fromJSONObject.optBoolean("clickable", false) + zIndex = fromJSONObject.optDouble("zIndex", 1.0).toFloat() + tag = fromJSONObject.optString("tag", "") + } + + + private fun processColor(hex: String, opacity: Double): Int { + val colorInt = Color.parseColor(hex) + + val alpha = (opacity * 255.0).toInt() + val red = android.graphics.Color.red(colorInt) + val green = android.graphics.Color.green(colorInt) + val blue = android.graphics.Color.blue(colorInt) + + return Color.argb(alpha, red, green, blue) + } +} \ No newline at end of file diff --git a/android/src/main/java/com/capgo/plugins/nativemap/CapacitorGoogleMapsPlugin.kt b/android/src/main/java/com/capgo/plugins/nativemap/CapacitorGoogleMapsPlugin.kt new file mode 100644 index 0000000..a8d91ac --- /dev/null +++ b/android/src/main/java/com/capgo/plugins/nativemap/CapacitorGoogleMapsPlugin.kt @@ -0,0 +1,1139 @@ +/* + * Portions Copyright (c) 2020-present Ionic, licensed under the MIT License. + * Adapted for @capgo/capacitor-native-map (MPL-2.0). + */ +package com.capgo.plugins.nativemap + +import android.Manifest +import android.annotation.SuppressLint +import android.graphics.RectF +import android.util.Log +import android.view.MotionEvent +import android.view.View +import com.getcapacitor.* +import com.getcapacitor.annotation.CapacitorPlugin +import com.getcapacitor.annotation.Permission +import com.getcapacitor.annotation.PermissionCallback +import com.google.android.gms.maps.MapsInitializer +import com.google.android.gms.maps.OnMapsSdkInitializedCallback +import com.google.android.gms.maps.model.LatLng +import com.google.android.gms.maps.model.LatLngBounds +import kotlinx.coroutines.CoroutineScope +import kotlinx.coroutines.Dispatchers +import kotlinx.coroutines.launch +import org.json.JSONArray +import org.json.JSONObject + +@CapacitorPlugin( + name = "NativeMap", + permissions = + [ + Permission( + strings = [Manifest.permission.ACCESS_FINE_LOCATION], + alias = CapacitorNativeMapPlugin.LOCATION + ), + ], +) +class CapacitorNativeMapPlugin : Plugin(), OnMapsSdkInitializedCallback { + private var maps: HashMap = HashMap() + private var cachedTouchEvents: HashMap> = HashMap() + private val tag: String = "CAP-NATIVE-MAP" + private var touchEnabled: HashMap = HashMap() + + companion object { + const val LOCATION = "location" + } + + @SuppressLint("ClickableViewAccessibility") + override fun load() { + super.load() + + MapsInitializer.initialize(this.context, MapsInitializer.Renderer.LATEST, this) + + + this.bridge.webView.setOnTouchListener( + object : View.OnTouchListener { + override fun onTouch(v: View?, event: MotionEvent?): Boolean { + if (event != null) { + if (event.source == -1) { + return v?.onTouchEvent(event) ?: true + } + + val touchX = event.x + val touchY = event.y + + for ((id, map) in maps) { + if (touchEnabled[id] == false) { + continue + } + val mapRect = map.getMapBounds() + if (mapRect.contains(touchX.toInt(), touchY.toInt())) { + if (event.action == MotionEvent.ACTION_DOWN) { + if (cachedTouchEvents[id] == null) { + cachedTouchEvents[id] = mutableListOf() + } + + cachedTouchEvents[id]?.clear() + } + + val motionEvent = MotionEvent.obtain(event) + cachedTouchEvents[id]?.add(motionEvent) + + val payload = JSObject() + payload.put("x", touchX / map.config.devicePixelRatio) + payload.put("y", touchY / map.config.devicePixelRatio) + payload.put("mapId", map.id) + + notifyListeners("isMapInFocus", payload) + return true + } + } + } + + return v?.onTouchEvent(event) ?: true + } + } + ) + } + + override fun onMapsSdkInitialized(renderer: MapsInitializer.Renderer) { + when (renderer) { + MapsInitializer.Renderer.LATEST -> Logger.debug("Capacitor Google Maps", "Latest Google Maps renderer enabled") + MapsInitializer.Renderer.LEGACY -> Logger.debug("Capacitor Google Maps", "Legacy Google Maps renderer enabled - Cloud based map styling and advanced drawing not available") + } + } + + override fun handleOnStart() { + super.handleOnStart() + maps.forEach { it.value.onStart() } + } + + override fun handleOnResume() { + super.handleOnResume() + maps.forEach { it.value.onResume() } + } + + override fun handleOnPause() { + super.handleOnPause() + maps.forEach { it.value.onPause() } + } + + override fun handleOnStop() { + super.handleOnStop() + maps.forEach { it.value.onStop() } + } + + override fun handleOnDestroy() { + super.handleOnDestroy() + maps.forEach { it.value.onDestroy() } + } + + @PluginMethod + fun create(call: PluginCall) { + try { + val id = call.getString("id") + + if (null == id || id.isEmpty()) { + throw InvalidMapIdError() + } + + val configObject = + call.getObject("config") + ?: throw InvalidArgumentsError("config object is missing") + + val forceCreate = call.getBoolean("forceCreate", false)!! + + val config = NativeMapConfig(configObject) + + if (maps.contains(id)) { + if (!forceCreate) { + call.resolve() + return + } + + val oldMap = maps.remove(id) + oldMap?.destroy() + } + + val newMap = CapacitorNativeMapView(id, config, this) + maps[id] = newMap + + call.resolve() + } catch (e: NativeMapsError) { + handleError(call, e) + } catch (e: Exception) { + handleError(call, e) + } + } + + @PluginMethod + fun destroy(call: PluginCall) { + try { + val id = call.getString("id") + + if (null == id || id.isEmpty()) { + throw InvalidMapIdError() + } + + val removedMap = maps.remove(id) ?: throw MapNotFoundError() + removedMap.destroy() + + call.resolve() + } catch (e: NativeMapsError) { + handleError(call, e) + } catch (e: Exception) { + handleError(call, e) + } + } + + @PluginMethod + fun enableTouch(call: PluginCall) { + try { + val id = call.getString("id") + id ?: throw InvalidMapIdError() + touchEnabled[id] = true + call.resolve() + } catch (e: NativeMapsError) { + handleError(call, e) + } catch (e: Exception) { + handleError(call, e) + } + } + + @PluginMethod + fun disableTouch(call: PluginCall) { + try { + val id = call.getString("id") + id ?: throw InvalidMapIdError() + touchEnabled[id] = false + call.resolve() + } catch (e: NativeMapsError) { + handleError(call, e) + } catch (e: Exception) { + handleError(call, e) + } + } + + @PluginMethod + fun addTileOverlay(call: PluginCall) { + try { + val id = call.getString("id") + id ?: throw InvalidMapIdError() + + val tileOverlayObj = call.getObject("tileOverlay", null) + tileOverlayObj ?: throw InvalidArgumentsError("tileOverlay object is missing") + + val map = maps[id] + map ?: throw MapNotFoundError() + + val tileOverlay = CapacitorNativeMapViewTileOverlay(tileOverlayObj) + map.addTileOverlay(tileOverlay) { result -> + val tileOverlayId = result.getOrThrow() + + val res = JSObject() + res.put("id", tileOverlayId) + call.resolve(res) + } + } catch (e: NativeMapsError) { + handleError(call, e) + } catch (e: Exception) { + handleError(call, e) + } + } + + @PluginMethod + fun removeTileOverlay(call: PluginCall) { + try { + val id = call.getString("id") + id ?: throw InvalidMapIdError() + + val tileOverlayId = call.getString("tileOverlayId") + tileOverlayId ?: throw InvalidArgumentsError("tileOverlayId is invalid or missing") + + val map = maps[id] + map ?: throw MapNotFoundError() + + map.removeTileOverlay(tileOverlayId) { err -> + if (err != null) { + throw err + } + + call.resolve() + } + } catch (e: NativeMapsError) { + handleError(call, e) + } catch (e: Exception) { + handleError(call, e) + } + } + + @PluginMethod + fun addMarker(call: PluginCall) { + try { + val id = call.getString("id") + id ?: throw InvalidMapIdError() + + val markerObj = call.getObject("marker", null) + markerObj ?: throw InvalidArgumentsError("marker object is missing") + + val map = maps[id] + map ?: throw MapNotFoundError() + + val marker = CapacitorNativeMapViewMarker(markerObj) + map.addMarker(marker) { result -> + val markerId = result.getOrThrow() + + val res = JSObject() + res.put("id", markerId) + call.resolve(res) + } + } catch (e: NativeMapsError) { + handleError(call, e) + } catch (e: Exception) { + handleError(call, e) + } + } + + @PluginMethod + fun addMarkers(call: PluginCall) { + try { + val id = call.getString("id") + id ?: throw InvalidMapIdError() + + val markerObjectArray = call.getArray("markers", null) + markerObjectArray ?: throw InvalidArgumentsError("markers array is missing") + + if (markerObjectArray.length() == 0) { + throw InvalidArgumentsError("markers array requires at least one marker") + } + + val map = maps[id] + map ?: throw MapNotFoundError() + + val markers: MutableList = mutableListOf() + + for (i in 0 until markerObjectArray.length()) { + val markerObj = markerObjectArray.getJSONObject(i) + val marker = CapacitorNativeMapViewMarker(markerObj) + + markers.add(marker) + } + + map.addMarkers(markers) { result -> + val ids = result.getOrThrow() + + val jsonIDs = JSONArray() + ids.forEach { jsonIDs.put(it) } + + val res = JSObject() + res.put("ids", jsonIDs) + call.resolve(res) + } + } catch (e: NativeMapsError) { + handleError(call, e) + } catch (e: Exception) { + handleError(call, e) + } + } + + @PluginMethod + fun addPolygons(call: PluginCall) { + try { + val id = call.getString("id") + id ?: throw InvalidMapIdError() + + val polygonsObjectArray = call.getArray("polygons", null) + polygonsObjectArray ?: throw InvalidArgumentsError("polygons array is missing") + + if (polygonsObjectArray.length() == 0) { + throw InvalidArgumentsError("polygons requires at least one shape") + } + + val map = maps[id] + map ?: throw MapNotFoundError() + + val polygons: MutableList = mutableListOf() + + for (i in 0 until polygonsObjectArray.length()) { + val polygonObj = polygonsObjectArray.getJSONObject(i) + val polygon = CapacitorNativeMapPolygon(polygonObj) + + polygons.add(polygon) + } + + map.addPolygons(polygons) { result -> + val ids = result.getOrThrow() + + val jsonIDs = JSONArray() + ids.forEach { jsonIDs.put(it) } + + val res = JSObject() + res.put("ids", jsonIDs) + call.resolve(res) + } + + } catch (e: NativeMapsError) { + handleError(call, e) + } catch (e: Exception) { + handleError(call, e) + } + } + + @PluginMethod + fun removePolygons(call: PluginCall) { + try { + val id = call.getString("id") + id ?: throw InvalidMapIdError() + + val shapeIdsArray = call.getArray("polygonIds") + shapeIdsArray ?: throw InvalidArgumentsError("polygonIds are invalid or missing") + + if (shapeIdsArray.length() == 0) { + throw InvalidArgumentsError("polygonIds requires at least one shape id") + } + + val map = maps[id] + map ?: throw MapNotFoundError() + + val shapeIds: MutableList = mutableListOf() + + for (i in 0 until shapeIdsArray.length()) { + val shapeId = shapeIdsArray.getString(i) + shapeIds.add(shapeId) + } + + map.removePolygons(shapeIds) { err -> + if (err != null) { + throw err + } + + call.resolve() + } + } catch (e: NativeMapsError) { + handleError(call, e) + } catch (e: Exception) { + handleError(call, e) + } + } + + @PluginMethod + fun addCircles(call: PluginCall) { + try { + val id = call.getString("id") + id ?: throw InvalidMapIdError() + + val circlesObjectArray = call.getArray("circles", null) + circlesObjectArray ?: throw InvalidArgumentsError("circles array is missing") + + if (circlesObjectArray.length() == 0) { + throw InvalidArgumentsError("circles array requires at least one circle") + } + + val map = maps[id] + map ?: throw MapNotFoundError() + + val circles: MutableList = mutableListOf() + + for (i in 0 until circlesObjectArray.length()) { + val circleObj = circlesObjectArray.getJSONObject(i) + val circle = CapacitorNativeMapCircle(circleObj) + + circles.add(circle) + } + + map.addCircles(circles) { result -> + val ids = result.getOrThrow() + + val jsonIDs = JSONArray() + ids.forEach { jsonIDs.put(it) } + + val res = JSObject() + res.put("ids", jsonIDs) + call.resolve(res) + } + + } catch (e: NativeMapsError) { + handleError(call, e) + } catch (e: Exception) { + handleError(call, e) + } + } + + @PluginMethod + fun addPolylines(call: PluginCall) { + try { + val id = call.getString("id") + id ?: throw InvalidMapIdError() + + val polylinesObjectArray = call.getArray("polylines", null) + polylinesObjectArray ?: throw InvalidArgumentsError("polylines array is missing") + + if (polylinesObjectArray.length() == 0) { + throw InvalidArgumentsError("polylines requires at least one line") + } + + val map = maps[id] + map ?: throw MapNotFoundError() + + val polylines: MutableList = mutableListOf() + + for (i in 0 until polylinesObjectArray.length()) { + val polylineObj = polylinesObjectArray.getJSONObject(i) + val polyline = CapacitorNativeMapViewPolyline(polylineObj) + + polylines.add(polyline) + } + + map.addPolylines(polylines) { result -> + val ids = result.getOrThrow() + + val jsonIDs = JSONArray() + ids.forEach { jsonIDs.put(it) } + + val res = JSObject() + res.put("ids", jsonIDs) + call.resolve(res) + } + + } catch (e: NativeMapsError) { + handleError(call, e) + } catch (e: Exception) { + handleError(call, e) + } + } + + @PluginMethod + fun removeCircles(call: PluginCall) { + try { + val id = call.getString("id") + id ?: throw InvalidMapIdError() + + val circleIdsArray = call.getArray("circleIds") + circleIdsArray ?: throw InvalidArgumentsError("circleIds are invalid or missing") + + if (circleIdsArray.length() == 0) { + throw InvalidArgumentsError("circleIds requires at least one circle id") + } + + val map = maps[id] + map ?: throw MapNotFoundError() + + val circleIds: MutableList = mutableListOf() + + for (i in 0 until circleIdsArray.length()) { + val circleId = circleIdsArray.getString(i) + circleIds.add(circleId) + } + + map.removeCircles(circleIds) { err -> + if (err != null) { + throw err + } + + call.resolve() + } + } catch (e: NativeMapsError) { + handleError(call, e) + } catch (e: Exception) { + handleError(call, e) + } + } + + @PluginMethod + fun enableClustering(call: PluginCall) { + try { + val id = call.getString("id") + id ?: throw InvalidMapIdError() + + val minClusterSize = call.getInt("minClusterSize") + + val map = maps[id] + map ?: throw MapNotFoundError() + + map.enableClustering(minClusterSize, { err -> + if (err != null) { + throw err + } + + call.resolve() + }) + } catch (e: NativeMapsError) { + handleError(call, e) + } catch (e: Exception) { + handleError(call, e) + } + } + + @PluginMethod + fun disableClustering(call: PluginCall) { + try { + val id = call.getString("id") + id ?: throw InvalidMapIdError() + + val map = maps[id] + map ?: throw MapNotFoundError() + + map.disableClustering { err -> + if (err != null) { + throw err + } + + call.resolve() + } + } catch (e: NativeMapsError) { + handleError(call, e) + } catch (e: Exception) { + handleError(call, e) + } + } + + @PluginMethod + fun removeMarker(call: PluginCall) { + try { + val id = call.getString("id") + id ?: throw InvalidMapIdError() + + val markerId = call.getString("markerId") + markerId ?: throw InvalidArgumentsError("markerId is invalid or missing") + + val map = maps[id] + map ?: throw MapNotFoundError() + + map.removeMarker(markerId) { err -> + if (err != null) { + throw err + } + + call.resolve() + } + } catch (e: NativeMapsError) { + handleError(call, e) + } catch (e: Exception) { + handleError(call, e) + } + } + + @PluginMethod + fun removeMarkers(call: PluginCall) { + try { + val id = call.getString("id") + id ?: throw InvalidMapIdError() + + val markerIdsArray = call.getArray("markerIds") + markerIdsArray ?: throw InvalidArgumentsError("markerIds are invalid or missing") + + if (markerIdsArray.length() == 0) { + throw InvalidArgumentsError("markerIds requires at least one marker id") + } + + val map = maps[id] + map ?: throw MapNotFoundError() + + val markerIds: MutableList = mutableListOf() + + for (i in 0 until markerIdsArray.length()) { + val markerId = markerIdsArray.getString(i) + markerIds.add(markerId) + } + + map.removeMarkers(markerIds) { err -> + if (err != null) { + throw err + } + + call.resolve() + } + } catch (e: NativeMapsError) { + handleError(call, e) + } catch (e: Exception) { + handleError(call, e) + } + } + + @PluginMethod + fun removePolylines(call: PluginCall) { + try { + val id = call.getString("id") + id ?: throw InvalidMapIdError() + + val lineIdsArray = call.getArray("polylineIds") + lineIdsArray ?: throw InvalidArgumentsError("polylineIds are invalid or missing") + + if (lineIdsArray.length() == 0) { + throw InvalidArgumentsError("polylineIds requires at least one line id") + } + + val map = maps[id] + map ?: throw MapNotFoundError() + + val lineIds: MutableList = mutableListOf() + + for (i in 0 until lineIdsArray.length()) { + val markerId = lineIdsArray.getString(i) + lineIds.add(markerId) + } + + map.removePolylines(lineIds) { err -> + if (err != null) { + throw err + } + + call.resolve() + } + } catch (e: NativeMapsError) { + handleError(call, e) + } catch (e: Exception) { + handleError(call, e) + } + } + + @PluginMethod + fun setCamera(call: PluginCall) { + try { + val id = call.getString("id") + id ?: throw InvalidMapIdError() + + val map = maps[id] + map ?: throw MapNotFoundError() + + val cameraConfigObject = + call.getObject("config") + ?: throw InvalidArgumentsError("config object is missing") + + val config = NativeMapCameraConfig(cameraConfigObject) + + map.setCamera(config) { err -> + if (err != null) { + throw err + } + + call.resolve() + } + } catch (e: NativeMapsError) { + handleError(call, e) + } catch (e: Exception) { + handleError(call, e) + } + } + + @PluginMethod + fun getMapType(call: PluginCall) { + try { + val id = call.getString("id") + id ?: throw InvalidMapIdError() + + val map = maps[id] + map ?: throw MapNotFoundError() + + map.getMapType() { type, err -> + + if (err != null) { + throw err + } + val data = JSObject() + data.put("type", type) + call.resolve(data) + } + } catch (e: NativeMapsError) { + handleError(call, e) + } catch (e: Exception) { + handleError(call, e) + } + } + + @PluginMethod + fun setMapType(call: PluginCall) { + try { + val id = call.getString("id") + id ?: throw InvalidMapIdError() + + val map = maps[id] + map ?: throw MapNotFoundError() + + val mapType = + call.getString("mapType") ?: throw InvalidArgumentsError("mapType is missing") + + map.setMapType(mapType) { err -> + if (err != null) { + throw err + } + + call.resolve() + } + } catch (e: NativeMapsError) { + handleError(call, e) + } catch (e: Exception) { + handleError(call, e) + } + } + + @PluginMethod + fun enableIndoorMaps(call: PluginCall) { + try { + val id = call.getString("id") + id ?: throw InvalidMapIdError() + + val map = maps[id] + map ?: throw MapNotFoundError() + + val enabled = + call.getBoolean("enabled") ?: throw InvalidArgumentsError("enabled is missing") + + map.enableIndoorMaps(enabled) { err -> + if (err != null) { + throw err + } + + call.resolve() + } + } catch (e: NativeMapsError) { + handleError(call, e) + } catch (e: Exception) { + handleError(call, e) + } + } + + @PluginMethod + fun enableTrafficLayer(call: PluginCall) { + try { + val id = call.getString("id") + id ?: throw InvalidMapIdError() + + val map = maps[id] + map ?: throw MapNotFoundError() + + val enabled = + call.getBoolean("enabled") ?: throw InvalidArgumentsError("enabled is missing") + + map.enableTrafficLayer(enabled) { err -> + if (err != null) { + throw err + } + + call.resolve() + } + } catch (e: NativeMapsError) { + handleError(call, e) + } catch (e: Exception) { + handleError(call, e) + } + } + + @PluginMethod + fun enableCurrentLocation(call: PluginCall) { + if (getPermissionState(LOCATION) != PermissionState.GRANTED) { + requestAllPermissions(call, "enableCurrentLocationCallback") + } else { + internalEnableCurrentLocation(call) + } + } + + @PermissionCallback + fun enableCurrentLocationCallback(call: PluginCall) { + if (getPermissionState(LOCATION) == PermissionState.GRANTED) { + internalEnableCurrentLocation(call) + } else { + call.reject("location permission was denied") + } + } + + @PluginMethod + fun setPadding(call: PluginCall) { + try { + val id = call.getString("id") + id ?: throw InvalidMapIdError() + + val map = maps[id] + map ?: throw MapNotFoundError() + + val paddingObj = + call.getObject("padding") ?: throw InvalidArgumentsError("padding is missing") + + val padding = NativeMapPadding(paddingObj) + + map.setPadding(padding) { err -> + if (err != null) { + throw err + } + + call.resolve() + } + } catch (e: NativeMapsError) { + handleError(call, e) + } catch (e: Exception) { + handleError(call, e) + } + } + + @PluginMethod + fun enableAccessibilityElements(call: PluginCall) { + call.unavailable("this call is not available on android") + } + + @PluginMethod + fun onScroll(call: PluginCall) { + try { + val id = call.getString("id") + id ?: throw InvalidMapIdError() + + val map = maps[id] + map ?: throw MapNotFoundError() + + val boundsObj = + call.getObject("mapBounds") + ?: throw InvalidArgumentsError("mapBounds object is missing") + + val bounds = boundsObjectToRect(boundsObj) + + map.updateRender(bounds) + + call.resolve() + } catch (e: NativeMapsError) { + handleError(call, e) + } catch (e: Exception) { + handleError(call, e) + } + } + + @PluginMethod + fun onResize(call: PluginCall) { + try { + val id = call.getString("id") + id ?: throw InvalidMapIdError() + + val map = maps[id] + map ?: throw MapNotFoundError() + + val boundsObj = + call.getObject("mapBounds") + ?: throw InvalidArgumentsError("mapBounds object is missing") + + val bounds = boundsObjectToRect(boundsObj) + + map.updateRender(bounds) + + call.resolve() + } catch (e: NativeMapsError) { + handleError(call, e) + } catch (e: Exception) { + handleError(call, e) + } + } + + @PluginMethod + fun onDisplay(call: PluginCall) { + call.unavailable("this call is not available on android") + } + + @PluginMethod + fun dispatchMapEvent(call: PluginCall) { + try { + val id = call.getString("id") + id ?: throw InvalidMapIdError() + + val map = maps[id] + map ?: throw MapNotFoundError() + + val focus = call.getBoolean("focus", false)!! + + val events = cachedTouchEvents[id] + if (events != null) { + while(events.size > 0) { + val event = events.first() + if (focus) { + map.dispatchTouchEvent(event) + } else { + this.bridge.webView.onTouchEvent(event) + } + events.removeAt(0) + } + } + + call.resolve() + } catch (e: NativeMapsError) { + handleError(call, e) + } catch (e: Exception) { + handleError(call, e) + } + } + + @PluginMethod + fun getMapBounds(call: PluginCall) { + try { + val id = call.getString("id") + id ?: throw InvalidMapIdError() + + val map = maps[id] + map ?: throw MapNotFoundError() + + CoroutineScope(Dispatchers.Main).launch { + val bounds = map.getLatLngBounds() + val data = getLatLngBoundsJSObject(bounds) + call.resolve(data) + } + } catch (e: NativeMapsError) { + handleError(call, e) + } catch (e: Exception) { + handleError(call, e) + } + } + + @PluginMethod + fun mapBoundsContains(call: PluginCall) { + try { + val boundsObject = call.getObject("bounds") + val pointObject = call.getObject("point") + + CoroutineScope(Dispatchers.Main).launch { + val bounds = createLatLngBounds(boundsObject) + val point = createLatLng(pointObject) + val contains = bounds.contains(point) + val data = JSObject() + data.put("contains", contains) + call.resolve(data) + } + } catch (e: NativeMapsError) { + handleError(call, e) + } catch (e: Exception) { + handleError(call, e) + } + } + + @PluginMethod + fun fitBounds(call: PluginCall) { + try { + val id = call.getString("id") + id ?: throw InvalidMapIdError() + + val map = maps[id] + map ?: throw MapNotFoundError() + + val boundsObject = + call.getObject("bounds") ?: throw InvalidArgumentsError("bounds is missing") + + val padding = call.getInt("padding", 0)!! + + CoroutineScope(Dispatchers.Main).launch { + val bounds = createLatLngBounds(boundsObject) + map.fitBounds(bounds, padding) + call.resolve() + } + } catch (e: NativeMapsError) { + handleError(call, e) + } catch (e: Exception) { + handleError(call, e) + } + } + + @PluginMethod + fun mapBoundsExtend(call: PluginCall) { + try { + val boundsObject = call.getObject("bounds") + val pointObject = call.getObject("point") + + CoroutineScope(Dispatchers.Main).launch { + val bounds = createLatLngBounds(boundsObject) + val point = createLatLng(pointObject) + val newBounds = bounds.including(point) + val data = JSObject() + data.put("bounds", getLatLngBoundsJSObject(newBounds)) + call.resolve(data) + } + } catch (e: NativeMapsError) { + handleError(call, e) + } catch (e: Exception) { + handleError(call, e) + } + } + + private fun createLatLng(point: JSObject): LatLng { + return LatLng( + point.getDouble("lat"), + point.getDouble("lng") + ) + } + + private fun createLatLngBounds(boundsObject: JSObject): LatLngBounds { + val southwestObject = boundsObject.getJSObject("southwest")!! + val southwestLatLng = createLatLng(southwestObject) + + val northeastObject = boundsObject.getJSObject("northeast")!! + val northeastLatLng = createLatLng(northeastObject) + + return LatLngBounds(southwestLatLng, northeastLatLng) + } + + private fun internalEnableCurrentLocation(call: PluginCall) { + try { + val id = call.getString("id") + id ?: throw InvalidMapIdError() + + val map = maps[id] + map ?: throw MapNotFoundError() + + val enabled = + call.getBoolean("enabled") ?: throw InvalidArgumentsError("enabled is missing") + + map.enableCurrentLocation(enabled) { err -> + if (err != null) { + throw err + } + + call.resolve() + } + } catch (e: NativeMapsError) { + handleError(call, e) + } catch (e: Exception) { + handleError(call, e) + } + } + + fun notify(event: String, data: JSObject) { + notifyListeners(event, data) + } + + private fun handleError(call: PluginCall, e: Exception) { + val error: NativeMapErrorObject = getErrorObject(e) + Log.w(tag, error.toString()) + call.reject(error.message, error.code.toString(), e) + } + + private fun handleError(call: PluginCall, e: NativeMapsError) { + val error: NativeMapErrorObject = getErrorObject(e) + Log.w(tag, error.toString()) + call.reject(error.message, error.code.toString()) + } + + private fun boundsObjectToRect(jsonObject: JSONObject): RectF { + if (!jsonObject.has("width")) { + throw InvalidArgumentsError( + "NativeMapConfig object is missing the required 'width' property" + ) + } + + if (!jsonObject.has("height")) { + throw InvalidArgumentsError( + "NativeMapConfig object is missing the required 'height' property" + ) + } + + if (!jsonObject.has("x")) { + throw InvalidArgumentsError( + "NativeMapConfig object is missing the required 'x' property" + ) + } + + if (!jsonObject.has("y")) { + throw InvalidArgumentsError( + "NativeMapConfig object is missing the required 'y' property" + ) + } + + val width = jsonObject.getDouble("width") + val height = jsonObject.getDouble("height") + val x = jsonObject.getDouble("x") + val y = jsonObject.getDouble("y") + + return RectF(x.toFloat(), y.toFloat(), (x + width).toFloat(), (y + height).toFloat()) + } +} diff --git a/android/src/main/java/com/capgo/plugins/nativemap/CapacitorGoogleMapsPoint.kt b/android/src/main/java/com/capgo/plugins/nativemap/CapacitorGoogleMapsPoint.kt new file mode 100644 index 0000000..628842b --- /dev/null +++ b/android/src/main/java/com/capgo/plugins/nativemap/CapacitorGoogleMapsPoint.kt @@ -0,0 +1,23 @@ +package com.capgo.plugins.nativemap + +import org.json.JSONObject + +class CapacitorNativeMapPoint() { + var x: Float = 0.00f + var y: Float = 0.00f + + constructor(fromJSONObject: JSONObject) : this() { + if(fromJSONObject.has("x")) { + this.x = fromJSONObject.getDouble("x").toFloat() + } + + if(fromJSONObject.has("y")) { + this.y = fromJSONObject.getDouble("y").toFloat() + } + } + + constructor(x: Float, y: Float) : this() { + this.x = x; + this.y = y + } +} \ No newline at end of file diff --git a/android/src/main/java/com/capgo/plugins/nativemap/CapacitorGoogleMapsPolygon.kt b/android/src/main/java/com/capgo/plugins/nativemap/CapacitorGoogleMapsPolygon.kt new file mode 100644 index 0000000..413cb50 --- /dev/null +++ b/android/src/main/java/com/capgo/plugins/nativemap/CapacitorGoogleMapsPolygon.kt @@ -0,0 +1,80 @@ +package com.capgo.plugins.nativemap + +import android.graphics.Color +import com.google.android.gms.maps.model.LatLng +import com.google.android.gms.maps.model.Polygon +import org.json.JSONArray +import org.json.JSONObject + +class CapacitorNativeMapPolygon(fromJSONObject: JSONObject) { + var shapes: MutableList> = mutableListOf>() + var strokeWidth: Float = 1.0f + var strokeColor: Int = Color.BLUE + var fillColor: Int = Color.BLUE + var clickable: Boolean + var geodesic: Boolean + var zIndex: Float = 0.00f + var tag: String = "" + var googleMapsPolygon: Polygon? = null + + init { + if (!fromJSONObject.has("paths")) { + throw InvalidArgumentsError("Polygon object is missing the required 'paths' property") + } + + val pathsArray = fromJSONObject.getJSONArray("paths") + for (i in 0 until pathsArray.length()) { + val arr = pathsArray.optJSONArray(i) + if (arr == null) { + // is a single shape + val shape = this.processShape(pathsArray) + this.shapes.add(shape) + break + } else { + val shape = this.processShape(arr) + this.shapes.add(shape) + } + } + + val strokeOpacity = fromJSONObject.optDouble("strokeOpacity", 1.0) + strokeColor = this.processColor(fromJSONObject.getString("strokeColor"), strokeOpacity) + + val fillOpacity = fromJSONObject.optDouble("fillOpacity", 1.0) + fillColor = this.processColor(fromJSONObject.getString("fillColor"), fillOpacity) + + strokeWidth = fromJSONObject.optDouble("strokeWeight", 1.0).toFloat() + clickable = fromJSONObject.optBoolean("clickable", false) + geodesic = fromJSONObject.optBoolean("geodesic", false) + zIndex = fromJSONObject.optDouble("zIndex", 1.0).toFloat() + tag = fromJSONObject.optString("tag", "") + } + + private fun processShape(shapeArr: JSONArray): MutableList { + var shape = mutableListOf() + + for (i in 0 until shapeArr.length()) { + val obj = shapeArr.getJSONObject(i) + if (!obj.has("lat") || !obj.has("lng")) { + throw InvalidArgumentsError("LatLng object is missing the required 'lat' and/or 'lng' property") + } + + val lat = obj.getDouble("lat") + val lng = obj.getDouble("lng") + + shape.add(LatLng(lat, lng)) + } + + return shape + } + + private fun processColor(hex: String, opacity: Double): Int { + val colorInt = Color.parseColor(hex) + + val alpha = (opacity * 255.0).toInt() + val red = android.graphics.Color.red(colorInt) + val green = android.graphics.Color.green(colorInt) + val blue = android.graphics.Color.blue(colorInt) + + return Color.argb(alpha, red, green, blue) + } +} \ No newline at end of file diff --git a/android/src/main/java/com/capgo/plugins/nativemap/CapacitorGoogleMapsStyleSpan.kt b/android/src/main/java/com/capgo/plugins/nativemap/CapacitorGoogleMapsStyleSpan.kt new file mode 100644 index 0000000..6b1055e --- /dev/null +++ b/android/src/main/java/com/capgo/plugins/nativemap/CapacitorGoogleMapsStyleSpan.kt @@ -0,0 +1,5 @@ +package com.capgo.plugins.nativemap + +import android.graphics.Color + +data class CapacitorNativeMapStyleSpan(val color: Int, val segments: Double?) diff --git a/android/src/main/java/com/capgo/plugins/nativemap/GoogleMapCameraConfig.kt b/android/src/main/java/com/capgo/plugins/nativemap/GoogleMapCameraConfig.kt new file mode 100644 index 0000000..328cadc --- /dev/null +++ b/android/src/main/java/com/capgo/plugins/nativemap/GoogleMapCameraConfig.kt @@ -0,0 +1,50 @@ +package com.capgo.plugins.nativemap + +import com.google.android.gms.maps.model.LatLng +import org.json.JSONObject + +class NativeMapCameraConfig(fromJSONObject: JSONObject) { + var coordinate: LatLng? = null + var zoom: Double? = null + var angle: Double? = null + var bearing: Double? = null + var animate: Boolean? = null + var animationDuration: Double? = null + + init { + if (fromJSONObject.has("zoom")) { + zoom = fromJSONObject.getDouble("zoom") + } + + if(fromJSONObject.has("angle")) { + angle = fromJSONObject.getDouble("angle") + } + + if (fromJSONObject.has("bearing")) { + bearing = fromJSONObject.getDouble("bearing") + } + + if (fromJSONObject.has("animate")) { + animate = fromJSONObject.getBoolean("animate") + } + + if (fromJSONObject.has("animationDuration")) { + animationDuration = fromJSONObject.getDouble("animationDuration") + } + + if (fromJSONObject.has("coordinate")) { + val coordinateJSONObject = fromJSONObject.getJSONObject("coordinate") + if(!coordinateJSONObject.has("lat") || !coordinateJSONObject.has("lng")) { + throw InvalidArgumentsError("LatLng object is missing the required 'lat' and/or 'lng' property") + } + + val lat = coordinateJSONObject.getDouble("lat") + val lng = coordinateJSONObject.getDouble("lng") + coordinate = LatLng(lat, lng) + } else { + coordinate = null + } + } + + +} \ No newline at end of file diff --git a/android/src/main/java/com/capgo/plugins/nativemap/GoogleMapConfig.kt b/android/src/main/java/com/capgo/plugins/nativemap/GoogleMapConfig.kt new file mode 100644 index 0000000..e6a9e71 --- /dev/null +++ b/android/src/main/java/com/capgo/plugins/nativemap/GoogleMapConfig.kt @@ -0,0 +1,165 @@ +package com.capgo.plugins.nativemap + +import com.google.android.gms.maps.GoogleMapOptions +import com.google.android.gms.maps.model.CameraPosition +import com.google.android.gms.maps.model.LatLng +import com.google.android.gms.maps.model.LatLngBounds +import org.json.JSONObject + +class NativeMapConfig(fromJSONObject: JSONObject) { + var width: Int = 0 + var height: Int = 0 + var x: Int = 0 + var y: Int = 0 + var center: LatLng = LatLng(0.0, 0.0) + var googleMapOptions: GoogleMapOptions? = null + var zoom: Int = 0 + var liteMode: Boolean = false + var devicePixelRatio: Float = 1.00f + var styles: String? = null + var mapId: String? = null + var minZoom: Int? = null + var maxZoom: Int? = null + var mapTypeId: String? = null + var restriction: NativeMapConfigRestriction? = null + var heading: Double? = null + + init { + if (!fromJSONObject.has("width")) { + throw InvalidArgumentsError( + "NativeMapConfig object is missing the required 'width' property" + ) + } + + if (!fromJSONObject.has("height")) { + throw InvalidArgumentsError( + "NativeMapConfig object is missing the required 'height' property" + ) + } + + if (!fromJSONObject.has("x")) { + throw InvalidArgumentsError( + "NativeMapConfig object is missing the required 'x' property" + ) + } + + if (!fromJSONObject.has("y")) { + throw InvalidArgumentsError( + "NativeMapConfig object is missing the required 'y' property" + ) + } + + if (!fromJSONObject.has("zoom")) { + throw InvalidArgumentsError( + "NativeMapConfig object is missing the required 'zoom' property" + ) + } + + if (fromJSONObject.has("devicePixelRatio")) { + devicePixelRatio = fromJSONObject.getDouble("devicePixelRatio").toFloat() + } + + if (!fromJSONObject.has("center")) { + throw InvalidArgumentsError( + "NativeMapConfig object is missing the required 'center' property" + ) + } + + val centerJSONObject = fromJSONObject.getJSONObject("center") + + if (!centerJSONObject.has("lat") || !centerJSONObject.has("lng")) { + throw InvalidArgumentsError( + "LatLng object is missing the required 'lat' and/or 'lng' property" + ) + } + + liteMode = + fromJSONObject.has("androidLiteMode") && + fromJSONObject.getBoolean("androidLiteMode") + + width = fromJSONObject.getInt("width") + height = fromJSONObject.getInt("height") + x = fromJSONObject.getInt("x") + y = fromJSONObject.getInt("y") + + val tempZoom = fromJSONObject.getInt("zoom") + var tempMinZoom = fromJSONObject.optInt("minZoom").takeIf { fromJSONObject.has("minZoom") } + var tempMaxZoom = fromJSONObject.optInt("maxZoom").takeIf { fromJSONObject.has("maxZoom") } + + if (tempMinZoom != null && tempMaxZoom != null && tempMinZoom > tempMaxZoom) { + tempMinZoom = tempMaxZoom.also { tempMaxZoom = tempMinZoom } + } + + minZoom = tempMinZoom + maxZoom = tempMaxZoom + + zoom = tempZoom.coerceIn( + tempMinZoom ?: Int.MIN_VALUE, + tempMaxZoom ?: Int.MAX_VALUE + ) + + mapTypeId = fromJSONObject.optString("mapTypeId").takeIf { fromJSONObject.has("mapTypeId") } + + val lat = centerJSONObject.getDouble("lat") + val lng = centerJSONObject.getDouble("lng") + center = LatLng(lat, lng) + + val cameraPosition = CameraPosition(center, zoom.toFloat(), 0.0F, 0.0F) + + styles = fromJSONObject.getString("styles") + + mapId = fromJSONObject.getString("androidMapId") + + restriction = fromJSONObject.optJSONObject("restriction")?.let { NativeMapConfigRestriction(it) } + + heading = fromJSONObject.optDouble("heading").takeIf { fromJSONObject.has("heading") } + + googleMapOptions = GoogleMapOptions().camera(cameraPosition).liteMode(liteMode) + if (mapId != null) { + googleMapOptions?.mapId(mapId!!) + } + } +} + +class NativeMapConfigRestriction(fromJSONObject: JSONObject) { + var latLngBounds: LatLngBounds + + init { + if (!fromJSONObject.has("latLngBounds")) { + throw InvalidArgumentsError( + "NativeMapConfigRestriction object is missing the required 'latLngBounds' property" + ) + } + val latLngBoundsObj = fromJSONObject.getJSONObject("latLngBounds") + + if (!latLngBoundsObj.has("north")) { + throw InvalidArgumentsError( + "NativeMapConfigRestriction object is missing the required 'latLngBounds.north' property" + ) + } + if (!latLngBoundsObj.has("south")) { + throw InvalidArgumentsError( + "NativeMapConfigRestriction object is missing the required 'latLngBounds.south' property" + ) + } + if (!latLngBoundsObj.has("east")) { + throw InvalidArgumentsError( + "NativeMapConfigRestriction object is missing the required 'latLngBounds.east' property" + ) + } + if (!latLngBoundsObj.has("west")) { + throw InvalidArgumentsError( + "NativeMapConfigRestriction object is missing the required 'latLngBounds.west' property" + ) + } + val north = latLngBoundsObj.getDouble("north") + val south = latLngBoundsObj.getDouble("south") + val east = latLngBoundsObj.getDouble("east") + val west = latLngBoundsObj.getDouble("west") + + latLngBounds = LatLngBounds( + LatLng(south, west), + LatLng(north, east) + ) + } +} diff --git a/android/src/main/java/com/capgo/plugins/nativemap/GoogleMapErrors.kt b/android/src/main/java/com/capgo/plugins/nativemap/GoogleMapErrors.kt new file mode 100644 index 0000000..4ee6c33 --- /dev/null +++ b/android/src/main/java/com/capgo/plugins/nativemap/GoogleMapErrors.kt @@ -0,0 +1,114 @@ +package com.capgo.plugins.nativemap + +import org.json.JSONObject +import kotlin.Exception + +enum class NativeMapErrors { + UNHANDLED_ERROR, INVALID_MAP_ID, MAP_NOT_FOUND, MARKER_NOT_FOUND, INVALID_ARGUMENTS, PERMISSIONS_DENIED_LOCATION, GOOGLE_MAP_NOT_AVAILABLE, BOUNDS_NOT_FOUND, TILE_OVERLAY_NOT_FOUND +} + +class NativeMapErrorObject(val code: Int, val message: String, val extra: HashMap = HashMap()) { + private fun asJSONObject(): JSONObject { + val returnJSONObject = JSONObject() + + returnJSONObject.put("code", code) + returnJSONObject.put("message", message) + returnJSONObject.put("extra", extra) + + return returnJSONObject + } + + override fun toString(): String { + return this.asJSONObject().toString() + } +} + +fun getErrorObject(err: NativeMapsError): NativeMapErrorObject { + return when(err) { + is InvalidArgumentsError -> { + NativeMapErrorObject(err.getErrorCode(), "Invalid Arguments Provided: ${err.message}.") + } + is InvalidMapIdError -> { + NativeMapErrorObject(err.getErrorCode(), "Missing or invalid map id.") + } + is MapNotFoundError -> { + NativeMapErrorObject(err.getErrorCode(), "Map not found for provided id.") + } + is MarkerNotFoundError -> { + NativeMapErrorObject(err.getErrorCode(), "Marker not found for provided id.") + } + is PermissionDeniedLocation -> { + NativeMapErrorObject(err.getErrorCode(), "Permissions denied for accessing device location.") + } + is NativeMapNotAvailable -> { + NativeMapErrorObject(err.getErrorCode(), "Google Map is not available.") + } + is BoundsNotFoundError -> { + NativeMapErrorObject(err.getErrorCode(), "Google Map Bounds could not be found.") + } + is TileOverlayNotFoundError -> { + NativeMapErrorObject(err.getErrorCode(), "Tile overlay not found for provided id.") + } + else -> { + NativeMapErrorObject(err.getErrorCode(), "Unhandled Error: ${err.message}.") + } + } +} + +fun getErrorObject(err: Exception): NativeMapErrorObject { + return NativeMapErrorObject(0, "Unhandled Error: ${err.message}.") +} + +open class NativeMapsError(message: String? = ""): Throwable(message) { + open fun getErrorCode(): Int { + return NativeMapErrors.UNHANDLED_ERROR.ordinal + } +} + +class InvalidMapIdError(message: String? = ""): NativeMapsError(message) { + override fun getErrorCode(): Int { + return NativeMapErrors.INVALID_MAP_ID.ordinal + } +} + +class MapNotFoundError(message: String? = ""): NativeMapsError(message) { + override fun getErrorCode(): Int { + return NativeMapErrors.MAP_NOT_FOUND.ordinal + } +} + +class MarkerNotFoundError(message: String? = ""): NativeMapsError(message) { + override fun getErrorCode(): Int { + return NativeMapErrors.MARKER_NOT_FOUND.ordinal + } +} + +class TileOverlayNotFoundError(message: String? = ""): NativeMapsError(message) { + override fun getErrorCode(): Int { + return NativeMapErrors.TILE_OVERLAY_NOT_FOUND.ordinal + } +} + +class InvalidArgumentsError(message: String? = ""): NativeMapsError(message) { + override fun getErrorCode(): Int { + return NativeMapErrors.INVALID_ARGUMENTS.ordinal + } +} + +class PermissionDeniedLocation(message: String? = ""): NativeMapsError(message) { + override fun getErrorCode(): Int { + return NativeMapErrors.PERMISSIONS_DENIED_LOCATION.ordinal + } +} + +class NativeMapNotAvailable(message: String? = ""): NativeMapsError(message) { + override fun getErrorCode(): Int { + return NativeMapErrors.GOOGLE_MAP_NOT_AVAILABLE.ordinal + } +} + +class BoundsNotFoundError(message: String? = ""): NativeMapsError(message) { + override fun getErrorCode(): Int { + return NativeMapErrors.BOUNDS_NOT_FOUND.ordinal + } +} diff --git a/android/src/main/java/com/capgo/plugins/nativemap/GoogleMapPadding.kt b/android/src/main/java/com/capgo/plugins/nativemap/GoogleMapPadding.kt new file mode 100644 index 0000000..35d25ee --- /dev/null +++ b/android/src/main/java/com/capgo/plugins/nativemap/GoogleMapPadding.kt @@ -0,0 +1,28 @@ +package com.capgo.plugins.nativemap + +import org.json.JSONObject + +class NativeMapPadding(fromJSONObject: JSONObject) { + var top: Int = 0 + var bottom: Int = 0 + var left: Int = 0 + var right: Int = 0 + + init { + if(fromJSONObject.has("top")) { + top = fromJSONObject.getInt("top") + } + + if(fromJSONObject.has("bottom")) { + bottom = fromJSONObject.getInt("bottom") + } + + if(fromJSONObject.has("left")) { + left = fromJSONObject.getInt("left") + } + + if(fromJSONObject.has("right")) { + right = fromJSONObject.getInt("right") + } + } +} \ No newline at end of file diff --git a/android/src/main/res/.gitkeep b/android/src/main/res/.gitkeep new file mode 100644 index 0000000..e69de29 diff --git a/assets/github-social-preview.png b/assets/github-social-preview.png new file mode 100644 index 0000000000000000000000000000000000000000..93df11f3a87a6b622b78a3f996883a741e421507 GIT binary patch literal 109623 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 z z1Di6IMqcg_MbxOBSVAKsMVLsDAGycIT}|CiGg7wb)B%>6MV&MLT1ow{xauWAU}?F# zJk;syyg(%U)LYCckyluqmc|3;@hi5*A^B-;DNJN}`SAht(E*1%PP3%5yPYa}f>Pp) zID4)X5fjx#htPjkuC%2b*!9=EFYtJD3*HTU%MAV&J8qu1*mQUc-yiFU%gV~Szf>JF zfXmKcHNH*m*R}bKfq(yYdGX@6uU`5awPL0Vg@2<+NyX>51j$5vY+z^f(db zivNaItSohOVRLmX1>A-t`cKvgq#W~v5^Jvw)sa15LE0Rm#-;jbYHAv)Y^RzpAFrgS zpjtwcC-GaIy6f|p!#jNZwln%BPk|RcZwd657I~hTb>Lr$$D^?r=JgYhb0=iLDq7Pd z4oj7xF6`O%o^ox3eD5>iXbOsM*ZiJn@X)-5RBYQ9tJIBu)%6mYM?lU>%irIh!{!(Y zduM0fdFes%i6wJ|RrRX6XSKqQT}t;f@*D7JST47?v6;=bOqWe5YrSV}nChF`R<*!e zGKhxJXcHiaeOL%han~H)b|Yy`ol=|1Wv)g@IKn+WZVL&Go%Tsj7sumu@C_`KIBcA< z6Ajud2i&vaybCi=M*0p0evnW7D>5>}0yUbYYJ_t)^Fw9Q4kxpUkb+hux_16;e^ z-6F4+Hxn!j`llHqV`8kgm-(0`4H+DF(d*%F>-J#3cj1nA&{?0>zn#Ij9hufH>hPuy z-gUFkIP^-;x0ZzliGa3zw3{-1Cq|EZi60s~%Ad=qhFL@|X8yuI0 zwNu1L@C&~^Y}Qo?CPXa$E-h)sx-9u!oqMj@taGd{Aa^?(`H%J@V~u#sJ1c8z5wSy4 z4c{hnF_SNFZ?V0rtLf|Q%+_L3Hdj`5I($;x{N(a7g@=qs2UA}5kBMeDb^O>=c*ED) zYEzbrJ~}!SmXIV^RP{bePOur;AIY(Ryr+M}PEzdp+~-ZhTFI(jrywFz`cQowhy4wx&dTrc*y;BP zao$U*tG~cR*t4gdZ#3m%_gd&2-(d#fysmE$o)q`3x<4`TyNxP7XhZ=2SR@uo)FzZF zmq%Gi>L-oIOtG5o)B*JCnF?nL1A{E!7(heA4B<~pt*h&;i*++C8QL$D7)%k*QoACU zcRhOPa@nH}vJ$AewRekmegV>%`Q_pF_v+zyZ-GT9G$CSu>xt#c$9AAZsC%91_5!y% zd4cQX3YkHg9_Ex5K1(kMRT7DclJWy++W`Co>khsC2Kx(6Q9yLEA%QhYSlIQ=jrEQ$ z(FwfYPTfj?)I>cm>()+Q~z^p zG+CnYEJVid?NcP9Ia92pTcu@Jc|%8k(*@xSTpO`$y6AvyI#6RjJDA!;LP~bobWAuK z8yy4=8@`lG{pkCq*GW=CAFCGzZKtHyr$x$>#BB~$nfwP;v%nWKYb!4y{uBX zZ6(0|wsRinPh4xEWp~IR-6&BNnG}|6uEf*ed^KozAtYF;^iAmqGR3SCD&{D7g+bizca~Oj5u_ zbJ?43%{|3V#DwrZX5x$YU-d21X>|7ukP(%Id^LzmNN59I62LgcSTAC4uEiN6O@S78${iDUr=8Z1(*CL=ggA(isUfQS7fPg1h%2q`IP zx?CO*{5Lv9BjT8Bae)8oT6+)=_2bD6(0z$%Xb`ltAf~4!WzBaNM?;G|^RTf{!BbY4Z9v;fF>*9fJ0tOCtq}l=k=mQf?xV4R#oy81_0QbA7 zC>q7-lXSA4`42=<$fZHnk+USo5W?ua@#%+&KZ~->EQxK z!qRdRlP1OGp0T#}6I+7KM1om)q~lFWEFcs>d5zxQHa48s)oiw2YHFM$byQR&2e%tH zF;#A~B7;iP(Gd_9w$2-F;IdFOgj0#bw(FA?V=FjqemZQ%1STEY*n4sxMvgf6u31Ke)HrmqF~`S~4p zYh!YYi@~V{RW#GND)T?}ZRYrbf}4cpjk>GXcLf%w9nFxm&cR#dn6>p2Js4P9oo(Nd zbAQPeK(qA%O zk1|RO5$w7#Iyu z7W(dg)|&Mh+HiL5Ef#6k2LAH!Vf=9{Gk$oe-aVwZ+(HB#LMl!B_HPLoAnHdml^#3H z=49N&s6Q9#aUkjw@)}<|I+0AV-5+3*9d2QPR_sw<|H?J|4n%M4!>IL7$Ctr?HLdfE zjmWiyZ(ZvOR-W?Wn$X_O(<^q-aJ{?0Y&hLb07kmg$$CN=&><8gIEt0_=&vR`x%`qU z$Vi{(js}*Nnwv>3C@h{!oO%NsM7YDcEjMo@LO}-sQtBv#iHWcKiwD!}wuP!?k@ZK7 zDT|`6H`f*PGL-9*cD4)EM(ocNDIonYpB{1YjHE`mdhVgzw4XGAUF+HObmh+~P4oT7 z0sbeK(EUP0{x)KVlcNez9%pZ?KGssBAt@WqMq8)*+z~z5JO!{=GZNOOzCuMSLDgG7 zK$>pU9ndqqD#jllS5R|(pEB*!BcF}-4$HWrp1LJIst=pn0gEV2r{T79E;2gu9j=9x z`r&j{hj|hP#s+AD0f7e621^24q259K*Fu%X@E-XbX0zD=0RcNQN(SGbEuT&D3ua2~ z1~6PL#QVk(Y|Ze2^a2=-_V&(|oo~*PG3b~oXcF`d=WhxWX^pl9v-cK$IaY*-M&zKF zs}z_G9VSg4*&WUHAfb_?;LUrvH{41OCi4hNeCKX$)p#Zu&7zaI@ny~9-Y&W?e=spM z0X<);X~xBSc_}<2z=Huhh4!IviVjQsFs=<-*FK~)Wrx{t^>AfSoPLP>;{o16{Z(pJ zRj1QYb=T>JxWjGSmZ;QWm-SGyZ;w7PFA+*aPrLty_JeL(mDuvUl zs>)65+}qX^i&2;K5gNMR?ZTE$vra@k(UBwof6iW;0Sg!afx-er@&SY40MTRJ#7p<>4ToE@;63BjO=X54Ffg~jFq z)8zJ8Q(K3Mg6*f6W3bfZYUf-v%>=vDF%jk7?-sQ5{-HNdo+>jlk(8V~x+}%SU#}|| z0B616+PFA8uF3EP1GURJ@e+0!z>KICZDwP$hsDSDYIE_@lpp| zk_B-I*vBai_m@OzM5JV7>~XiwOk`f6!wk2Vdqatb3$pcj3Au*V<_mw9TRi|Tx?DN6 zn3}sCZi^%?Y;0OtsMVZ|OD>_kd%h!JcOdjb<{i)h6uy3~uw3)*OJ0f`eBin%0kY43 zJR9&)NwajLWVE(O=4nD!L!$#?)ZAUiN|RSy{1<5Xz!sk_j(KCy%H8y^d)AlSYo22M!`KIyw|k!)wQxU2a#L zB`1?!C^I~9v0145sICpR_l#{rj9=f})J`Hnpm?9wzu0}B3j}=A7oVVZUOolMsZwQA5Bb66ULp-yLGC*tAFxclY-%w_Pofb8!V+Ukh{w6hkjjpymdpXb;*UA=Ls6{(D73o7+D3m&1+D(m)3NWKG>cK2k8X z2WAN$Xl)_&^;{t0Gi0b|YF%m0nwh1sH2{tUnfWz5(pq+cMOJ>k|ChJu4Qkcj0lx9j zEZZbqZQ`lFv0S`@D%7g?kBp!=K0O8QH*6SKd!2{)uWVaeo14cguZ{qdY7i%uECP&5 zkdLuL$wKx1Y7YftW!jI((9tF2!c|Zz*F!q)&1*a15U~V6IRWG%^HyVZJeaS^ zXS>1a+1YC(1f$!)IE6?hWqX9;jLb~Wj)3>+V>@7gB#Y(C%{*YRh4SNjY;buQb@~3t zi_Qs=5nX_^(CeQzg@65e9Y~b-OIs#TH;&L*Sr@p%)AhU|KA+t}+z|&^3YG?89WakjZTA+5KIGbfG+9^WCOtG`*IXo!$E=3=CS;YlN=g z*(wM-JHW;+DIhaHd-|7}9)SN?e}x`WW}f7j)DOrK3aM#2ZRe9!!A&;?pTIyHAdV0b z5rGtj10)V#AYSP)#a$mZFUiTu^6~Q%M^H!`bPXN=3-GMj(CX5AA|>kA$RVE#iVSu} z$tIE1+#WV4-n^lEM}X1;yk4>jHY0{R&&KRc3!fMW$M zno+hoH(FrJ-I$w*c~t(5pz2n%QQ4JaM)~rNO3t|!C<#BdH;6R zzej)Fhp;K5yga6uG zC{vUemi#PG@PieyJUIb}gm3^b+l`_D>2?Prp=`P9NmgA!U?`a`=3>6^L(i4N&ZZiqr!#l@+_52JskRk##i%t@@ zypxtGQU5PqfQ_IL?bO2lM-NXDb&UmpofKImP4_KrZNHREak|VcmU4LU2lsYV%DP^L z_2@e|Ic7}ZQqokW0Kp5x!O=-xQFT_J(%_>o9nitiiWKJxofhWDfp0)YT|wW-WZuAq zExz4Gm106JJ>g@fT3dq z7w@h@g`=>1V@;VnW@TeX($+R=VZjU31$7M#DmpszaE3!5-b!;na03c~+hs`uWV(4C zZc3Vu9fO5J^$rdWsPC{ufR2EU5yw7W`%I)YJkS9R&#@yt{LgHL72n#S)VFVClIa$^ z=LvBv2As{bv0b}gFS92_fo%y?bU8WoQGI4uC_+Ll6O;Ud+f^@2Eh1o|c4`+rLuey4jy!M)&p8g!J z(RQ}bRSlzCpUK1oXOTI6b`5Chf`Td$7n5|(0pTKr)IFo4a`p1=B{H517HG~_D?K?W zd^uAU$2lqA(Zg(eh`?<=^NadDkb3fib?OVqr@p&-VQ+6wiu%np(DWT7M>3_=(~sSX zn#>D%(H+xEJvg9%W&`Q)3e^u?ON;RS{^3)K)1cD>&&m4Oxu}@oSSQlG#Urxht^y@G z2)^mUl*?+&Cn=i}&4!DiDN*qX4T|DHh9Dsiv8?pWKkb{U&}X;bH8pu7qoP2T{hsjB z<>aCo2&TMu>w4fESsNHmD+oAq^)yv3HiIbLVL`!v%v9xa(ddX&m<=|+OYIm z%xiSDjVZx0U54`b{5-R;aK4UQ^Q_k8z5!1$B`TWb#3N{dnv9Nm%JAWRo!tHTkE_pV z3eyK|ebF>ws|N>yf(Bke{Nr+Y7?_xth;SYTh||@AN08tsMSREU1)f zw!n5jwJ!&sw;(*r_dr1orRLf@@kOSSMNk5YtvdB>I@+z)>Md2!?AfsDq&HD7_PN&Duerwu0$=R#D(5AEd183&)WPGBZ{gK$8D zUAVD*p+uWQ^!00$!q>{JySq!x zwKmQR;Avg4j&)Gu&Ey<5n+vIzm)G~jnzvr+<_p(ZWpAW^JAM>)hS%_DZ2@JK!{s_P zNwvRfd~#B5`LpB8Ke_JvkmH0}m(`NRbe;0FX&$|u&`(Q%$HM#FRckR8n&-BhZ*ARv+Q=yoowthFS(!oiUZc< z$7TOF&|(UI)_&J`r##uuGk>0?Uz@}P1U#_G_ZJ(-ID=-Ab$~-`@>^XHBUT{WRU=J@ zw6opMS_tl8{K4ypo@w2S7{#2*yKsJR8nP-yRgl?yBFJ^~wOLWsx6uLfD5c^*g*c3Q;qvh(T^u;0Y&J) z>}2VESrR5Yhdw5-TV3{36*nHjp`xORO6;3G6lZ69R~QX07mxht89YTO%DEu{oBVVp zhtP8ACGr?Eb$oKPBqlhjqkKPCGN9Qt2!0r3;DN70@~1%f|NL12Uvs)n(3kCG$KGhe zRHogQn0-s)G2x(0wVHnEAT-XPTf@T~p}>Ivad&g{pQ) z%W6(R0EUMg)66$RkZ9pIS>x3*_{?q9P&)WXaIU0vG!- zXV6N%fbT_RCF{p{r`h+H>O8aR?L7ou7=QMy1n&`Nm>4dez`j-!VnWoCkhVPBd_JwcRd_T@-!~gUIaW=vy z=$P<2v1dR0wTv>qK-9XhkR?JTRW`~`^+$nHP&M_lc(Yt;4LUsfZ&OQqpXF$n)utsv zqELN%yQBWW!^OD7rL*%JUb~}t$F2T>#D$8Z#;F$M=3cV9_fSYjFAC4^dfvD?%3{tu z_678&($nwqk7#KY9zCuRn3qJH=8#gl=Ogr{fU7t1ud}w%e_KB&+^^w{TBwy9ozUaA z!G6Y;@pS&B{j=J+BY_}!`6FAy4v}ZsZ*WOSqr=*A| zNP`m6-Q7|G(jC&>b8!?CV42cHA z<}B>@_ei2j?jolss=`*}uod=+$mfptZ`+hC%3;%B{8Y#jN2Ff~?j#T`I_l27_$FicCDf#j6i}(C}=?&QUezVIi4o6ha(c% zA~5$hJVI@oZdm&LH8`zrJ^UEn$3fhFAM3vc4nF8&_vbZ;W4 zeDLtY3I1iWY0i)o7+HJ{vqBhL!!d2#UHz*j_On88f)BGt(|qylB@M$U!{V5qvi!}9 zZ(jGGtGojHZI!#BA8{use81Uq;I!^L7yW4^S9BJ@EWP&odLJ5Z~;A&vd_hhRtN-dQTu|E#O{h4L##As@7Kf@BHX!qgd`B*{xF^cr|6?Q_Jp zGw6T$?VE8b!c@@fXIcJsSz|>hd{=Z7iGP2>oH^cJDPaH4YX05C26NUSJlRFAX#S4{ z1@nSDw@dhUle($YbPIgwrvLvu5<|Pl_VA6Hae*%-2Ez=>ILgL(HpFy$?Xm~jCHQ&1 z5_}J88QRTP{$(UJ#I9iVH5Ybt4t`%sRDDJtO-wXK8h+laiF9>i^dCD2E6zBv9^!a^ z8R6e;)<2ff6r%_EkuiA3f7mD3FkoVc{@!+8R*E-ZJ+emOsv*Are>U2zw<-wt&-^ui z^9+l3=M35ssU%43IreY=RH$hFd*4t>xao*sFC5y_aPRK_%{Q#T48?rrD0^(=T-`zX&uf2H`%RT&NeB5n4 zlHWtbMEfm8`bscf92Erv7dwYT2W61xyCPGW?fhP1z|-3+=2_#?KzcYk@7;qDZ^ zGgt=p98dmYx-C0SFJSM%+Bp5)=4@~MhYR{})ApY(Xsmw^(mmj(e_gv9kNevOy|Jm^ zXZ#lr6t|<)cuO(!%tyfQpG zyk!DQ4;lV&MZcT%FCGGSPq7eqB%i-}r2l8a)#iZZ zQ#ab5BEncw4i1Ht!H>jBN?fjo$GHVRCvHxkz=|0kDyrRmwzt?rLnYuJNF9Ze19jf> zNB~6}PxO_LygYO&h+9~EygGVn%x?h|*l>}a?nxAsi+gM6$?_o~(Nr{of>M=@cYP1D z3DbX%v#W03BlfMfpETMzM9>faj_D`lBH&-#si6ljq?pk~CyV6Fbu_$&ljQ*%}cHAb8|a|L70e% zURG7r*1Z_Oxw72Yoh(d@aF20_fS4oTd;vMDpm|R#AjG+7@@sKPSpCkG;GT?RvDzCgcc1 zRV$h|+8AJEs|-3cb^ey>cC;$JA8gF1&Dg9Ln>TKqZde6#B_}m@6D^gzP|oV)d+aY? z$R5eUb*YH>wt|j4z4_eYHaz`N4uTnz{gtbOHiF9ckHkzeqd7`!JL5VrvmlLM-kyv& z>*YIOQm(y!xYBP}`pVuO4In?(N(rN1U;5Q0=FM$s#12kZ#R&K;zWW*YIay^hk*^s; zl!zJT=32eH{pMEp$pGU0_OzDFV)I_-9#g~7wn4VCePR+RAGeamt3h@C8izIMgkk#l z%NpAQw7JH}zT;12vG`Hcn0`&EMMH*NK4OHuYWc=E-6K%${GTH+sd}3qmm{g%j>af| z*vwFY^~{p~ai_RB;3c;wAzZf6+{u2m?~T3jbMA@;`;!N)ZFFMw`@1hxVHF7d zx5MT(@^$L&8baVx?WE^nm_HRJ$)<7M2-VbxSO<~>hxr%?l_8=sY; z@bMzY+YG(Fm#rYbJpses-su=@j*3=zbnuQ4hmaCeYc7u~QzlIdaB8Ndq@`%m6iLHh zUl6c9V15sQ;8OXbqXTq=2*cNr9t z<2LgDa1p#YFLEhVIdt29)DHT_Of;M+W{n@N_5*6eR)R>Sa)@d??}urUax`wv}+1u&N}l;_v*NL;T5*;f=W(40s9NZ z!%5k;M30tM#;FE9ud~!IOxp1~Hff>X=h3Rh&DGG?QM_fLH0q0O2Pu=gTBBcY0TZ{dPRow|ZAw88@MG1s|M4yN2`u$EDKGcB(zXk}ji#Ei1admL}l|H{( zr(69mhO3n%tLtiLgdTL}d!v#rT2*U?v5sr-=kQ5KlJq&Q=L;TT5+LxnR9l>hdGcFv zQ&2=eJ^|&7en3=x2`fYUU zeCLc_^@Y*%n-gcu7LM4wHLf3jI?I}AwL9zMtGf!dCKMghyX?DgyWFqx>PFQ=m#IjOG+4I=q0YNlgNG&dR6IQ!tv{*;w@NUJ_3`9kme

i>Sixu`J~k0#6D1vbaX7A^AMIeO_Tg678)5ItJQ}h>Imt# zvPAx|0ef!RGaN@E>RsBB>w|(tB~=&Yb>fV@dL|@??s0KQIOV(@zRWPN-T>5t{PgJ< z^x8TL@@I2z-5iy-#@&{F2s&o}~zTpId^d^cOf` zY-LtN*!Ybq^W2)7uNPd za&pW-xsI&LdcLHBmj&d5Da9YIIOy_JZJNgxD06iAagfn3>G=4tvImpeMlJZ|D02I7 z57!Uy%XfaD0Ff~9IA+4drR|8TGfBJib-VV?Z!h=PexGndQc(u^6e-0v=bTr0WY0b@ z-dT67w%>UmpCS|j_%Go}%Fti8`2E&FGT+H&=y>f*bOE7H{7`;MHDY33^I;sV05}+h z1Z_R0+H)G)NHiIr9BG*3m&~XLn$70_4STN!0QCKk-Uj z92&>;G7#h8EgdkkVweu5bX8gj+Z}!QF2sAdw6YTVAd)Q28(Pb#RZ9RAm~hGQ!-;s6@gGdYpy5=ovTrww4yEr%!u; zK;UB|6@uNFnvkP4j>Y4IBiGZJC$c=+rZKHS-wUmJ&)|hGzTlN*EwrqX<7P2sZiTI*6T~w=Khv{2lXY@B^L$BY=uvedU$9kKdH`;3x}(RN4oBOiY%0# zf!=UviT?YBM zMocq|R9JP1Fv*HV@zwHmqW6nY#Sf&y38WLp`r|LB>Q8h8aM-~z)8Ila?6TA5({^s-1^QBEaSJ0^F>CLI24pT8re=vf?Vu#k9# z;@8Jqw{M@fP50tQ$wxhrmlt1|ej?&^iotI^+tH(JYIiy#^=7;)tE<1CkQ#fv-|@#m ztf?(f8$aj<|o^{#Kot9BQ*Yr+NW zHd)`rc0f3UT+D9i&R;*6wwi7v$CjWraqkCzW2MO_8Mzs!^x0M%%sVaECJHH{ZC{>` z7aOjL%@Al-inn&LFv!RNb9of^?5EOKBd(Q!IP_g>>+j+r<3+8YcJ6nDO|`fXV+f+G z($B8y;doNvX;MeQvR3?7lQD}IpNOitzl3Mnwbed|Ztz+YlW?Z)KK`VdCzYH=W~Kr` zHGUTNC@N|0yBV+R)dRe7o4L+(x-Pr*eY^V)=(%zX9pG`SN(4@~EHYGjGEn!=0;;Nr zx3|kf!y-Dj_H992jRwMuwjsmph;8>iL~zjH44lMXMLRrcvI6Hi+d?KnJf_)DDJhT| zOPES&vb`I}@{)6MV74Dqj*P#(a%VXEsq^-CqS&S+UjwOd63-^%qpWxlb0pYgJz;FN zX9)42?h~<(T-!T42R&U-PVc@aE8miP^%9+}G#Bg4mG`^gu-0e@)biv6JDi9mq9|LQ zcXIbfZW+i-o%~SpcEqe~UPX-cRSuh>6POXWGKa+#-Ly@o1eT7?m_ zgbmT5WO{)t!olg`yXm)pM7MG%8i8>Zf>=H=^e+3 z@%o($AdB2wYW&RL+eiHG<#t}TY(7W>U%~0B2+?kIr_}Wn#LSjYHWX@N`o#M+8W2~x zDxgP2aqd!1G&3{WLq!TM7~AvcL1=e4x9*~&cYSh7+`oc8?6+6Zk)oCrKU>pmvehmjJ8$7b`4K>S|`sAmXG&g~8od<)bNE%8Q5xY?- zl;M^;@ScP>n}P!!7Sbl8k^MMZau@Qas!6M?B?MW3y!s~2@u=LWee>q&xzYZURU{mX zCJj3Wr;hnvSThi-xJv{d9x~%yAI`mXx`QR%gSQ<-uZp%Z82t)v4Q$?%PW}3M*U%6m zoeYNf{s*V-jaVMJ)a|g9Vy6+ZmL*+jPy367?2VCP{eF88oxTxLNKVrfaPowh zz>kx2mZ;x4`)u7FZQVon>0G=etW+hxgJBc4`OU-yO7hHs05 z%{0wA$%BgbhQ@K+_K&Mfhc=%$m2GK{m>o|rSc-+SV0RP zCn2HCFhq019FzX9@$lYg0e4#zGA;q-cEg4i0n2WL?b(`1+XD{tpS>SC$0AvVDjYmm z7<-WnVcWwcYy-&?AvR4Zj9<@D5X8g;xqym8l3)q3A%qeQ1?9s$=7qPdn5Ev66{qIcW-Hk73Z;l8~5b6rr6#g&-kcy4owq~s*l zjG_5KVw&l3{U4#?cfx%%%x7}gPj_d0D@iG9BihD${ND3S~Q*97RM$ zIg51_l0+^!vg8t)KaXmv+wW-80I(y=NBC|pJc&X5x;NCu?^<2JMu=ztjvIv~Q6n<} z9WS?gl_XG(IntEetpZkUKt8;AYP48?)Zn&_dKmC9+|(9!-Ow(YKf}^m`d3JLe9a?m zw<5{nVYGJ?#aXm&hwUY(FjIQ_mG>Md>WP&FpY&makWluwFBx_3Xz{UzeEgW5fOZVwd|jb= z&1r?F%BB?vrXgXpuAzZajFJl#EO)}JnyS64hyL;uMCqB45>T8%_F?@L`JtaI!R&&D z@8alZ$H2lUiJ;@X?VT@cZl(+j800h9aBGbqPq(8`5zQLv-LgaA7|yF9)1^eD8^h@j ziJ(Ha$S}270Xw=8W>0YgCV-zI^lFUwk*|bYS5+XM_(4v6fOU~l0`HGP39V6cC33Un z63k*QgUKO=-AHXJDq7fuYx_F1d_y^soKNp{;y}{mNLh8-#NGWfAe1E^<7lZ$K|!&9 zHaxGCleVFoiHS>~f-WgW${0>m!}RLw?W|`>%;=xx&{ITuj^B4$zY;bWi?Hcu<}{Yd z99pO|kL9`?NiRJyHwR!!yPu>?{L}}gS9le%$fwjkBWFM+8weu0pj7sy(Xe`k8!NhlmhpPZxc06m;j8Sd4`R> z^6h7UAkP;FM>ru{M5?J5OWp&(H3~X1(c4dJEIrk#biBJgQH$1yjE0)3wbB6i%p8i< zZ_BAaZEtTE>&-bdCFQO({L@^&t1kH{%3qCH0b^D-OnD zq2PF~#;MBJVdA&kNylQvKS*b`%xKK(oxk;dHyB4~YRYh3VoNktrLVO-YVh_dTJq1e z5byiL|(V!sN|`3 zN_fK%q^{12ydag4_Q)+lOHlDkkI+hLSNA%!BB)^3HWF2dov7G$I zhp7%kZB#KA9~QkH&F|E{H({x_S(2R%Vwg*OH>o-~*_#aFy2h2NjJ%BiU}UXDM<(CK zbXCR3g^?aws8&3gw~wU@;rC9tNY?N=zaVOE_SR@(oDK%WPc%8Q(XuD=9brT*05s&R zd+(Ld}>E55S(6ePm?`$KeD%b)mdTFYBPRr5NkMj8z^M@UXjPjggC>cMbV4qL!9_l><{ zu%QC!Ny2P&l1h#u7A1XQe>^S$1Qp|Ra37qjW%^&j5{JFyI%^`57jL^7XO zH(7-pSDtT~4HvVIJmARM-?x=XO-Y`EKA(rGfgR$>XA(cThTA&XbN6V~)3k&-F9MV| zu@?VCyO<=y0z3rl3@!lrU=R~mc4U{;!iHykv-S^`gr1oD}pO*3Au7_BGPG#|0dJz zON2*|3(r`d#R0+VT9-YeS{mQ@3HAKxVp1NHfsSirpM}G?t-iHforW-03v^997Z?8H z4dWD^Paq%J=3GXx>*WRP;H87u>`;X#I8HOw!0dF^dNn5|CwnTnqysL+Gx$C~k%SA1 zEnhKZjFpUTIJ#bL3mO z^VQX9fm|W^L|(SQxT3bU$cG~JpfXdA=ANFrPFp{u$Jr^3?GTSQnRa`fAG_X$sh47a z&JI7&M=@3YI!Zcnf=@LD^Ud<Itx$ca+VXjz* z^1=98!L-ZwS}*K+?~_ZY#k{BRt)_v*H**+gkANq#|8fXQJ50O?QON>9(sB@4HFCZc zL&u%rm<>(M$_@WOR%9UQ$C+iQF#IYXKWc zhs%iW?~LOwu9#h3ECFOq;m&DG)yUeT(`$2mP$byDcZ{3#N*g38xJp3+z>laDsghn{ z7Z(V>4iyrAsQ87uF4lWw%;#W~AF?=_H~#%~#rjMMrU{G_d3QIKce{j;wp0MKxQ zy93C)4}RhCgRf-!(OiAaP@W9Kb%kdnOU1YnxZs z)n)(e#~@Z|crEqAKznm>{;k&y$Y1YzunD!0kBTCB=y?yMQwH2VQKTn#B~B@DzD%?J zH4L48mo?vs_2>)AkN`k6&4$~56uOuLJ0Szu+2DTI9XO?MRCf+z*0NT)nTcb+V1a75 zyHh~?C6X@yp3HuHCVU`&Nk-0R4G_vLPNNAD$Bi*!kn;3FNm{EOArf$OHij<%>rbD0`C~#<1Ynw1+={TlE=A` zx0i6WK3j%9URPpD570wNY0qHpxXlc=#NC|vYD(spHi49Nr*Ag1T}x~GGNi9CErNDjN(+07Ljf3^Ojq=MDDI4+Mr?Zrta_ytkT%B?rUgj;&8 zpKW5|+hH~L%IE~x_}JM8*88f7me%cb7mI#cfW!{r-ti*c@w)KsaqAhrNtvnv2`qOf zZ}tYSGcir4^?=v+h`XRy1GZf&I$kxNVt1 zA^wWnah`}x$N$^tCfc>y9@J;rC6HvB$42ZFlX*t_)djSyU&7Im_jDK1{e!Pq)hTNn z;Az{X?1(*F*cq?Rd5_o=!puzOu$Bm;RcVkW98o5VoT>i8GM4tbKbRC| zVYJ`m!-qmHB4*P#^Wb6Da$hxuzfm7W+Cz(C8zVe=dSx^NlmsvH5@iPGbyL1&So=dSjy7?&6Q2&8(BCW^N~DVI)B3>3kB&_y7=s) zvKex%%ANM=!6tF_V9%taB>$f*WBQxr34PEN-eTP64QZOTc6`vJYTFIwN=u%kao_R; zbcZz#zDWh(^;v6S=F*nQka?iBzDAV_Fwo}-I!&G@cWO_l!n&VSQh!2h77kI%LN6^F z$*_}L984j-fMwT6XPa|q*JI%Bc}H*tAIrHu{*S=r1NNoWI)aKjj@(Ei<<)?9!uZt) zYQ6QQXX{90IFYdni-`B(?Zir>>*3T39VqMyuf6k)RsbVi$Kz`F=?)~2W!xII5#Gyz zet)YNbR@Veb;`A|2LjKn9 zYk&3DA9b!aAb0jE@{w%4396(p)_7sRs%s4ZhS3Ny9;N#u&qIq~J{-FBypz$OO8s^G zZDTk%m;;+hzFq5%MZUbL6#}ShIa;dei5S0vfS^$8;K$kYYO|qK|GiiBo|sqI6mgOt z?tfJ)Xs_p68F+PtLq(;(FACOlly#(c9=BWI)T+Pc=%elacb_}+;Qoh}*7*;dXFn|$ zYAi{hgF?p7J{qO)UCkc=wU$f8eP|r*Zfs4W`1N(KjsI^3gNthue`)6qZ|ew|D3+&b zaN1%=yK_zs-7_W{ucHANtD;uXe$l|-7eEncMfXcOyzW5Hhntdv*@;T%@+!#)T3n88 zTd^xCu>*QdGA#&@7Wm<6PvjN0tc|xCL-Cz%sHxN+#8oMEgss9GBH)L4=-TFzf0o>2 z7QC~IVPT=A?auskgA3%vix=@(>J_giDX_5cV~q5e`L~$KO|VRTd?2e^ZcrhNk40$kdx)Q{ututJ6X~R_ zLDgbl=JdyggY-Pat@Hefl!-|{;I5WP5Qwj=j-fnj9Hd^l?CtGapWj?LUiKlcHa?5f zqo&q)6Y3g3E}a$rfS!JN_~%xRuELDtrQ@?WqwuFy>^t8J(5LUHXE7?(qdM=1GCtQ8 zak&0`U@QZQF&LcImdPhalDT-6koDTy+JzsuZYGulESgU~c>iaH@S*S0s_bs)Qh?c~ z2XbUwY{l3JGEr2Lj2vj;MqcgP-G^~AK10~Uh*USoj!o|{{#f?BQT zg=Vl1X`>o3$E$bR2*-yesbQWMhc7etwj71DYdr}g$@$-Y?s#GJ%7ud^U;Zu;2;D%E z8#UKZn+{xPM%LNanDuy)?MV-WovCu(sR00RzRY{sI+V$PfbjCGs?n6X@jR@}Juw8~ zk#A^grS{5U50jQIIJw1(c9Vz7pLzk7l0v1oTUT$m7umv3mT@`xg9g{0bDrLJprMny zs=;acd`h>@7Oo{NitX_XTp!L(<3XB64r!rHRZ`vc4f;X8s{sAuWtO!Vt z6n8%Dq5FzQjQCUmv=H65W`To2Flg+AfXh0Zh{-$iy>hsW9W=6(MKl)0PBXLbYX@MA4ygNI&R;sN0%*;e8p-o1_JOgk> zKoRMj^O|H~k$qRp_&$AyQYeQJUShIAuEeX=#u=D|k5BTbR9 zv#a!=5)}C4T$~mA*6dpIg|c!?{Cgw!Oi~1SY3H=TM$|P02HdkZ#(fsypgAMj?7=QF=pw{$oX62W?#jgsO;NETOj3k>{ z8MnM=q0MO3H=xb>G*cEQyv)rt>WrBPTrg#P}?l*;0BGRYB;4 zt(T+EM`F`m1!!>BIc;d zBJ!37-yqHrP5(GQM0S?NVa)4Iq#?(9g6>pmQ+>}E2Z*k5K7^j3sSg%o-cXx=Q|X06 zU64FZselSaI9pl-wSNFyD#W=Uq7tCV;y<4e-soC~Uxv#LREj>SIwFHfb|0JITCa63_hcKC$>fs-pa zBilTw3!o~DxMNZ^2sLi*L|GSyD!Hy*d2+D zga70Rj7XI~aNIy!Y|AhQXJ?5clkE{7Hu32(w*ASqSRSuO?uRR+M+XlrRPeozW}Qkc zpV77}<7xu;7`y`yMs3^!1vj*xz0byIQLC1T7`3tpUXStGM|1CAj#^yTIMPQ^hz7H$ z6#>q{PIz`MrTu6#uo4`6atnK_#^$Mq31g4KBE#Eu8(Irn0c}JnUcYJwloS`UHI9yT zJ{os(IlstJ6z8>649T?uc*2K5^?-m7*bVt)e>HN3oId^mK>0s%Tg!j$xokY9Moba$ z7?`QlPIv)0ky4iV`_Uv7Byc{qmRS$%_-WNbbt?GojN!3Y&0z0=;iynOdNa5$As#zd zJC_2cQ=zjD1+_cwy7b*QB-CT8a{(cY%2UVko72wQEme?f*5!mUXbx{U3N{s2MR-)0 z`1qV;p9r~vJl>ZG@?S_zuI?rdZb;~K`SU``zH*_8_>p8kOjDu^nLz359%GJb);LvQ zFgG|~Bbt19GZc1wnC>$%g$FyiSc-&Eg}bh-Jgf9`C* zR+UnjHP1D#1v?P7K4}CMC}-#GEl%dRiE4rEDJ$28#)#WvU!$5ev(TsN&awyzf~xJd z_+kqs?l_}Yo{p3_^=8TLPz8!TR%{zPUj#4%s4IgsQL|ty-&~!EmdMs-TH3YGqCzus z4?U*v`echUpiYRq6%avortjLYF9QT3YA3Qzo~>tei$8vv&)U*+cCs^all#nRr;}~9 z@~~~%6n(_KP{%Y{t?klJI(0m9vyAW%ap4lP()2xBwNrS1KcIW+c9tFTIlu3c!>@aj zy$qtazMl^Q_XuaD68=rKrQyHR`QDg?fvf@EcK3rF9MK$^h01Kc@*x(b&?Rgh)N`et zJwsDoyeT%$%O-<+n`BJAC1Y1@uVINreZ$U+!^W$X0GZc2|E|F40;6p>vtR3pyt@o} z_&i+PmAp`cQH9YrcQz@N_?}4LK30#n_gHGy`ocPbx>GU(COE*-V&63NbOOL?fr}4H zi~vZaev6V~AfE_dm0Q?deNg@39>V#`w>P+wa%WDfeQw*RlZmI;xXYEc;voOt8}D#E zSo+d(b`ACHXGW0blBc}oD^ICuc=TZhb+SQsPY42Val&tLG5NO;*k3hg-!Em(M_14udFYm~KC zkEjIBQ+xPWFO)}(st3M@L<3-m294{Q@{)+r_p|_9b+(Vya5ghLyRWoY*oTK@bS~RW z4yekV)kBhUl@P(k&#=OG8o*G;~me(ajy5Qm4xPFUv(DT1xC{vn?1N- zu_9x5&#J#MYDaTv?n3g&F}xH8d)!rF_q1 zVW;jS8R;5&aJ0RVqgoKAF*T6d)Xw{mCz(mt3yabbkOCnw@$t720OT%0bS)HOF2`OG zGaX`ORahK~+H&T8Vgw&H!}yR}wgJjtaps0tf|F(ZRwGyr{6F7By=h7DLW!&t^jsks z8EDhdNr~q<(!wBrhzOY3?$KtT>_gp@8a6;FN37SW@K!ZqFmC!-GYA2Ps!(_3S++-2 z)VqP?fy}PxglSOYW7R6f0oh9Xji-a1Vj_Vn`!X$LR&)DEd&rL9QOQQ^2zPFu8_s@% z>;IT|T75B4u>w*N1sSYPfDb>mh>2ZUA=sYtz?rRc)_dKgw~JA3HbSYuBOBms@7PX_ zzQ)OcZwvO@j8F3}=SSi>v9yw{N!(KGwh#=x*TROE1lqOklz?&I1OEi-i>v(?h(PC6 zZ}WyBA>fh%?c%p^IQ*ee??sNx!LiK4sI8sEWxC3XK_y1j)5GMxXTeJ*o5+pW;Ni&a zHc-@*$fm(@;0OGtVYAGvT;3))F3n|i^5 z082p#3;EL#gBroqONdaGepRF&;J(jY5wI%^=%kzuV;mXB;2J4UK|2w^Jmm<*{#>*C zdc4ptQwCBk>|eE`$Buy1+>GcoR3@V~)96J!z%I|IopW!bMlR<4`@m!x4^Rs7$U4<5 zAOa2`(9TeLX}963J7I(z=I#Aq($lwU@il_#_{(Y4exRtK-!NY1v=h3BvCB==ZpnT$ zo{Da_xuVhD-jSi_3z3ev1R0Swk5}6LVFQAXIMIMo_5F*XaGCpb!12 zO9Bb2@d9*8J6AX#V55=P&}Ayso9S2Alt9z;&0$q5HmgW_e%BYa$IZ?+$1D&TepByu zr1z+aicz&ZH1w!|cQSa!=aPd>qwkL zV6rB6eb}_~m93C8(yhWK}%p@|dFq-0nMo3s_uLC0W5t$Yrvk z$NRebG_!fPA>{L$e)i=LF+cOhGJWQ)9~?cyvf&84UDVo_O04f-+wDPI0kYj%7xQqX zHk40*8QxrYT+cxKS5lT0S3xR;FZVD&QI6-q#RLYsB2e>!EHm{c_Dyi#_sB@4Qx?*~ z*U>GmgQJp+FjoK#g17)C#|P6X2?ht z>m`%}u!H*7YvVS4vS&gz(tzY+dwJ~kqwv-2c4NEVI>*IkMWTQU4DYLo ziBBVd`njww4XoI;Yr{l6utD3z9oZdG!0WIs=UrRM>{2K`NY#7V^$8m?xWe1M;dZ{x z#dnP#K@}md2_z;WNQ4x_IKic+<)+ktv=KDwH!DT(XrKQ>c zr67t{Y??yYTk}VjU?3-m6IGDGDh8%~lAt{#hBHViip&4UM4a<8}`Dfbz&_4+Rh z5Y9c27^(hfRmHV8G?LXY!GCMH4s&pHeAG+SAAf~$7kAEUh(y?>gnGPCu2+`5W^FLl zaPsiwy8#ydkm&0W!!G$LO=%Nw@*-*1I>yylWn)?GpOwy+cx?%>#zUTuE$MzD+ED)X zRXsmGujd%zaYkt{x6*<$G{iMg7v0Zfe>UgUr(3M90tfpYa04>Je89eo7c-Qfg50kr zX4h>P@O+&3p}*L&2g!1}oGjcsnf^IwV>hfz45PUTjm3Unf89 z`br@iFVO!PJ$}Zg)yC_njUvF}>9_v(<~)&w2@L4mGlMrg+JTvQDN4ZAUEKM}^!5BB zuz@|F;rTboZ??IurMNE=NkhX8Q*jYK6T;esvegP^?+XN}yOxUyz(8DgStB{ z?Cf;>P|Y5pF**}_x_0-e?tZFY{l#I1YC+%bC(<(Smb{OaSll!j8JQ)}d7QFK1m8EY zP2NpesVdg9jR64D{8Z2(;3(OcE=!7e3<_zQ2xpg#?qhfpe6bF6Q#Z8et~2IkS(ELE8h_jRkY102x3*psQkHwDgkLo4%1sXy(l-dm*Z>~%fOyD@V+^>zw!eYh?=UYpg)DqK| zZ>2_E;YCwHVmz;NmDh?FQwxTXyU!`6O05_kC?s3QIL(7%b?63MwZcy13|&EZkBEYTQvP}}sm3cb)V%&qG%=S~^{Yfx z_e5g~0aucM5bva~ACX$aNrj=)81A z+1s(dIcnj_Yg>)c5nJAr2k6?4n^U^OQ(+vsjjd_vhOC>uxV_ZRVV!9-hI4x>*6iS< z0+lW82r76SCja||qXbJVa(*kxL2t=}OQ(1Y_u;H+_VXPM3^ML9+90Xt_@tykSg)?= z&UK-fp`XEBZDAMa@b-NLhNtdhIF@}{=M2)3skH7w#asir^%Q4*t-7 z2zyH&%tdd5$eCCR-vq4ND2lm0=q|=2+tb0TWhnxjqqV`1&C$H|hDLJ-PEehW@HpG! zIjeAtUS#HI|D49){Fo2wo zezRJQLpRejHQM-724GQxi2E4sN-~x|%UFxz#_zEM^t35mh<1s|7m`8K|ZQmbr@!CmF-!F0E+!gFJ>X)>!782%@MM^w8Uk$?utRdJ;tiWj*ukifmx(UGMvX z66jP29rD0G6~Z_oW|i)Dm$N(X=9-M7zklDLJsbafmY2(QokLYm#Uj`dw!7E#_1^T+ z%RxbGcv*@*zpriY*~`I@(p^roJWHx3IJqjb-Fd8JcrWU|Xm-I&_53P{d=3SB-yo8tXk zXX6mt*rA`42div+)^kyX4R_M*!r2AfHk0yeEqhKWJrpzLSv*CIC}5bAXWnb-%777o z#-e8P_=+9+{i~!+k|={$8?%H6HnphuykBaDciF)C{O~BMS9hhQtfwau7NwwHNveY6 zXxfK!!=7)l$aZso$wN4!nB?9t%Q>ai zh+jD60xkk!p-uyPFE50Tp1S-TWYNRM&uC4fC_*D6JMzYh>^6o8HL~OCg>!%KTlw0F zQtj^MsFzS2{_MX6Fu*5IpNa#ps_<3Q8!eYzvZT}dP_#(u4S=42;>>c>-D8x7T#whe zZt{jMg$T<+1DZ2`Kz(LbWe%yYaiCLUr~VAiw9_4}nQFHi=<$Pj84{l;BFvldv zJqYO23X=#z0=HHoa$vgvf()&Y(4FX1k&ehj7XUKE-0xCx?n`Cmcur$8H^cZcg9MEj z%@@StBBCNV)YQ>A>m;B(i2{5~M*|A>+jo`$Op|=wsZm&1j5_tGVZ>|^*B3{vfFliB zjYA{Cq`_@eH?7%Q{JSK!n4i*RPN(}e1S*SJA@fL}hQx_RjNzM@$RZ*-8}s&U=z6@m zh{q)bHkDZG=vLL+_xF=bjbfhcLdvjXsc#x%Xa3w6`}S(E(hLKpOJl!woPm_Kp4nF` zg51%0=Y^F4M6FNcAVYjS6~8zoowW zU6)5{O@ZcphBE5FiSog3?J4O?sa7#rsbdJ`Wc8Swe~1;(L=euP-{uLkg*Sx!E;jPt zb(c_Ua0RpaIDpvwzk1Yf`qV+k>!V$W=-<8i-<>g5F@+!rQ}wGt?EGC6f+p}r=LB@T z|35TGSR}0PM=%`$;hTS;*I=sEH==;`D71c7xj}rs~!>3@Z)v8KL*+% z|3K$ylIZ9p_SW}|eZJ;DM05Vt(+64uf0cRpMRY`}JCfA!nI=%6`3Eu_mf<3oJ&0yp zuH<^ZYJc1YL-8M01>7?i|G8? z_i9hq7GL_&Sz=C_=ik~uyF=Bk5?jgGq0ti0+IjFJrA{oPSkeFg8kbsAHPXEn-wpE5 zc8)=vlbGK((w;x{X9s-36C>TTC5+iQroy`Hxej2H=gz_?uw6cyg@GlWi8pxVi( z-4aR;ax}sIPrI1$`IBHt;7m7AR6+;F7#lIxgE{a}sJX;|M}R2*c7a-o?B3QpytjC; z+dYHUG#5jJ_q8DrpM|r362HU!mlBa}xMa^GS4=oM8OoY$(e%&bAdf+6J+)$y3^loL z+P78ykng!(Q(#a3A9<~RZ{t7jCEc5dgT5DY*la-)PUl*liW-?%wXcLFUp%OF`_wHQ zAx`tr);5hYqT4GH!Con?->cUG$0jMC$cex1Bmdml=*KRE@f4e# z_F#bNbEBIz-51BA_qXai#Fw|R2K|~g3E|vJcoVmt^1~!s6Rfy5dUgJD$JW5}|1Hmk zS`%X@TSAD?17)Bppsc^s7x27)AOl;@(^g5E=8j?w_~j+Uk3tO#+69ypXsWk)x7Xy| zpg4Bfe000}XyinVK;H-ckvYl9dJ{Zu!iO8-sV zXxf1ECLM|F}_S?SB|bzaNKJ7wdUR8-dBvhd6$t+T#KQzR}g2vQa~0G z{cSE*6>j~{T>J+tP?F?rkMK=mm3(FFHE-I`vrQ(!<98Us{>)y@;cW#MsMRh>_g{bI zU?C&McJ<~ZkNUDjYkxtq{w{V!ET9jH`$4kagXZ9y_qvdRU+2JiCf~u5b>^P%ORHO5 zFP!A=KK_=6!pDlBN&K5v`$g;QFIz@kPnNXkMU02|wct$sqIO}-%5tm(M-RgT7G_5d zSI4V6yUC5^PYyWf21cjbEV`+E#|ARiaDl#FHN(#nx^`>$q*>w$!~e(ES4LIUZf$S6 zVbk5Mv~+D66eI*G2`NFk8#Y~10s_(@se*Jj(jC&>-E5j~ao+ge=bY!9ACAFTLs)Cg zdCzOswdNE6H`s;el*Z3Pk)J%AMlu9RIYsR0$A5{(jdkwFtSx1bd6sCp@v3Br!=1xV zjvk?J3hVYBS$$e7)@Gei^~j;dRcAt9?9gL|411?dF6*@VBn2aN_Jj9n>3oL)fM`_Gf!ZioN>h&~`q!-!&C@%XrI5F6z4fHz>XrefPZS7j(k zj1L#pgs^{>ByqYYe~SJ}-s}*mJICBMI z&_33)W-#(wmJYCovkg{;}XbhU84b;;6i>|n{D3@7T{O$ax1 z{9KVx>;Bg46J8j#ME9`IA2?-~^c+N`pWj~e24hoPe-D1bhz#>*mDd3-bOsv1G*Ne zM&RmeS%7DzW89~Wqt=re3p@idNzCnGxAY`0^vH1b4_3{Yo+_YMnjik;-6C}{_)qB5E5MHM2%vwDlYF)R z?we>!U_ybwXZHitH@O`$7dRl->xi}@Z~XWJ=icxzkz=hC4iK4_yr8BXPCk+nGF=FxHQW95^!1lOeOsu7m?NAkwjYyC+U{yjEZ!v|Yj#rX z`7-<)1BkmD!@GydetmFs-p)Nb_GS%YuEx+>H(Lb$BB!?E6v zqIewpQkGXHE7%p5z3)h(2~&XA+J1(o4Dd^ut@ihg40%waH^@6Uv_QOvLjLOv-(*B( zPw$-+8f!6%R#aY}_l5jnN7?_R8Q26Bng(2cS2wXP3iI|pFoBE#P>2*Uargu=?DOe4 zGN2a;Ao8IX8#AXg`tOhhsNMbl!I(gV7~GxU3l}>lIZ)u$)~w3t?wrDQBN){b*tYh@ zK#WTVG$AP5!C1(wM~)rj(`-DjHSxPqa=#Y}ZZPM5Bje5L{1eCzWs6g+iJN?|0bmJ0 zCabL?L8@`h+!5J}nCg6-5!pK~jJ}U*G1p%O8@v0xmkd<2=UhxQ&Lensu4#Mwy`iS& z;HUJ0MP1&6Vi^$zkzRmE5IAh_=J5KytoMU}RfTv%`taHLN5`R_2B*!m4&SpO@3-%o zPlZ7&N!ZTHF!0^QRYB9|yF2L1qDafSXL@d|xYddCe%+B_-}&eOn!c zoC?a~H31XEQ!(szkV$HYCa63Ep((j8=L0w6HjPS+KIfH|PUQ1slJGS1vgLdt*JccUHWq9}h%ejwv%SU{0%~ zT=SgSa*}e4YAq}6hQv8kAj|dQ9hZR{bt5s88_k~_$Y&EYP=p9}h-23aFjJL7R^Gex z#O`ddO6=Xq$KbLnJT>Y+_ENZ=VqKE_7KztB>o3dMGXx%St&i+R4j<4OB~_-2x_Nv; z>K@@yogQV02JYo)6ZXsxA$>+S(il#U!HLT|ZYv;6m?S1cHaYpn7>BU*`)7y_y;M^h z2@a~!wUiP2*P8?1tQL_=r>^yL9ov1vED3^+iOYYGhxMQCT55RPfA3$;S`c`RNg;f4*91k4&5_*;%|QC-kmE|PL%EQYZBjMozW{j*+r zzF367Br$8VU@Kd!cIXqoCynRg9yrhSyq1GGQIh{yt_OL*&vOc=@cxAHIE5@`E*n=; z>4nVF9R-6}mzTj;e2MvH>du2(N$3ujWwQ@K$oGQ#61C}XLdJ*h;3PEymgcH=nCmEW zHk;razS|m166d*uSZuzCjcLZHYH3D3XkNPi0glDWh$d8pW-%At@m0}`4y@dAS7^YL9>f`zYzUo~WVam0P^)P~HFESil5wQywDFRj zuNE++C(60p(#nEV=RJILvw5J;vaz-p@36;qdPKtF&%%UuY!V1r{~&o_LUro9G~Az1 zHWprhO3Kp64D4&+wyZ0b20($+z@319C?7Ach0lI)f#{&i%)%_TKE=O>D3ts z!%otV-Xp?AmNk3D>fqq8N5wI$I17`GXP)w+ysMA{FCcQCElTX$9L*r@dVd{S#YO-- z?Y*Nq@b3xl468rUVPSqqt&IlWs1tJ9Fx3XJ3PLLi)4$`+`5+36Pe%a#KAr8 zOE2xIJ05!&)p-c==TA z-mN%L*RQ<`@1JFtu9Qlc#dUyjpfJZ=Y6m_y^~tAm9p#CEH&n)b1qSS(G!VZp949#m zxj{0G8_Zn;-FAFgB)}raAvX~6s11sJ=a zS>w{|x{R^RuouGV{+|Z1#)i7=jzZh=Qm5DuG-EBJ+4LL6WtcE8lCT|#X zHk%JG?n~1iYOjTMQ3O3Ob8J0k`uivnUStH+Htj*8!$fdoC)hb}AJf|%ROgSu>n4Yn zb`7{lHjmifUgLBK4crs+PW$oPVWq0C|0*-SN~IYr3W2^=7YYA*%jvmm5^MGvTVbv} zXj4J^l<(D2^6p%-B}lN0f+xT)wgy%GMOgo?%2vQsk?3KEwpv(9rXkZ!fK4&0n|m65 z1h~P1Rj@sBB!ljN8~e1)DQofar^>hvw=r(eNztM}t3%k=GqP982fRlr+l66l=w%p7 zINGY(+}3dC%#K-uPR+2?$|DUH=GX>8F-el7fNfdooYO(lWni5AIW9}k%bhTtN`f?n z-N!B=Y_%7eA!X}4&fPUv^JxrL5l1O{t>I>2I>*?8p9N_S6mJLp4mbAnli=(}zhp#Z zBBU8GEL_7|GEs~=03;$r7*Fkg*-GXo;IR+_nfGe1H3bfCfaSrhcolsw$#w;iq&Jyq zhi&leGdN|ju^;3#VP{7~gi$L&bSzBsF~u=ND3zJVfz?oyvHZ{#3P2EK))J%-AwWxi zTATasHFzt5W}4Eo3o?J-?GVJ| zkracd8g50pUqBx>EjS5ph_ADBzzSb3nSFYm5Y;psFQEa4~E%$8zUD zwbW-RE_<4CH9C-{a#1U(?vW1T?+;M+=u!_H$zdRg0!2*J<%n>CHam4h${jS;#fdt3 z#f2>4q1#s{wQN0Z!~A1`b(pRzqh{gIJ?`Z93<2oL3V_LtxZD*6Oy~m+QrrZ&hZ2)+ zF}N^d=Wpx&6wUc;eo|@lN(%I^c#Os-vQ`gLvs)&>g+GvJsCiJhoeb!A73b?wDp97~ zpHIS{U=JhPTmoDllhfLiB;kPZQZShr;SZT!z>%>~*p+tupkqGHqyyP?Xj zx1g-Fb1>kb=*MVm$2&MISdYwqSn_q%FDLW}|q&+&MWxVdta#AJc z%>92FNV_#bvSEZ3nPHKPNg(_=2`0CmMlK{2w6NKF`E{ZGE!EX5`l@(fI7=Qv5ZXuE{*x-gLU(hb$Y68p z=ze+55J&VGC-v!K5&JmNkt0lX8zEkyexpWTsx(pLI9n4@$8+?YRH=C(@_KscZAo4} z!K}^F*D4lc+8u7}RqScpM&QG|xJDBMhl`XvI(;5_u$nNe z?olMkt11NvmDX|&qYI%KqDYT0`#`CXN)_Uie9LL^3(o9{oWG#Q$mI92fMkZc|4ec} zXHe+vu!cHv{M%pQr7n$}X@MzRwGKtBAw%?kvS(Vzz8Egz_?6-t2Y7bBI@aY|C4$OK zgfu=XX*?dYxi=-&8k%np9|T&S5p(Gc1r}Aq!^^TEo)m#=4w2)N{6YQ${`~`JLzi0^ zyg8euI<|ZwEj4Hllevp0VmTkg52n?oP~jv;+9^YFJ{7uKF)6*3#UiWz>F3>JEi=r7 zAp`HnVDd{J6wAA2cVL(~jr0hTsJg~j1!c9i8HAL>3E&=yS+G5qxK156Dz>n%C57F= zFNE7{TDP3A+Rnv(h(3P@8qs)*sQ$KW!_7clT5~ijm=-c@hU?HE4$hBdFWBO%D%7jb z;@CFx4I}%+nd3Nf5C&b>g0&GQr?-{=U{$rdPbpMM^3?b;vhIy>uyVomRu6?4FHpTp zIw27*{?C~h1WqDZE|E~T>4LmrnOaaH{)`<+2#~j0e}9-FZWDD3%|0f0wv=vyuR3XM z2=}{3R#l1d5g}U8#7`eIGCuWfrO)9>iH-Gra-X~h7F3lyV{0jaWXBawLRqd_G@Y}- z694Xdw}v|UMdlHW<%*Z>9B}qZ_7VyeTiWNLa6$iN&AH&dix)8J4X*p_;JQaC#qINV zJ|fsp(RUj)xiXu7?U`y$dE=3M`29Sf z8io?X+q3?s-%*-mEWBTP-8lg5w;|6V(hs}EV2tCS59=?k@iC`94-lf!x!n>8qeU$N z`7to~vX>LM?Yy+31Q+yAwgl9QECh7k-L7m)GN zq0XX(%tZlA&{@5h-xpae^dZ)nN{)#!eV}be?-Sf)=8_2@VfiK_QkjEW{3CppSHtCY zhNZN9IUI+4xaD`bBZoI_hjpbQ^|%|u0>0SOka!OlzRyEFq5sz9pl%Z6VYeRJKO*6& zeNsY2g>j6h_xP9nXx-V;IJ%-%1A##dlsC5opb0A7n3N?0Sbg(z_n#5l7_=b!2$JJ3 zmtPqXqF$;aOxITRFi|tBNsKvwbC@6mzas0RM$@O!r60Hpw%(G9(_w?q@yA-j8J91F z`?(GDk#Yld7Z=FP-YAtWhJpTTqHiyUd5+9>&EPQ?vt%dD6?X%m55Zbm zUWB04^;ZhQ*uloD2)o(A`@f=)OIqjAkmp}|!BwTvOb1^-Eo($EiU z|F~}ayul>@R4NBiDoqu2kr6-{7ktN9S9>_3-l%N*Cl@UDMdpa_ik=J4T=1PonkEkGLTmGD>^d%max^aIFV3Dqf0oY%H=-JTGc0Zzz{IVZhZy z7ShA+DCOMlX(M2d$;FD{mnVS|s76vwBqf>5yYIkBm}o~vQp7gF6hKUGe_dKskJ*)j zF@!-9HDV}=__BcZuz|3j#$t>jKd%4VE1MBYJrv+vU;Ol#3=u#zPLWLbgBuW}0Te>o z7{8?)&D0XuJFu<~K_J;8E5Z$RD|fyU1<0uLZD|@nQi%^dbL03b(|G;LzQHjvrQqkz zCL&ojLD?U#t1a$#^ublTaz8@xBWNra@N?wQ{FTg*0J;0E+(|xx_sW=2{n2QwW`kTy{%n%#-R(6(o6)@t;xk}Pa?5Y&6bu$wKtafeMS?Iqv!yK(6ntH zN+4C|yZMkykq@Z^u2`To`JyBE@#5BFbb7=d2WZvlen4wA4FW9IfBrsy7rvdbI+`mH zg@5$}i!hEuYQ`Z(ds?Klo2QnQ6BeUS_*0*`XtC4; z#87~O*SgJh1T!q=(?+JVfzZ(j%jf7>pVozSNmT=yvxgbu;zmuF`f^Da4L@4nj*7&r z*PGUxW5PHFbtb}VF~vCA#iB$qw|o0#E3ss1JfR=NVX1xSS=Uyi>ubGuaG&WSRs6m8 z7h=tZst zcV5@AewoHc0Sp-hx!bTiw6w_`+4dF_#tn7QguUW2r@jOkNs*<9u87hG@zuYmV}V-b z4|4l!kW#flY7NUVVu#5=n@!z6z@5C(clXc3ZcYRmQD89@!wTK>v%~JOl&K7LC?DTY zsoc7brN&&OR~AP~?>F^_<0%J``O^`}36$u?9P0dpg~tiXvbjf9z>u^Geg|HUZePQJ zmH~>lH(7{cXm;`)7*P%J_OoZ0_qjfoo*?Ez*=t`r5z(xJm-2rb@X=t(pUVRqZ?S~&Pl;fVH^G+Joe32ky$_hwc4?lg%Q;n=g;A?5#R1+A>zz^#uD@pq$ zlAnBT2NZ(x`;51T4nsJO>{z-M5Y%{da*z$dOyAnNOd{e3s168(!;zlhbtOT;O^Y`<~_)hdo|?ZEV8lD+$bu?1l-N zkA%OG5ZZ+P@by`VG}IQyS^go!cyk2|h8LvCU!32&FE@$EBUv%df_+A8#G3kghv#1BgJTKrt1FnVt$YYN#7G zUvFa^lOINaE7`$R_kd_V(w!3ntL~nG!rr-sdTzZ++Cmt$`?ca?xvg>#^lc9{=QKji zP0GuH{hSyF|I5}>9kVV~J7#57a_)wXn;_7Zwz&T(3A}?#$t5?c^+wF^TdkJ^{Vx37 zN#-pHR0S(T{|Je30`8b$zLgrJL^#C;!N^Gkqo{kl#+sPZl5i76xw*^bzfC&<>MXmq z=i3hsze-Kl#7zz#-~%kC`jb7Huo+>uiLxRi$GU_{U#4ioUOT?iOdg|3lfhp6{Ng*d zn&K(j&#pZV9`puAfHv_JZ>)K|2YpXN_2>@nX6>C(59Grdho-WxAk7UKz3mi=C$U%R zQ{JJFQX3@T52IDDFVv^rru>jBVEEifj|UO0$n;I59Le`j`bnb`Qt=fODQO$a1Pq-P+}@_C<;Da?nNbo#zF0c9}yQ4;*cZ`-RmfaNFsXJqAFAG!78plIkGuf*RT z?}PzX^rz#!g*muVrHb8>UTD2P|Cse-SrAi}n7vyto1_e5G1$*u-Q8q{kmOYV2#wg8 z%uppBx5{csexOmHHx(R_MdC|N&|w!?R8P<~_Ix=?7nR@y%vg0X?a)n*rD}6Ea#$N{ z58;iU#G69?y!rUjEAq^G&6`>+x&>$1qmZAig6)C;@Rq<|8&upy9Zm18x=yF3z-aDj z)1II`f{gD7;Q?5Lj|75~$PlCMT2)lFc^K<@`JB28{FGH!8P&eu;JJV~h1nZQ8hJkh z3h`X^)2XlBOcA&a9Ow#?Ykdq^x|c#{`Hp5OlAMP^L~k|eUW2m4%KdAtxoBs$z#ye( zTj2r>I_j-xforo!pp6N6xNOvvK||eg`cEltaubbHVzd3KP}i7yNt~^pjyL#z3Ya!S z0$94buCf#JQ(}F0HWuGxN4^QI=k~xKg;aQDK`Q1BYk{P+9s!Dn0`kDYm-F}!wb1jO z0veD4zOz2fMLuUXh1_O2t_)*V?>JPt>iYRMC$&FUJ({WXrqq5LmF?zoXbl=>008;0 z*ozk2xXXLdlILNzQVHj6W{;^Yer-bsvf^&vzS3vw!kRZQoWybxzlNos)vL^kh5-Gw zE6{o_QHS%rD9xvk!jBj+fjP5*Loht&;L2`opchq{>K3Ogot<`CsAcmfcjopv(5^&R zCRNc8x7-|$#cD*mak_2&8VPpW#xX*_&hSk^FrCS5@}I*0V6`FGDOOK*gMk8f3}&pB zy8a$-o#+YFDI~p|Uwr!-Xxkviv`Z5z8J_@z3QLnvG!T~xdgnHa*puS!lY3@y1k_Zlo!pJ}x+QEwZBX@k~(0gzKA!;_z zFeETJ@-N$_LsUC)(G_)1N{JlVvZ)j@ZFCN*^_;Ld%DLP_$rh;^*VMJfJK-^1vXiS zd%=bb(U@I3YPq{Ls1yxG#ye~-6ctOYmV+xj7c@2URm}zPTkJgYZ(;0A_ISP zyAKDTVlTT`P5_I@b3{=YBHp~9c{O-k%Xz;uAF{Cl=Z<|sI2GQHp0jEb;FUv^z6T$G zRXEjz^Kr_kQv#p%S%u6DY7$Hw^@9VKn0y|!8+UzD1v%-Z1<)( zFZc{vKqjL?$GeuOt8Zv5=g8A~?&I7+Txp9)25UZYrf&Z}H3k;NZh|T$=8$;yigYhT z8NSkoC!KgIPT~x=ek(z@pneDpT)FYk@bwf}P4p(L%pxr{1a%a+M z6FztOR2PC2V^BuJ=Y%|8H=*50!+N=84SiLfwRpw4?o;5gzJ5ls7?c9(N&4m$I4(wy z2Cf>Y!~pGbQU!S4J^~fpZmo|TqnQxU#n2JLY$zwmS#Lah_#7;78e@vvvbWIc?MO3Ut!Kn+rCPkKyLrWZ}3so?ymF9(+DH|@sCju!ap~Q$on=mEPh~s zfDQi2f??cn(C><{mx8r=@{KvcOBy%^IUP34*w2fm%ypP%8Ob{?q$f*FPUg z?}MeeGzo66I?JOcnnK0-NX4ZU;6c2Doyy7VE(@DtcpJK0%SMj)Bjw7J6! zak?F7LEP3HrCM0O5GAhKJv??l80M6Q3fX)4rW8l0-B0=`SHzF|Jt%Qp>2BTLeqP-Z zWt5$=DEc7)PzOFV7&0zTHeP&6oToObU3bT}bbH*-H0!e+Sub&{4b1{R!2Y*!slh!h zCTI-NhPX#F=5m`!gX6Kq53wGotI5CBzZ^eqb+w+TgJhouUN28Z>3ckMXuOR)t+5L^ zJm;A5bjP=RJRj8QAU`iOI0;g*iOpHK6#xUAL}fcoseqZj4_n$^qHlC~rJdOPC=E?s-Xstvmyj}|k{@Lg70 z^Tf{i8?&S}Ft@=7=J&PkBW9$ABh*XiZ(~a+DM#$5bfo{*u@Vdwf&Y=es85J!<{0n5 zC*OT38ZnhQn1!jH%;2@kzUQWx$C$+zV)1cEFr;90wV|Hz8%yc}qx4P8wFF)+lO^Lj z4*m}pp!D|p^$rqs^Rk!cPj?L;Abu-0j`8A2G?e`<&y&~T zlwVAzaR-yzjX+^Z86DXp0u$Z{q4~b`hg^b zd3wde!m(NQ!d$VH{Nk|R>!n~Lqyy*){#}>QdCweMVwWS?-_3`ZAN{b81beU$fXCrJ++mzbO4( z79@U8M^+i6_NioO?yXj~PTG4 zQ6u>)bgD@0e!*m9|AA4Wox%i=Y=oO_NZA#g1LZ**U!k{2h|1Jdb|P>_FNWB;J|jzb zP}TcDvrd10?S#4m?4Jp54@fbjZajB*AG2eF9*{qkCDfC<5N5ZXy<39d<4H0ER3)?8 zkP}wyrqk#`qX;{eRD}zqViAGjd}Gd`Q%bR->hw0mQ{at z?;Pqy33Zl8UHY&7V<%3FvxflwBhIJ%vvNyDp&=@SB~MIE-=x>f;*4La;z(e759WLZ z4~TKHCPpg#mY$%)Hn38WUy%8wo_iB=%KdjBM4`o;8V>1fde7D?fBhYwhFX*u=<8#@ zusijn1nQEKRU6NNe3s!)hn1DubuVSCGb#4<@=UBV8K!cMy>_6MmUIP7tMCtJaM}Fz zn3~~}0Pb#tEgx?XPunVJfZSm+$@=S>mX8Y>vmpK*0HvP>aSU!Ev6%U z9CnDsNyl;UB%%Qevk#M3a-~6*nMRC=N@wozD{rBpl`yQ>%M3(^E|5K45xJxs2?s^M z=CQ7Y>reFUH+K^4dwhityGu_#`#M$#>_)LV!Pjf`7U+UvP2QNT`*XG!HERMmqI%ND z&=WEk=sm&?#QYyi$FqVDdzMt~u93UCydGxwx9~&S$625*c}@yXFv}>{)sRJlg<`^_t0pT3z#YRqE3ad+Md(buvn(#laaFTiKslpe8sh^HnWZ z@o^;(wrjihHJ*=l$j~|a_@As~UPfq#sf$QW|G+}*6O#HEeZj;X+Vo(#83=P z-Rv_YXf}xeDBw;~1|-X%8mIc>N3?$b{=U|i3h>&?Sh}3LEep6QOi&=tbA8VtO--ty)z|3({^Tp(dWrH+f+)xjJqGG^3B6kJE z!#S?kx^mk02|nfa)0KRPqpyL+^?;jMvUZLW*JNDirn|Ys>8bR#e}0aADND$2g(W$z31(Ss z-J9I3Bgyi52aZQIvP2F#Vf7OwgD=7Z_qTq3*7p6o5!-XWqGQa+FApx_abVV?;nw9` zDk2ajouvI^87OP&Ej-Fw<9#DIiLnqV8Iowo)_D?F5E4illLwF z?R8py#NLRe9*Xk%RheQ+bK@0qX>riuzU{L0GLKmO{*uKnmvq&Kjo;dFI40qoLrhyZ z;)_`qzJ{%!wkb^s=m(s0^F}>ks&-D!#`;;W1(4p($^{w8X$=4V1`Nk@5%8~=TQGV( z@yfERobipaHeV>&CysXQb?r|r+;0g1=Z~3WG!)y|N4ItVk}{zM;uCtviR~MT^p6G# z+tq(HP}+b73f0YHn-^%z)!$-V8ox3M%Lc$Ov;Z%ENhQJBN3yJ^Lh!z>P-t~o_CJ2S zC;baqhrDk~1B~#L;t~!tfq@#ilqv3?LnNH@5hgKJndvRlqhVF&-o;F~z$OU&r(eEM zVR}7h;lRK4aKvvOv#}*+Ilwla76Jc#qk$#~{DJ#!RLuWy^Hi>6bxCv(4=hvb>BepI z7@uXe8;Fx{hoez%)AsL4BRFPmU%dYXGY1~(NX0zpld}0=3%%`%kB|{Kg*l|0*Ep|7 z`1vb$j08jLh%JCd6N$gS{`0N>xz+>;L?%}aX)$t&py1cUgyJ(fJwt_)*nBuc-!uqg zOZK8IN40{%J3Y?e8fC^eL8M0+y`adLmk*I_?Kk&3k@llIn15}{UhO=F3V}X0NL21* zqs?}O@QYz?alznUbHS+Txqew~Q2h5b;OR%+BLM5Ztd&1^bVaP#wOc4734#EYnZeTw zBRO%(5E&g9yg!79(Cs^w!^~Og0ipY~EoK73Xn~~TatNnO{53YktPO~jrfgN6K#!|YjEwH$@KW#i$UqsIN2B$g$N48TRdQH4LhmW+;6I8{RYxICfAl$Q_Z>MP*Y zJY`F9Dn2QSj(KPXFA+R2WSRAB_A3R{+#dkdV`|5B+#;3&x8 zEvY3TZNQUiZ0;3<6igpzaaO&K=UuJjhd|P`vfZg`r4KdW-qAcKkf|tmQK*c z?KtU5&N%5`+0H#<)c${uX2h)jfRq0<_kTHQbf(JJw12DW!g~PEb_kzt`yb$pP6ZnD z_n2b%P2wL$&16ANK6}oU*0Go=8HmNwvGhww7MuKeNK1H@5TkWm+=HIkjtl4a@lAuQ zgTAZ#;aP*V(iZWH{RI^13i+&W-w><#CJ%)#E=^I7C1Wx<&RW}~M{6D>2#5$Ia!1`u zLu3EgjB~s9aGAOug|Dw`Xe1;F?IiKTq~5o*Dww^AOtnXtt^63Mn8eX)y4o~`M;37O zU^TDgtc1y=oB|9;PNjo9mP3V4kcM_RC9_>p`APUbh@K;h^}SN``P06b+4k1xFpeK) zn5_4lx|j!Mn1yN&imiL}F4=?@;;xbaaQv+d49;I0p1B9-KecC9C>}_}r$1@-<$;4G zUixM270)~OdpjSF4W8b@o;P>(uE|Rm_PEWu^|Y!FH^E1*aXAjS&%4~}9XEbo4tud( zr#b#%KGIgq6Aq+#fAo$5XOwSO;60eibDb3=QM%}JvYv~B{DU)k?bp?z7q{!YOzPUO z_%+M3XMG5NN};HYUMqis-HZpOPe6XtwTM4-uhTPiquCB?&!`v*zQKbMeUABGy?O-# z0n1*wO>7|U?mpoc68uNtq$_F{WClKD-T4)q=7b7^SUN6wV^fwcI4 z?dM;p+wGePIB*iP^BCtepB1>wZlY9K5)w`F@?Z7#`nWTBcvgLI@Ud_EoRUc_Tc@<|J?6*Aov1XPS?@+Z{LC1nVr?r7&m37441twb@J$<_vAi)$j#8B)*JHcK!$GU;j?|K|=qj)xfczQ5H z&s%H-6+0AA>?`uFUeAGbbgeaFL@Dp^PC8r}6VR#nWp!`UBHQMx^hxBAG26Dv^ znlPO#*gt%Gxf!tK!Q9pY&G*VKFUQM-)<^!};zNWULCgt=41UWiF5y@+GpIU-WA870 z0v3blQUb2F6oBR@hRqWr^q)Corh74iSVn;{_j^7nJ9==Na*vZqKFPI6jM% zLwFVO>9gAv4L0?xT?KRrOWmA?yX@-YzFP+#Ax zldYo`2{xj&O`$V(&U)&WM{LWVvvShFO_V`&xI-D@!B|#W^v{IJ)|i!$ zL3*q`-J8Op8n0eGlZ(m#fqGgTN#F6`o4L$4QZIzZcmJ|e;oxb2wfad)`+meMxxX}XZuesa|#1*uyR4i*B8uX zK69EHT5p9Y$>qa3>CO)X!20#B(t3Jq8qWwz2#Ji{4mtEbCOFe`@M8npuaQ6r2?_5P zW+$t+)>gT9LRgiD5hSKc7Dnw_L7m;qS>-wKsr>iBXXe9#lLEY6h`QC*NTBK36HWpH z_FqE74ixn+d;U~Sp7hx-@wc6Y3H0g$Y~BfEPkg#R`Syks8HY0D-1Ptq=qF|O**c|A zz(Rvt>wB*D8*#hwe0F3kGI)@ny*)&k0uu5=+-FqeJ7oJy+-#oBSUz9 zu+QyWHXHWLZ>Rwl`K{Jf>geTi<**pAMg{HKG)E zKf-FL#}Pke@SH?q|M8Xo?8Ev7W&0kdnAIqc<+*#M#pLW8Ii@c>A8AIcDl(igD_OuI+HESs2XvI=Fq>PACMesRRFlG)wfVWvNCd`Fh8 zF{$~G4Sgj+=X8=iTYwr(R-!#dke6 z-;zP@k0D8!MP9>;uHlgK&{Rmrh9WT=Kv$q?-LI<=ZsdqB7?4<8k#^r3)Kb%b`%!2y zN7kypTo>Q2{rsyywxX63UfQRv;f9IHIz=tT1z>!a(MdW?d-u-^hf|HllU+qY?`^-q z6At|sC(9iwG#nh*QD6DCG}#_+Uff;ZmV*4Qf|wG0cYAxbgCZl9xxPjwg5D=_EO5Ep zM1lOq#@?g}yTJ1S9~9P4PQLA#sn1j6BCY-SheA>HYBDLKg2HaLl9kH$?&G(Dni^J! z^R)fI*9H(UAd6U}CjQ+K%D`+8YHY(kpxqlewsPfNb{q)WbMc^leF)@=DhT+qZ9 z=E^1u!gC-)CF>s>6&XT4eM}%0qHu>{pU19c+8KTqxfse&*pf$oQCIUlN|xcHKgiFd zJ9-)sgpZf9{7B_NaqvQTb}v&5XQ@;>ddc_tvtXU-hnmAHm~;%Fo372Pp3yZ`VA+se z^8*iup)G1ewe=*rdVcC-nA*?c-(k49pT)d`UN4~GGp~)SBpR<7?%71k%Xcr2c4tL_*25Lt!o*Fb?KcdV`9bQb~d z6@>r#VM$8?@r=19%6(tM{GG0dteG{uDaAFP%YS03tN|5!F&%<(IEJ z+C>ii<-WJ&DH3N*@+1D1izW^A5436dwshOtk+^Iq>mkJdP(=l`)3!pJHT`he+WuRS zZ9^qp*gw}Jl)Z)g9GODg85D{`X`fof)7^(PS+E3ZIP=*JfCI%=iPs?l^RoT*DPt-G>~c6p2t4&K*33VRLK(gfNc~rtVoqf5YOFf}?ZJUw z4u}U{M(B&5R z?4ud*M5zc+>2mqiBP=U1+XjzMiPL2^7>m#?2(UvgEF!vVO{FPpNPj?)up%_3Yv|w| zyRdH6%g|Aa&dKN3?suPW*$tmT?;b?Fk59C~;j$#6&Vu4M$2KJA$ZS4G>?{PYfN6hr zAitE9XQGc2^fI%q)=Lp{M4bK#3^JOT4`B3QF0#QxmSCyy68(WTthY8l&FUP_h}hYO za`&dtPX^*~a%;Ei^M=NUTLL1Z)48p$ES`W@5IS@nCvCOvh*bRSxx>;zO>SXN!ajJ@%Y+8?WZo6B%2$%N*Qyz6iwrX+#>EtLm;ri$6%jLI76f z{TU=b*&xo$sxQWq%3hPmrq`{uj1n;PLThlfK><1M%wnlPU_711+{SChqq*iP`!nen zpzZWY;*k2h=?&t*O>M!R++q87*l`08C9bV@47ej zvu!JrtwIn*#BH$i#c(s`XYHVO#2oD%IE#DbkAQtis|qBhJ}ml~Q8!!ZC<_};Sg>7B zA%Oh$jp)n7%%6{%JIYB(;VY%_PM+RwW%>lUSZM}sc>wFlR!*2RrGeN9_$J?FR_R+l z9||Z<%nO-Q9G0+AH}PGIh{|J?6g3!rUet@Dddu3Ofx`V{;SoR|#Njjdt(HfC^)olX zEcm`_AeGzdQuOH%v#J-E)O~qgp22T3YkWOrxEurVMX=+c{psN(3TuB3tcMEKX6W*h z3_O|Rgurp3EO}k-Vzu6Ne-?N+i!d{6>Fi_x{-2@&3Me<%#QtEHRrK<>MNLNstxO?O zBHH}nHeckvgj!^OFy+I~FLNB0?&=_@zsoG&N%%q!KwZZyKe$m8Zi?FH1( z?JrEl|2~21he$(7M4qb66v$Yl*#50|NIpjy`XiHd=a)x=!E)c>K+c2vA&50Ym|o|e zVu`-ThM&$#fh>2)=d5nSyLhtM)+{eiyWE}1_A56WuzS5FD)(FAHd$YvA}EO3Ji|x=-qUk?ISN}d!c|@#@H#%V{3?F+j%q3dIner-?h8PDPD#Me7==e z{9C}#7rk}gmRz;QoER9be^SN>e0zC&x!<1OGNt27%{3xI%!G#UgCfJwyM6)>*gz;& zCt~ye*m~=*D7&a{bV%uxPHAb7?i55qxA_RV^)jG)ct{w%D|EySP2ZrZDZ=5QIf_W-yeye8kXjXb;XUoXIX zRvi%CIXU$T88+=;F7w#q?~G?fP>`_ri#TqiZtwP)kNw1Kv|loIq`CgJw6>GcaKT-q zSS3a&b&Yg^a}XJc;&XQ=!!r^ZM=>U;_}v^NmfrYF)~&jHE^Vbnu-dYlbTpHjEZetz z#{A3S5H32#cfirGiDa_)-d}~iv-A@t6-^EU4vxZP?RLWySCn)E$-48qk&x-HtXR6^ zzxBhDm5i?%bE(M|#>l`+$gezCcmu0+Q1%+=@Vih%X1b@O6e8;B`i z@W0~C|4KWuRmu5&_k58_hH)R#0(zeb7Y4_rgAPbve@=HVB^DBgRhS4 zZaC;gf4wrIJU_?y;(xq^MYzytmbkr(p>dphc}*7o=?B(445(yQW&FM%i6&M4HR&>V z{P?!BqlHkl395gQ40I*c^@ezhvnJ+$P<1|)E}Et~`6k}x^l)=DaGGGU%)1xx_?CdB zJJJgUl{mR>xWk1~dpcLL*L9(ZckcLcvOO5^S3n$TIa`Ph*w0I^rH^nHikX)TdloVI zTd0~9$%n(+*V)SIx={e>6M1G#GzDKNY5DQAHDLI2yF%b5gLmI)YZC$EKY~W>gn^hl zD7ivs^SmJH9YYd6{qdD`2%qmTY4ls0A82Q1$N&gaiVx(&b=I#$Dqn!sN?mn~+34U-wvO5z8xP;xBjkD`EB5A1gl1atU)=BiuVn>F`t&{xA+-^; z?*(^7i>=$Fo$x4;_`z4k{5+Q3+Bz8zQVp$i->nRrRGtOG1$T!>Mmo{Z(gttx z_4Nv6iN60U z)BN8s^9}`j5z>F9-`L!R#xFGXsfRw)50}?OvI^F*WeA#&mBDafz--}-ZD_m65QDa! z-bdWQa|c=|4v_H&{|?4Se%L-Py!>qi4i^It*Yo2)e-8R#yGX^#3WE}Y1FB}RsEhGd zsIvZM)v^<}mQ$fib%bOA11FKcxYYe*#?q>lDcb?ayL>Z#)1D|Bq1H;I# zOzd~8liIB5@mE|iX^fHYFG&I@G=1Ylo`{p-?3Zd6&g)z$?-v^+wvH{e77xSUVvv6L z5l#FG!<~hLzJJ}5oPaH3@Yi&a!__dJ9sqw8WqVIfW178+tElOuDBz6f<;0;MBx|&A z1;5Q)&i`>Cx4Gd7>Z|Wz25o;oJMonp zZGN6{PBdqmPpElZ7f|>>4$tG*q}K`ZFY|vuHuQx=jIEkvV1BXG|7}SD6r+yv=1BCL zxqo*>%ylOdE2~7h0KxPCcy1j4aQr5L+&KXVEKw@AmPqZFD!VzY?UGxw2c&)MuDRJGs!pLoS@-(x zLbP%Pm2~j^hN<%>luX5_-E1$?B1LX^$z_%oSNKV#_|LA7rJ;erzk%0JDk>9oMg07I zcNZ46$=fN($*DJEn|#IUj6QA4BG@7H@~z#Eo}P)wRp4u!>!Sr*{*;NYCA|VaSZh-W zz1`F5o@7VLGfIEiE}6W7)bg`ozny6Jj2f8DP|?tV&7XwNeHXCxS?!xCrzKaTc;`Jl z6X>0a-b^zxN%=|%!T0RmrV(&$8YjeG2ACkLn@ncmvLBrYuqVTQiH8h_!&7X=n+!cd zxpHfFv&|lSU5y~HmW?L!uaBSw8uWkk5nNz?QH6ga2DB`YUB!xkiq&V0hBiE#trMR7 zDcTFZ4$0}Jt>0enNW9}&ajg3KY|hrB zTQ3_QjNj0xL}#=2%N0GX`oxql+am>_kqe+@RKI5yFm;jGWz|302lDUh6I-O=QLt@| z0^%|-&>=dV@5`YiJlRFavUS7BTC-!~A?K}Pn$YY9@e%-;nSY1JEs-~OOfg_;2TrcT z1;l2y@>N(@Xy>Y7U79~k3@=!%j(pnWTkhOr{f4*0(`dV5tXf%Gi&LbO4G*ffo5nv{ zY-qCf+`s&y)x5_lpT!C1SW}r&IQQ&8jWJ09IF2LW=0vJhS!|U$IF?4cWO|H;f{>hJ zY;ul4QTr%FG_dFj}zrEsDER0+>YSp>)Gp9<_o1$NV7?_l%~O72lDsKnah)h zi}^Dl%NZ+>7#Q+|y<+JNA1D?c5_R0wu4~^58pEZL?6^kKiw#};g~?d}_zo@iCj9dVTT zV()IV6iH$+CT(o|Dw>EF8vtky=AK~GZCN;h3F1N0?k_kdGq@xD4_Do%Gnf?{d?%@imc@nJhe<*uwqr1 zycM`R1M-u}}aRGa?3x-t~L`gf$}Ks2AQ+6hPQ z`AGD5e}Va~WQLI4fxS@i!5_F>UL?}W9`5$l67Rz0M;tMoy`1n%Min)91nJU%ppG?b zdp*3R*#qlAIqa{CsKpFHRFpZFg_p!r-aNXyPbNc!hc;u$3tM-qm~)4RpI_A_Dx4pl zWH<|h2Cbitcnw2~@m9g(Owq4DCnZz;FcPcVA^4q=&)0fVf0jeIM<bBQL0$#^i98*7iRs1&^3v$z<;L1z2>O-kp}+DdVWjagRy3=XTil^l-CrS(0eEx&hnQ z*SGPDpKYTqX(T>9Ju0fzFuG<=@${FD`ps2J_GaF(Fz{Yr3ChlhFhc{zOL6%1(C9h&Jx*5m z+YF>pXgsW}?nCC=iRNNNV=m3dfKg~4H4S`m(|MmT5*I!m6WoYdSy5|M@a$^E=Nj{T zIo-r8a~x|vz@o?wD9ZA~$Y$0FNTgSye92E_G8iKRhQw;exu2|tP-ysT+FE-;9%)`W zwedJvW3~+LgR9pO3XC>|w*?KDP#O_klsu6^+E2R*+vS}}JWr6ar3=$&YIg(!QjUeEFHH*P1XEoTQ@&GnU^pDnd! zbDT#`f&$7a$-~OnG1!E8Npzv}TV9kA7mr6x4b7#CHbr?1#=TVsdOuzfkDT2@4f=4Q zo){b)HO>3`HQ!k?XKk0O$xA*RF;Z=%66EgbRqoUZDMxazJnSOfLn zrOk|$2Gw2Gy_p4Nb+`M`H;1b&aQT(317>a1VUX@;C!Gx=xKglw;fBq zal|(No_eS%oj+^bUl>EezH!c!IdXlx5d8Qkl;Ya-Sc6^G`GlewLlgz1tIIc4VKg^4 z$4gb+HfKUv8#iU(ep~ltI8gIdV;j5kjxE*;i3$yq@nikHsRrvYWdHBra;9XKZt6H; z1aYjK=>x~ByR$da%6;vaYrSJltLsk8Z7ZSfYo54D!WX12I%HGn+=Csni=FP{b__`< zF8hZ%$Oqp6IJCy8Uj=}7@PJ)XwM&hC*}%Aqf^vQ~U|l7v7^%FJ7jiLKsGw_Fe-hwE zCa?hj$S&ISY-|Lm1U`GtBr6>03b$ZrN3=|KY78*Uq>mVl(67^Y(y?N-=aR&Nina3I z0VenEuEpt2rQUW9L%+=+T%$sFa|kMQP-~^EjJ@M~Yalil$EN|EWh;l28EQSzOLE$a zmO)KpkK&j$pwb$>HvZ4mLBmG~PW44^o9x1sWCLccq&>BX-0areAfCS{*Kg1dCV+k! zkl0Bl+;5g~x9(}sN4o7w!Qw|Pm}TcN^!WHy`wV);?kZ)A1oGEW^p7qbOVnN9iO7j} ztv$P5e{x^#`uK7>W0oh+@>yvJ`GrU-YWi$wpk%1PV7(P!3~W}~vGZ1rGiZ8jcxLA- zr*eazIXuoQbJ?b0fcQKdC~E6CX~$2xI)y#kE8lp&j*cFf%#3_;com*!Vk{J!@z$*cz9Wd62gHJSa!Zg$pn3mLmKi#8sR zFZ7O^QrFEQN4n zm55>NK+JUJlJ=IY)ZN()e1qp!y~aH|XK%C(G$Ji5L_@zctp@T`keNu9s$0>})4yQj z9k=!d89m)+b9l(ApMoJN*~?iML2;{tqEOPV)Uqn+D14U8ks~(}4D$Ifpyapt?fr>~ z5#+Mhs`xWwblb64-+;gX4xThNiJxwmH0sX#<7cQjY7C^frfSwB*}Bj!sDU3jkiJXi zzm9?73#!2z5$!(K7X)UrDS-6AMNpAuiaH8^BwqRSUxxzBkyO9c_hzRv;sJ8?uHm70 z-}meN&F79EHv<+UDZh;xq4&y_wC*Js2dxb z@tKJ+6kx*`Nq>sIz9H3&lP`G;0!`ds7)w_*mzk^lGKQ<<3sEd|r6!NjipKC?WqI$s zjPCSe4#gyi_-eJ8kj6sy*ka41!D^^ueQlV#n6)itca)&2yX9uPHBZi;pz6I0)=2Qg z+jg-PLe9yoy>ARpJ~+f!I$2hbIxb;ohj3S_KW_wwhE76qo^5wS*clfM5k--YyrZ#{ z9_!xjmvp)9-Qc>eI)7|_&=Q0N8%G>hDNGms3V$mv^+p++b3E(JGn=>q|IM2>?7E{< zKx4iS|D%6}ivXF*)D%$WkLr1Z1x6#@H9Sp?ldjM!(Bayp36O)ZOv0t}Un{)RQ~Mb7 z_}Dd2h70t(1Oq|ubNroNAHN?gXVA`$o!??s@G8x=;k?dRv7`KAwk9K zsElRO&(A}wrs8yt&NhjFF9V)3XVNmk^BPU=t(?!QuY?3_y_Yb67{2HHk>$yAd%_

Ex& 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

  • 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 z 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 literal 0 HcmV?d00001 diff --git a/assets/github-social-template.svg b/assets/github-social-template.svg new file mode 100644 index 0000000..0105301 --- /dev/null +++ b/assets/github-social-template.svg @@ -0,0 +1,78 @@ + + native audio GitHub social preview + + + + + + + + + + + + + + + + + + + + + + + + + + + GitHub social preview - Cap-go/capacitor-native-audio - @capgo/capacitor-native-audio + + + + Add native audio in one line + for Capacitor apps + + + + A native plugin for native audio engine + + + + + + + + + + + + + + + + + Capgo + + + $ + + npm i @capgo/capacitor-native-audio + + + + + + + iOS + + + + + + Android + + + + + + Web + + diff --git a/bun.lock b/bun.lock new file mode 100644 index 0000000..749c1d2 --- /dev/null +++ b/bun.lock @@ -0,0 +1,837 @@ +{ + "lockfileVersion": 2, + "configVersion": 1, + "workspaces": { + "": { + "name": "@capgo/capacitor-native-map", + "dependencies": { + "@googlemaps/js-api-loader": "^2.0.2", + "@googlemaps/markerclusterer": "^2.6.2", + "@types/google.maps": "^3.58.1", + }, + "devDependencies": { + "@capacitor/android": "^8.0.0", + "@capacitor/cli": "^8.0.0", + "@capacitor/core": "^8.0.0", + "@capacitor/docgen": "^0.3.1", + "@capacitor/ios": "^8.0.0", + "@ionic/eslint-config": "^0.4.0", + "@ionic/prettier-config": "^4.0.0", + "@ionic/swiftlint-config": "^2.0.0", + "@types/node": "^24.10.1", + "@types/resize-observer-browser": "^0.1.11", + "eslint": "^8.57.1", + "eslint-plugin-import": "^2.31.0", + "prettier": "^3.6.2", + "prettier-plugin-java": "^2.7.7", + "prettier-pretty-check": "^0.2.0", + "rimraf": "^6.1.0", + "rollup": "^4.53.2", + "swiftlint": "^2.0.0", + "typescript": "^5.9.3", + }, + "peerDependencies": { + "@capacitor/core": ">=8.0.0", + }, + }, + }, + "packages": { + "@babel/code-frame": ["@babel/code-frame@7.29.7", "", { "dependencies": { "@babel/helper-validator-identifier": "^7.29.7", "js-tokens": "^4.0.0", "picocolors": "^1.1.1" } }, "sha512-Aup7aUOfpbAUg2ROOJN6Iw5f9DMBlzu0mIkm/malLQFN/YQgO48wCj0Kxa3sEHJvPVFg7siR+qRInwXd2qhQKw=="], + + "@babel/helper-validator-identifier": ["@babel/helper-validator-identifier@7.29.7", "", {}, "sha512-qehxGkRj55h/ff8EMaJ+cYhyaKlHIxqYDn682wQD7RNp9UujOQsHog2uS0r2vzr4pW+sXf90NeeayjcNaX3fFg=="], + + "@capacitor/android": ["@capacitor/android@8.5.2", "", { "peerDependencies": { "@capacitor/core": "^8.5.0" } }, "sha512-rtiaz78egCcS+vs29wkWCL3C+RhazKMSygXcjutwWP8NmO6r5UBxOvGf3Wjz5+ahobyQ723tn9gCePwRwcNDZQ=="], + + "@capacitor/cli": ["@capacitor/cli@8.5.2", "", { "dependencies": { "@ionic/cli-framework-output": "^2.2.8", "@ionic/utils-subprocess": "^3.0.1", "@ionic/utils-terminal": "^2.3.5", "commander": "^12.1.0", "debug": "^4.4.0", "env-paths": "^2.2.0", "fs-extra": "^11.2.0", "kleur": "^4.1.5", "native-run": "^2.0.3", "open": "^8.4.0", "plist": "^3.1.0", "prompts": "^2.4.2", "rimraf": "^6.0.1", "semver": "^7.6.3", "tar": "^7.5.3", "tslib": "^2.8.1", "xcode": "^3.0.1", "xml2js": "^0.6.2" }, "bin": { "cap": "bin/capacitor", "capacitor": "bin/capacitor" } }, "sha512-O2kpA5ZPJUAmliDCcmpMf8xnJwMezxlFPUrlyOAjbL3U9MFNY3l4ZpPI/UXwvyPmR8ETcVF9pFr+VdWq61rqTQ=="], + + "@capacitor/core": ["@capacitor/core@8.5.2", "", { "dependencies": { "tslib": "^2.1.0" } }, "sha512-agnQbGdhGw/KZFuLf7H9SY2o+oE7upkr/WPQsYaokXP6f9chaE8iVmbKkfN6SVl4w3pmz7oZ3Ur1hbkmy1hx+w=="], + + "@capacitor/docgen": ["@capacitor/docgen@0.3.1", "", { "dependencies": { "colorette": "^2.0.20", "github-slugger": "^1.5.0", "minimist": "^1.2.8", "typescript": "~4.2.4" }, "bin": { "docgen": "bin/docgen" } }, "sha512-WBdAUquQC4hiZOVk1YbY5Rs3vlDrNdCGt3KGnMa2dc2UBa91Q7PQ/jLW/oZyfVIfiXWu7t1KUhhM3MyiZepUrQ=="], + + "@capacitor/ios": ["@capacitor/ios@8.5.2", "", { "peerDependencies": { "@capacitor/core": "^8.5.0" } }, "sha512-eOT2S67AfTFG7KN0T3oxwAajrJz4rSye+ODfvChiwrk0F/+kWufFM1qU6cDjGJUOfwdAoeuEpZyWHSwZlu4GFg=="], + + "@eslint-community/eslint-utils": ["@eslint-community/eslint-utils@4.10.1", "", { "dependencies": { "eslint-visitor-keys": "^3.4.3" }, "peerDependencies": { "eslint": "^6.0.0 || ^7.0.0 || >=8.0.0" } }, "sha512-cuadcxVFE8sDK6iWJbs8Sn0av2Nrh2QSGQhVlBW9AaAHqHwjWsZHT8LJ4hFGPh7ASBV2deFdM7H/DPjulmh8rg=="], + + "@eslint-community/regexpp": ["@eslint-community/regexpp@4.12.2", "", {}, "sha512-EriSTlt5OC9/7SXkRSCAhfSxxoSUgBm33OH+IkwbdpgoqsSsUg7y3uh+IICI/Qg4BBWr3U2i39RpmycbxMq4ew=="], + + "@eslint/eslintrc": ["@eslint/eslintrc@2.1.4", "", { "dependencies": { "ajv": "^6.12.4", "debug": "^4.3.2", "espree": "^9.6.0", "globals": "^13.19.0", "ignore": "^5.2.0", "import-fresh": "^3.2.1", "js-yaml": "^4.1.0", "minimatch": "^3.1.2", "strip-json-comments": "^3.1.1" } }, "sha512-269Z39MS6wVJtsoUl10L60WdkhJVdPG24Q4eZTH3nnF6lpvSShEK3wQjDX9JRWAUPvPh7COouPpU9IrqaZFvtQ=="], + + "@eslint/js": ["@eslint/js@8.57.1", "", {}, "sha512-d9zaMRSTIKDLhctzH12MtXvJKSSUhaHcjV+2Z+GK+EEY7XKpP5yR4x+N3TAcHTcu963nIr+TMcCb4DBCYX1z6Q=="], + + "@googlemaps/js-api-loader": ["@googlemaps/js-api-loader@2.1.3", "", { "dependencies": { "@types/google.maps": "^3.65.3" } }, "sha512-1t6umwRufEGzIPjHPjPeuuY1dCal0zU2bZeomkf4OA0MprFdlKCnXY3zeFkzDaCvKjwbFubeapm61P5+EbrAoA=="], + + "@googlemaps/markerclusterer": ["@googlemaps/markerclusterer@2.6.2", "", { "dependencies": { "@types/supercluster": "^7.1.3", "fast-equals": "^5.2.2", "supercluster": "^8.0.1" } }, "sha512-U6uVhq8iWhiIckA89sgRu8OK35mjd6/3CuoZKWakKEf0QmRRWpatlsPb3kqXkoWSmbcZkopRiI4dnW6DQSd7bQ=="], + + "@humanwhocodes/config-array": ["@humanwhocodes/config-array@0.13.0", "", { "dependencies": { "@humanwhocodes/object-schema": "^2.0.3", "debug": "^4.3.1", "minimatch": "^3.0.5" } }, "sha512-DZLEEqFWQFiyK6h5YIeynKx7JlvCYWL0cImfSRXZ9l4Sg2efkFGTuFf6vzXjK1cq6IYkU+Eg/JizXw+TD2vRNw=="], + + "@humanwhocodes/module-importer": ["@humanwhocodes/module-importer@1.0.1", "", {}, "sha512-bxveV4V8v5Yb4ncFTT3rPSgZBOpCkjfK0y4oVVVJwIuDVBRMDXrPyXRL988i5ap9m9bnyEEjWfm5WkBmtffLfA=="], + + "@humanwhocodes/object-schema": ["@humanwhocodes/object-schema@2.0.3", "", {}, "sha512-93zYdMES/c1D69yZiKDBj0V24vqNzB/koF26KPaagAfd3P/4gUlh3Dys5ogAK+Exi9QyzlD8x/08Zt7wIKcDcA=="], + + "@ionic/cli-framework-output": ["@ionic/cli-framework-output@2.2.8", "", { "dependencies": { "@ionic/utils-terminal": "2.3.5", "debug": "^4.0.0", "tslib": "^2.0.1" } }, "sha512-TshtaFQsovB4NWRBydbNFawql6yul7d5bMiW1WYYf17hd99V6xdDdk3vtF51bw6sLkxON3bDQpWsnUc9/hVo3g=="], + + "@ionic/eslint-config": ["@ionic/eslint-config@0.4.0", "", { "dependencies": { "@typescript-eslint/eslint-plugin": "^5.58.0", "@typescript-eslint/parser": "^5.58.0", "eslint-config-prettier": "^8.8.0", "eslint-plugin-import": "^2.27.0" }, "peerDependencies": { "eslint": ">=7" } }, "sha512-L8OXY29D3iGqNtteFj0iz3eoZIVgokBiVjCO8WMssNZa4GTHjYsase0rC9ASXGefMnLJu6rbNl3Gbx7NNxJRZQ=="], + + "@ionic/prettier-config": ["@ionic/prettier-config@4.0.0", "", { "peerDependencies": { "prettier": "^2.4.0 || ^3.0.0" } }, "sha512-0DqL6CggVdgeJAWOLPUT73rF1VD5p0tVlCpC5GXz5vTIUBxNwsJ5085Q7wXjKiE5Odx3aOHGTcuRWCawFsLFag=="], + + "@ionic/swiftlint-config": ["@ionic/swiftlint-config@2.0.0", "", {}, "sha512-TXy76ALSKhUZzBziHz7aoEtSQwHofBIDRNzM9x4sndtC7fefbZsBw3UgGwXFTOc7hoj72EAGyqZNUhj9LlhaNQ=="], + + "@ionic/utils-array": ["@ionic/utils-array@2.1.6", "", { "dependencies": { "debug": "^4.0.0", "tslib": "^2.0.1" } }, "sha512-0JZ1Zkp3wURnv8oq6Qt7fMPo5MpjbLoUoa9Bu2Q4PJuSDWM8H8gwF3dQO7VTeUj3/0o1IB1wGkFWZZYgUXZMUg=="], + + "@ionic/utils-fs": ["@ionic/utils-fs@3.1.7", "", { "dependencies": { "@types/fs-extra": "^8.0.0", "debug": "^4.0.0", "fs-extra": "^9.0.0", "tslib": "^2.0.1" } }, "sha512-2EknRvMVfhnyhL1VhFkSLa5gOcycK91VnjfrTB0kbqkTFCOXyXgVLI5whzq7SLrgD9t1aqos3lMMQyVzaQ5gVA=="], + + "@ionic/utils-object": ["@ionic/utils-object@2.1.6", "", { "dependencies": { "debug": "^4.0.0", "tslib": "^2.0.1" } }, "sha512-vCl7sl6JjBHFw99CuAqHljYJpcE88YaH2ZW4ELiC/Zwxl5tiwn4kbdP/gxi2OT3MQb1vOtgAmSNRtusvgxI8ww=="], + + "@ionic/utils-process": ["@ionic/utils-process@2.1.12", "", { "dependencies": { "@ionic/utils-object": "2.1.6", "@ionic/utils-terminal": "2.3.5", "debug": "^4.0.0", "signal-exit": "^3.0.3", "tree-kill": "^1.2.2", "tslib": "^2.0.1" } }, "sha512-Jqkgyq7zBs/v/J3YvKtQQiIcxfJyplPgECMWgdO0E1fKrrH8EF0QGHNJ9mJCn6PYe2UtHNS8JJf5G21e09DfYg=="], + + "@ionic/utils-stream": ["@ionic/utils-stream@3.1.7", "", { "dependencies": { "debug": "^4.0.0", "tslib": "^2.0.1" } }, "sha512-eSELBE7NWNFIHTbTC2jiMvh1ABKGIpGdUIvARsNPMNQhxJB3wpwdiVnoBoTYp+5a6UUIww4Kpg7v6S7iTctH1w=="], + + "@ionic/utils-subprocess": ["@ionic/utils-subprocess@3.0.1", "", { "dependencies": { "@ionic/utils-array": "2.1.6", "@ionic/utils-fs": "3.1.7", "@ionic/utils-process": "2.1.12", "@ionic/utils-stream": "3.1.7", "@ionic/utils-terminal": "2.3.5", "cross-spawn": "^7.0.3", "debug": "^4.0.0", "tslib": "^2.0.1" } }, "sha512-cT4te3AQQPeIM9WCwIg8ohroJ8TjsYaMb2G4ZEgv9YzeDqHZ4JpeIKqG2SoaA3GmVQ3sOfhPM6Ox9sxphV/d1A=="], + + "@ionic/utils-terminal": ["@ionic/utils-terminal@2.3.5", "", { "dependencies": { "@types/slice-ansi": "^4.0.0", "debug": "^4.0.0", "signal-exit": "^3.0.3", "slice-ansi": "^4.0.0", "string-width": "^4.1.0", "strip-ansi": "^6.0.0", "tslib": "^2.0.1", "untildify": "^4.0.0", "wrap-ansi": "^7.0.0" } }, "sha512-3cKScz9Jx2/Pr9ijj1OzGlBDfcmx7OMVBt4+P1uRR0SSW4cm1/y3Mo4OY3lfkuaYifMNBW8Wz6lQHbs1bihr7A=="], + + "@isaacs/fs-minipass": ["@isaacs/fs-minipass@4.0.1", "", { "dependencies": { "minipass": "^7.0.4" } }, "sha512-wgm9Ehl2jpeqP3zw/7mo3kRHFp5MEDhqAdwy1fTGkHAwnkGOVsgpvQhL8B5n1qlb01jV3n/bI0ZfZp5lWA1k4w=="], + + "@napi-rs/lzma-linux-x64-gnu": ["@napi-rs/lzma-linux-x64-gnu@1.5.1", "", { "os": "linux", "cpu": "x64" }, "sha512-oTXEIha4SsuXdTA4Iyskj0kpdx2yVXdhd75c2v3xGrHFfVMsbhTPZU/nMPL4sWKo4pBHm3aucLaqGlF696dTyQ=="], + + "@nodelib/fs.scandir": ["@nodelib/fs.scandir@2.1.5", "", { "dependencies": { "@nodelib/fs.stat": "2.0.5", "run-parallel": "^1.1.9" } }, "sha512-vq24Bq3ym5HEQm2NKCr3yXDwjc7vTsEThRDnkp2DK9p1uqLR+DHurm/NOTo0KG7HYHU7eppKZj3MyqYuMBf62g=="], + + "@nodelib/fs.stat": ["@nodelib/fs.stat@2.0.5", "", {}, "sha512-RkhPPp2zrqDAQA/2jNhnztcPAlv64XdhIp7a7454A5ovI7Bukxgt7MX7udwAu3zg1DcpPU0rz3VV1SeaqvY4+A=="], + + "@nodelib/fs.walk": ["@nodelib/fs.walk@1.2.8", "", { "dependencies": { "@nodelib/fs.scandir": "2.1.5", "fastq": "^1.6.0" } }, "sha512-oGB+UxlgWcgQkgwo8GcEGwemoTFt3FIO9ababBmaGwXIoBKZ+GTy0pP185beGg7Llih/NSHSV2XAs1lnznocSg=="], + + "@rollup/rollup-android-arm-eabi": ["@rollup/rollup-android-arm-eabi@4.63.5", "", { "os": "android", "cpu": "arm" }, "sha512-J25QJU+B78T4FhhBsNpLJyVWOi31mwtpcMwywHmOKH65Q9IWGA81gPj+dnwlhU8wktVriYE+tFAaQgrnJRzAZg=="], + + "@rollup/rollup-android-arm64": ["@rollup/rollup-android-arm64@4.63.5", "", { "os": "android", "cpu": "arm64" }, "sha512-LDopB3zuZM5Ux9TT2luNEBJW/tYbGU2g1d+VpKk6I+gSKDb+/7sYE6M225gRQt4RbMX6MSwMsVR/phdjVUgRLg=="], + + "@rollup/rollup-darwin-arm64": ["@rollup/rollup-darwin-arm64@4.63.5", "", { "os": "darwin", "cpu": "arm64" }, "sha512-wlJEERGfeuHeBavCL2qVnNacOK43NDoZM4sjkeRPymd04OAE9T1zBqDJgmZ+CIsPTYKwdzpUC8vmOw84dwY4Tg=="], + + "@rollup/rollup-darwin-x64": ["@rollup/rollup-darwin-x64@4.63.5", "", { "os": "darwin", "cpu": "x64" }, "sha512-4nJJGg5jbo2wwPP4JP+LfEBA3bvP8rU9CLuhp7jWvq9sxEyhjQFTFdrqi+/dHEin/pd8jpT0vcehIpnZtmEdcQ=="], + + "@rollup/rollup-freebsd-arm64": ["@rollup/rollup-freebsd-arm64@4.63.5", "", { "os": "freebsd", "cpu": "arm64" }, "sha512-DrZbyCDF1hneuO6jRbvZ2D7+PIBM6yIwYnJpg2vIk58T+wuFpiaGZrfUr59lDWw45bg+IrpTGLPiNi/Fk4w3Cg=="], + + "@rollup/rollup-freebsd-x64": ["@rollup/rollup-freebsd-x64@4.63.5", "", { "os": "freebsd", "cpu": "x64" }, "sha512-gqfUVMJMB3mehqywxp6hTBFfgtMQykZY19+cfiaYP0toIJLb/1DZRJHVkQQGP13W4TAwfZDWeg1qBcheTRioXQ=="], + + "@rollup/rollup-linux-arm-gnueabihf": ["@rollup/rollup-linux-arm-gnueabihf@4.63.5", "", { "os": "linux", "cpu": "arm" }, "sha512-CFmhpvAwzSaWMlN3VN7UtmoTihlZNzoP0juQib5TQRnYUyDV8dXeWOp29sobWAT6gXl/hQgAClLlEiYozQG3OQ=="], + + "@rollup/rollup-linux-arm-musleabihf": ["@rollup/rollup-linux-arm-musleabihf@4.63.5", "", { "os": "linux", "cpu": "arm" }, "sha512-Uc9H8eXCOayV6JLTH5bXKMId6qbhNHa818/BgYjm4jrlq3vZquC9cqyvHBw17xy5Mnj5f+I3gFK5JcEf3hSqrw=="], + + "@rollup/rollup-linux-arm64-gnu": ["@rollup/rollup-linux-arm64-gnu@4.63.5", "", { "os": "linux", "cpu": "arm64" }, "sha512-VcPr/szv/1BFw112Kt//fxulXt/JPqzzidU84iW68L2DdjnOO8QFUv2zTSYBEPHD6movBD4z+bbr5y60GYM7Jw=="], + + "@rollup/rollup-linux-arm64-musl": ["@rollup/rollup-linux-arm64-musl@4.63.5", "", { "os": "linux", "cpu": "arm64" }, "sha512-BnxtJ5/91BrIHYIkGrmjz/lbMhqEHt1dPFqIxIFR+jPn0xVc/oUSCtIT089zfp5ufwGDlYz2UC+Fe1SRBpYFbQ=="], + + "@rollup/rollup-linux-loong64-gnu": ["@rollup/rollup-linux-loong64-gnu@4.63.5", "", { "os": "linux", "cpu": "none" }, "sha512-LrYcHZwF+fAMNKHYTOQ5osWM4AZF7YF6D+XtsjDyEvljtt11twc+zHVXBLNEjxVSUnKYsOhvVz4Z213eW02COQ=="], + + "@rollup/rollup-linux-loong64-musl": ["@rollup/rollup-linux-loong64-musl@4.63.5", "", { "os": "linux", "cpu": "none" }, "sha512-nj7QKQePAAUpCpJHtg0pR0W/b92A9NO17JS3BAQmHDn/yhmkir2p8llrKY9TOhleKIaSzy1JhxS3T9FVld6coA=="], + + "@rollup/rollup-linux-ppc64-gnu": ["@rollup/rollup-linux-ppc64-gnu@4.63.5", "", { "os": "linux", "cpu": "ppc64" }, "sha512-5ylkX6dWMeBKge9nTU+Rxfb+ZfaCIJ9lRqIFaK0eAMcWp7OJbYnLveLgXmm0VrvuLKb8qIK+mHyH0qu88RM+iA=="], + + "@rollup/rollup-linux-ppc64-musl": ["@rollup/rollup-linux-ppc64-musl@4.63.5", "", { "os": "linux", "cpu": "ppc64" }, "sha512-oHK4ZHYFDKjZviK34I+NwgfbGxgI7ztrNxj2hPTSSNFgeq1a/lEd7dHV2fdGAuTH4Iym3RHJg+vAbWaWG4B7Zg=="], + + "@rollup/rollup-linux-riscv64-gnu": ["@rollup/rollup-linux-riscv64-gnu@4.63.5", "", { "os": "linux", "cpu": "none" }, "sha512-UcetmHZ6XOXuUByiKZyQmb55ZPr0LABr3Ec/HB9wKZn6CEAFWZkE+hsJErJ9hbPBC7nI0dKuELx7CoV6IM7TMg=="], + + "@rollup/rollup-linux-riscv64-musl": ["@rollup/rollup-linux-riscv64-musl@4.63.5", "", { "os": "linux", "cpu": "none" }, "sha512-C5CmDPQBtvjVo8cgQsBs+w6WB0JLkiixhgi6hVLV11hERWdn/p0XcPU2OUcZzac9BPOFq7SbaHFa8r3SWEysCQ=="], + + "@rollup/rollup-linux-s390x-gnu": ["@rollup/rollup-linux-s390x-gnu@4.63.5", "", { "os": "linux", "cpu": "s390x" }, "sha512-lHVQHJFKsuuxLMi3MQO9XVL8Tje3JR82CzB+QDKC5NWBcsIWuwsn9uIM5e3lBhI+fF1/s63qnyYqsg65+8rV/w=="], + + "@rollup/rollup-linux-x64-gnu": ["@rollup/rollup-linux-x64-gnu@4.63.5", "", { "os": "linux", "cpu": "x64" }, "sha512-3W9bTFcQNJn71cSJVM9RKIiZOy8DO/XLDii8Uv/Pm6WKqDRj7JV3ZfuXIEfyuy5LXpIzAbB/1M4Ukp9GKNa7nA=="], + + "@rollup/rollup-linux-x64-musl": ["@rollup/rollup-linux-x64-musl@4.63.5", "", { "os": "linux", "cpu": "x64" }, "sha512-VDC7rRJlee/scpki96GZ27Omf6yU87s1YXwVTpjE5841faVlDYYT565rgfmoR1U0sqL7z5ivQSDjcsF6VRXyBA=="], + + "@rollup/rollup-openbsd-x64": ["@rollup/rollup-openbsd-x64@4.63.5", "", { "os": "openbsd", "cpu": "x64" }, "sha512-z86Ok2p4pTdv5xqCKZsTooO7yBEiaJR/HzU3Wx8RmWsPoLppnMKROhJusQob8B3IE1ghC343kUW9rC2r+Wf3ig=="], + + "@rollup/rollup-openharmony-arm64": ["@rollup/rollup-openharmony-arm64@4.63.5", "", { "os": "none", "cpu": "arm64" }, "sha512-IzQmj+xXwQFGhMAMKMQVXkMwMZN3TqkJgAE0nSsqvVwWWciP4AIPMmWRqOQ2GfX7TUDZr+xqGFcBS36CRPGw0g=="], + + "@rollup/rollup-win32-arm64-msvc": ["@rollup/rollup-win32-arm64-msvc@4.63.5", "", { "os": "win32", "cpu": "arm64" }, "sha512-F6qpTaPc9bwBH85kjy0/BLmLSW1uv7AoOXCoRIkg2arlgCYlWYcAbiMkvZuAcaWk9TpCRG//okznLAqLGshkMw=="], + + "@rollup/rollup-win32-ia32-msvc": ["@rollup/rollup-win32-ia32-msvc@4.63.5", "", { "os": "win32", "cpu": "ia32" }, "sha512-igoDsTFhhwECBeGbUuLeIk7t8Y1apa+cs6mDWpx2EZ0ch7oEQgzHbFUXN9euoHekCAQzXdXApAGkV6jznS7tWw=="], + + "@rollup/rollup-win32-x64-gnu": ["@rollup/rollup-win32-x64-gnu@4.63.5", "", { "os": "win32", "cpu": "x64" }, "sha512-U3teMeMbXFmaM5D+OTJpsOXd+wV/qftIeYF9kBKL4v73641qyJmoXFtA28DQLsnmlyayEsTe72xpLHrArq6vHw=="], + + "@rollup/rollup-win32-x64-msvc": ["@rollup/rollup-win32-x64-msvc@4.63.5", "", { "os": "win32", "cpu": "x64" }, "sha512-ypfC34F3RKXvCXBglGqGMsUSMKlgwd1HX9AOAlx9RoZZ6GaI42YHVeKpzg3JG+wpBUJYTG+NNZhqbDWL8tBZkw=="], + + "@rtsao/scc": ["@rtsao/scc@1.1.0", "", {}, "sha512-zt6OdqaDoOnJ1ZYsCYGt9YmWzDXl4vQdKTyJev62gFhRGKdx7mcT54V9KIjg+d2wi9EXsPvAPKe7i7WjfVWB8g=="], + + "@types/estree": ["@types/estree@1.0.9", "", {}, "sha512-GhdPgy1el4/ImP05X05Uw4cw2/M93BCUmnEvWZNStlCzEKME4Fkk+YpoA5OiHNQmoS7Cafb8Xa3Pya8m1Qrzeg=="], + + "@types/fs-extra": ["@types/fs-extra@8.1.5", "", { "dependencies": { "@types/node": "*" } }, "sha512-0dzKcwO+S8s2kuF5Z9oUWatQJj5Uq/iqphEtE3GQJVRRYm/tD1LglU2UnXi2A8jLq5umkGouOXOR9y0n613ZwQ=="], + + "@types/geojson": ["@types/geojson@7946.0.16", "", {}, "sha512-6C8nqWur3j98U6+lXDfTUWIfgvZU+EumvpHKcYjujKH7woYyLj2sUmff0tRhrqM7BohUw7Pz3ZB1jj2gW9Fvmg=="], + + "@types/google.maps": ["@types/google.maps@3.66.4", "", {}, "sha512-t01LM0VeIsUOZWno7ABUv4XL82RalnhRGaTzWykPUtQ+hHT39vsIekeU+roqEaibwebpYIjS7dslx51HwG95nw=="], + + "@types/json-schema": ["@types/json-schema@7.0.15", "", {}, "sha512-5+fP8P8MFNC+AyZCDxrB2pkZFPGzqQWUzpSeuuVLvm8VMcorNYavBqoFcxK8bQz4Qsbn4oUEEem4wDLfcysGHA=="], + + "@types/json5": ["@types/json5@0.0.29", "", {}, "sha512-dRLjCWHYg4oaA77cxO64oO+7JwCwnIzkZPdrrC71jQmQtlhM556pwKo5bUzqvZndkVbeFLIIi+9TC40JNF5hNQ=="], + + "@types/node": ["@types/node@24.19.0", "", { "dependencies": { "undici-types": ">=7.24.0 <7.24.7" } }, "sha512-zY+5tKxXdhGh1PYI0ac+7juvEu4OI6vWtVVoj5i2m42jxAY1U+zHGt6QCyOFwykdP62sM3MJ9stoYYUw5aCWew=="], + + "@types/resize-observer-browser": ["@types/resize-observer-browser@0.1.11", "", {}, "sha512-cNw5iH8JkMkb3QkCoe7DaZiawbDQEUX8t7iuQaRTyLOyQCR2h+ibBD4GJt7p5yhUHrlOeL7ZtbxNHeipqNsBzQ=="], + + "@types/semver": ["@types/semver@7.8.0", "", {}, "sha512-1mAINjtQCXXeLkJ9ehXkwOcBpqtLxiVtKhpUf83DdRNdQKV0iXZpaHYqRr7nj+wvxuJzoAmAwXI+sCNMv1CzLQ=="], + + "@types/slice-ansi": ["@types/slice-ansi@4.0.0", "", {}, "sha512-+OpjSaq85gvlZAYINyzKpLeiFkSC4EsC6IIiT6v6TLSU5k5U83fHGj9Lel8oKEXM0HqgrMVCjXPDPVICtxF7EQ=="], + + "@types/supercluster": ["@types/supercluster@7.1.3", "", { "dependencies": { "@types/geojson": "*" } }, "sha512-Z0pOY34GDFl3Q6hUFYf3HkTwKEE02e7QgtJppBt+beEAxnyOpJua+voGFvxINBHa06GwLFFym7gRPY2SiKIfIA=="], + + "@typescript-eslint/eslint-plugin": ["@typescript-eslint/eslint-plugin@5.62.0", "", { "dependencies": { "@eslint-community/regexpp": "^4.4.0", "@typescript-eslint/scope-manager": "5.62.0", "@typescript-eslint/type-utils": "5.62.0", "@typescript-eslint/utils": "5.62.0", "debug": "^4.3.4", "graphemer": "^1.4.0", "ignore": "^5.2.0", "natural-compare-lite": "^1.4.0", "semver": "^7.3.7", "tsutils": "^3.21.0" }, "peerDependencies": { "@typescript-eslint/parser": "^5.0.0", "eslint": "^6.0.0 || ^7.0.0 || ^8.0.0", "typescript": "*" }, "optionalPeers": ["typescript"] }, "sha512-TiZzBSJja/LbhNPvk6yc0JrX9XqhQ0hdh6M2svYfsHGejaKFIAGd9MQ+ERIMzLGlN/kZoYIgdxFV0PuljTKXag=="], + + "@typescript-eslint/parser": ["@typescript-eslint/parser@5.62.0", "", { "dependencies": { "@typescript-eslint/scope-manager": "5.62.0", "@typescript-eslint/types": "5.62.0", "@typescript-eslint/typescript-estree": "5.62.0", "debug": "^4.3.4" }, "peerDependencies": { "eslint": "^6.0.0 || ^7.0.0 || ^8.0.0", "typescript": "*" }, "optionalPeers": ["typescript"] }, "sha512-VlJEV0fOQ7BExOsHYAGrgbEiZoi8D+Bl2+f6V2RrXerRSylnp+ZBHmPvaIa8cz0Ajx7WO7Z5RqfgYg7ED1nRhA=="], + + "@typescript-eslint/scope-manager": ["@typescript-eslint/scope-manager@5.62.0", "", { "dependencies": { "@typescript-eslint/types": "5.62.0", "@typescript-eslint/visitor-keys": "5.62.0" } }, "sha512-VXuvVvZeQCQb5Zgf4HAxc04q5j+WrNAtNh9OwCsCgpKqESMTu3tF/jhZ3xG6T4NZwWl65Bg8KuS2uEvhSfLl0w=="], + + "@typescript-eslint/type-utils": ["@typescript-eslint/type-utils@5.62.0", "", { "dependencies": { "@typescript-eslint/typescript-estree": "5.62.0", "@typescript-eslint/utils": "5.62.0", "debug": "^4.3.4", "tsutils": "^3.21.0" }, "peerDependencies": { "eslint": "*", "typescript": "*" }, "optionalPeers": ["typescript"] }, "sha512-xsSQreu+VnfbqQpW5vnCJdq1Z3Q0U31qiWmRhr98ONQmcp/yhiPJFPq8MXiJVLiksmOKSjIldZzkebzHuCGzew=="], + + "@typescript-eslint/types": ["@typescript-eslint/types@5.62.0", "", {}, "sha512-87NVngcbVXUahrRTqIK27gD2t5Cu1yuCXxbLcFtCzZGlfyVWWh8mLHkoxzjsB6DDNnvdL+fW8MiwPEJyGJQDgQ=="], + + "@typescript-eslint/typescript-estree": ["@typescript-eslint/typescript-estree@5.62.0", "", { "dependencies": { "@typescript-eslint/types": "5.62.0", "@typescript-eslint/visitor-keys": "5.62.0", "debug": "^4.3.4", "globby": "^11.1.0", "is-glob": "^4.0.3", "semver": "^7.3.7", "tsutils": "^3.21.0" }, "peerDependencies": { "typescript": "*" }, "optionalPeers": ["typescript"] }, "sha512-CmcQ6uY7b9y694lKdRB8FEel7JbU/40iSAPomu++SjLMntB+2Leay2LO6i8VnJk58MtE9/nQSFIH6jpyRWyYzA=="], + + "@typescript-eslint/utils": ["@typescript-eslint/utils@5.62.0", "", { "dependencies": { "@eslint-community/eslint-utils": "^4.2.0", "@types/json-schema": "^7.0.9", "@types/semver": "^7.3.12", "@typescript-eslint/scope-manager": "5.62.0", "@typescript-eslint/types": "5.62.0", "@typescript-eslint/typescript-estree": "5.62.0", "eslint-scope": "^5.1.1", "semver": "^7.3.7" }, "peerDependencies": { "eslint": "^6.0.0 || ^7.0.0 || ^8.0.0" } }, "sha512-n8oxjeb5aIbPFEtmQxQYOLI0i9n5ySBEY/ZEHHZqKQSFnxio1rv6dthascc9dLuwrL0RC5mPCxB7vnAVGAYWAQ=="], + + "@typescript-eslint/visitor-keys": ["@typescript-eslint/visitor-keys@5.62.0", "", { "dependencies": { "@typescript-eslint/types": "5.62.0", "eslint-visitor-keys": "^3.3.0" } }, "sha512-07ny+LHRzQXepkGg6w0mFY41fVUNBrL2Roj/++7V1txKugfjm/Ci/qSND03r2RhlJhJYMcTn9AhhSSqQp0Ysyw=="], + + "@ungap/structured-clone": ["@ungap/structured-clone@1.4.0", "", {}, "sha512-1mEZtMKPM09vDmQt5y7YvmN2+DFTP7Tg0EWXdic8/C6VRnpb33e4ghisCIE3WZjsE2N8mf+QV1Zqh7ZFYLWInQ=="], + + "@xmldom/xmldom": ["@xmldom/xmldom@0.9.12", "", {}, "sha512-5AXjrcMClTryPe9LgZrygpB1lj7s0S9E0+W+AHaVKAVyHanafK86iPSvG5xHVSp/jC+VH1UXu0TAEmY279xH7A=="], + + "acorn": ["acorn@8.18.0", "", { "bin": { "acorn": "bin/acorn" } }, "sha512-lGq+9yr1/GuAWaVYIHRjvvySG5/4VfKIvC8EWxStPdcDh/Ka7FG3twP6v4d5BkravUilhIAsG4Qj83t02LWUPQ=="], + + "acorn-jsx": ["acorn-jsx@5.3.2", "", { "peerDependencies": { "acorn": "^6.0.0 || ^7.0.0 || ^8.0.0" } }, "sha512-rq9s+JNhf0IChjtDXxllJ7g41oZk5SlXtp0LHwyA5cejwn7vKmKp4pPri6YEePv2PU65sAsegbXtIinmDFDXgQ=="], + + "ajv": ["ajv@6.15.0", "", { "dependencies": { "fast-deep-equal": "^3.1.1", "fast-json-stable-stringify": "^2.0.0", "json-schema-traverse": "^0.4.1", "uri-js": "^4.2.2" } }, "sha512-fgFx7Hfoq60ytK2c7DhnF8jIvzYgOMxfugjLOSMHjLIPgenqa7S7oaagATUq99mV6IYvN2tRmC0wnTYX6iPbMw=="], + + "ansi-regex": ["ansi-regex@5.0.1", "", {}, "sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ=="], + + "ansi-styles": ["ansi-styles@4.3.0", "", { "dependencies": { "color-convert": "^2.0.1" } }, "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg=="], + + "argparse": ["argparse@2.0.1", "", {}, "sha512-8+9WqebbFzpX9OR+Wa6O29asIogeRMzcGtAINdpMHHyAg10f05aSFVBbcEqGf/PXw1EjAZ+q2/bEBg3DvurK3Q=="], + + "array-buffer-byte-length": ["array-buffer-byte-length@1.0.2", "", { "dependencies": { "call-bound": "^1.0.3", "is-array-buffer": "^3.0.5" } }, "sha512-LHE+8BuR7RYGDKvnrmcuSq3tDcKv9OFEXQt/HpbZhY7V6h0zlUXutnAD82GiFx9rdieCMjkvtcsPqBwgUl1Iiw=="], + + "array-includes": ["array-includes@3.2.0", "", { "dependencies": { "call-bind": "^1.0.9", "call-bound": "^1.0.4", "define-properties": "^1.2.1", "es-abstract": "^1.24.2", "es-object-atoms": "^1.1.2", "es-shim-unscopables": "^1.1.0", "is-string": "^1.1.1", "math-intrinsics": "^1.1.0" } }, "sha512-VXY5eFRarnXcYxwBjJzPmEhH55+rmP79/+ueDhi0F+TuqfHCItagIHqxeUZrmgrOPa31QTh9H85DjX3FfJ0FTg=="], + + "array-union": ["array-union@2.1.0", "", {}, "sha512-HGyxoOTYUyCM6stUe6EJgnd4EoewAI7zMdfqO+kGjnlZmBDz/cR5pf8r/cR4Wq60sL/p0IkcjUEEPwS3GFrIyw=="], + + "array.prototype.findlastindex": ["array.prototype.findlastindex@1.2.6", "", { "dependencies": { "call-bind": "^1.0.8", "call-bound": "^1.0.4", "define-properties": "^1.2.1", "es-abstract": "^1.23.9", "es-errors": "^1.3.0", "es-object-atoms": "^1.1.1", "es-shim-unscopables": "^1.1.0" } }, "sha512-F/TKATkzseUExPlfvmwQKGITM3DGTK+vkAsCZoDc5daVygbJBnjEUCbgkAvVFsgfXfX4YIqZ/27G3k3tdXrTxQ=="], + + "array.prototype.flat": ["array.prototype.flat@1.3.3", "", { "dependencies": { "call-bind": "^1.0.8", "define-properties": "^1.2.1", "es-abstract": "^1.23.5", "es-shim-unscopables": "^1.0.2" } }, "sha512-rwG/ja1neyLqCuGZ5YYrznA62D4mZXg0i1cIskIUKSiqF3Cje9/wXAls9B9s1Wa2fomMsIv8czB8jZcPmxCXFg=="], + + "array.prototype.flatmap": ["array.prototype.flatmap@1.3.3", "", { "dependencies": { "call-bind": "^1.0.8", "define-properties": "^1.2.1", "es-abstract": "^1.23.5", "es-shim-unscopables": "^1.0.2" } }, "sha512-Y7Wt51eKJSyi80hFrJCePGGNo5ktJCslFuboqJsbf57CCPcm5zztluPlc4/aD8sWsKvlwatezpV4U1efk8kpjg=="], + + "arraybuffer.prototype.slice": ["arraybuffer.prototype.slice@1.0.4", "", { "dependencies": { "array-buffer-byte-length": "^1.0.1", "call-bind": "^1.0.8", "define-properties": "^1.2.1", "es-abstract": "^1.23.5", "es-errors": "^1.3.0", "get-intrinsic": "^1.2.6", "is-array-buffer": "^3.0.4" } }, "sha512-BNoCY6SXXPQ7gF2opIP4GBE+Xw7U+pHMYKuzjgCN3GwiaIR09UUeKfheyIry77QtrCBlC0KK0q5/TER/tYh3PQ=="], + + "astral-regex": ["astral-regex@2.0.0", "", {}, "sha512-Z7tMw1ytTXt5jqMcOP+OQteU1VuNK9Y02uuJtKQ1Sv69jXQKKg5cibLwGJow8yzZP+eAc18EmLGPal0bp36rvQ=="], + + "async-function": ["async-function@1.0.0", "", {}, "sha512-hsU18Ae8CDTR6Kgu9DYf0EbCr/a5iGL0rytQDobUcdpYOKokk8LEjVphnXkDkgpi0wYVsqrXuP0bZxJaTqdgoA=="], + + "at-least-node": ["at-least-node@1.0.0", "", {}, "sha512-+q/t7Ekv1EDY2l6Gda6LLiX14rU9TV20Wa3ofeQmwPFZbOMo9DXrLbOjFaaclkXKWidIaopwAObQDqwWtGUjqg=="], + + "available-typed-arrays": ["available-typed-arrays@1.0.7", "", { "dependencies": { "possible-typed-array-names": "^1.0.0" } }, "sha512-wvUjBtSGN7+7SjNpq/9M2Tg350UZD3q62IFZLbRAR1bSMlCo1ZaeW+BJ+D090e4hIIZLBcTDWe4Mh4jvUDajzQ=="], + + "balanced-match": ["balanced-match@1.0.2", "", {}, "sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw=="], + + "base64-js": ["base64-js@1.5.1", "", {}, "sha512-AKpaYlHn8t4SVbOHCy+b5+KKgvR4vrsD8vbvrbiQJps7fKDTkjkDry6ji0rUJjC0kzbNePLwzxq8iypo41qeWA=="], + + "big-integer": ["big-integer@1.6.52", "", {}, "sha512-QxD8cf2eVqJOOz63z6JIN9BzvVs/dlySa5HGSBH5xtR8dPteIRQnBxxKqkNTiT6jbDTF6jAfrd4oMcND9RGbQg=="], + + "bplist-creator": ["bplist-creator@0.1.0", "", { "dependencies": { "stream-buffers": "2.2.x" } }, "sha512-sXaHZicyEEmY86WyueLTQesbeoH/mquvarJaQNbjuOQO+7gbFcDEWqKmcWA4cOTLzFlfgvkiVxolk1k5bBIpmg=="], + + "bplist-parser": ["bplist-parser@0.3.2", "", { "dependencies": { "big-integer": "1.6.x" } }, "sha512-apC2+fspHGI3mMKj+dGevkGo/tCqVB8jMb6i+OX+E29p0Iposz07fABkRIfVUPNd5A5VbuOz1bZbnmkKLYF+wQ=="], + + "brace-expansion": ["brace-expansion@1.1.21", "", { "dependencies": { "balanced-match": "^1.0.0", "concat-map": "0.0.1" } }, "sha512-9zeA+KLZNNzglF2TPKRQEDyx6Yby7daAkuy8MiPzpXPsYDWi/DRM8jmwUDxokQjYqBpv5DgPiwD4h4ZZSy1Ujw=="], + + "braces": ["braces@3.0.3", "", { "dependencies": { "fill-range": "^7.1.1" } }, "sha512-yQbXgO/OSZVD2IsiLlro+7Hf6Q18EJrKSEsdoMzKePKXct3gvD8oLcOQdIzGupr5Fj+EDe8gO/lxc1BzfMpxvA=="], + + "buffer-crc32": ["buffer-crc32@0.2.13", "", {}, "sha512-VO9Ht/+p3SN7SKWqcrgEzjGbRSJYTx+Q1pTQC0wrWqHx0vpJraQ6GtHx8tvcg1rlK1byhU5gccxgOgj7B0TDkQ=="], + + "call-bind": ["call-bind@1.0.9", "", { "dependencies": { "call-bind-apply-helpers": "^1.0.2", "es-define-property": "^1.0.1", "get-intrinsic": "^1.3.0", "set-function-length": "^1.2.2" } }, "sha512-a/hy+pNsFUTR+Iz8TCJvXudKVLAnz/DyeSUo10I5yvFDQJBFU2s9uqQpoSrJlroHUKoKqzg+epxyP9lqFdzfBQ=="], + + "call-bind-apply-helpers": ["call-bind-apply-helpers@1.0.2", "", { "dependencies": { "es-errors": "^1.3.0", "function-bind": "^1.1.2" } }, "sha512-Sp1ablJ0ivDkSzjcaJdxEunN5/XvksFJ2sMBFfq6x0ryhQV/2b/KwFe21cMpmHtPOSij8K99/wSfoEuTObmuMQ=="], + + "call-bound": ["call-bound@1.0.4", "", { "dependencies": { "call-bind-apply-helpers": "^1.0.2", "get-intrinsic": "^1.3.0" } }, "sha512-+ys997U96po4Kx/ABpBCqhA9EuxJaQWDQg7295H4hBphv3IZg0boBKuwYpt4YXp6MZ5AmZQnU/tyMTlRpaSejg=="], + + "callsites": ["callsites@3.1.0", "", {}, "sha512-P8BjAsXvZS+VIDUI11hHCQEv74YT67YUi5JJFNWIqL235sBmjX4+qx9Muvls5ivyNENctx46xQLQ3aTuE7ssaQ=="], + + "chalk": ["chalk@4.1.2", "", { "dependencies": { "ansi-styles": "^4.1.0", "supports-color": "^7.1.0" } }, "sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA=="], + + "chownr": ["chownr@3.0.0", "", {}, "sha512-+IxzY9BZOQd/XuYPRmrvEVjF/nqj5kgT4kEq7VofrDoM1MxoRjEWkrCC3EtLi59TVawxTAn+orJwFQcrqEN1+g=="], + + "color-convert": ["color-convert@2.0.1", "", { "dependencies": { "color-name": "~1.1.4" } }, "sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ=="], + + "color-name": ["color-name@1.1.4", "", {}, "sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA=="], + + "colorette": ["colorette@2.0.20", "", {}, "sha512-IfEDxwoWIjkeXL1eXcDiow4UbKjhLdq6/EuSVR9GMN7KVH3r9gQ83e73hsz1Nd1T3ijd5xv1wcWRYO+D6kCI2w=="], + + "commander": ["commander@12.1.0", "", {}, "sha512-Vw8qHK3bZM9y/P10u3Vib8o/DdkvA2OtPtZvD871QKjy74Wj1WSKFILMPRPSdUSx5RFK1arlJzEtA4PkFgnbuA=="], + + "concat-map": ["concat-map@0.0.1", "", {}, "sha512-/Srv4dswyQNBfohGpz9o6Yb3Gz3SrUDqBH5rTuhGR7ahtlbYKnVxw2bCFMRljaA7EXHaXZ8wsHdodFvbkhKmqg=="], + + "cosmiconfig": ["cosmiconfig@9.0.2", "", { "dependencies": { "env-paths": "^2.2.1", "import-fresh": "^3.3.0", "js-yaml": "^4.1.0", "parse-json": "^5.2.0" }, "peerDependencies": { "typescript": ">=4.9.5" }, "optionalPeers": ["typescript"] }, "sha512-gtTZxTDau1wL7Y7zifc2dd8jHSK/k6BTx/2Xp/BpdlAdnlYWFVt7qhJqgwi7637yRwRQ3qL4ZidbB4I8tA5VOg=="], + + "cross-spawn": ["cross-spawn@7.0.6", "", { "dependencies": { "path-key": "^3.1.0", "shebang-command": "^2.0.0", "which": "^2.0.1" } }, "sha512-uV2QOWP2nWzsy2aMp8aRibhi9dlzF5Hgh5SHaB9OiTGEyDTiJJyx0uy51QXdyWbtAHNua4XJzUKca3OzKUd3vA=="], + + "data-view-buffer": ["data-view-buffer@1.0.2", "", { "dependencies": { "call-bound": "^1.0.3", "es-errors": "^1.3.0", "is-data-view": "^1.0.2" } }, "sha512-EmKO5V3OLXh1rtK2wgXRansaK1/mtVdTUEiEI0W8RkvgT05kfxaH29PliLnpLP73yYO6142Q72QNa8Wx/A5CqQ=="], + + "data-view-byte-length": ["data-view-byte-length@1.0.2", "", { "dependencies": { "call-bound": "^1.0.3", "es-errors": "^1.3.0", "is-data-view": "^1.0.2" } }, "sha512-tuhGbE6CfTM9+5ANGf+oQb72Ky/0+s3xKUpHvShfiz2RxMFgFPjsXuRLBVMtvMs15awe45SRb83D6wH4ew6wlQ=="], + + "data-view-byte-offset": ["data-view-byte-offset@1.0.1", "", { "dependencies": { "call-bound": "^1.0.2", "es-errors": "^1.3.0", "is-data-view": "^1.0.1" } }, "sha512-BS8PfmtDGnrgYdOonGZQdLZslWIeCGFP9tpan0hi1Co2Zr2NKADsvGYA8XxuG/4UWgJ6Cjtv+YJnB6MM69QGlQ=="], + + "debug": ["debug@4.4.3", "", { "dependencies": { "ms": "^2.1.3" }, "peerDependencies": { "supports-color": "*" }, "optionalPeers": ["supports-color"] }, "sha512-RGwwWnwQvkVfavKVt22FGLw+xYSdzARwm0ru6DhTVA3umU5hZc28V3kO4stgYryrTlLpuvgI9GiijltAjNbcqA=="], + + "deep-is": ["deep-is@0.1.4", "", {}, "sha512-oIPzksmTg4/MriiaYGO+okXDT7ztn/w3Eptv/+gSIdMdKsJo0u4CfYNFJPy+4SKMuCqGw2wxnA+URMg3t8a/bQ=="], + + "define-data-property": ["define-data-property@1.1.4", "", { "dependencies": { "es-define-property": "^1.0.0", "es-errors": "^1.3.0", "gopd": "^1.0.1" } }, "sha512-rBMvIzlpA8v6E+SJZoo++HAYqsLrkg7MSfIinMPFhmkorw7X+dOXVJQs+QT69zGkzMyfDnIMN2Wid1+NbL3T+A=="], + + "define-lazy-prop": ["define-lazy-prop@2.0.0", "", {}, "sha512-Ds09qNh8yw3khSjiJjiUInaGX9xlqZDY7JVryGxdxV7NPeuqQfplOpQ66yJFZut3jLa5zOwkXw1g9EI2uKh4Og=="], + + "define-properties": ["define-properties@1.2.1", "", { "dependencies": { "define-data-property": "^1.0.1", "has-property-descriptors": "^1.0.0", "object-keys": "^1.1.1" } }, "sha512-8QmQKqEASLd5nx0U1B1okLElbUuuttJ/AnYmRXbbbGDWh6uS208EjD4Xqq/I9wK7u0v6O08XhTWnt5XtEbR6Dg=="], + + "diff": ["diff@5.2.2", "", {}, "sha512-vtcDfH3TOjP8UekytvnHH1o1P4FcUdt4eQ1Y+Abap1tk/OB2MWQvcwS2ClCd1zuIhc3JKOx6p3kod8Vfys3E+A=="], + + "dir-glob": ["dir-glob@3.0.1", "", { "dependencies": { "path-type": "^4.0.0" } }, "sha512-WkrWp9GR4KXfKGYzOLmTuGVi1UWFfws377n9cc55/tb6DuqyF6pcQ5AbiHEshaDpY9v6oaSr2XCDidGmMwdzIA=="], + + "doctrine": ["doctrine@3.0.0", "", { "dependencies": { "esutils": "^2.0.2" } }, "sha512-yS+Q5i3hBf7GBkd4KG8a7eBNNWNGLTaEwwYWUijIYM7zrlYDM0BFXHjjPWlWZ1Rg7UaddZeIDmi9jF3HmqiQ2w=="], + + "dunder-proto": ["dunder-proto@1.0.1", "", { "dependencies": { "call-bind-apply-helpers": "^1.0.1", "es-errors": "^1.3.0", "gopd": "^1.2.0" } }, "sha512-KIN/nDJBQRcXw0MLVhZE9iQHmG68qAVIBg9CqmUYjmQIhgij9U5MFvrqkUL5FbtyyzZuOeOt0zdeRe4UY7ct+A=="], + + "elementtree": ["elementtree@0.1.7", "", { "dependencies": { "sax": "1.1.4" } }, "sha512-wkgGT6kugeQk/P6VZ/f4T+4HB41BVgNBq5CDIZVbQ02nvTVqAiVTbskxxu3eA/X96lMlfYOwnLQpN2v5E1zDEg=="], + + "emoji-regex": ["emoji-regex@8.0.0", "", {}, "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A=="], + + "env-paths": ["env-paths@2.2.1", "", {}, "sha512-+h1lkLKhZMTYjog1VEpJNG7NZJWcuc2DDk/qsqSTRRCOXiLjeQ1d1/udrUGhqMxUgAlwKNZ0cf2uqan5GLuS2A=="], + + "error-ex": ["error-ex@1.3.4", "", { "dependencies": { "is-arrayish": "^0.2.1" } }, "sha512-sqQamAnR14VgCr1A618A3sGrygcpK+HEbenA/HiEAkkUwcZIIB/tgWqHFxWgOyDh4nB4JCRimh79dR5Ywc9MDQ=="], + + "es-abstract": ["es-abstract@1.24.2", "", { "dependencies": { "array-buffer-byte-length": "^1.0.2", "arraybuffer.prototype.slice": "^1.0.4", "available-typed-arrays": "^1.0.7", "call-bind": "^1.0.8", "call-bound": "^1.0.4", "data-view-buffer": "^1.0.2", "data-view-byte-length": "^1.0.2", "data-view-byte-offset": "^1.0.1", "es-define-property": "^1.0.1", "es-errors": "^1.3.0", "es-object-atoms": "^1.1.1", "es-set-tostringtag": "^2.1.0", "es-to-primitive": "^1.3.0", "function.prototype.name": "^1.1.8", "get-intrinsic": "^1.3.0", "get-proto": "^1.0.1", "get-symbol-description": "^1.1.0", "globalthis": "^1.0.4", "gopd": "^1.2.0", "has-property-descriptors": "^1.0.2", "has-proto": "^1.2.0", "has-symbols": "^1.1.0", "hasown": "^2.0.2", "internal-slot": "^1.1.0", "is-array-buffer": "^3.0.5", "is-callable": "^1.2.7", "is-data-view": "^1.0.2", "is-negative-zero": "^2.0.3", "is-regex": "^1.2.1", "is-set": "^2.0.3", "is-shared-array-buffer": "^1.0.4", "is-string": "^1.1.1", "is-typed-array": "^1.1.15", "is-weakref": "^1.1.1", "math-intrinsics": "^1.1.0", "object-inspect": "^1.13.4", "object-keys": "^1.1.1", "object.assign": "^4.1.7", "own-keys": "^1.0.1", "regexp.prototype.flags": "^1.5.4", "safe-array-concat": "^1.1.3", "safe-push-apply": "^1.0.0", "safe-regex-test": "^1.1.0", "set-proto": "^1.0.0", "stop-iteration-iterator": "^1.1.0", "string.prototype.trim": "^1.2.10", "string.prototype.trimend": "^1.0.9", "string.prototype.trimstart": "^1.0.8", "typed-array-buffer": "^1.0.3", "typed-array-byte-length": "^1.0.3", "typed-array-byte-offset": "^1.0.4", "typed-array-length": "^1.0.7", "unbox-primitive": "^1.1.0", "which-typed-array": "^1.1.19" } }, "sha512-2FpH9Q5i2RRwyEP1AylXe6nYLR5OhaJTZwmlcP0dL/+JCbgg7yyEo/sEK6HeGZRf3dFpWwThaRHVApXSkW3xeg=="], + + "es-abstract-get": ["es-abstract-get@1.0.0", "", { "dependencies": { "es-errors": "^1.3.0", "es-object-atoms": "^1.1.2", "is-callable": "^1.2.7", "object-inspect": "^1.13.4" } }, "sha512-6PMWXpdhshVvFp+FoWYs1EvG1Nj0tvk0dZM+XcK0xMEM1czRVcP6ohqPWHy6qPagSpC8j4+p89WXlT+xXJs/fg=="], + + "es-define-property": ["es-define-property@1.0.1", "", {}, "sha512-e3nRfgfUZ4rNGL232gUgX06QNyyez04KdjFrF+LTRoOXmrOgFKDg4BCdsjW8EnT69eqdYGmRpJwiPVYNrCaW3g=="], + + "es-errors": ["es-errors@1.3.0", "", {}, "sha512-Zf5H2Kxt2xjTvbJvP2ZWLEICxA6j+hAmMzIlypy4xcBg1vKVnx89Wy0GbS+kf5cwCVFFzdCFh2XSCFNULS6csw=="], + + "es-object-atoms": ["es-object-atoms@1.1.2", "", { "dependencies": { "es-errors": "^1.3.0" } }, "sha512-HWcBoN6NileqtSydK2FqHbS/LoDd2pqrnQHLyJzBj4kOp/ky2MWMN694xOfkK8/SnUsW2DH7EfyVlydKCsm1Zw=="], + + "es-set-tostringtag": ["es-set-tostringtag@2.1.0", "", { "dependencies": { "es-errors": "^1.3.0", "get-intrinsic": "^1.2.6", "has-tostringtag": "^1.0.2", "hasown": "^2.0.2" } }, "sha512-j6vWzfrGVfyXxge+O0x5sh6cvxAog0a/4Rdd2K36zCMV5eJ+/+tOAngRO8cODMNWbVRdVlmGZQL2YS3yR8bIUA=="], + + "es-shim-unscopables": ["es-shim-unscopables@1.1.0", "", { "dependencies": { "hasown": "^2.0.2" } }, "sha512-d9T8ucsEhh8Bi1woXCf+TIKDIROLG5WCkxg8geBCbvk22kzwC5G2OnXVMO6FUsvQlgUUXQ2itephWDLqDzbeCw=="], + + "es-to-primitive": ["es-to-primitive@1.3.4", "", { "dependencies": { "es-abstract-get": "^1.0.0", "es-define-property": "^1.0.1", "es-errors": "^1.3.0", "is-callable": "^1.2.7", "is-date-object": "^1.1.0", "is-symbol": "^1.1.1" } }, "sha512-yPDz7wqpg1/mmHLmS3tcfTfbw5f1eryXvyghYBffGdERwe+mV7ZcWzTR8LR17Kvqt3qfPurjlonmnq3MKXIOXw=="], + + "escape-string-regexp": ["escape-string-regexp@4.0.0", "", {}, "sha512-TtpcNJ3XAzx3Gq8sWRzJaVajRs0uVxA2YAkdb1jm2YkPz4G6egUFAyA3n5vtEIZefPk5Wa4UXbKuS5fKkJWdgA=="], + + "eslint": ["eslint@8.57.1", "", { "dependencies": { "@eslint-community/eslint-utils": "^4.2.0", "@eslint-community/regexpp": "^4.6.1", "@eslint/eslintrc": "^2.1.4", "@eslint/js": "8.57.1", "@humanwhocodes/config-array": "^0.13.0", "@humanwhocodes/module-importer": "^1.0.1", "@nodelib/fs.walk": "^1.2.8", "@ungap/structured-clone": "^1.2.0", "ajv": "^6.12.4", "chalk": "^4.0.0", "cross-spawn": "^7.0.2", "debug": "^4.3.2", "doctrine": "^3.0.0", "escape-string-regexp": "^4.0.0", "eslint-scope": "^7.2.2", "eslint-visitor-keys": "^3.4.3", "espree": "^9.6.1", "esquery": "^1.4.2", "esutils": "^2.0.2", "fast-deep-equal": "^3.1.3", "file-entry-cache": "^6.0.1", "find-up": "^5.0.0", "glob-parent": "^6.0.2", "globals": "^13.19.0", "graphemer": "^1.4.0", "ignore": "^5.2.0", "imurmurhash": "^0.1.4", "is-glob": "^4.0.0", "is-path-inside": "^3.0.3", "js-yaml": "^4.1.0", "json-stable-stringify-without-jsonify": "^1.0.1", "levn": "^0.4.1", "lodash.merge": "^4.6.2", "minimatch": "^3.1.2", "natural-compare": "^1.4.0", "optionator": "^0.9.3", "strip-ansi": "^6.0.1", "text-table": "^0.2.0" }, "bin": { "eslint": "bin/eslint.js" } }, "sha512-ypowyDxpVSYpkXr9WPv2PAZCtNip1Mv5KTW0SCurXv/9iOpcrH9PaqUElksqEB6pChqHGDRCFTyrZlGhnLNGiA=="], + + "eslint-config-prettier": ["eslint-config-prettier@8.10.2", "", { "peerDependencies": { "eslint": ">=7.0.0" }, "bin": { "eslint-config-prettier": "bin/cli.js" } }, "sha512-/IGJ6+Dka158JnP5n5YFMOszjDWrXggGz1LaK/guZq9vZTmniaKlHcsscvkAhn9y4U+BU3JuUdYvtAMcv30y4A=="], + + "eslint-import-resolver-node": ["eslint-import-resolver-node@0.3.10", "", { "dependencies": { "debug": "^3.2.7", "is-core-module": "^2.16.1", "resolve": "^2.0.0-next.6" } }, "sha512-tRrKqFyCaKict5hOd244sL6EQFNycnMQnBe+j8uqGNXYzsImGbGUU4ibtoaBmv5FLwJwcFJNeg1GeVjQfbMrDQ=="], + + "eslint-module-utils": ["eslint-module-utils@2.14.0", "", { "dependencies": { "debug": "^3.2.7" }, "peerDependencies": { "eslint": "*" }, "optionalPeers": ["eslint"] }, "sha512-W2WCRZ9Dqntd+2u8jJcVMV2PKulc6RdLgUUoh/yQr3uB6lo/ZOeGx11sv60/8S4QFFKNslAlWhr9u0Ef7ZW6Ig=="], + + "eslint-plugin-import": ["eslint-plugin-import@2.32.0", "", { "dependencies": { "@rtsao/scc": "^1.1.0", "array-includes": "^3.1.9", "array.prototype.findlastindex": "^1.2.6", "array.prototype.flat": "^1.3.3", "array.prototype.flatmap": "^1.3.3", "debug": "^3.2.7", "doctrine": "^2.1.0", "eslint-import-resolver-node": "^0.3.9", "eslint-module-utils": "^2.12.1", "hasown": "^2.0.2", "is-core-module": "^2.16.1", "is-glob": "^4.0.3", "minimatch": "^3.1.2", "object.fromentries": "^2.0.8", "object.groupby": "^1.0.3", "object.values": "^1.2.1", "semver": "^6.3.1", "string.prototype.trimend": "^1.0.9", "tsconfig-paths": "^3.15.0" }, "peerDependencies": { "eslint": "^2 || ^3 || ^4 || ^5 || ^6 || ^7.2.0 || ^8 || ^9" } }, "sha512-whOE1HFo/qJDyX4SnXzP4N6zOWn79WhnCUY/iDR0mPfQZO8wcYE4JClzI2oZrhBnnMUCBCHZhO6VQyoBU95mZA=="], + + "eslint-scope": ["eslint-scope@7.2.2", "", { "dependencies": { "esrecurse": "^4.3.0", "estraverse": "^5.2.0" } }, "sha512-dOt21O7lTMhDM+X9mB4GX+DZrZtCUJPL/wlcTqxyrx5IvO0IYtILdtrQGQp+8n5S0gwSVmOf9NQrjMOgfQZlIg=="], + + "eslint-visitor-keys": ["eslint-visitor-keys@3.4.3", "", {}, "sha512-wpc+LXeiyiisxPlEkUzU6svyS1frIO3Mgxj1fdy7Pm8Ygzguax2N3Fa/D/ag1WqbOprdI+uY6wMUl8/a2G+iag=="], + + "espree": ["espree@9.6.1", "", { "dependencies": { "acorn": "^8.9.0", "acorn-jsx": "^5.3.2", "eslint-visitor-keys": "^3.4.1" } }, "sha512-oruZaFkjorTpF32kDSI5/75ViwGeZginGGy2NoOSg3Q9bnwlnmDm4HLnkl0RE3n+njDXR037aY1+x58Z/zFdwQ=="], + + "esquery": ["esquery@1.7.0", "", { "dependencies": { "estraverse": "^5.1.0" } }, "sha512-Ap6G0WQwcU/LHsvLwON1fAQX9Zp0A2Y6Y/cJBl9r/JbW90Zyg4/zbG6zzKa2OTALELarYHmKu0GhpM5EO+7T0g=="], + + "esrecurse": ["esrecurse@4.3.0", "", { "dependencies": { "estraverse": "^5.2.0" } }, "sha512-KmfKL3b6G+RXvP8N1vr3Tq1kL/oCFgn2NYXEtqP8/L3pKapUA4G8cFVaoF3SU323CD4XypR/ffioHmkti6/Tag=="], + + "estraverse": ["estraverse@5.3.0", "", {}, "sha512-MMdARuVEQziNTeJD8DgMqmhwR11BRQ/cBP+pLtYdSTnf3MIO8fFeiINEbX36ZdNlfU/7A9f3gUw49B3oQsvwBA=="], + + "esutils": ["esutils@2.0.3", "", {}, "sha512-kVscqXk4OCp68SZ0dkgEKVi6/8ij300KBWTJq32P/dYeWTSwK41WyTxalN1eRmA5Z9UU/LX9D7FWSmV9SAYx6g=="], + + "fast-deep-equal": ["fast-deep-equal@3.1.3", "", {}, "sha512-f3qQ9oQy9j2AhBe/H9VC91wLmKBCCU/gDOnKNAYG5hswO7BLKj09Hc5HYNz9cGI++xlpDCIgDaitVs03ATR84Q=="], + + "fast-equals": ["fast-equals@5.4.3", "", {}, "sha512-8unmvA0qrfpFWBYUate9BTGtQdKHWBYt+KdAIkag7Vvxe7wz8Q2nJg7fLMC0bJqe0bjP31kca7Ckaawrs4Istg=="], + + "fast-glob": ["fast-glob@3.3.3", "", { "dependencies": { "@nodelib/fs.stat": "^2.0.2", "@nodelib/fs.walk": "^1.2.3", "glob-parent": "^5.1.2", "merge2": "^1.3.0", "micromatch": "^4.0.8" } }, "sha512-7MptL8U0cqcFdzIzwOTHoilX9x5BrNqye7Z/LuC7kCMRio1EMSyqRK3BEAUD7sXRq4iT4AzTVuZdhgQ2TCvYLg=="], + + "fast-json-stable-stringify": ["fast-json-stable-stringify@2.1.0", "", {}, "sha512-lhd/wF+Lk98HZoTCtlVraHtfh5XYijIjalXck7saUtuanSDyLMxnHhSXEDJqHxD7msR8D0uCmqlkwjCV8xvwHw=="], + + "fast-levenshtein": ["fast-levenshtein@2.0.6", "", {}, "sha512-DCXu6Ifhqcks7TZKY3Hxp3y6qphY5SJZmrWMDrKcERSOXWQdMhU9Ig/PYrzyw/ul9jOIyh0N4M0tbC5hodg8dw=="], + + "fastq": ["fastq@1.20.3", "", { "dependencies": { "reusify": "^1.0.4" } }, "sha512-XKv5nnLs6nLF71NgiKJLIZFLkPyIEuOselLG7ujZnGrRfQK8HpvY+WqKhAJUAdLomwVHErVS4LfxFlPq0/FTAw=="], + + "fd-slicer": ["fd-slicer@1.1.0", "", { "dependencies": { "pend": "~1.2.0" } }, "sha512-cE1qsB/VwyQozZ+q1dGxR8LBYNZeofhEdUNGSMbQD3Gw2lAzX9Zb3uIU6Ebc/Fmyjo9AWWfnn0AUCHqtevs/8g=="], + + "file-entry-cache": ["file-entry-cache@6.0.1", "", { "dependencies": { "flat-cache": "^3.0.4" } }, "sha512-7Gps/XWymbLk2QLYK4NzpMOrYjMhdIxXuIvy2QBsLE6ljuodKvdkWs/cpyJJ3CVIVpH0Oi1Hvg1ovbMzLdFBBg=="], + + "fill-range": ["fill-range@7.1.1", "", { "dependencies": { "to-regex-range": "^5.0.1" } }, "sha512-YsGpe3WHLK8ZYi4tWDg2Jy3ebRz2rXowDxnld4bkQB00cc/1Zw9AWnC0i9ztDJitivtQvaI9KaLyKrc+hBW0yg=="], + + "find-up": ["find-up@5.0.0", "", { "dependencies": { "locate-path": "^6.0.0", "path-exists": "^4.0.0" } }, "sha512-78/PXT1wlLLDgTzDs7sjq9hzz0vXD+zn+7wypEe4fXQxCmdmqfGsEPQxmiCSQI3ajFV91bVSsvNtrJRiW6nGng=="], + + "flat-cache": ["flat-cache@3.2.0", "", { "dependencies": { "flatted": "^3.2.9", "keyv": "^4.5.3", "rimraf": "^3.0.2" } }, "sha512-CYcENa+FtcUKLmhhqyctpclsq7QF38pKjZHsGNiSQF5r4FtoKDWabFDl3hzaEQMvT1LHEysw5twgLvpYYb4vbw=="], + + "flatted": ["flatted@3.4.4", "", {}, "sha512-5+ybhBZANEJxaH3X5evAFatUxLfEHSr7n6kYJ+1Qd0mUqr4eu9gIf6GDbWHf8RJijHrjjO8G+la14SlL2SeS1Q=="], + + "for-each": ["for-each@0.3.5", "", { "dependencies": { "is-callable": "^1.2.7" } }, "sha512-dKx12eRCVIzqCxFGplyFKJMPvLEWgmNtUrpTiJIR5u97zEhRG8ySrtboPHZXx7daLxQVrl643cTzbab2tkQjxg=="], + + "fs-extra": ["fs-extra@11.4.1", "", { "dependencies": { "graceful-fs": "^4.2.0", "jsonfile": "^6.0.1", "universalify": "^2.0.0" } }, "sha512-KYAb4c9BJQI6QqGKthV68OHe0badztdXJWKo0WtBA9IuCFPTKvE5ZdUBglP833aMjhaSPNO4A5j/EkzZtGlKjA=="], + + "fs.realpath": ["fs.realpath@1.0.0", "", {}, "sha512-OO0pH2lK6a0hZnAdau5ItzHPI6pUlvI7jMVnxUQRtw4owF2wk8lOSabtGDCTP4Ggrg2MbGnWO9X8K1t4+fGMDw=="], + + "fsevents": ["fsevents@2.3.3", "", { "os": "darwin" }, "sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw=="], + + "function-bind": ["function-bind@1.1.2", "", {}, "sha512-7XHNxH7qX9xG5mIwxkhumTox/MIRNcOgDrxWsMt2pAr23WHp6MrRlN7FBSFpCpr+oVO0F744iUgR82nJMfG2SA=="], + + "function.prototype.name": ["function.prototype.name@1.2.0", "", { "dependencies": { "call-bind": "^1.0.9", "call-bound": "^1.0.4", "es-define-property": "^1.0.1", "es-errors": "^1.3.0", "functions-have-names": "^1.2.3", "has-property-descriptors": "^1.0.2", "hasown": "^2.0.4", "is-callable": "^1.2.7", "is-document.all": "^1.0.0" } }, "sha512-jObKIik1P2QjPHP5nz5BaOtUlfgS0fWo8IUByNXkM+o+02sJOi94em77GwJKQSJ3gfPHdgzLNrHc1uokV4P/ew=="], + + "functions-have-names": ["functions-have-names@1.2.3", "", {}, "sha512-xckBUXyTIqT97tq2x2AMb+g163b5JFysYk0x4qxNFwbfQkmNZoiRHb6sPzI9/QV33WeuvVYBUIiD4NzNIyqaRQ=="], + + "generator-function": ["generator-function@2.0.1", "", {}, "sha512-SFdFmIJi+ybC0vjlHN0ZGVGHc3lgE0DxPAT0djjVg+kjOnSqclqmj0KQ7ykTOLP6YxoqOvuAODGdcHJn+43q3g=="], + + "get-intrinsic": ["get-intrinsic@1.3.0", "", { "dependencies": { "call-bind-apply-helpers": "^1.0.2", "es-define-property": "^1.0.1", "es-errors": "^1.3.0", "es-object-atoms": "^1.1.1", "function-bind": "^1.1.2", "get-proto": "^1.0.1", "gopd": "^1.2.0", "has-symbols": "^1.1.0", "hasown": "^2.0.2", "math-intrinsics": "^1.1.0" } }, "sha512-9fSjSaos/fRIVIp+xSJlE6lfwhES7LNtKaCBIamHsjr2na1BiABJPo0mOjjz8GJDURarmCPGqaiVg5mfjb98CQ=="], + + "get-proto": ["get-proto@1.0.1", "", { "dependencies": { "dunder-proto": "^1.0.1", "es-object-atoms": "^1.0.0" } }, "sha512-sTSfBjoXBp89JvIKIefqw7U2CCebsc74kiY6awiGogKtoSGbgjYE/G/+l9sF3MWFPNc9IcoOC4ODfKHfxFmp0g=="], + + "get-symbol-description": ["get-symbol-description@1.1.0", "", { "dependencies": { "call-bound": "^1.0.3", "es-errors": "^1.3.0", "get-intrinsic": "^1.2.6" } }, "sha512-w9UMqWwJxHNOvoNzSJ2oPF5wvYcvP7jUvYzhp67yEhTi17ZDBBC1z9pTdGuzjD+EFIqLSYRweZjqfiPzQ06Ebg=="], + + "github-slugger": ["github-slugger@1.5.0", "", {}, "sha512-wIh+gKBI9Nshz2o46B0B3f5k/W+WI9ZAv6y5Dn5WJ5SK1t0TnDimB4WE5rmTD05ZAIn8HALCZVmCsvj0w0v0lw=="], + + "glob": ["glob@13.0.6", "", { "dependencies": { "minimatch": "^10.2.2", "minipass": "^7.1.3", "path-scurry": "^2.0.2" } }, "sha512-Wjlyrolmm8uDpm/ogGyXZXb1Z+Ca2B8NbJwqBVg0axK9GbBeoS7yGV6vjXnYdGm6X53iehEuxxbyiKp8QmN4Vw=="], + + "glob-parent": ["glob-parent@6.0.2", "", { "dependencies": { "is-glob": "^4.0.3" } }, "sha512-XxwI8EOhVQgWp6iDL+3b0r86f4d6AX6zSU55HfB4ydCEuXLXc5FcYeOu+nnGftS4TEju/11rt4KJPTMgbfmv4A=="], + + "globals": ["globals@13.24.0", "", { "dependencies": { "type-fest": "^0.20.2" } }, "sha512-AhO5QUcj8llrbG09iWhPU2B204J1xnPeL8kQmVorSsy+Sjj1sk8gIyh6cUocGmH4L0UuhAJy+hJMRA4mgA4mFQ=="], + + "globalthis": ["globalthis@1.0.4", "", { "dependencies": { "define-properties": "^1.2.1", "gopd": "^1.0.1" } }, "sha512-DpLKbNU4WylpxJykQujfCcwYWiV/Jhm50Goo0wrVILAv5jOr9d+H+UR3PhSCD2rCCEIg0uc+G+muBTwD54JhDQ=="], + + "globby": ["globby@11.1.0", "", { "dependencies": { "array-union": "^2.1.0", "dir-glob": "^3.0.1", "fast-glob": "^3.2.9", "ignore": "^5.2.0", "merge2": "^1.4.1", "slash": "^3.0.0" } }, "sha512-jhIXaOzy1sb8IyocaruWSn1TjmnBVs8Ayhcy83rmxNJ8q2uWKCAj3CnJY+KpGSXCueAPc0i05kVvVKtP1t9S3g=="], + + "gopd": ["gopd@1.2.0", "", {}, "sha512-ZUKRh6/kUFoAiTAtTYPZJ3hw9wNxx+BIBOijnlG9PnrJsCcSjs1wyyD6vJpaYtgnzDrKYRSqf3OO6Rfa93xsRg=="], + + "graceful-fs": ["graceful-fs@4.2.11", "", {}, "sha512-RbJ5/jmFcNNCcDV5o9eTnBLJ/HszWV0P73bc+Ff4nS/rJj+YaS6IGyiOL0VoBYX+l1Wrl3k63h/KrH+nhJ0XvQ=="], + + "graphemer": ["graphemer@1.4.0", "", {}, "sha512-EtKwoO6kxCL9WO5xipiHTZlSzBm7WLT627TqC/uVRd0HKmq8NXyebnNYxDoBi7wt8eTWrUrKXCOVaFq9x1kgag=="], + + "has-bigints": ["has-bigints@1.1.0", "", {}, "sha512-R3pbpkcIqv2Pm3dUwgjclDRVmWpTJW2DcMzcIhEXEx1oh/CEMObMm3KLmRJOdvhM7o4uQBnwr8pzRK2sJWIqfg=="], + + "has-flag": ["has-flag@4.0.0", "", {}, "sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ=="], + + "has-property-descriptors": ["has-property-descriptors@1.0.2", "", { "dependencies": { "es-define-property": "^1.0.0" } }, "sha512-55JNKuIW+vq4Ke1BjOTjM2YctQIvCT7GFzHwmfZPGo5wnrgkid0YQtnAleFSqumZm4az3n2BS+erby5ipJdgrg=="], + + "has-proto": ["has-proto@1.2.0", "", { "dependencies": { "dunder-proto": "^1.0.0" } }, "sha512-KIL7eQPfHQRC8+XluaIw7BHUwwqL19bQn4hzNgdr+1wXoU0KKj6rufu47lhY7KbJR2C6T6+PfyN0Ea7wkSS+qQ=="], + + "has-symbols": ["has-symbols@1.1.0", "", {}, "sha512-1cDNdwJ2Jaohmb3sg4OmKaMBwuC48sYni5HUw2DvsC8LjGTLK9h+eb1X6RyuOHe4hT0ULCW68iomhjUoKUqlPQ=="], + + "has-tostringtag": ["has-tostringtag@1.0.2", "", { "dependencies": { "has-symbols": "^1.0.3" } }, "sha512-NqADB8VjPFLM2V0VvHUewwwsw0ZWBaIdgo+ieHtK3hasLz4qeCRjYcqfB6AQrBggRKppKF8L52/VqdVsO47Dlw=="], + + "hasown": ["hasown@2.0.4", "", { "dependencies": { "function-bind": "^1.1.2" } }, "sha512-T2UbfbBEF32wiepXIsMlTW9+dDYC6wMh/t/vYA4tuOMKqWz/n3vr1NFSxQiyP+zk2mXsoMA/i/7qV6LKut1t1A=="], + + "ignore": ["ignore@5.3.2", "", {}, "sha512-hsBTNUqQTDwkWtcdYI2i06Y/nUBEsNEDJKjWdigLvegy8kDuJAS8uRlpkkcQpyEXL0Z/pjDy5HBmMjRCJ2gq+g=="], + + "import-fresh": ["import-fresh@3.3.1", "", { "dependencies": { "parent-module": "^1.0.0", "resolve-from": "^4.0.0" } }, "sha512-TR3KfrTZTYLPB6jUjfx6MF9WcWrHL9su5TObK4ZkYgBdWKPOFoSoQIdEuTuR82pmtxH2spWG9h6etwfr1pLBqQ=="], + + "imurmurhash": ["imurmurhash@0.1.4", "", {}, "sha512-JmXMZ6wuvDmLiHEml9ykzqO6lwFbof0GG4IkcGaENdCRDDmMVnny7s5HsIgHCbaq0w2MyPhDqkhTUgS2LU2PHA=="], + + "inflight": ["inflight@1.0.6", "", { "dependencies": { "once": "^1.3.0", "wrappy": "1" } }, "sha512-k92I/b08q4wvFscXCLvqfsHCrjrF7yiXsQuIVvVE7N82W3+aqpzuUdBbfhWcy/FZR3/4IgflMgKLOsvPDrGCJA=="], + + "inherits": ["inherits@2.0.4", "", {}, "sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ=="], + + "ini": ["ini@4.1.3", "", {}, "sha512-X7rqawQBvfdjS10YU1y1YVreA3SsLrW9dX2CewP2EbBJM4ypVNLDkO5y04gejPwKIY9lR+7r9gn3rFPt/kmWFg=="], + + "internal-slot": ["internal-slot@1.1.0", "", { "dependencies": { "es-errors": "^1.3.0", "hasown": "^2.0.2", "side-channel": "^1.1.0" } }, "sha512-4gd7VpWNQNB4UKKCFFVcp1AVv+FMOgs9NKzjHKusc8jTMhd5eL1NqQqOpE0KzMds804/yHlglp3uxgluOqAPLw=="], + + "is-array-buffer": ["is-array-buffer@3.0.5", "", { "dependencies": { "call-bind": "^1.0.8", "call-bound": "^1.0.3", "get-intrinsic": "^1.2.6" } }, "sha512-DDfANUiiG2wC1qawP66qlTugJeL5HyzMpfr8lLK+jMQirGzNod0B12cFB/9q838Ru27sBwfw78/rdoU7RERz6A=="], + + "is-arrayish": ["is-arrayish@0.2.1", "", {}, "sha512-zz06S8t0ozoDXMG+ube26zeCTNXcKIPJZJi8hBrF4idCLms4CG9QtK7qBl1boi5ODzFpjswb5JPmHCbMpjaYzg=="], + + "is-async-function": ["is-async-function@2.1.1", "", { "dependencies": { "async-function": "^1.0.0", "call-bound": "^1.0.3", "get-proto": "^1.0.1", "has-tostringtag": "^1.0.2", "safe-regex-test": "^1.1.0" } }, "sha512-9dgM/cZBnNvjzaMYHVoxxfPj2QXt22Ev7SuuPrs+xav0ukGB0S6d4ydZdEiM48kLx5kDV+QBPrpVnFyefL8kkQ=="], + + "is-bigint": ["is-bigint@1.1.0", "", { "dependencies": { "has-bigints": "^1.0.2" } }, "sha512-n4ZT37wG78iz03xPRKJrHTdZbe3IicyucEtdRsV5yglwc3GyUfbAfpSeD0FJ41NbUNSt5wbhqfp1fS+BgnvDFQ=="], + + "is-boolean-object": ["is-boolean-object@1.2.2", "", { "dependencies": { "call-bound": "^1.0.3", "has-tostringtag": "^1.0.2" } }, "sha512-wa56o2/ElJMYqjCjGkXri7it5FbebW5usLw/nPmCMs5DeZ7eziSYZhSmPRn0txqeW4LnAmQQU7FgqLpsEFKM4A=="], + + "is-callable": ["is-callable@1.2.7", "", {}, "sha512-1BC0BVFhS/p0qtw6enp8e+8OD0UrK0oFLztSjNzhcKA3WDuJxxAPXzPuPtKkjEY9UUoEWlX/8fgKeu2S8i9JTA=="], + + "is-core-module": ["is-core-module@2.17.0", "", { "dependencies": { "hasown": "^2.0.4" } }, "sha512-J/vG0zBCbIKOQFfufSwyXdMrsohyJIUNkrnmo6WZGzoM7tr/lsbfW5b2BvisL6zsyMzK9UxV9L6c7AoFbyXHOA=="], + + "is-data-view": ["is-data-view@1.0.2", "", { "dependencies": { "call-bound": "^1.0.2", "get-intrinsic": "^1.2.6", "is-typed-array": "^1.1.13" } }, "sha512-RKtWF8pGmS87i2D6gqQu/l7EYRlVdfzemCJN/P3UOs//x1QE7mfhvzHIApBTRf7axvT6DMGwSwBXYCT0nfB9xw=="], + + "is-date-object": ["is-date-object@1.1.0", "", { "dependencies": { "call-bound": "^1.0.2", "has-tostringtag": "^1.0.2" } }, "sha512-PwwhEakHVKTdRNVOw+/Gyh0+MzlCl4R6qKvkhuvLtPMggI1WAHt9sOwZxQLSGpUaDnrdyDsomoRgNnCfKNSXXg=="], + + "is-docker": ["is-docker@2.2.1", "", { "bin": { "is-docker": "cli.js" } }, "sha512-F+i2BKsFrH66iaUFc0woD8sLy8getkwTwtOBjvs56Cx4CgJDeKQeqfz8wAYiSb8JOprWhHH5p77PbmYCvvUuXQ=="], + + "is-document.all": ["is-document.all@1.0.0", "", { "dependencies": { "call-bound": "^1.0.4" } }, "sha512-+XSoyS05OdBbhFuELhgTCpFNHkpBOJqtsZfUFFpe5QTw+9Sjbh8zitxhQkYAo6wV7e1Vb8cAPvpCk9jGam/82g=="], + + "is-extglob": ["is-extglob@2.1.1", "", {}, "sha512-SbKbANkN603Vi4jEZv49LeVJMn4yGwsbzZworEoyEiutsN3nJYdbO36zfhGJ6QEDpOZIFkDtnq5JRxmvl3jsoQ=="], + + "is-finalizationregistry": ["is-finalizationregistry@1.1.1", "", { "dependencies": { "call-bound": "^1.0.3" } }, "sha512-1pC6N8qWJbWoPtEjgcL2xyhQOP491EQjeUo3qTKcmV8YSDDJrOepfG8pcC7h/QgnQHYSv0mJ3Z/ZWxmatVrysg=="], + + "is-fullwidth-code-point": ["is-fullwidth-code-point@3.0.0", "", {}, "sha512-zymm5+u+sCsSWyD9qNaejV3DFvhCKclKdizYaJUuHA83RLjb7nSuGnddCHGv0hk+KY7BMAlsWeK4Ueg6EV6XQg=="], + + "is-generator-function": ["is-generator-function@1.1.2", "", { "dependencies": { "call-bound": "^1.0.4", "generator-function": "^2.0.0", "get-proto": "^1.0.1", "has-tostringtag": "^1.0.2", "safe-regex-test": "^1.1.0" } }, "sha512-upqt1SkGkODW9tsGNG5mtXTXtECizwtS2kA161M+gJPc1xdb/Ax629af6YrTwcOeQHbewrPNlE5Dx7kzvXTizA=="], + + "is-glob": ["is-glob@4.0.3", "", { "dependencies": { "is-extglob": "^2.1.1" } }, "sha512-xelSayHH36ZgE7ZWhli7pW34hNbNl8Ojv5KVmkJD4hBdD3th8Tfk9vYasLM+mXWOZhFkgZfxhLSnrwRr4elSSg=="], + + "is-map": ["is-map@2.0.3", "", {}, "sha512-1Qed0/Hr2m+YqxnM09CjA2d/i6YZNfF6R2oRAOj36eUdS6qIV/huPJNSEpKbupewFs+ZsJlxsjjPbc0/afW6Lw=="], + + "is-negative-zero": ["is-negative-zero@2.0.3", "", {}, "sha512-5KoIu2Ngpyek75jXodFvnafB6DJgr3u8uuK0LEZJjrU19DrMD3EVERaR8sjz8CCGgpZvxPl9SuE1GMVPFHx1mw=="], + + "is-number": ["is-number@7.0.0", "", {}, "sha512-41Cifkg6e8TylSpdtTpeLVMqvSBEVzTttHvERD741+pnZ8ANv0004MRL43QKPDlK9cGvNp6NZWZUBlbGXYxxng=="], + + "is-number-object": ["is-number-object@1.1.1", "", { "dependencies": { "call-bound": "^1.0.3", "has-tostringtag": "^1.0.2" } }, "sha512-lZhclumE1G6VYD8VHe35wFaIif+CTy5SJIi5+3y4psDgWu4wPDoBhF8NxUOinEc7pHgiTsT6MaBb92rKhhD+Xw=="], + + "is-path-inside": ["is-path-inside@3.0.3", "", {}, "sha512-Fd4gABb+ycGAmKou8eMftCupSir5lRxqf4aD/vd0cD2qc4HL07OjCeuHMr8Ro4CoMaeCKDB0/ECBOVWjTwUvPQ=="], + + "is-regex": ["is-regex@1.2.1", "", { "dependencies": { "call-bound": "^1.0.2", "gopd": "^1.2.0", "has-tostringtag": "^1.0.2", "hasown": "^2.0.2" } }, "sha512-MjYsKHO5O7mCsmRGxWcLWheFqN9DJ/2TmngvjKXihe6efViPqc274+Fx/4fYj/r03+ESvBdTXK0V6tA3rgez1g=="], + + "is-set": ["is-set@2.0.3", "", {}, "sha512-iPAjerrse27/ygGLxw+EBR9agv9Y6uLeYVJMu+QNCoouJ1/1ri0mGrcWpfCqFZuzzx3WjtwxG098X+n4OuRkPg=="], + + "is-shared-array-buffer": ["is-shared-array-buffer@1.0.4", "", { "dependencies": { "call-bound": "^1.0.3" } }, "sha512-ISWac8drv4ZGfwKl5slpHG9OwPNty4jOWPRIhBpxOoD+hqITiwuipOQ2bNthAzwA3B4fIjO4Nln74N0S9byq8A=="], + + "is-string": ["is-string@1.1.1", "", { "dependencies": { "call-bound": "^1.0.3", "has-tostringtag": "^1.0.2" } }, "sha512-BtEeSsoaQjlSPBemMQIrY1MY0uM6vnS1g5fmufYOtnxLGUZM2178PKbhsk7Ffv58IX+ZtcvoGwccYsh0PglkAA=="], + + "is-symbol": ["is-symbol@1.1.1", "", { "dependencies": { "call-bound": "^1.0.2", "has-symbols": "^1.1.0", "safe-regex-test": "^1.1.0" } }, "sha512-9gGx6GTtCQM73BgmHQXfDmLtfjjTUDSyoxTCbp5WtoixAhfgsDirWIcVQ/IHpvI5Vgd5i/J5F7B9cN/WlVbC/w=="], + + "is-typed-array": ["is-typed-array@1.1.15", "", { "dependencies": { "which-typed-array": "^1.1.16" } }, "sha512-p3EcsicXjit7SaskXHs1hA91QxgTw46Fv6EFKKGS5DRFLD8yKnohjF3hxoju94b/OcMZoQukzpPpBE9uLVKzgQ=="], + + "is-weakmap": ["is-weakmap@2.0.2", "", {}, "sha512-K5pXYOm9wqY1RgjpL3YTkF39tni1XajUIkawTLUo9EZEVUFga5gSQJF8nNS7ZwJQ02y+1YCNYcMh+HIf1ZqE+w=="], + + "is-weakref": ["is-weakref@1.1.1", "", { "dependencies": { "call-bound": "^1.0.3" } }, "sha512-6i9mGWSlqzNMEqpCp93KwRS1uUOodk2OJ6b+sq7ZPDSy2WuI5NFIxp/254TytR8ftefexkWn5xNiHUNpPOfSew=="], + + "is-weakset": ["is-weakset@2.0.4", "", { "dependencies": { "call-bound": "^1.0.3", "get-intrinsic": "^1.2.6" } }, "sha512-mfcwb6IzQyOKTs84CQMrOwW4gQcaTOAWJ0zzJCl2WSPDrWk/OzDaImWFH3djXhb24g4eudZfLRozAvPGw4d9hQ=="], + + "is-wsl": ["is-wsl@2.2.0", "", { "dependencies": { "is-docker": "^2.0.0" } }, "sha512-fKzAra0rGJUUBwGBgNkHZuToZcn+TtXHpeCgmkMJMMYx1sQDYaCSyjJBSCa2nH1DGm7s3n1oBnohoVTBaN7Lww=="], + + "isarray": ["isarray@2.0.5", "", {}, "sha512-xHjhDr3cNBK0BzdUJSPXZntQUx/mwMS5Rw4A7lPJ90XGAO6ISP/ePDNuo0vhqOZU+UD5JoodwCAAoZQd3FeAKw=="], + + "isexe": ["isexe@2.0.0", "", {}, "sha512-RHxMLp9lnKHGHRng9QFhRCMbYAcVpn69smSGcq3f36xjgVVWThj4qqLbTLlq7Ssj8B+fIQ1EuCEGI2lKsyQeIw=="], + + "js-tokens": ["js-tokens@4.0.0", "", {}, "sha512-RdJUflcE3cUzKiMqQgsCu06FPu9UdIJO0beYbPhHN4k6apgJtifcoCtT9bcxOpYBtpD2kCM6Sbzg4CausW/PKQ=="], + + "js-yaml": ["js-yaml@4.3.2", "", { "dependencies": { "argparse": "^2.0.1" }, "bin": { "js-yaml": "bin/js-yaml.js" } }, "sha512-SFNOvSJ+Dgf/9An904Yx+CgSlIPCkIpao4qo51lpee25TIRejdH3rhR4EZMGoNx3/TP3O+wzWuiTFl4sqbltzA=="], + + "json-buffer": ["json-buffer@3.0.1", "", {}, "sha512-4bV5BfR2mqfQTJm+V5tPPdf+ZpuhiIvTuAB5g8kcrXOZpTT/QwwVRWBywX1ozr6lEuPdbHxwaJlm9G6mI2sfSQ=="], + + "json-parse-even-better-errors": ["json-parse-even-better-errors@2.3.1", "", {}, "sha512-xyFwyhro/JEof6Ghe2iz2NcXoj2sloNsWr/XsERDK/oiPCfaNhl5ONfp+jQdAZRQQ0IJWNzH9zIZF7li91kh2w=="], + + "json-schema-traverse": ["json-schema-traverse@0.4.1", "", {}, "sha512-xbbCH5dCYU5T8LcEhhuh7HJ88HXuW3qsI3Y0zOZFKfZEHcpWiHU/Jxzk629Brsab/mMiHQti9wMP+845RPe3Vg=="], + + "json-stable-stringify-without-jsonify": ["json-stable-stringify-without-jsonify@1.0.1", "", {}, "sha512-Bdboy+l7tA3OGW6FjyFHWkP5LuByj1Tk33Ljyq0axyzdk9//JSi2u3fP1QSmd1KNwq6VOKYGlAu87CisVir6Pw=="], + + "json5": ["json5@1.0.2", "", { "dependencies": { "minimist": "^1.2.0" }, "bin": { "json5": "lib/cli.js" } }, "sha512-g1MWMLBiz8FKi1e4w0UyVL3w+iJceWAFBAaBnnGKOpNa5f8TLktkbre1+s6oICydWAm+HRUGTmI+//xv2hvXYA=="], + + "jsonfile": ["jsonfile@6.2.1", "", { "dependencies": { "universalify": "^2.0.0" }, "optionalDependencies": { "graceful-fs": "^4.1.6" } }, "sha512-zwOTdL3rFQ/lRdBnntKVOX6k5cKJwEc1HdilT71BWEu7J41gXIB2MRp+vxduPSwZJPWBxEzv4yH1wYLJGUHX4Q=="], + + "kdbush": ["kdbush@4.1.0", "", {}, "sha512-e9vurzrXJQrFX6ckpHP3bvj5l+9CnYzkxDNnNQ1h2QTqdWsUAJgXiKdGNcOa1EY85dU8KbQ+z/FdQdB7P+9yfQ=="], + + "keyv": ["keyv@4.5.4", "", { "dependencies": { "json-buffer": "3.0.1" } }, "sha512-oxVHkHR/EJf2CNXnWxRLW6mg7JyCCUcG0DtEGmL2ctUo1PNTin1PUil+r/+4r5MpVgC/fn1kjsx7mjSujKqIpw=="], + + "kleur": ["kleur@4.1.5", "", {}, "sha512-o+NO+8WrRiQEE4/7nwRJhN1HWpVmJm511pBHUxPLtp0BUISzlBplORYSmTclCnJvQq2tKu/sgl3xVpkc7ZWuQQ=="], + + "levn": ["levn@0.4.1", "", { "dependencies": { "prelude-ls": "^1.2.1", "type-check": "~0.4.0" } }, "sha512-+bT2uH4E5LGE7h/n3evcS/sQlJXCpIp6ym8OWJ5eV6+67Dsql/LaaT7qJBAt2rzfoa/5QBGBhxDix1dMt2kQKQ=="], + + "lines-and-columns": ["lines-and-columns@1.2.4", "", {}, "sha512-7ylylesZQ/PV29jhEDl3Ufjo6ZX7gCqJr5F7PKrqc93v7fzSymt1BpwEU8nAUXs8qzzvqhbjhK5QZg6Mt/HkBg=="], + + "locate-path": ["locate-path@6.0.0", "", { "dependencies": { "p-locate": "^5.0.0" } }, "sha512-iPZK6eYjbxRu3uB4/WZ3EsEIMJFMqAoopl3R+zuq0UjcAm/MO6KCweDgPfP3elTztoKP3KtnVHxTn2NHBSDVUw=="], + + "lodash.merge": ["lodash.merge@4.6.2", "", {}, "sha512-0KpjqXRVvrYyCsX1swR/XTK0va6VQkQM6MNo7PqW77ByjAhoARA8EfrP1N4+KlKj8YS0ZUCtRT/YUuhyYDujIQ=="], + + "lru-cache": ["lru-cache@11.5.3", "", {}, "sha512-U4N8FgzmWxc8k1VH8Kr6lQg18U7Fjvby6wXHVRX/ZZ7IwWbRMgrRbP0Wrb5q5NVinryp4SQampHKdvtecItxUg=="], + + "math-intrinsics": ["math-intrinsics@1.1.0", "", {}, "sha512-/IXtbwEk5HTPyEwyKX6hGkYXxM9nbj64B+ilVJnC/R6B0pH5G4V3b0pVbL7DBj4tkhBAppbQUlf6F6Xl9LHu1g=="], + + "merge2": ["merge2@1.4.1", "", {}, "sha512-8q7VEgMJW4J8tcfVPy8g09NcQwZdbwFEqhe/WZkoIzjn/3TGDwtOCYtXGxA3O8tPzpczCCDgv+P2P5y00ZJOOg=="], + + "micromatch": ["micromatch@4.0.8", "", { "dependencies": { "braces": "^3.0.3", "picomatch": "^2.3.1" } }, "sha512-PXwfBhYu0hBCPw8Dn0E+WDYb7af3dSLVWKi3HGv84IdF4TyFoC0ysxFd0Goxw7nSv4T/PzEJQxsYsEiFCKo2BA=="], + + "minimatch": ["minimatch@3.1.5", "", { "dependencies": { "brace-expansion": "^1.1.7" } }, "sha512-VgjWUsnnT6n+NUk6eZq77zeFdpW2LWDzP6zFGrCbHXiYNul5Dzqk2HHQ5uFH2DNW5Xbp8+jVzaeNt94ssEEl4w=="], + + "minimist": ["minimist@1.2.8", "", {}, "sha512-2yyAR8qBkN3YuheJanUpWC5U3bb5osDywNB8RzDVlDwDHbocAJveqqj1u8+SVD7jkWT4yvsHCpWqqWqAxb0zCA=="], + + "minipass": ["minipass@7.1.3", "", {}, "sha512-tEBHqDnIoM/1rXME1zgka9g6Q2lcoCkxHLuc7ODJ5BxbP5d4c2Z5cGgtXAku59200Cx7diuHTOYfSBD8n6mm8A=="], + + "minizlib": ["minizlib@3.1.0", "", { "dependencies": { "minipass": "^7.1.2" } }, "sha512-KZxYo1BUkWD2TVFLr0MQoM8vUUigWD3LlD83a/75BqC+4qE0Hb1Vo5v1FgcfaNXvfXzr+5EhQ6ing/CaBijTlw=="], + + "ms": ["ms@2.1.3", "", {}, "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA=="], + + "native-run": ["native-run@2.0.3", "", { "dependencies": { "@ionic/utils-fs": "^3.1.7", "@ionic/utils-terminal": "^2.3.4", "bplist-parser": "^0.3.2", "debug": "^4.3.4", "elementtree": "^0.1.7", "ini": "^4.1.1", "plist": "^3.1.0", "split2": "^4.2.0", "through2": "^4.0.2", "tslib": "^2.6.2", "yauzl": "^2.10.0" }, "bin": { "native-run": "bin/native-run" } }, "sha512-U1PllBuzW5d1gfan+88L+Hky2eZx+9gv3Pf6rNBxKbORxi7boHzqiA6QFGSnqMem4j0A9tZ08NMIs5+0m/VS1Q=="], + + "natural-compare": ["natural-compare@1.4.0", "", {}, "sha512-OWND8ei3VtNC9h7V60qff3SVobHr996CTwgxubgyQYEpg290h9J0buyECNNJexkFm5sOajh5G116RYA1c8ZMSw=="], + + "natural-compare-lite": ["natural-compare-lite@1.4.1", "", {}, "sha512-8Mz06azhPqiDlxhUaUTjBhNAbib/1MoPr89kgmuV6Ir8ICT2/Q/XSYg6VfL3fq2x8MpSQX8sqyI/NeZ5GsGyXA=="], + + "node-exports-info": ["node-exports-info@1.6.2", "", { "dependencies": { "array.prototype.flatmap": "^1.3.3", "es-errors": "^1.3.0", "object.entries": "^1.1.9", "semver": "^6.3.1" } }, "sha512-kXs9Go0cah0qHVV2v389IXQLdLCeE1xfFtjOAF+iobu0OIoG1pje8At2vMHyaPMiPMnG/LWP50twML21eMcAag=="], + + "object-inspect": ["object-inspect@1.13.4", "", {}, "sha512-W67iLl4J2EXEGTbfeHCffrjDfitvLANg0UlX3wFUUSTx92KXRFegMHUVgSqE+wvhAbi4WqjGg9czysTV2Epbew=="], + + "object-keys": ["object-keys@1.1.1", "", {}, "sha512-NuAESUOUMrlIXOfHKzD6bpPu3tYt3xvjNdRIQ+FeT0lNb4K8WR70CaDxhuNguS2XG+GjkyMwOzsN5ZktImfhLA=="], + + "object.assign": ["object.assign@4.1.7", "", { "dependencies": { "call-bind": "^1.0.8", "call-bound": "^1.0.3", "define-properties": "^1.2.1", "es-object-atoms": "^1.0.0", "has-symbols": "^1.1.0", "object-keys": "^1.1.1" } }, "sha512-nK28WOo+QIjBkDduTINE4JkF/UJJKyf2EJxvJKfblDpyg0Q+pkOHNTL0Qwy6NP6FhE/EnzV73BxxqcJaXY9anw=="], + + "object.entries": ["object.entries@1.1.9", "", { "dependencies": { "call-bind": "^1.0.8", "call-bound": "^1.0.4", "define-properties": "^1.2.1", "es-object-atoms": "^1.1.1" } }, "sha512-8u/hfXFRBD1O0hPUjioLhoWFHRmt6tKA4/vZPyckBr18l1KE9uHrFaFaUi8MDRTpi4uak2goyPTSNJLXX2k2Hw=="], + + "object.fromentries": ["object.fromentries@2.0.8", "", { "dependencies": { "call-bind": "^1.0.7", "define-properties": "^1.2.1", "es-abstract": "^1.23.2", "es-object-atoms": "^1.0.0" } }, "sha512-k6E21FzySsSK5a21KRADBd/NGneRegFO5pLHfdQLpRDETUNJueLXs3WCzyQ3tFRDYgbq3KHGXfTbi2bs8WQ6rQ=="], + + "object.groupby": ["object.groupby@1.0.3", "", { "dependencies": { "call-bind": "^1.0.7", "define-properties": "^1.2.1", "es-abstract": "^1.23.2" } }, "sha512-+Lhy3TQTuzXI5hevh8sBGqbmurHbbIjAi0Z4S63nthVLmLxfbj4T54a4CfZrXIrt9iP4mVAPYMo/v99taj3wjQ=="], + + "object.values": ["object.values@1.2.1", "", { "dependencies": { "call-bind": "^1.0.8", "call-bound": "^1.0.3", "define-properties": "^1.2.1", "es-object-atoms": "^1.0.0" } }, "sha512-gXah6aZrcUxjWg2zR2MwouP2eHlCBzdV4pygudehaKXSGW4v2AsRQUK+lwwXhii6KFZcunEnmSUoYp5CXibxtA=="], + + "once": ["once@1.4.0", "", { "dependencies": { "wrappy": "1" } }, "sha512-lNaJgI+2Q5URQBkccEKHTQOPaXdUxnZZElQTZY0MFUAuaEqe1E+Nyvgdz/aIyNi6Z9MzO5dv1H8n58/GELp3+w=="], + + "open": ["open@8.4.2", "", { "dependencies": { "define-lazy-prop": "^2.0.0", "is-docker": "^2.1.1", "is-wsl": "^2.2.0" } }, "sha512-7x81NCL719oNbsq/3mh+hVrAWmFuEYUqrq/Iw3kUzH8ReypT9QQ0BLoJS7/G9k6N81XjW4qHWtjWwe/9eLy1EQ=="], + + "optionator": ["optionator@0.9.4", "", { "dependencies": { "deep-is": "^0.1.3", "fast-levenshtein": "^2.0.6", "levn": "^0.4.1", "prelude-ls": "^1.2.1", "type-check": "^0.4.0", "word-wrap": "^1.2.5" } }, "sha512-6IpQ7mKUxRcZNLIObR0hz7lxsapSSIYNZJwXPGeF0mTVqGKFIXj1DQcMoT22S3ROcLyY/rz0PWaWZ9ayWmad9g=="], + + "own-keys": ["own-keys@1.0.2", "", { "dependencies": { "call-bound": "^1.0.4", "get-intrinsic": "^1.3.0", "object-keys": "^1.1.1", "safe-push-apply": "^1.0.0" } }, "sha512-19YVAg7T+WTrxggPukVq7DjTv6+PJ867TmhCvBsYwmbFCsZd344rq2Ld1p0wo8f8Qrrhgp82c6FJRqdXWtSEhg=="], + + "p-limit": ["p-limit@3.1.0", "", { "dependencies": { "yocto-queue": "^0.1.0" } }, "sha512-TYOanM3wGwNGsZN2cVTYPArw454xnXj5qmWF1bEoAc4+cU/ol7GVh7odevjp1FNHduHc3KZMcFduxU5Xc6uJRQ=="], + + "p-locate": ["p-locate@5.0.0", "", { "dependencies": { "p-limit": "^3.0.2" } }, "sha512-LaNjtRWUBY++zB5nE/NwcaoMylSPk+S+ZHNB1TzdbMJMny6dynpAGt7X/tl/QYq3TIeE6nxHppbo2LGymrG5Pw=="], + + "package-json-from-dist": ["package-json-from-dist@1.0.1", "", {}, "sha512-UEZIS3/by4OC8vL3P2dTXRETpebLI2NiI5vIrjaD/5UtrkFX/tNbwjTSRAGC/+7CAo2pIcBaRgWmcBBHcsaCIw=="], + + "parent-module": ["parent-module@1.0.1", "", { "dependencies": { "callsites": "^3.0.0" } }, "sha512-GQ2EWRpQV8/o+Aw8YqtfZZPfNRWZYkbidE9k5rpl/hC3vtHHBfGm2Ifi6qWV+coDGkrUKZAxE3Lot5kcsRlh+g=="], + + "parse-json": ["parse-json@5.2.0", "", { "dependencies": { "@babel/code-frame": "^7.0.0", "error-ex": "^1.3.1", "json-parse-even-better-errors": "^2.3.0", "lines-and-columns": "^1.1.6" } }, "sha512-ayCKvm/phCGxOkYRSCM82iDwct8/EonSEgCSxWxD7ve6jHggsFl4fZVQBPRNgQoKiuV/odhFrGzQXZwbifC8Rg=="], + + "path-exists": ["path-exists@4.0.0", "", {}, "sha512-ak9Qy5Q7jYb2Wwcey5Fpvg2KoAc/ZIhLSLOSBmRmygPsGwkVVt0fZa0qrtMz+m6tJTAHfZQ8FnmB4MG4LWy7/w=="], + + "path-is-absolute": ["path-is-absolute@1.0.1", "", {}, "sha512-AVbw3UJ2e9bq64vSaS9Am0fje1Pa8pbGqTTsmXfaIiMpnr5DlDhfJOuLj9Sf95ZPVDAUerDfEk88MPmPe7UCQg=="], + + "path-key": ["path-key@3.1.1", "", {}, "sha512-ojmeN0qd+y0jszEtoY48r0Peq5dwMEkIlCOu6Q5f41lfkswXuKtYrhgoTpLnyIcHm24Uhqx+5Tqm2InSwLhE6Q=="], + + "path-parse": ["path-parse@1.0.7", "", {}, "sha512-LDJzPVEEEPR+y48z93A0Ed0yXb8pAByGWo/k5YYdYgpY2/2EsOsksJrq7lOHxryrVOn1ejG6oAp8ahvOIQD8sw=="], + + "path-scurry": ["path-scurry@2.0.2", "", { "dependencies": { "lru-cache": "^11.0.0", "minipass": "^7.1.2" } }, "sha512-3O/iVVsJAPsOnpwWIeD+d6z/7PmqApyQePUtCndjatj/9I5LylHvt5qluFaBT3I5h3r1ejfR056c+FCv+NnNXg=="], + + "path-type": ["path-type@4.0.0", "", {}, "sha512-gDKb8aZMDeD/tZWs9P6+q0J9Mwkdl6xMV8TjnGP3qJVJ06bdMgkbBlLU8IdfOsIsFz2BW1rNVT3XuNEl8zPAvw=="], + + "pend": ["pend@1.2.0", "", {}, "sha512-F3asv42UuXchdzt+xXqfW1OGlVBe+mxa2mqI0pg5yAHZPvFmY3Y6drSf/GQ1A86WgWEN9Kzh/WrgKa6iGcHXLg=="], + + "picocolors": ["picocolors@1.1.1", "", {}, "sha512-xceH2snhtb5M9liqDsmEw56le376mTZkEX/jEb/RxNFyegNul7eNslCXP9FDj/Lcu0X8KEyMceP2ntpaHrDEVA=="], + + "picomatch": ["picomatch@2.3.2", "", {}, "sha512-V7+vQEJ06Z+c5tSye8S+nHUfI51xoXIXjHQ99cQtKUkQqqO1kO/KCJUfZXuB47h/YBlDhah2H3hdUGXn8ie0oA=="], + + "plist": ["plist@3.1.1", "", { "dependencies": { "@xmldom/xmldom": "^0.9.10", "base64-js": "^1.5.1", "xmlbuilder": "^15.1.1" } }, "sha512-ZIfcLJC+7E7FBFnDxm9MPmt7D+DidyQ26lewieO75AdhA2ayMtsJSES0iWzqJQbcVRSrTufQoy0DR94xHue0oA=="], + + "possible-typed-array-names": ["possible-typed-array-names@1.1.0", "", {}, "sha512-/+5VFTchJDoVj3bhoqi6UeymcD00DAwb1nJwamzPvHEszJ4FpF6SNNbUbOS8yI56qHzdV8eK0qEfOSiodkTdxg=="], + + "prelude-ls": ["prelude-ls@1.2.1", "", {}, "sha512-vkcDPrRZo1QZLbn5RLGPpg/WmIQ65qoWWhcGKf/b5eplkkarX0m9z8ppCat4mlOqUsWpyNuYgO3VRyrYHSzX5g=="], + + "prettier": ["prettier@3.9.9", "", { "bin": { "prettier": "bin/prettier.cjs" } }, "sha512-Z/CJHIkdujO/OtN7nXUii0Rf3VT5SRuhjBA82Xvu2XhBUgX3nhP67T0LHceBdQLex7OOFGTox+Q5Yg8Jk2Qivg=="], + + "prettier-plugin-java": ["prettier-plugin-java@2.11.0", "", { "dependencies": { "web-tree-sitter": "0.27.0" }, "peerDependencies": { "prettier": "^3.0.0" } }, "sha512-pLwm2wHvVvW5eVVLf1cq2orY2ATaIj5ngN8hJ5ZdXYzUHzxrfaZkk2xmu8Mz/duBXAc2xT/cUH5+dK414HQSTw=="], + + "prettier-pretty-check": ["prettier-pretty-check@0.2.0", "", { "dependencies": { "diff": "^5.2.0" }, "bin": { "prettier-pretty-check": "index.js" } }, "sha512-gVmwxYvm1Qii1H6eULNcNchlruyXyKkluP1LBhUaqdSvvACc8FZ99zTWzqQHJrBu9qUrYmNRysPmnYSm9c7G6Q=="], + + "prompts": ["prompts@2.4.2", "", { "dependencies": { "kleur": "^3.0.3", "sisteransi": "^1.0.5" } }, "sha512-NxNv/kLguCA7p3jE8oL2aEBsrJWgAakBpgmgK6lpPWV+WuOmY6r2/zbAVnP+T8bQlA0nzHXSJSJW0Hq7ylaD2Q=="], + + "punycode": ["punycode@2.3.1", "", {}, "sha512-vYt7UD1U9Wg6138shLtLOvdAu+8DsC/ilFtEVHcH+wydcSpNE20AfSOduf6MkRFahL5FY7X1oU7nKVZFtfq8Fg=="], + + "queue-microtask": ["queue-microtask@1.2.3", "", {}, "sha512-NuaNSa6flKT5JaSYQzJok04JzTL1CA6aGhv5rfLW3PgqA+M2ChpZQnAC8h8i4ZFkBS8X5RqkDBHA7r4hej3K9A=="], + + "readable-stream": ["readable-stream@3.6.2", "", { "dependencies": { "inherits": "^2.0.3", "string_decoder": "^1.1.1", "util-deprecate": "^1.0.1" } }, "sha512-9u/sniCrY3D5WdsERHzHE4G2YCXqoG5FTHUiCC4SIbr6XcLZBY05ya9EKjYek9O5xOAwjGq+1JdGBAS7Q9ScoA=="], + + "reflect.getprototypeof": ["reflect.getprototypeof@1.0.10", "", { "dependencies": { "call-bind": "^1.0.8", "define-properties": "^1.2.1", "es-abstract": "^1.23.9", "es-errors": "^1.3.0", "es-object-atoms": "^1.0.0", "get-intrinsic": "^1.2.7", "get-proto": "^1.0.1", "which-builtin-type": "^1.2.1" } }, "sha512-00o4I+DVrefhv+nX0ulyi3biSHCPDe+yLv5o/p6d/UVlirijB8E16FtfwSAi4g3tcqrQ4lRAqQSoFEZJehYEcw=="], + + "regexp.prototype.flags": ["regexp.prototype.flags@1.5.4", "", { "dependencies": { "call-bind": "^1.0.8", "define-properties": "^1.2.1", "es-errors": "^1.3.0", "get-proto": "^1.0.1", "gopd": "^1.2.0", "set-function-name": "^2.0.2" } }, "sha512-dYqgNSZbDwkaJ2ceRd9ojCGjBq+mOm9LmtXnAnEGyHhN/5R7iDW2TRw3h+o/jCFxus3P2LfWIIiwowAjANm7IA=="], + + "resolve": ["resolve@2.0.0-next.7", "", { "dependencies": { "es-errors": "^1.3.0", "is-core-module": "^2.16.2", "node-exports-info": "^1.6.0", "object-keys": "^1.1.1", "path-parse": "^1.0.7", "supports-preserve-symlinks-flag": "^1.0.0" }, "bin": { "resolve": "bin/resolve" } }, "sha512-tqt+NBWwyaMgw3zDsnygx4CByWjQEJHOPMdslYhppaQSJUtL/D4JO9CcBBlhPoI8lz9oJIDXkwXfhF4aWqP8xQ=="], + + "resolve-from": ["resolve-from@4.0.0", "", {}, "sha512-pb/MYmXstAkysRFx8piNI1tGFNQIFA3vkE3Gq4EuA1dF6gHp/+vgZqsCGJapvy8N3Q+4o7FwvquPJcnZ7RYy4g=="], + + "reusify": ["reusify@1.1.0", "", {}, "sha512-g6QUff04oZpHs0eG5p83rFLhHeV00ug/Yf9nZM6fLeUrPguBTkTQOdpAWWspMh55TZfVQDPaN3NQJfbVRAxdIw=="], + + "rimraf": ["rimraf@6.1.3", "", { "dependencies": { "glob": "^13.0.3", "package-json-from-dist": "^1.0.1" }, "bin": { "rimraf": "dist/esm/bin.mjs" } }, "sha512-LKg+Cr2ZF61fkcaK1UdkH2yEBBKnYjTyWzTJT6KNPcSPaiT7HSdhtMXQuN5wkTX0Xu72KQ1l8S42rlmexS2hSA=="], + + "rollup": ["rollup@4.63.5", "", { "dependencies": { "@types/estree": "1.0.9" }, "optionalDependencies": { "@napi-rs/lzma-linux-x64-gnu": "1.5.1", "@rollup/rollup-android-arm-eabi": "4.63.5", "@rollup/rollup-android-arm64": "4.63.5", "@rollup/rollup-darwin-arm64": "4.63.5", "@rollup/rollup-darwin-x64": "4.63.5", "@rollup/rollup-freebsd-arm64": "4.63.5", "@rollup/rollup-freebsd-x64": "4.63.5", "@rollup/rollup-linux-arm-gnueabihf": "4.63.5", "@rollup/rollup-linux-arm-musleabihf": "4.63.5", "@rollup/rollup-linux-arm64-gnu": "4.63.5", "@rollup/rollup-linux-arm64-musl": "4.63.5", "@rollup/rollup-linux-loong64-gnu": "4.63.5", "@rollup/rollup-linux-loong64-musl": "4.63.5", "@rollup/rollup-linux-ppc64-gnu": "4.63.5", "@rollup/rollup-linux-ppc64-musl": "4.63.5", "@rollup/rollup-linux-riscv64-gnu": "4.63.5", "@rollup/rollup-linux-riscv64-musl": "4.63.5", "@rollup/rollup-linux-s390x-gnu": "4.63.5", "@rollup/rollup-linux-x64-gnu": "4.63.5", "@rollup/rollup-linux-x64-musl": "4.63.5", "@rollup/rollup-openbsd-x64": "4.63.5", "@rollup/rollup-openharmony-arm64": "4.63.5", "@rollup/rollup-win32-arm64-msvc": "4.63.5", "@rollup/rollup-win32-ia32-msvc": "4.63.5", "@rollup/rollup-win32-x64-gnu": "4.63.5", "@rollup/rollup-win32-x64-msvc": "4.63.5", "fsevents": "~2.3.2" }, "bin": { "rollup": "dist/bin/rollup" } }, "sha512-KRWwmNLlPw5M7HcdYfm15oBv9n9LPtjzpzCIxS/phwqvPyxHSoKX6Y2YU3pxSPfy0CLquVgsx/j/hBi6OvH1Nw=="], + + "run-parallel": ["run-parallel@1.2.0", "", { "dependencies": { "queue-microtask": "^1.2.2" } }, "sha512-5l4VyZR86LZ/lDxZTR6jqL8AFE2S0IFLMP26AbjsLVADxHdhB/c0GUsH+y39UfCi3dzz8OlQuPmnaJOMoDHQBA=="], + + "safe-array-concat": ["safe-array-concat@1.1.4", "", { "dependencies": { "call-bind": "^1.0.9", "call-bound": "^1.0.4", "get-intrinsic": "^1.3.0", "has-symbols": "^1.1.0", "isarray": "^2.0.5" } }, "sha512-wtZlHyOje6OZTGqAoaDKxFkgRtkF9CnHAVnCHKfuj200wAgL+bSJhdsCD2l0Qx/2ekEXjPWcyKkfGb5CPboslg=="], + + "safe-buffer": ["safe-buffer@5.2.1", "", {}, "sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ=="], + + "safe-push-apply": ["safe-push-apply@1.0.0", "", { "dependencies": { "es-errors": "^1.3.0", "isarray": "^2.0.5" } }, "sha512-iKE9w/Z7xCzUMIZqdBsp6pEQvwuEebH4vdpjcDWnyzaI6yl6O9FHvVpmGelvEHNsoY6wGblkxR6Zty/h00WiSA=="], + + "safe-regex-test": ["safe-regex-test@1.1.0", "", { "dependencies": { "call-bound": "^1.0.2", "es-errors": "^1.3.0", "is-regex": "^1.2.1" } }, "sha512-x/+Cz4YrimQxQccJf5mKEbIa1NzeCRNI5Ecl/ekmlYaampdNLPalVyIcCZNNH3MvmqBugV5TMYZXv0ljslUlaw=="], + + "sax": ["sax@1.6.1", "", {}, "sha512-42tBVwLWnaQvW5zc4HbZrTuWccECCZfBi92FDuwtqxasH+JbPB3/FOKb1m222K42R4WxuxzzMsTswfzgtSu64Q=="], + + "semver": ["semver@7.8.5", "", { "bin": { "semver": "bin/semver.js" } }, "sha512-Y7/KDsb8LjooZpwaqGyulO6DQlksgCncchHGk+sZIY4SBvUocMBEFH5Ur1fI4dV+Jvl0w6cjvucaIi40puRioA=="], + + "set-function-length": ["set-function-length@1.2.2", "", { "dependencies": { "define-data-property": "^1.1.4", "es-errors": "^1.3.0", "function-bind": "^1.1.2", "get-intrinsic": "^1.2.4", "gopd": "^1.0.1", "has-property-descriptors": "^1.0.2" } }, "sha512-pgRc4hJ4/sNjWCSS9AmnS40x3bNMDTknHgL5UaMBTMyJnU90EgWh1Rz+MC9eFu4BuN/UwZjKQuY/1v3rM7HMfg=="], + + "set-function-name": ["set-function-name@2.0.2", "", { "dependencies": { "define-data-property": "^1.1.4", "es-errors": "^1.3.0", "functions-have-names": "^1.2.3", "has-property-descriptors": "^1.0.2" } }, "sha512-7PGFlmtwsEADb0WYyvCMa1t+yke6daIG4Wirafur5kcf+MhUnPms1UeR0CKQdTZD81yESwMHbtn+TR+dMviakQ=="], + + "set-proto": ["set-proto@1.0.0", "", { "dependencies": { "dunder-proto": "^1.0.1", "es-errors": "^1.3.0", "es-object-atoms": "^1.0.0" } }, "sha512-RJRdvCo6IAnPdsvP/7m6bsQqNnn1FCBX5ZNtFL98MmFF/4xAIJTIg1YbHW5DC2W5SKZanrC6i4HsJqlajw/dZw=="], + + "shebang-command": ["shebang-command@2.0.0", "", { "dependencies": { "shebang-regex": "^3.0.0" } }, "sha512-kHxr2zZpYtdmrN1qDjrrX/Z1rR1kG8Dx+gkpK1G4eXmvXswmcE1hTWBWYUzlraYw1/yZp6YuDY77YtvbN0dmDA=="], + + "shebang-regex": ["shebang-regex@3.0.0", "", {}, "sha512-7++dFhtcx3353uBaq8DDR4NuxBetBzC7ZQOhmTQInHEd6bSrXdiEyzCvG07Z44UYdLShWUyXt5M/yhz8ekcb1A=="], + + "side-channel": ["side-channel@1.1.1", "", { "dependencies": { "es-errors": "^1.3.0", "object-inspect": "^1.13.4", "side-channel-list": "^1.0.1", "side-channel-map": "^1.0.1", "side-channel-weakmap": "^1.0.2" } }, "sha512-6x6dK6zJdpTzF4sQeNYxwtvBzf6Eg4GtlesS94HOvTudUeyK2WXAaIfmDgsyslYrRBeFIlsi54AYsFGUuhmvrQ=="], + + "side-channel-list": ["side-channel-list@1.0.1", "", { "dependencies": { "es-errors": "^1.3.0", "object-inspect": "^1.13.4" } }, "sha512-mjn/0bi/oUURjc5Xl7IaWi/OJJJumuoJFQJfDDyO46+hBWsfaVM65TBHq2eoZBhzl9EchxOijpkbRC8SVBQU0w=="], + + "side-channel-map": ["side-channel-map@1.0.1", "", { "dependencies": { "call-bound": "^1.0.2", "es-errors": "^1.3.0", "get-intrinsic": "^1.2.5", "object-inspect": "^1.13.3" } }, "sha512-VCjCNfgMsby3tTdo02nbjtM/ewra6jPHmpThenkTYh8pG9ucZ/1P8So4u4FGBek/BjpOVsDCMoLA/iuBKIFXRA=="], + + "side-channel-weakmap": ["side-channel-weakmap@1.0.2", "", { "dependencies": { "call-bound": "^1.0.2", "es-errors": "^1.3.0", "get-intrinsic": "^1.2.5", "object-inspect": "^1.13.3", "side-channel-map": "^1.0.1" } }, "sha512-WPS/HvHQTYnHisLo9McqBHOJk2FkHO/tlpvldyrnem4aeQp4hai3gythswg6p01oSoTl58rcpiFAjF2br2Ak2A=="], + + "signal-exit": ["signal-exit@3.0.7", "", {}, "sha512-wnD2ZE+l+SPC/uoS0vXeE9L1+0wuaMqKlfz9AMUo38JsyLSBWSFcHR1Rri62LZc12vLr1gb3jl7iwQhgwpAbGQ=="], + + "simple-plist": ["simple-plist@1.3.1", "", { "dependencies": { "bplist-creator": "0.1.0", "bplist-parser": "0.3.1", "plist": "^3.0.5" } }, "sha512-iMSw5i0XseMnrhtIzRb7XpQEXepa9xhWxGUojHBL43SIpQuDQkh3Wpy67ZbDzZVr6EKxvwVChnVpdl8hEVLDiw=="], + + "sisteransi": ["sisteransi@1.0.5", "", {}, "sha512-bLGGlR1QxBcynn2d5YmDX4MGjlZvy2MRBDRNHLJ8VI6l6+9FUiyTFNJ0IveOSP0bcXgVDPRcfGqA0pjaqUpfVg=="], + + "slash": ["slash@3.0.0", "", {}, "sha512-g9Q1haeby36OSStwb4ntCGGGaKsaVSjQ68fBxoQcutl5fS1vuY18H3wSt3jFyFtrkx+Kz0V1G85A4MyAdDMi2Q=="], + + "slice-ansi": ["slice-ansi@4.0.0", "", { "dependencies": { "ansi-styles": "^4.0.0", "astral-regex": "^2.0.0", "is-fullwidth-code-point": "^3.0.0" } }, "sha512-qMCMfhY040cVHT43K9BFygqYbUPFZKHOg7K73mtTWJRb8pyP3fzf4Ixd5SzdEJQ6MRUg/WBnOLxghZtKKurENQ=="], + + "split2": ["split2@4.2.0", "", {}, "sha512-UcjcJOWknrNkF6PLX83qcHM6KHgVKNkV62Y8a5uYDVv9ydGQVwAHMKqHdJje1VTWpljG0WYpCDhrCdAOYH4TWg=="], + + "stop-iteration-iterator": ["stop-iteration-iterator@1.1.0", "", { "dependencies": { "es-errors": "^1.3.0", "internal-slot": "^1.1.0" } }, "sha512-eLoXW/DHyl62zxY4SCaIgnRhuMr6ri4juEYARS8E6sCEqzKpOiE521Ucofdx+KnDZl5xmvGYaaKCk5FEOxJCoQ=="], + + "stream-buffers": ["stream-buffers@2.2.0", "", {}, "sha512-uyQK/mx5QjHun80FLJTfaWE7JtwfRMKBLkMne6udYOmvH0CawotVa7TfgYHzAnpphn4+TweIx1QKMnRIbipmUg=="], + + "string-width": ["string-width@4.2.3", "", { "dependencies": { "emoji-regex": "^8.0.0", "is-fullwidth-code-point": "^3.0.0", "strip-ansi": "^6.0.1" } }, "sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g=="], + + "string.prototype.trim": ["string.prototype.trim@1.2.11", "", { "dependencies": { "call-bind": "^1.0.9", "call-bound": "^1.0.4", "define-data-property": "^1.1.4", "define-properties": "^1.2.1", "es-abstract": "^1.24.2", "es-object-atoms": "^1.1.2", "has-property-descriptors": "^1.0.2", "safe-regex-test": "^1.1.0" } }, "sha512-PwvK7BU+CMTJGYQCTZb5RWXIML92lftJLhQz1tBzgKiqGxJaMlBAa48POXaNAC2s4y8jr3EFqrkF9+44neS46w=="], + + "string.prototype.trimend": ["string.prototype.trimend@1.0.10", "", { "dependencies": { "call-bind": "^1.0.9", "call-bound": "^1.0.4", "define-properties": "^1.2.1", "es-object-atoms": "^1.1.2" } }, "sha512-2+3aDAOmPTmuFwjDnmJG2ctEkQKVki7vOSqaxkv42Mowj1V6PnvuwFCRrR5lChUux1TBskPjfkeTOhqczDMxTw=="], + + "string.prototype.trimstart": ["string.prototype.trimstart@1.0.8", "", { "dependencies": { "call-bind": "^1.0.7", "define-properties": "^1.2.1", "es-object-atoms": "^1.0.0" } }, "sha512-UXSH262CSZY1tfu3G3Secr6uGLCFVPMhIqHjlgCUtCCcgihYc/xKs9djMTMUOb2j1mVSeU8EU6NWc/iQKU6Gfg=="], + + "string_decoder": ["string_decoder@1.3.0", "", { "dependencies": { "safe-buffer": "~5.2.0" } }, "sha512-hkRX8U1WjJFd8LsDJ2yQ/wWWxaopEsABU1XfkM8A+j0+85JAGppt16cr1Whg6KIbb4okU6Mql6BOj+uup/wKeA=="], + + "strip-ansi": ["strip-ansi@6.0.1", "", { "dependencies": { "ansi-regex": "^5.0.1" } }, "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A=="], + + "strip-bom": ["strip-bom@3.0.0", "", {}, "sha512-vavAMRXOgBVNF6nyEEmL3DBK19iRpDcoIwW+swQ+CbGiu7lju6t+JklA1MHweoWtadgt4ISVUsXLyDq34ddcwA=="], + + "strip-json-comments": ["strip-json-comments@3.1.1", "", {}, "sha512-6fPc+R4ihwqP6N/aIv2f1gMH8lOVtWQHoqC4yK6oSDVVocumAsfCqjkXnqiYMhmMwS/mEHLp7Vehlt3ql6lEig=="], + + "supercluster": ["supercluster@8.0.1", "", { "dependencies": { "kdbush": "^4.0.2" } }, "sha512-IiOea5kJ9iqzD2t7QJq/cREyLHTtSmUT6gQsweojg9WH2sYJqZK9SswTu6jrscO6D1G5v5vYZ9ru/eq85lXeZQ=="], + + "supports-color": ["supports-color@7.2.0", "", { "dependencies": { "has-flag": "^4.0.0" } }, "sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw=="], + + "supports-preserve-symlinks-flag": ["supports-preserve-symlinks-flag@1.0.0", "", {}, "sha512-ot0WnXS9fgdkgIcePe6RHNk1WA8+muPa6cSjeR3V8K27q9BB1rTE3R1p7Hv0z1ZyAc8s6Vvv8DIyWf681MAt0w=="], + + "swiftlint": ["swiftlint@2.0.0", "", { "dependencies": { "@ionic/utils-fs": "^3.1.7", "@ionic/utils-subprocess": "^3.0.1", "cosmiconfig": "^9.0.0" }, "bin": { "node-swiftlint": "bin.js" } }, "sha512-MMVuyZ4/6WcIJlk0z6GM0pZjRuwnyUJqRPbJBFW3oACN/qjAvRbolCWEu+zE2MycF/cEgqfUpI+oLECNfjfOJA=="], + + "tar": ["tar@7.5.22", "", { "dependencies": { "@isaacs/fs-minipass": "^4.0.0", "chownr": "^3.0.0", "minipass": "^7.1.2", "minizlib": "^3.1.0", "yallist": "^5.0.0" } }, "sha512-MFO/QzvtAOmJbkhOaCTvbGcFN9L9b+JunIsDwaKljSOdcLMea3NJ1k9Usz/rjdfSXTq4dfzfeS7W4p4YOAAHeA=="], + + "text-table": ["text-table@0.2.0", "", {}, "sha512-N+8UisAXDGk8PFXP4HAzVR9nbfmVJ3zYLAWiTIoqC5v5isinhr+r5uaO8+7r3BMfuNIufIsA7RdpVgacC2cSpw=="], + + "through2": ["through2@4.0.2", "", { "dependencies": { "readable-stream": "3" } }, "sha512-iOqSav00cVxEEICeD7TjLB1sueEL+81Wpzp2bY17uZjZN0pWZPuo4suZ/61VujxmqSGFfgOcNuTZ85QJwNZQpw=="], + + "to-regex-range": ["to-regex-range@5.0.1", "", { "dependencies": { "is-number": "^7.0.0" } }, "sha512-65P7iz6X5yEr1cwcgvQxbbIw7Uk3gOy5dIdtZ4rDveLqhrdJP+Li/Hx6tyK0NEb+2GCyneCMJiGqrADCSNk8sQ=="], + + "tree-kill": ["tree-kill@1.2.2", "", { "bin": { "tree-kill": "cli.js" } }, "sha512-L0Orpi8qGpRG//Nd+H90vFB+3iHnue1zSSGmNOOCh1GLJ7rUKVwV2HvijphGQS2UmhUZewS9VgvxYIdgr+fG1A=="], + + "tsconfig-paths": ["tsconfig-paths@3.15.0", "", { "dependencies": { "@types/json5": "^0.0.29", "json5": "^1.0.2", "minimist": "^1.2.6", "strip-bom": "^3.0.0" } }, "sha512-2Ac2RgzDe/cn48GvOe3M+o82pEFewD3UPbyoUHHdKasHwJKjds4fLXWf/Ux5kATBKN20oaFGu+jbElp1pos0mg=="], + + "tslib": ["tslib@2.8.1", "", {}, "sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w=="], + + "tsutils": ["tsutils@3.21.0", "", { "dependencies": { "tslib": "^1.8.1" }, "peerDependencies": { "typescript": ">=2.8.0 || >= 3.2.0-dev || >= 3.3.0-dev || >= 3.4.0-dev || >= 3.5.0-dev || >= 3.6.0-dev || >= 3.6.0-beta || >= 3.7.0-dev || >= 3.7.0-beta" } }, "sha512-mHKK3iUXL+3UF6xL5k0PEhKRUBKPBCv/+RkEOpjRWxxx27KKRBmmA60A9pgOUvMi8GKhRMPEmjBRPzs2W7O1OA=="], + + "type-check": ["type-check@0.4.0", "", { "dependencies": { "prelude-ls": "^1.2.1" } }, "sha512-XleUoc9uwGXqjWwXaUTZAmzMcFZ5858QA2vvx1Ur5xIcixXIP+8LnFDgRplU30us6teqdlskFfu+ae4K79Ooew=="], + + "type-fest": ["type-fest@0.20.2", "", {}, "sha512-Ne+eE4r0/iWnpAxD852z3A+N0Bt5RN//NjJwRd2VFHEmrywxf5vsZlh4R6lixl6B+wz/8d+maTSAkN1FIkI3LQ=="], + + "typed-array-buffer": ["typed-array-buffer@1.0.3", "", { "dependencies": { "call-bound": "^1.0.3", "es-errors": "^1.3.0", "is-typed-array": "^1.1.14" } }, "sha512-nAYYwfY3qnzX30IkA6AQZjVbtK6duGontcQm1WSG1MD94YLqK0515GNApXkoxKOWMusVssAHWLh9SeaoefYFGw=="], + + "typed-array-byte-length": ["typed-array-byte-length@1.0.3", "", { "dependencies": { "call-bind": "^1.0.8", "for-each": "^0.3.3", "gopd": "^1.2.0", "has-proto": "^1.2.0", "is-typed-array": "^1.1.14" } }, "sha512-BaXgOuIxz8n8pIq3e7Atg/7s+DpiYrxn4vdot3w9KbnBhcRQq6o3xemQdIfynqSeXeDrF32x+WvfzmOjPiY9lg=="], + + "typed-array-byte-offset": ["typed-array-byte-offset@1.0.5", "", { "dependencies": { "available-typed-arrays": "^1.0.7", "call-bind": "^1.0.9", "for-each": "^0.3.5", "gopd": "^1.2.0", "is-typed-array": "^1.1.15", "reflect.getprototypeof": "^1.0.10" } }, "sha512-0FHJvLPqZ7KJzp17O13jfsAjsqazgrxBu2zEK95PmUz8lv2+GjRuxUInCr2Rk9Dms3ihN21zJ929ZO43yJ95QQ=="], + + "typed-array-length": ["typed-array-length@1.0.8", "", { "dependencies": { "call-bind": "^1.0.9", "for-each": "^0.3.5", "gopd": "^1.2.0", "is-typed-array": "^1.1.15", "possible-typed-array-names": "^1.1.0", "reflect.getprototypeof": "^1.0.10" } }, "sha512-phPGCwqr2+Qo0fwniCE8e4pKnGu/yFb5nD5Y8bf0EEeiI5GklnACYA9GFy/DrAeRrKHXvHn+1SUsOWgJp6RO+g=="], + + "typescript": ["typescript@5.9.3", "", { "bin": { "tsc": "bin/tsc", "tsserver": "bin/tsserver" } }, "sha512-jl1vZzPDinLr9eUt3J/t7V6FgNEw9QjvBPdysz9KfQDD41fQrC2Y4vKQdiaUpFT4bXlb1RHhLpp8wtm6M5TgSw=="], + + "unbox-primitive": ["unbox-primitive@1.1.0", "", { "dependencies": { "call-bound": "^1.0.3", "has-bigints": "^1.0.2", "has-symbols": "^1.1.0", "which-boxed-primitive": "^1.1.1" } }, "sha512-nWJ91DjeOkej/TA8pXQ3myruKpKEYgqvpw9lz4OPHj/NWFNluYrjbz9j01CJ8yKQd2g4jFoOkINCTW2I5LEEyw=="], + + "undici-types": ["undici-types@7.24.6", "", {}, "sha512-WRNW+sJgj5OBN4/0JpHFqtqzhpbnV0GuB+OozA9gCL7a993SmU+1JBZCzLNxYsbMfIeDL+lTsphD5jN5N+n0zg=="], + + "universalify": ["universalify@2.0.1", "", {}, "sha512-gptHNQghINnc/vTGIk0SOFGFNXw7JVrlRUtConJRlvaw6DuX0wO5Jeko9sWrMBhh+PsYAZ7oXAiOnf/UKogyiw=="], + + "untildify": ["untildify@4.0.0", "", {}, "sha512-KK8xQ1mkzZeg9inewmFVDNkg3l5LUhoq9kN6iWYB/CC9YMG8HA+c1Q8HwDe6dEX7kErrEVNVBO3fWsVq5iDgtw=="], + + "uri-js": ["uri-js@4.4.1", "", { "dependencies": { "punycode": "^2.1.0" } }, "sha512-7rKUyy33Q1yc98pQ1DAmLtwX109F7TIfWlW1Ydo8Wl1ii1SeHieeh0HHfPeL2fMXK6z0s8ecKs9frCuLJvndBg=="], + + "util-deprecate": ["util-deprecate@1.0.2", "", {}, "sha512-EPD5q1uXyFxJpCrLnCc1nHnq3gOa6DZBocAIiI2TaSCA7VCJ1UJDMagCzIkXNsUYfD1daK//LTEQ8xiIbrHtcw=="], + + "uuid": ["uuid@7.0.3", "", { "bin": { "uuid": "dist/bin/uuid" } }, "sha512-DPSke0pXhTZgoF/d+WSt2QaKMCFSfx7QegxEWT+JOuHF5aWrKEn0G+ztjuJg/gG8/ItK+rbPCD/yNv8yyih6Cg=="], + + "web-tree-sitter": ["web-tree-sitter@0.27.0", "", {}, "sha512-XK08gj6RwTMQatAG7uVRP8MunqotL/XC19vHgkSPKmELgbGPBj4ECvB8haHOUnyj6ls2B8t42UTro14zxGgAHg=="], + + "which": ["which@2.0.2", "", { "dependencies": { "isexe": "^2.0.0" }, "bin": { "node-which": "./bin/node-which" } }, "sha512-BLI3Tl1TW3Pvl70l3yq3Y64i+awpwXqsGBYWkkqMtnbXgrMD+yj7rhW0kuEDxzJaYXGjEW5ogapKNMEKNMjibA=="], + + "which-boxed-primitive": ["which-boxed-primitive@1.1.1", "", { "dependencies": { "is-bigint": "^1.1.0", "is-boolean-object": "^1.2.1", "is-number-object": "^1.1.1", "is-string": "^1.1.1", "is-symbol": "^1.1.1" } }, "sha512-TbX3mj8n0odCBFVlY8AxkqcHASw3L60jIuF8jFP78az3C2YhmGvqbHBpAjTRH2/xqYunrJ9g1jSyjCjpoWzIAA=="], + + "which-builtin-type": ["which-builtin-type@1.2.1", "", { "dependencies": { "call-bound": "^1.0.2", "function.prototype.name": "^1.1.6", "has-tostringtag": "^1.0.2", "is-async-function": "^2.0.0", "is-date-object": "^1.1.0", "is-finalizationregistry": "^1.1.0", "is-generator-function": "^1.0.10", "is-regex": "^1.2.1", "is-weakref": "^1.0.2", "isarray": "^2.0.5", "which-boxed-primitive": "^1.1.0", "which-collection": "^1.0.2", "which-typed-array": "^1.1.16" } }, "sha512-6iBczoX+kDQ7a3+YJBnh3T+KZRxM/iYNPXicqk66/Qfm1b93iu+yOImkg0zHbj5LNOcNv1TEADiZ0xa34B4q6Q=="], + + "which-collection": ["which-collection@1.0.2", "", { "dependencies": { "is-map": "^2.0.3", "is-set": "^2.0.3", "is-weakmap": "^2.0.2", "is-weakset": "^2.0.3" } }, "sha512-K4jVyjnBdgvc86Y6BkaLZEN933SwYOuBFkdmBu9ZfkcAbdVbpITnDmjvZ/aQjRXQrv5EPkTnD1s39GiiqbngCw=="], + + "which-typed-array": ["which-typed-array@1.1.24", "", { "dependencies": { "available-typed-arrays": "^1.0.7", "call-bind": "^1.0.9", "call-bound": "^1.0.4", "for-each": "^0.3.5", "get-proto": "^1.0.1", "gopd": "^1.2.0", "has-tostringtag": "^1.0.2" } }, "sha512-wk4Mf4pR5mRP7eYuuTBCIQ9d0ud2Fv2jRLQpfgnRjbOxAFHmjKFValgTpitVKzJJS8ajnYQV2Du1SZ8j6b/EUQ=="], + + "word-wrap": ["word-wrap@1.2.5", "", {}, "sha512-BN22B5eaMMI9UMtjrGd5g5eCYPpCPDUy0FJXbYsaT5zYxjFOckS53SQDE3pWkVoWpHXVb3BrYcEN4Twa55B5cA=="], + + "wrap-ansi": ["wrap-ansi@7.0.0", "", { "dependencies": { "ansi-styles": "^4.0.0", "string-width": "^4.1.0", "strip-ansi": "^6.0.0" } }, "sha512-YVGIj2kamLSTxw6NsZjoBxfSwsn0ycdesmc4p+Q21c5zPuZ1pl+NfxVdxPtdHvmNVOQ6XSYG4AUtyt/Fi7D16Q=="], + + "wrappy": ["wrappy@1.0.2", "", {}, "sha512-l4Sp/DRseor9wL6EvV2+TuQn63dMkPjZ/sp9XkghTEbV9KlPS1xUsZ3u7/IQO4wxtcFB4bgpQPRcR3QCvezPcQ=="], + + "xcode": ["xcode@3.0.1", "", { "dependencies": { "simple-plist": "^1.1.0", "uuid": "^7.0.3" } }, "sha512-kCz5k7J7XbJtjABOvkc5lJmkiDh8VhjVCGNiqdKCscmVpdVUpEAyXv1xmCLkQJ5dsHqx3IPO4XW+NTDhU/fatA=="], + + "xml2js": ["xml2js@0.6.2", "", { "dependencies": { "sax": ">=0.6.0", "xmlbuilder": "~11.0.0" } }, "sha512-T4rieHaC1EXcES0Kxxj4JWgaUQHDk+qwHcYOCFHfiwKz7tOVPLq7Hjq9dM1WCMhylqMEfP7hMcOIChvotiZegA=="], + + "xmlbuilder": ["xmlbuilder@15.1.1", "", {}, "sha512-yMqGBqtXyeN1e3TGYvgNgDVZ3j84W4cwkOXQswghol6APgZWaff9lnbvN7MHYJOiXsvGPXtjTYJEiC9J2wv9Eg=="], + + "yallist": ["yallist@5.0.0", "", {}, "sha512-YgvUTfwqyc7UXVMrB+SImsVYSmTS8X/tSrtdNZMImM+n7+QTriRXyXim0mBrTXNeqzVF0KWGgHPeiyViFFrNDw=="], + + "yauzl": ["yauzl@2.10.0", "", { "dependencies": { "buffer-crc32": "~0.2.3", "fd-slicer": "~1.1.0" } }, "sha512-p4a9I6X6nu6IhoGmBqAcbJy1mlC4j27vEPZX9F4L4/vZT3Lyq1VkFHw/V/PUcB9Buo+DG3iHkT0x3Qya58zc3g=="], + + "yocto-queue": ["yocto-queue@0.1.0", "", {}, "sha512-rVksvsnNCdJ/ohGc6xgPwyN8eheCxsiLM8mxuE/t/mOVqJewPuO1miLpTHQiRgTKCLexL4MeAFVagts7HmNZ2Q=="], + + "@capacitor/docgen/typescript": ["typescript@4.2.4", "", { "bin": { "tsc": "bin/tsc", "tsserver": "bin/tsserver" } }, "sha512-V+evlYHZnQkaz8TRBuxTA92yZBPotr5H+WhQ7bD3hZUndx5tGOa1fuCgeSjxAzM1RiN5IzvadIXTVefuuwZCRg=="], + + "@ionic/utils-fs/fs-extra": ["fs-extra@9.1.0", "", { "dependencies": { "at-least-node": "^1.0.0", "graceful-fs": "^4.2.0", "jsonfile": "^6.0.1", "universalify": "^2.0.0" } }, "sha512-hcg3ZmepS30/7BSFqRvoo3DOMQu7IjqxO5nCDt+zM9XWjb33Wg7ziNT+Qvqbuc3+gWpzO02JubVyk2G4Zvo1OQ=="], + + "@types/fs-extra/@types/node": ["@types/node@26.6.3", "", { "dependencies": { "undici-types": "~8.9.0" } }, "sha512-dsqMQQoeTLqu9wynDD00q573mNzso3IdQOAfHRJqLCcmCFPoGo9A1bDpUcv/9tnKpErQWv9uKeGfl37EIS02Yg=="], + + "@typescript-eslint/utils/eslint-scope": ["eslint-scope@5.1.1", "", { "dependencies": { "esrecurse": "^4.3.0", "estraverse": "^4.1.1" } }, "sha512-2NxwbF/hZ0KpepYN0cNbo+FN6XoK7GaHlQhgx/hIZl6Va0bF45RQOOwhLIy8lQDbuCiadSLCBnH2CFYquit5bw=="], + + "elementtree/sax": ["sax@1.1.4", "", {}, "sha512-5f3k2PbGGp+YtKJjOItpg3P99IMD84E4HOvcfleTb5joCHNXYLsR9yWFPOYGgaeMPDubQILTCMdsFb2OMeOjtg=="], + + "eslint-import-resolver-node/debug": ["debug@3.2.7", "", { "dependencies": { "ms": "^2.1.1" } }, "sha512-CFjzYYAi4ThfiQvizrFQevTTXHtnCqWfe7x1AhgEscTz6ZbLbfoLRLPugTQyBth6f8ZERVUSyWHFD/7Wu4t1XQ=="], + + "eslint-module-utils/debug": ["debug@3.2.7", "", { "dependencies": { "ms": "^2.1.1" } }, "sha512-CFjzYYAi4ThfiQvizrFQevTTXHtnCqWfe7x1AhgEscTz6ZbLbfoLRLPugTQyBth6f8ZERVUSyWHFD/7Wu4t1XQ=="], + + "eslint-plugin-import/debug": ["debug@3.2.7", "", { "dependencies": { "ms": "^2.1.1" } }, "sha512-CFjzYYAi4ThfiQvizrFQevTTXHtnCqWfe7x1AhgEscTz6ZbLbfoLRLPugTQyBth6f8ZERVUSyWHFD/7Wu4t1XQ=="], + + "eslint-plugin-import/doctrine": ["doctrine@2.1.0", "", { "dependencies": { "esutils": "^2.0.2" } }, "sha512-35mSku4ZXK0vfCuHEDAwt55dg2jNajHZ1odvF+8SSr82EsZY4QmXfuWso8oEd8zRhVObSN18aM0CjSdoBX7zIw=="], + + "eslint-plugin-import/semver": ["semver@6.3.1", "", { "bin": { "semver": "bin/semver.js" } }, "sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA=="], + + "fast-glob/glob-parent": ["glob-parent@5.1.2", "", { "dependencies": { "is-glob": "^4.0.1" } }, "sha512-AOIgSQCepiJYwP3ARnGx+5VnTu2HBYdzbGP45eLw1vr3zB3vZLeyed1sC9hnbcOc9/SrMyM5RPQrkGz4aS9Zow=="], + + "flat-cache/rimraf": ["rimraf@3.0.2", "", { "dependencies": { "glob": "^7.1.3" }, "bin": { "rimraf": "bin.js" } }, "sha512-JZkJMZkAGFFPP2YqXZXPbMlMBgsxzE8ILs4lMIX/2o0L9UBw9O/Y3o6wFw/i9YLapcUJWwqbi3kdxIPdC62TIA=="], + + "glob/minimatch": ["minimatch@10.2.6", "", { "dependencies": { "brace-expansion": "^5.0.8" } }, "sha512-vpLQEs+VLCr1nU0BXS07maYoFwlDAH0gngQuuttxIwutDFEMHq2blX+8vpgxDdK3J1PwjCJiep77OitTZ4Ll1A=="], + + "node-exports-info/semver": ["semver@6.3.1", "", { "bin": { "semver": "bin/semver.js" } }, "sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA=="], + + "prompts/kleur": ["kleur@3.0.3", "", {}, "sha512-eTIzlVOSUR+JxdDFepEYcBMtZ9Qqdef+rnzWdRZuMbOywu5tO2w2N7rqjoANZ5k9vywhL6Br1VRjUIgTQx4E8w=="], + + "simple-plist/bplist-parser": ["bplist-parser@0.3.1", "", { "dependencies": { "big-integer": "1.6.x" } }, "sha512-PyJxiNtA5T2PlLIeBot4lbp7rj4OadzjnMZD/G5zuBNt8ei/yCU7+wW0h2bag9vr8c+/WuRWmSxbqAl9hL1rBA=="], + + "tsutils/tslib": ["tslib@1.14.1", "", {}, "sha512-Xni35NKzjgMrwevysHTCArtLDpPvye8zV/0E4EyYn43P7/7qvQwPh9BGkHewbMulVntbigmcT7rdX3BNo9wRJg=="], + + "xml2js/xmlbuilder": ["xmlbuilder@11.0.1", "", {}, "sha512-fDlsI/kFEx7gLvbecc0/ohLG50fugQp8ryHzMTuW9vSa1GJ0XYWKnhsUx7oie3G98+r56aTQIUB4kht42R3JvA=="], + + "@types/fs-extra/@types/node/undici-types": ["undici-types@8.9.0", "", {}, "sha512-KTDyRTYX8sWmKXAikPHHSyc63CRPETMctyjKFupcC6OBLXT3xsN0e9aF7m+mIXutFWpUXuedtowG7iLOzp0kQg=="], + + "@typescript-eslint/utils/eslint-scope/estraverse": ["estraverse@4.3.0", "", {}, "sha512-39nnKffWz8xN1BU/2c79n9nB9HDzo0niYUqx6xyqUnyoAnQyyWpOTdZEeiCch8BBu515t4wp9ZmgVfVhn9EBpw=="], + + "flat-cache/rimraf/glob": ["glob@7.2.3", "", { "dependencies": { "fs.realpath": "^1.0.0", "inflight": "^1.0.4", "inherits": "2", "minimatch": "^3.1.1", "once": "^1.3.0", "path-is-absolute": "^1.0.0" } }, "sha512-nFR0zLpU2YCaRxwoCJvL6UvCH2JFyFVIvwTLsIf21AuHlMskA1hhTdk+LlYJtOlYt9v6dvszD2BGRqBL+iQK9Q=="], + + "glob/minimatch/brace-expansion": ["brace-expansion@5.0.12", "", { "dependencies": { "balanced-match": "^4.0.2" } }, "sha512-YovQ3rzhaLMIrDjNDMkNS01tea93qhEhG5xy8f6+R0l+dw3Ki+5sCoIoI942iuLZTHWogWktgwVDhU09iNEimQ=="], + + "glob/minimatch/brace-expansion/balanced-match": ["balanced-match@4.0.4", "", {}, "sha512-BLrgEcRTwX2o6gGxGOCNyMvGSp35YofuYzw9h1IMTRmKqttAZZVU67bdb9Pr2vUHA8+j3i2tJfjO6C6+4myGTA=="], + } +} diff --git a/example-app/README.md b/example-app/README.md new file mode 100644 index 0000000..cc63839 --- /dev/null +++ b/example-app/README.md @@ -0,0 +1,34 @@ +# Native Audio Example + +This Vite + React application demonstrates how to use `@capgo/capacitor-native-audio` with local bundled assets and remote streaming audio. + +## Getting started + +1. Install dependencies: + ```bash + bun install + ``` +2. Run the web demo: + ```bash + bun run dev + ``` +3. Sync native projects (optional): + ```bash + bun run sync + ``` +4. Launch a native shell application: + ```bash + bun run ios + # or + bun run android + ``` + +## Features + +- Preload bundled and remote audio assets +- Playback controls (play, pause, resume, stop, loop) +- Volume adjustments with live updates +- Display of current playback time and duration +- Remote cache clearing for streaming assets + +The example references the local plugin source via `"@capgo/capacitor-native-audio": ".."`, so any local changes to the plugin code are picked up after reinstalling dependencies. diff --git a/example-app/android/.gitignore b/example-app/android/.gitignore new file mode 100644 index 0000000..48354a3 --- /dev/null +++ b/example-app/android/.gitignore @@ -0,0 +1,101 @@ +# Using Android gitignore template: https://github.com/github/gitignore/blob/HEAD/Android.gitignore + +# Built application files +*.apk +*.aar +*.ap_ +*.aab + +# Files for the ART/Dalvik VM +*.dex + +# Java class files +*.class + +# Generated files +bin/ +gen/ +out/ +# Uncomment the following line in case you need and you don't have the release build type files in your app +# release/ + +# Gradle files +.gradle/ +build/ + +# Local configuration file (sdk path, etc) +local.properties + +# Proguard folder generated by Eclipse +proguard/ + +# Log Files +*.log + +# Android Studio Navigation editor temp files +.navigation/ + +# Android Studio captures folder +captures/ + +# IntelliJ +*.iml +.idea/workspace.xml +.idea/tasks.xml +.idea/gradle.xml +.idea/assetWizardSettings.xml +.idea/dictionaries +.idea/libraries +# Android Studio 3 in .gitignore file. +.idea/caches +.idea/modules.xml +# Comment next line if keeping position of elements in Navigation Editor is relevant for you +.idea/navEditor.xml + +# Keystore files +# Uncomment the following lines if you do not want to check your keystore files in. +#*.jks +#*.keystore + +# External native build folder generated in Android Studio 2.2 and later +.externalNativeBuild +.cxx/ + +# Google Services (e.g. APIs or Firebase) +# google-services.json + +# Freeline +freeline.py +freeline/ +freeline_project_description.json + +# fastlane +fastlane/report.xml +fastlane/Preview.html +fastlane/screenshots +fastlane/test_output +fastlane/readme.md + +# Version control +vcs.xml + +# lint +lint/intermediates/ +lint/generated/ +lint/outputs/ +lint/tmp/ +# lint/reports/ + +# Android Profiling +*.hprof + +# Cordova plugins for Capacitor +capacitor-cordova-android-plugins + +# Copied web assets +app/src/main/assets/public + +# Generated Config files +app/src/main/assets/capacitor.config.json +app/src/main/assets/capacitor.plugins.json +app/src/main/res/xml/config.xml diff --git a/example-app/android/app/.gitignore b/example-app/android/app/.gitignore new file mode 100644 index 0000000..043df80 --- /dev/null +++ b/example-app/android/app/.gitignore @@ -0,0 +1,2 @@ +/build/* +!/build/.npmkeep diff --git a/example-app/android/app/build.gradle b/example-app/android/app/build.gradle new file mode 100644 index 0000000..e0ccd82 --- /dev/null +++ b/example-app/android/app/build.gradle @@ -0,0 +1,54 @@ +apply plugin: 'com.android.application' + +android { + namespace = "app.capgo.nativeaudio" + compileSdk = rootProject.ext.compileSdkVersion + defaultConfig { + applicationId = "app.capgo.nativeaudio" + minSdkVersion = rootProject.ext.minSdkVersion + targetSdkVersion = rootProject.ext.targetSdkVersion + versionCode = 1 + versionName = "1.0" + testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner" + aaptOptions { + // Files and dirs to omit from the packaged assets dir, modified to accommodate modern web apps. + // Default: https://android.googlesource.com/platform/frameworks/base/+/282e181b58cf72b6ca770dc7ca5f91f135444502/tools/aapt/AaptAssets.cpp#61 + ignoreAssetsPattern = '!.svn:!.git:!.ds_store:!*.scc:.*:!CVS:!thumbs.db:!picasa.ini:!*~' + } + } + buildTypes { + release { + minifyEnabled = false + proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules.pro' + } + } +} + +repositories { + flatDir{ + dirs '../capacitor-cordova-android-plugins/src/main/libs', 'libs' + } +} + +dependencies { + implementation fileTree(include: ['*.jar'], dir: 'libs') + implementation "androidx.appcompat:appcompat:$androidxAppCompatVersion" + implementation "androidx.coordinatorlayout:coordinatorlayout:$androidxCoordinatorLayoutVersion" + implementation "androidx.core:core-splashscreen:$coreSplashScreenVersion" + implementation project(':capacitor-android') + testImplementation "junit:junit:$junitVersion" + androidTestImplementation "androidx.test.ext:junit:$androidxJunitVersion" + androidTestImplementation "androidx.test.espresso:espresso-core:$androidxEspressoCoreVersion" + implementation project(':capacitor-cordova-android-plugins') +} + +apply from: 'capacitor.build.gradle' + +try { + def servicesJSON = file('google-services.json') + if (servicesJSON.text) { + apply plugin: 'com.google.gms.google-services' + } +} catch(Exception e) { + logger.info("google-services.json not found, google-services plugin not applied. Push Notifications won't work") +} diff --git a/example-app/android/app/capacitor.build.gradle b/example-app/android/app/capacitor.build.gradle new file mode 100644 index 0000000..3b38683 --- /dev/null +++ b/example-app/android/app/capacitor.build.gradle @@ -0,0 +1,19 @@ +// DO NOT EDIT THIS FILE! IT IS GENERATED EACH TIME "capacitor update" IS RUN + +android { + compileOptions { + sourceCompatibility JavaVersion.VERSION_21 + targetCompatibility JavaVersion.VERSION_21 + } +} + +apply from: "../capacitor-cordova-android-plugins/cordova.variables.gradle" +dependencies { + implementation project(':capgo-capacitor-native-audio') + +} + + +if (hasProperty('postBuildExtras')) { + postBuildExtras() +} diff --git a/example-app/android/app/proguard-rules.pro b/example-app/android/app/proguard-rules.pro new file mode 100644 index 0000000..f1b4245 --- /dev/null +++ b/example-app/android/app/proguard-rules.pro @@ -0,0 +1,21 @@ +# Add project specific ProGuard rules here. +# You can control the set of applied configuration files using the +# proguardFiles setting in build.gradle. +# +# For more details, see +# http://developer.android.com/guide/developing/tools/proguard.html + +# If your project uses WebView with JS, uncomment the following +# and specify the fully qualified class name to the JavaScript interface +# class: +#-keepclassmembers class fqcn.of.javascript.interface.for.webview { +# public *; +#} + +# Uncomment this to preserve the line number information for +# debugging stack traces. +#-keepattributes SourceFile,LineNumberTable + +# If you keep the line number information, uncomment this to +# hide the original source file name. +#-renamesourcefileattribute SourceFile diff --git a/example-app/android/app/src/androidTest/java/com/getcapacitor/myapp/ExampleInstrumentedTest.java b/example-app/android/app/src/androidTest/java/com/getcapacitor/myapp/ExampleInstrumentedTest.java new file mode 100644 index 0000000..f2c2217 --- /dev/null +++ b/example-app/android/app/src/androidTest/java/com/getcapacitor/myapp/ExampleInstrumentedTest.java @@ -0,0 +1,26 @@ +package com.getcapacitor.myapp; + +import static org.junit.Assert.*; + +import android.content.Context; +import androidx.test.ext.junit.runners.AndroidJUnit4; +import androidx.test.platform.app.InstrumentationRegistry; +import org.junit.Test; +import org.junit.runner.RunWith; + +/** + * Instrumented test, which will execute on an Android device. + * + * @see Testing documentation + */ +@RunWith(AndroidJUnit4.class) +public class ExampleInstrumentedTest { + + @Test + public void useAppContext() throws Exception { + // Context of the app under test. + Context appContext = InstrumentationRegistry.getInstrumentation().getTargetContext(); + + assertEquals("com.getcapacitor.app", appContext.getPackageName()); + } +} diff --git a/example-app/android/app/src/main/AndroidManifest.xml b/example-app/android/app/src/main/AndroidManifest.xml new file mode 100644 index 0000000..b7297ee --- /dev/null +++ b/example-app/android/app/src/main/AndroidManifest.xml @@ -0,0 +1,42 @@ + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/example-app/android/app/src/main/java/app/capgo/nativeaudio/MainActivity.java b/example-app/android/app/src/main/java/app/capgo/nativeaudio/MainActivity.java new file mode 100644 index 0000000..00fde36 --- /dev/null +++ b/example-app/android/app/src/main/java/app/capgo/nativeaudio/MainActivity.java @@ -0,0 +1,5 @@ +package app.capgo.nativeaudio; + +import com.getcapacitor.BridgeActivity; + +public class MainActivity extends BridgeActivity {} \ No newline at end of file diff --git a/example-app/android/app/src/main/res/drawable-land-hdpi/splash.png b/example-app/android/app/src/main/res/drawable-land-hdpi/splash.png new file mode 100644 index 0000000000000000000000000000000000000000..e31573b4fc93e60d171f4046c0220e1463075d9e GIT binary patch literal 7705 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 wKmFJ0_JHhk1&0B>;%YXATM literal 0 HcmV?d00001 diff --git a/example-app/android/app/src/main/res/drawable-land-mdpi/splash.png b/example-app/android/app/src/main/res/drawable-land-mdpi/splash.png new file mode 100644 index 0000000000000000000000000000000000000000..f7a64923ea1a0565d25fa139c176d6bf42184e48 GIT binary patch literal 4040 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 XyOn+%7f`N3b2T^T3uj5+eShz7v)7qy literal 0 HcmV?d00001 diff --git a/example-app/android/app/src/main/res/drawable-land-xhdpi/splash.png b/example-app/android/app/src/main/res/drawable-land-xhdpi/splash.png new file mode 100644 index 0000000000000000000000000000000000000000..807725501bdd92e94e51e7b2b0006f69e0083a0b GIT binary patch literal 9251 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 literal 0 HcmV?d00001 diff --git a/example-app/android/app/src/main/res/drawable-land-xxhdpi/splash.png b/example-app/android/app/src/main/res/drawable-land-xxhdpi/splash.png new file mode 100644 index 0000000000000000000000000000000000000000..14c6c8fe39fcd51a0414866ad28cbe8ff3acb060 GIT binary patch literal 13984 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®q@N z14_H8ofW)l{|J8q+a)eH)I0r)>WXdzV%7J>PA~6_J)KLT90iYa^K=Wz7D!OybzqSru=f4?|KFl;Y)gP_H6V4x`~kZ6fE(xM1&;?72-TZNk+0 zr+Crr5yl%Iy@vfmt3eYFl!jIvPGFz^8Ek+2`48O1_pCX3xNWh-zBa{rIcc%+=|XVj zANYTg&s}TKb#OztQrCW(Xk?V^i{`q~%HtcveTxq(_HKeC9GzrtguMT4Nvs@KakPTA z9>*8bBZmLz`lK5=l)=b|=dT3a5ag^a1^znZyx5QKfUb1b9yacArRp%3@QWo(hrsCU z-K!-=jDmv!zb7XT>)r|-Z0Ry}lk2;dk-ECqMwr_nKN#x*X6~B5hVIN>6$1HwBz3Of z=Pk){AL5*=d90f17_qZEJLm;Q%WMdX=*N&!ki@E&cy7?>{1ssAH(tACtp*r@d^til z)x(1#6(kPD+joSF&J3sxJU@{-sWCS+pZq{Gsx=?z4wP;>?)1yHv0?X?VP{}cX4~aH zxeBPKw_rgW8rvewS1W2#^y+c>-183iMbJCqc38RN_o~__9-n|jcd&oA`m7*&Fqqpc z;Tev*0LS-ZK47Sq1unfvP1S43uA12P?PJmI8BeTYPr~R*tYUm^0;U%Hmu?bSZHEK6 zPjsW=E67Kq-&trmf;)UkmRABH2U)V)-eRT$j(%G12lLMsThSsU10iP#{)ZnvjzN$d z*K%P3`}oqyvpWP~venr>3viH8^`)Ma*=B31hw*Q+tqE>i2y7w!(o^lI^Yss^=tHW( z;cnCT(%B1gLz+TRGW9roFjI1EQTu-u`(f#RmZ8;FSN(bsC1J;+(i_R6mrW=yYx$cy z#%QKVrEx~kVMg~yo?^N28Wnk6x%L;J8i|*|ANEiNjq(Vhzuzl3ikpA*G!Z}kLAzAI z9qnySo%D|AuJj12%h;Otqjs(>LPj?rNdeU8so>P(C>XMzlho94ZD#w=cCOOU;=3&^ zsqAG!i{~lY271D|m>ztPV`)X@FO_;`wPjppYNQpM+ncvtz1lZjN>!Q^*I}T%uP78Z7tbV2$q3W_)14=kLFyJ z1GqL6T>ClgeZorL!}xP4f%OB_EsmJ`uw7dGWNV9OLlhb|UMpVhc{4@Bhh`tO!ZqzD zhusd<=K^ah!L@gQ?6dOpI-ge^e>S5W9eII57Zu16eU?GRbgKTeVk9yS{iK|O(zLR> zheb?;jwGCHS80NCn=jKxgJ>}qu4l%5NPihjzazGv#J?Jcyl;<#IW&x4mm>nrW8>}C z3U@aeD~)*F(0o^2{GnKVm$Jr#aZE ztl~TOkM^SdzJapQ((!-i8b!RkVQBKkL`2ZCBuy!qI1L{3Er526plVols~68U-^9Px zR(3{j;Z9RHX^muc0dUywJ|`yyZFf=k&-Gb#m4u73Lm5Ks%BfHj%2|gjn#i> zLC5pO$2Em9H;qoKQmMtl<@wgtPF1%2HariD5O~u>8=^*J&au~JH%Ih@&2Uging3U_ z0bzfKucW$ZHSx}!#buB?+-J)%RQbbXM-!BJTS&#dU_@lxU6>te2O+9 z@F{F{Nb!;{Cd`Gx+$G?11aB~S#wIH%D=*=7f7H@D@%B1)&bF$@t3JDq4l*%(wJTlh zo`?uMq{YilKUewPNaC)GuOr<8j9&ofqRU__BRUX^x8Cj3a;a$rXzgXqW>LR#CUn%~m)t zYC&ol(gAkbc^fd`xWU&bk5vT6KbFmsR=O78Bn%t7 znbw&=c+|T&#r+bls5rU6D#HMvqA<|;)BV%jOMonkm^p$7Vcel-Wwn$=uAJv&(8W>% z9))Fxpl*(%E#wFm_m!U~2HqgZs^2vaGeY(UfYKrSHV}w^D0N6!se5Ewy)Yy-!(2

    aKj2hWG7>znxs|SE zN4rHtiSPqLskWp(?(_YYwgq+1@8v+~8As|(bC>$D(atG3ZE8-ZM3SVcg|vHQz$I=!(A`k`5= zOqR>&%G)$)k*QLz7MTB9wleWpv&N9Sta64wy}3Ytd?x!Ja8z>(z~(3UNFu^eFmn#6 zw!!gUxOuZi$PQIs*ixfZR3iLyADJ z5&s%tPfk>V!x|A-;oq%1!yk9H$UBP0ToA*EDtz(^!_AnF1bBQ7joj|? z5b)gSI8c8O$PYFE!vXJ<4gebg*9G9P2wcB{#kv0FItc5T@PDNo)}Rh4Us}L{e}xzW zhwt`)j`M)mP=G6H0;^&q=I0{jU%bIRkF#uLF;{vVC&H|_uc literal 0 HcmV?d00001 diff --git a/example-app/android/app/src/main/res/drawable-land-xxxhdpi/splash.png b/example-app/android/app/src/main/res/drawable-land-xxxhdpi/splash.png new file mode 100644 index 0000000000000000000000000000000000000000..244ca2506dbe0fd8f6a05520ac7d1a629ea81438 GIT binary patch literal 17683 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 literal 0 HcmV?d00001 diff --git a/example-app/android/app/src/main/res/drawable-port-xxhdpi/splash.png b/example-app/android/app/src/main/res/drawable-port-xxhdpi/splash.png new file mode 100644 index 0000000000000000000000000000000000000000..bfabe6871a17a5e95b78fb30d49b7d2b4d2fe4c0 GIT binary patch literal 13346 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

    VwO4Hu8X}%XHUAz_J@50rzbkIsat>4oWtQt< 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 literal 0 HcmV?d00001 diff --git a/example-app/android/app/src/main/res/drawable-port-xxxhdpi/splash.png b/example-app/android/app/src/main/res/drawable-port-xxxhdpi/splash.png new file mode 100644 index 0000000000000000000000000000000000000000..6929071268eb03ee0f088142b6523566b78550e2 GIT binary patch literal 17489 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 KR&><$`~L^lv%S~= literal 0 HcmV?d00001 diff --git a/example-app/android/app/src/main/res/drawable-v24/ic_launcher_foreground.xml b/example-app/android/app/src/main/res/drawable-v24/ic_launcher_foreground.xml new file mode 100644 index 0000000..c7bd21d --- /dev/null +++ b/example-app/android/app/src/main/res/drawable-v24/ic_launcher_foreground.xml @@ -0,0 +1,34 @@ + + + + + + + + + + + diff --git a/example-app/android/app/src/main/res/drawable/ic_launcher_background.xml b/example-app/android/app/src/main/res/drawable/ic_launcher_background.xml new file mode 100644 index 0000000..d5fccc5 --- /dev/null +++ b/example-app/android/app/src/main/res/drawable/ic_launcher_background.xml @@ -0,0 +1,170 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/example-app/android/app/src/main/res/drawable/splash.png b/example-app/android/app/src/main/res/drawable/splash.png new file mode 100644 index 0000000000000000000000000000000000000000..f7a64923ea1a0565d25fa139c176d6bf42184e48 GIT binary patch literal 4040 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 XyOn+%7f`N3b2T^T3uj5+eShz7v)7qy literal 0 HcmV?d00001 diff --git a/example-app/android/app/src/main/res/layout/activity_main.xml b/example-app/android/app/src/main/res/layout/activity_main.xml new file mode 100644 index 0000000..b5ad138 --- /dev/null +++ b/example-app/android/app/src/main/res/layout/activity_main.xml @@ -0,0 +1,12 @@ + + + + + diff --git a/example-app/android/app/src/main/res/mipmap-anydpi-v26/ic_launcher.xml b/example-app/android/app/src/main/res/mipmap-anydpi-v26/ic_launcher.xml new file mode 100644 index 0000000..036d09b --- /dev/null +++ b/example-app/android/app/src/main/res/mipmap-anydpi-v26/ic_launcher.xml @@ -0,0 +1,5 @@ + + + + + \ No newline at end of file diff --git a/example-app/android/app/src/main/res/mipmap-anydpi-v26/ic_launcher_round.xml b/example-app/android/app/src/main/res/mipmap-anydpi-v26/ic_launcher_round.xml new file mode 100644 index 0000000..036d09b --- /dev/null +++ b/example-app/android/app/src/main/res/mipmap-anydpi-v26/ic_launcher_round.xml @@ -0,0 +1,5 @@ + + + + + \ No newline at end of file diff --git a/example-app/android/app/src/main/res/mipmap-hdpi/ic_launcher.png b/example-app/android/app/src/main/res/mipmap-hdpi/ic_launcher.png new file mode 100644 index 0000000000000000000000000000000000000000..c023e50595074292c7361183a64de08cf9686c9c GIT binary patch literal 2786 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 literal 0 HcmV?d00001 diff --git a/example-app/android/app/src/main/res/mipmap-hdpi/ic_launcher_foreground.png b/example-app/android/app/src/main/res/mipmap-hdpi/ic_launcher_foreground.png new file mode 100644 index 0000000000000000000000000000000000000000..2127973b2d318df7085734d236d0ec649a2b0292 GIT binary patch literal 3450 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 literal 0 HcmV?d00001 diff --git a/example-app/android/app/src/main/res/mipmap-xhdpi/ic_launcher.png b/example-app/android/app/src/main/res/mipmap-xhdpi/ic_launcher.png new file mode 100644 index 0000000000000000000000000000000000000000..4d1e077104cd61e6a4c3707e87363b523077245a GIT binary patch literal 3981 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 nm0GElTB(&OnKI&V600000NkvXXu0mjff+~0a literal 0 HcmV?d00001 diff --git a/example-app/android/app/src/main/res/mipmap-xhdpi/ic_launcher_foreground.png b/example-app/android/app/src/main/res/mipmap-xhdpi/ic_launcher_foreground.png new file mode 100644 index 0000000000000000000000000000000000000000..df0f15880bee46332dfc6622583215194f948b0f GIT binary patch literal 5036 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 literal 0 HcmV?d00001 diff --git a/example-app/android/app/src/main/res/mipmap-xxhdpi/ic_launcher.png b/example-app/android/app/src/main/res/mipmap-xxhdpi/ic_launcher.png new file mode 100644 index 0000000000000000000000000000000000000000..6cdf97c1196d48e9833487ff6de7c4cfc4e1232d GIT binary patch literal 6644 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 literal 0 HcmV?d00001 diff --git a/example-app/android/app/src/main/res/mipmap-xxhdpi/ic_launcher_foreground.png b/example-app/android/app/src/main/res/mipmap-xxhdpi/ic_launcher_foreground.png new file mode 100644 index 0000000000000000000000000000000000000000..2960cbb6104b915c84760f889deed9bff2b3e17a GIT binary patch literal 9793 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 y3vD~Wi9;mL_v z7xo7KSWDz+M=Rp9m`_0a0lhg5l^&CC5BgTJ8~rS9SnxkU19>e|C7+YL@oW>oCNY~% zjVaC?;3_T_7YlcX;!4CHF6O@bK=w=3NCfVpder~+} zlN~`b;ZH0cqf)!anP6auHDwr2j1MwqivrM}D4y7zDN5QdIC*xfPfy#6Jpo~e>_)!x zF=AeZc`K$+Nj(iiSI|EYm%+91t@RkYEp50Fb$oH(=LnB0Hd9b~x58vt)(rmXq3PpfJJ>#E_a`eP*G4lhV92sh zbXI2&wZHc?FWR^m_YsE(f7^=(i6UMrRF*M&!zdenDyv*bN_8H}5an{^P4zNHY#6Tc z)i+L?j3t%eX4Pxkzr0EOY6u%Yw-NUUc7AtfIdW55h;Jyg-dLN;WU>ksc+OcyXo`lC z7t7Lo;jdSB>`k{Tu+2Qoi$S<)+2d+3ego@0V>ovAG7H>!ZiBZr&|Km6Y7yKi2u#sCQd>&w_Q3pqS1D z-u_vP59v|e5QWMs4JWNB1<&9`pitC0?-hGt^o=9MN|SAN;>>mC(6dDQ?qRscdK0xR zRC8J#l=GdZxX$mu7hD0=OaTt?Db(*>rQs8?DZUsFU~AHJ(d>`8X&FWaz4E5#71%o~ zG!%o-pSid?x9j!j<%0xt3IZ)W#yxO)`Z26OLF?3w8Smx{(dRtVwSjC6pWR<8JBs!=ZyZkxJ{N9*89VkN99f3 zf8(oE=#s4|gZS%J^UNK8`}h`+20jJsUq)b_%ZoHn{7$NKG9EQ`|D)ne{G_ku@gthG z7-niKMeVIfPMrgZ^`Odpm9XhGjd70CO&si_R!5kuWvT1swi6GK8Nd6a)V1wg3?hQ5zy87yG)A z>l-%CDZkTXe+WkeA;GuOM%rG42n1ieIJ&c}9~w~aRpNB-RAO!-(wEVm7P>QhNZIt9 zndan|MWquZpErNAp~;O&i~IC6nA%BJr1fHlL73Dnjt)Z?*MCp&>itYcar+@PsFoJQ25T5$R_O_runRf zYy9wp{K7O-l zu4%*E(S3+5s8jzT+L?W`tTU-n9S68ayCHt+h$L)#VDMqai7Kyrb&%z5`@d4GbEt(Z{6Zc@HeGjn zLzkc{rsU>1kvipF;X_O2`5T9vc&E)Dm*A%{8uRYdeIzn}-VuExvbm@fYRkFkIl&xZRR~3+zu%pCw*v+hop9YfG{} z9PAo5)z%ejk?(5~{={nIJl@jQGE58oA)Ss(?i$_@lgl9a&?qA@gC$S(@)(+|l0EDp zkUIZKtOp6gkuoN4TC{3j#SPIT?1G}o!meIU&1yA6z~`SSjCePLfo`6EG4@Q^SQYfD zME-0j+%@=0&VAfw9Y5_WvMGliaFPk{%3FI|b;jusr~AH|8USTRd?k|cV2vLq^4mng zBbK{jx34U{b->g2b00EjxS8GQ_8h7{Qbfh@&CMXrJ_&~3hxHXZFPckU?^m_Tk7p*8J@@0Wc zuu-6B0IE(`72?ZVQ1o+uu6Tt(J6kKmN#r$X$kw_rmnnLAU#`6i6oL%RENvDm&`rL# zyZ5li(X6^=9icG~lp41ln{gubrnhOKkIMm7%PH7ra1u(d*@ zi7@&!+4?ug=pS|)13s*#$&ScZ=QtY8*gnKe`W7r){B4m_IhMf$pzK1hdLelO$4@=4 zS8%erVQyIhZnGiN;})kh`1eHIR4@$Fi%v5EV-#5kn$z?mDfc}*#EGjB zk|sx5I+_c$Ns0pFYfl?j+AP!x+p^YFJG=zYj&2a?DnIj$ zccEWAlL4$A-Y2$CSf8FuqiO%K@f~LyRmujzNZNnLX!ozOD8cxscX0zfP&` z2)d){2xXh#3mu89_Tfw&hppPL0IF>n;~o}~40wK_+lq@+RytODW3p;vfkEH1#2goi z8a2eR<;Z)3Oq*)~k}$09S>op_FRxlr(VACElefuBp6qZRUQ)f}9AlV{%Rm-l*ZW2KEg@mTk^vReLa*bRHHFPUPx=o?my9TrfCXdx8Y&v4yLVmFisW}xDSJQ!PQli}Vv;xwdP;f8` zq;@jO2TtV9{TYgQIuQ;4`PRd*F_@6(X*bhzK;L$@e)Qr8`sr&dXHDVuq{ywl31V%7 zkeCB6O0TA`187$ofjRC5e=T zKBG1a0d2dhJZN=}v&a42h(nE8kadY8Zyz>ApKv)I^Zw22} zS@CK|(l#2SX?XY^_HHGAVV**d1gRWVF7HM)ZDd+sZoZV9cz_ddL`TjHme`^YMkz{cKKujz6<=Z#HSOMb( z^OGCAXi;9c6NAS*{pBcYmA7H4D3O9J3Zl2>{$+9?nxrNPtDSSw=Xa&7m%gS+?mc<7 z>XPo{t?R`Jm3n}zo*n9I%uVBD0k~%__$8Y9EoZ8v4Y)6H0uGuL-+s{6I{&3=HiCX8 zrYb#tgQ-PH_^s7v&# z2^ubzq(}w5|8pH_eu(#*v}EUWG0zDuczM-()4YJ-Q_soMz72`bABz6GbA?l4xnO(V z(^{Qi@4rkBos7DTLo;4+7(WkM!O+|w=vm{UJag(GF~^ZReVUW^y6azP2H2oo*5pI# zK6bDpFEy0Je$Ifs{~w1Iy`gDX<*@Vu4H@eB!E^F_Rd7HVsqrjnGdC9e>WFIrv;-wl zu&w5Z#GuV@)AbEO5=$~6smh0{eUAcp(Ye2DpaKP`oW2+Mr=;4jIQeVG?;{D~km4-q zYo5p|#mL~&xP0-dc~PX9H;H$k!a^(}Decp{GCX5i3dR=!WGI$C*-jUdd*|o#?FqRgbfvEmou58aq2W`d=Tm~J1>USN(f{?bSNgu* zOp|?QwOVBbDPM~Q&eWnL#36m+uoZNkSeM}S7VPKtcf_2-?RVm`tCOI+ zcVz8*+tVlaqIjkKqKczlU9CILo2C24&nl<*)$a+M8E5H@*laf|uO9*c<0NSf3&l2zAwUefgo5=tHQyaEF>fUvB!`Qyb7Y7_!;i#tin-6rPyMhMo35{qyYAul zzqSn5C^nN>uqM@eqfCS?b(@m7;~BIs2sX$_+r(C*@5O3TaLnU`D(?= zIPV{WdulsgNaITPZ1_C)d~`{tvMCpfI#=(;;kd#4{NYp*wd?QLh)3PaG$7^eM_7q1 zWM`zNk_o#<7xszE)zP^#dT3Fwe7@?;*=58RSAB;{D^>HBb1pwtI!FwD=I^2Gl8sNd zB{^G(c|Te%yeI)!we4qsI_iFa#6OqMOc#rT5pSyip(>}6P!uu)Kb_o%I6AU8G@uA@ zAyi>m|A8Fpod4-16No_j;>6;81Swgw;?*EjNN24eRe*L^igbgA_Dv|>QFH`o+DGY> zbAE#?YpD)FQ#6(*M6uw=e(}FRLv@*O4+oDuoa$-Ne-T+O2feT_dqz7c!iKXAHeli# zbdOqI+FBr11cls9uCpF8`$>S{QPb>5VyOi}`#4N$NzijET9trixd&1e-VoGW`WrJ^ zMn|v7$t`Y?o3FMjqNG;-_voJUmt2Oc%UO~y!2cv8O9&11;}>7f=d48{J+}Pi$n?KL zDLTS0Mv_ySccwQ~Tei|zL)>K{VZ|HzhcH6xvZ4#)5-4BYiV|24Y_wJ}%>hApUGJm? z?@a9h1HHK2JsbP>qQ&zZG-D%HGM#3^V@A}8s43#}K^yuY((yP;4LD&Eq3Y=7IY*QT z+%#3oaCJ+@&vDBv0gpkvB3Pq)H)?q`SR5>k)zFk#Y0 z)*OIyPDPlO!48$I{#2%~1^D%7T-`lAbapZK?@whU_QM(y|L5Ro3;0tfKHxtBp2(=X zrvvyYB~r!Ct2WK#=w)Svfbw z44Cf^yEV06QE<01NEKOpFm-GOJ@JWPF4IwZ?*SKRiWPyTcqNT-p5wSPY{CEMmow;#v(0pX)_K5-W0edv=Pi4pBMF`+3P@!- zUd@FLfiCBhdS_(BkqLtlu`q8O9T1%zrdSM+UVSqc=LinJni z#0bUiQ4EYMi+2=Z{1XP0BQU4GgH2Eg;0&n>w~-Y2&M9I?aN`ABE+Gy4f}hs}3BO;- zPRGB|Qq!vCb^-rLuXAlIT#1xtW1vfNk~0A^6AqEJRwxlt#J5D8(pi&6=UfgjxxtjL zXdWb)ISVZj>;8^J>FZSH+@BFWvDhC`nEH>nW3WQvK@sZaOV4dZZFYu9Dvq%9XhjL) zT&h7h!UJlkzl^d@$+qT}%Xsrfv)^QNc5Lmv<4f*fQmcTr2l%r+(WE0T53>m)Y>&At z&aHTynvej_oHbIM!2>ko@2plJxlj}=-(zMJ8LA5SX+k|`Tw%(aRZX)j+RstYL5%}= zRI}CjTxR}7pdVxO?Do|&Ukf@Z!7+}E}7XmlhL? z+o`}*@Mmd2)dZ>OScGSUnK|$loE3nwUgRc61DV~U$d`Ww-4c`8F(3%Dwc6Yl!$9pd%l-oVOpXE4mPB`PIR({&N?rZ;!VThbE!2&OieN|3x@Te%lhvz8CX7%Ls& zP8U-t(NLRW!jKpo^w$-l!tyE;BD>*B!KEEHbU|i61kR2*FYN?JH}bkRh%x6DcJ_^4 zUvj;8Q>8SH#yF1X2Jn=eSU?)#>t2g}B2~}`ZKu13IoJ91`A?7V$(e17%ewQWF-oJi z?tlw~ScDE*zWi@mQ2^l-+yI(SGNuZ3$B4*k&P#PB<*_yIrxJ!Zdb3XbwCH;_uGobw zX4OWA+an{LTMTZAdA|(*Q*we8GQR@pSou=W$D-+=_ja)FN~?zbI96I{&;mm2?7y!I zrxBI8gIzGaPMPyyCti|zUhJS7}t$>Q9<3LvIDE+q1y;J@&Ci6*m?7gs{K*%`ng_Hc=&_{@x@jLZ4TVu=W+4>0Ed3~t^fc4 literal 0 HcmV?d00001 diff --git a/example-app/android/app/src/main/res/mipmap-xxxhdpi/ic_launcher_round.png b/example-app/android/app/src/main/res/mipmap-xxxhdpi/ic_launcher_round.png new file mode 100644 index 0000000000000000000000000000000000000000..a40d73e9c68ea638c28c7b13e4bcd1e179a3a102 GIT binary patch literal 15916 zcmY*gWmuEn``^Zh(J)ZDQ$RtwTR>7kN=j*DB1ktQ21<++q+3clB!@IeNJ@8ujBfbv z`+N6)vF&=^JlA!0?)yHUI*~eBDn$4+_y7QaNKI8q7xRny?}LYf`PQ9x!UX`NPt=s; z^}S{f{2_i68+UD{K=BRopI{(%Dc8%=0+TOyrFG?X<&<^!5%&~_pE(VD?XT+2&J8Jl zI$>j1ae4C71p^>zjTND9u)rYZE!&z4t<47+!Nca%jNiY9e-Ae|cVvug-H|fQ><>$g zT-^A@Ufg7U(z0!*@to)gpLFO?+vT3gu&3#^nEl+Q<~Nb+EW&N*P_NeeFL2D8I3vnN|*;9 z<3l=1XktkT!)UvD2rLM!v5%xreYHokhKefAoUdmu#+SmDW;&Mr>ozx{$EIgUd>~RZ z57RMa>itb2WrqFN@G@!ZBs~DFIS~=j*fFlcJNI%GLa<_7pk4*lSGm9~hHD12d4T#9 ze~U`=#SojxH^QC4(Xob!OV1!jUSqvt;U6MBULkS@RO+PQv(Kh7fjZy6yApI*s*W~( zyXE!QY^f)cEZOl*f4OwRpD~hnPPoJKj`~gUeYwAT#)U-eGw{!<z?c6ckFV3zH`^Pw+%5kk5;_3qy7snl@m3Qv5+e(`SI2IReD9YDj9xQ=gJe7D!+T= z@!d`Tti}|DpMlNCa(C^qY2zoK^dG|IT*-}T@d9qaw=BRwB|E{H6}DwzH909cY-V|; z0CH6qZ1ce_l0N73036Cx`Ea7s8j>+IzJs@0{Q#ZgLBPu?P9Y>4%7K*oGReSPWBnKx z{>~=aMtlN%`+8ltrK{BbwjH$||Cw;()cjU|gL3?M+o^Apt4^ATa9X)Q50BT;bWx|3 zlPR<_61&w0*vJ%2uPx^mYox~8K26Jiau-GDn9~rmn0H>{<~YkLWLT`&_D^HV%KAX} zy$|T}qkDN#huNX_6ZB+e_OEvufI$-Uji0=vi=t5{&$79+mciFrAxGPe^3_9nF7%hz z*qr^xWT)ysy@F(Ck}Y^RzCY(ir0gH1)ZB(!kD~FrPZ>OPyhGh8)8P{B*sKcvtrzAj z@9ViUZNQgae~SqNY&^c_&hp`eTxT-%S;szGUO!BZkUOMqu8%wO-H_Jm#VvL?`=ech zuT5x>h|Ff@RW(N96d2epYb!5{7DGwN+j^T7n#^r@G!D&!rM-*;YBdP5x9gBZW1!{|Nz!fWAb)K>8y9QW~kq zB~+D?{gby~|41DM{h%_-A=a0>Q|6KV`**=JTsCbk3I(j`4}u03)aa?=YH3{!xqE3U zd|{HEPLO%nzI+^^()m>g_YuQuw!a%^K7onJO2jW2ToX9s+ncG;ad{$%1c3I^KgXhx z5PQq?UDt>@QG3dtfPiKgl+G%I6h`TJb9b*Y7SE-H&O7~Aa?+mHr$lRV7qMBiEP5@I zPYTSo{5-&%yd{e7wNVf8eAxwdbY?p6JGoghtF)9a6@oYgEp52Evj$I+uOFLzko8IE ztU@uy^f6==>)Ykg;TNTEiq0*fcEQCgh;95%`=9eNF1L`O5MzQ;zZXoBw=`@}P{qAFsgh3;*1C7dxPjZQr z2gv`};fd?J?oJfHA5#_#5whc=xDH(36QsD6FIex0cK_L0$@^+b!ur+uHlH}ZRwiA% zZiY*}sC}I#8_lhkjL}O)WZCeCNq>_UTcx^p zfZ^@3GYf)T1H?H;>sO|Qv~&)?IRssrnQJ~9Qk7fRk!J3o=j}hrU=RLv+`uHd-{8ii z|67CPgHVFvWZhZ4P3%)h1YNw8JRCrgoxIe4j$=&B{*=G)n}vz(bEPimWdvOl!N|Sj z9_0Hb?q#6OquT))uUhQ%Vz*CKQyRoa=inFK0SspOE!MH>isxM{!P9$ZNy*9gG4a`F zp5(VmCrjUXKc)iPt6Sx{5$OSyXT1EIN^na$V8zZsQu-VROLfuk`yFb2@`;4f{QPyh zC2n$lw69cVY5#OlIou-kAh2T~HaJul!b5SlQJfFHDO0$8X0o2yZ9d7eyB`0knq;mL(VN7R@Xj-IdH60yWTj*Zy%7sO2GlquwiUu9BcK<-E=1TDz8iQ zO7F<$Y@@iNE8taAvQ|3Lnr#zXDMS6_i1V5u)%Mwc)pF(vwr4{-E(HX zRu9=1tC^iljY>g%hbcIydU@#?1w^;y=rECzYNv};`F6mu7mVr}#p}guv&Zbd8H|?N z2DVhIG{ADrlNFh@T))3mB*tcmh7}Xs7p_f&)X&ncR^9%PSZK>Z&K*38r4v7fu*-e1 zr6d{cd~8C>u|z2xVLU!N=!)n1tG`D?Q@l$+l7hNT`Q-L&aUx5qXwkf1H{W%uJT_rp z;I&-m`Ab!1myt|qC>LZ_h;wH=x1^+m@rtxJ^-Q#h86e~1o8K5TuIO<@992xIX^^>; zT0G%uInU*LDKzv`LqB!}8{Uy^WMbm;TvC!2;Z@t$-|vudJcbCEi3h-bB<&DUU3Qgz zD@{~v0j;e~0*^{rvWyJYoIRFftw&mzk50^Fs?aG}SeMZ@vF82&-R;pFMT;l9SbVxN zdy4rZ3$J=PdN899MHoi2L0a)A%ylmGL_TBiS%kAQWf!giWEC;jnJfDD78QHZVwuGh zW6Tl}*!QTb^EEtg@vrR?GBo4!XM7jTUXkRx8APaM9UmW?gHLd+)EI3_1Wkzhg9QxL zRaC<{L^)MI_OM1AlA@QsDo;i?K=XHQU}dH$YXrNn$H{FB_48mVgQNBSgv^$f7TVxC*j#;`S^=s7o5=4g zjT$50479nTx6_a~N6YdRaYpguu7-#W#s*z;D?>+QP?;};OlDTiI^&tJ4GHf<2H@eH z_uUHw7^$diS5`0jcZnyPGmMlJ`mFM^Ww~%EN&e?^XXDqeZzS_jqQ5;{jqzMrQ?W$t z#I18+x!;1W4q$Mxx5B`OlD}+?f$UO1=5MlfDA@*8(!lmIvfD9}{6h#6;y03MOjLi% zi{|yOiDJE?E;t;16Z|vZFv4Nbks!B!xV*$;%lA%RbB{45uN9aYLGu-%t~}?^g(9nTgP6Tja%xnfX4z0uo(E@aAuWNyU1hlWcw!Qd*NDT;czV)b?Hd>0Fn zEn)$V+SzQs{_@U1^>5;z`TpZbejug=TM7glSkh_99m8X+9&2aG@I89;NJbNDH7eia zAw4}kWCT{5zfJlszn)3nc`2)OY04fqi8 z>kujMt;IfTwVgP&EIZ(hBl&F)6Gsr8!e^m*>xv-6&5>RoUIzi4lvm|;*2ArxVTqgx z`_OfQ=t;Kj4VGA6m3q@RhX7pXAU1?)WP)Onxx8N>Zq@Dk?`Ia}njlv3{Bz7!Mn*we zC~iIZk_2Vi-@JDe=9a{d%_6lu+UMccKbBq$!_zKJ`B zqn*^8-$up2e)dAVs|NP#S+c%Yw`T*Q8@GlVSgUHOOU#Y6=3?z%%OfzuY=1BAi+!~C z`vqEsjOh`Ckd5p~Pg?Ai_aMX2BZyb<>gplp&3#jA^Q)xub4%c!4p(Av?fuK4k^84{L7h1h zZ@cd;%tIUn=y-07Qjl^HYVaciHMvNDxc=T6*8RwrjiATNv80v`PTJWjAoj~YB1cR9 z_Spm`v*tVbkH43eLOl-`TazsXSl_w>3-1O82P>>_^*S#RlzHlj2B};9`vZ}Gw0>Id zub1eap4>!+4U20D9X9=CvuBCautxNZqyDOq%boifCCPVry%A&-<2|xunkI>h7MzctpEQN|qpMPrN^e<_W@!s2tv4d{oXP z;|K?@S;aAx7IOk1g@+z5h=VKDiOG=UGlDo%fvLoh7#m0u$6{005bIzzi=Iy zArU;GOk+0(mb-Fz#d?`E7{wVuNwwzth=J7YCN2LU={2VER3ph1qkjGEPZhK?2RRL= z2;>ntgKAki4wXDeX@F)SGg5(hbjL@KDA*JP9*_9k8cjCkP9LWjTT$}}8YP&(awpMN z4^caTYRbg444avNBRZj$IWUlNtt*yD%0!`Ny}>x z@VKwZK@1OJ{Pd6jH{w*4e~L*mv_0=j?d*G3L3M#E>UUR%=1(i|Aj$na$)f!6ihV3^ zi&7@dJ{;FV?p^U9RJAV|#a+8J-vwm>@=UEsiTF*Xr>EP&L6gu=q}rS8WUhT&l3hKN zvu8>`7K8!gBxeVh#~sdl@KhIx>VpCjEf|n#2mgjAn1WtwXR`ozagov<4PMu`k^RIu z1Vt?^rt_6=J7t4k^@gk%TKK4JT3y;YO@1`1M$jqLO`DiUn_1Yx_)A&^QknA+(eC z-~7)S^z8eJ1Hv-h-x5559*^j6<;_}`CgnaoXc_N$#fU|laYihHN36A56%|XDAxL^3 zx=bd?`;=vw=oHIuB{0ypzzLzoks^!x}D1X?@FsWFRCdj^N_&~1|@W;g*tm6YJQVY`L z(z^)l-a7uZ+O)>Zoi$?9M3bagILq;la!?50X6!-lx#is=Aw&bG=OQjE!;tM`mIGUc zaSt;;4u_dLgUiWOhRtEy&A*Sm|Gm7cb-tMHxc_8ZXQS|2qi8FXUNS`LFQ+JZWVJkL z7CW1f1lbZFTU!#fqW0WehRoLd8C$)l7>IWkrqiM3zwor8&3rk$vSg zJ|-Q)vFUnqt1u!fC5IDPZ6QkIx$5>bt3Ss}WL)1Xa)XoPJTm&&C;f-rG5BbYyp1iQ zR@0icNc8~R<48VV$`ORE9aJCLjT;sk>kN@F;{0BOOU=UDO(C9ZQV6U;eK4iZEjx-X z^9X2{P0N){kD#Tfpes2eSQUDA^?;mC1fanQuGsxhbfRLDKnD%MOb#zh+AEH$s~X zEt|?y!TDDg32^1w3Pr(K>fX+E(fAU%d2AqOq1mu^=2gg3@j|8!>NFViY~K&3DUkNB z((A_W-@oslOCMgP5BEA~m7rE9!vQKeFK9F|_ z_f~l$5=u$NC4w^+b6#&Ysh0PE|8fRpyeod*H625zn>CoNig*_rgvNl7d8~bM5=%*9 zdwB@*)$7-1ez~XZKR7>j$3RHYpxXqI{;3D<8aAe-ufDoZ9bMEOa$u_|;dCZ2I;hwR zgaw=(m>YmLjzhXa%gX6iXyT+xj)YYUu=2Kv@2>YM9*FmK2^%Vt9vG#4gxGW>$pH_N zao0=RbijsTjaT^+vWqIb4;%cDKd* z3CQye{Vn*N!a$6(oja%<2-%(C&Y-DDlLPc+@9sL*s;p@Qd!Q=IeE@ekQ`2UiW}M`J zEsiw6D;Tuo(f$+AJvI1tWL=aTK)y}#5@f^#)Yc|-NUMxzF{5thY?M{UY3J-7d1?uR znp^0RH`du`LqV4Bl;q_*>Ia`T6C(C!H~?jVX;&v(7o5-1(SW}ikBf!cLi;jP0fE6x zGMaekQx0zdaw;EC9o;Nb0#k#=)W4Q@@Fez4RZF|su2vd0)z>ptDf9|+p}(N~LyUWV zwvX@*7n&RPF*`tqPxv1-i(UYTS#1qx$g(`!-82K#tU+Fu-mUV2?$xf29Tfn4;)%2& z;LoU(B07^I)i|xnKa$oW{5>+k%D7>P4C4&%Wr2eyX;Opo5|)RkV5~Dn|I%B zruo$bZ5aoZdne!9%cEvW%H?o<*CY$ZqsV6;49MgV;K0!%uurgn6i_!mn5|B8o9u1+ z|N2Jz9DnGzk7G*2rRf)Yff^s3HH!^AhF+56sc9pc%<^)EKs$U0@zoL!oo3*b&El7FY~e4n=^r zNXfW)Z2Soc^?2W~ zqWa=k$*|l$HZPp$aRa7ibzEn7;TTmy(;3kCM_BYk(!!knR+OJKxm=v%_RIVGpe9|f5$|d{4 z(&@Q!Q|6~RB{s>#g+#m~gDAZnB=M&MBIcoeoiKso zlPw?81O^53x!tBAHD<5|8Q=S0@$T5Mad<68(N$AJtr@q{ScE102KVhf3Mi_d!&n@W zWna`I>NLHG&Oe0!x<2MTs%$W{0&pU!nEWaI;RzyhBZdB@31)_UVKp>x^o8$mQ$W2~FiTZ; z_!v?TaY(rRx6rJu^-ahDTpCMR)&v1Fw+(9!?RWK6+)9Iq`;T^dV$BWih zV^FO%*yyJ#J059}WXG4|Z$}Y&>=}vDFOv275Sb#W^ghq0hO3EOyS*s4>Lbs5U{K<8 z{k1M;dfP%#F^8)L4wt%QkEs@`4tmuK~m9b^ohUCjF??KS?xSh0Ln+6IARSwVm+{fXt5FBdoWN3nso zAfrO^K04sGsHah_{U5Gl_*oR-m7To!@-LR^-aT!5fbCzAs{T|>;m8kZmBOydcKZWj zh&c`;)S#Y1>2)x8`O``L!eaZq`v4#6xGNGm_l5&?dv(&TZC+`j7SxBcDTbTzvbtz0 z;Uk)dZ)aYS1IvmwbNOcrTfJskWFTn4NFu3e_Um=E$`=4?f3dZ@ZbbHBOq&mC`70C> z5B`Q}g{1XvEr&@U6G9FonHjWk1!ebjs?!wH5eP``&*5)>m->g9{wUMx_b_kG9_052 zt95~=^ns5kDPK$7pN>ys4T{bEdJZhqNPR9uikG-e`D_2T7a@n*d6#3FSC92v7o(F~ z+>ea~5f_d2Bp-P6Q{5Vbo7lqQ@~Jma((|8`%fsD8Y^_ERhJ9~wg}OIhEc)VJ-rc{; zd&w_}(;G#%nzZGaYb0X$n$v66n&&Lx=Vra(%W)1dAJAN9gN7H}y-ODfH(PC<^i14{K%qG*=ZtNeR?gB!#%4pRM)H^6Dbku90#6^o-Xw$m9#2qA zOP@1NMmj)eHnl5+<|IQiZ1jXxNwp0*Nk9`56A?THWk$r9BcVZL0l$OeSDb8fmYB;b zj3;f?AM>V0xy1t_sT#$x+DJcI?y>oa6p_u#|=IBBTp7*|j`k9L9NAqg zr=7Uv9WhnpXnmxYU0lg5$Kv9Xh=NI1d7%^*hM?#d^EGzb3m9Q9kcjZVa>;uQs-+Wl zq`=2DWAHP;iHdy@l>W%F{tsy4|{O0lb&XceOk5v z0CjlG(*$zd)$1Nrqg^E+Ake;DecX-;SboZ?5@QV`Ewsa`qkC?x`bI*pz!L_85wpwv z)yiB_|6&tN@l_EJ_z1YF{>B=uUMi;y2g$T5j(k`RRPFtiH#H()kN|kVL1!JMWX)wQ z6C&NT{_akeHjwX|;}K%Sw^27TUIl>2cbu!VR1SI+6YFpjaezE4EfMKZOo-`IXG_HqNMiON7TDr;XFAhZy2&RjcKs z`kR?vT%=HQ`C(DFFVl#2A%Piz2P6fE(njWTu3` zIw4;b#|-*%b90y9SG0P_R{9>)O?%YqVnwh3qBEPN&;ME(BIPb=ZJ6ky@)|fTM@8c7 z(G^VJ0;@r{ufTuHm=Salkl*@IPyrarjeQD|$w}-3w#CDH#2GB!HPA>wv_rMqM5tq9 zYwPQx_g021$fNvGN3L$p-SwFw$F`IZ#cM;u3hUrXH;q^6l;-92kxGx7lIfvchV}hT zjC)sn9BMlD3izot74s~#5~;SGa0w-(Y@!uP@Ll&nsj?-Rf7zS~D=5XSJuk8+L4WV>ZaM=WZkDnDwkpvylS5iKTu-1%ArYBS z4h<@ol9pXsI*Xmt#Ks;?Vdj6!7RFB^0%sTT0?f#rM4ln2$Wn?bXCqv7BEEZ#dazye9?rGsshJ^a>T{gf=y!GO2mjN7deU76yJMupwQM;>GAqgj-Ftg` zKhqnUWcny2mWJJf(FS;Zf30SDl8-tYmccfqItT<*F{;Mvf}T$6yh2S1qcW;JFL`K?Q{I0!|cA)*HV+SmR}*7ieu^;9inL8y2^qC+jH zBa<-F-8qg0mZ*3OvMP0lBiY8K-kG&(qcPe)X@w((WHtcvI>U+fv`!w%SJ~zA8Ai+B zh~_K0tS&0Ev$GE-LL0q)sLq9|X)_f`bguGH-0s?hwS**Flh7))k${9W59A_A2atqLFes!txyvZ<^sdv`^2w#H-d1Em}SqrZOi{Un4H1{F{R==@-cU#@7jUU=xG#{pL|A^ul~)4c~nqYZAV z2sLeVqoZtas-gtV$O_RLE#W4w0p@WAH5^PSp;dK{N*f!E{4hZOp3sTBz!gZpGd>I1 zV@x7Gn6AiT3;EEv5?+e&GKs$h4aCGK^cF7(jb}%vr;gC(Rr8xb9F5f(l z?e+{(vYrivV)Q|B7!vnbfjCUuzAiD? zqJxTuD#BPBjhpu_b(oo+Csu?#*sQ!<&H4$V5!1#rrpjZaHMbuuCN2}4+pb=uW6XIw z6kE3~C+CJXlv)TA=ja07sqy=j4sMiaCK8UNDL-)tSiQDb&;(S-16Z{!IXL9zz&?od z^m)roBynrBux-qH5Jcojz2U&|uQelD&>*pV2&V$E+OnszwRZkl@bE*K?{*I2ADH7= z({`@8)?gOLO!i6NWShS)KdcY4#7CV3NKp!W&W|TpgTz1m<@=wrPF~?p5yL<&PT>F= zHq=7}@5ZMO$?9v!n4%$D1fgp7ym7J~&4>BY!5mzb5-1bLvOeec@5wiv`A)Gc1j^&+ z94Mz&1i>R-BP?D}0;(`!hH)sD%9tLPm@Y!jYPr^7yk~N9G7NfvO$9MXy37x{NXqzZ zBM0IM7BI(cRg@x$4l%si*SSS_@43gxWIcZLNxfyPme|}ZU)S=t8U`GvOPS5(Q{nE# zE;YdBL{^dv&AsW2==d$=oGr&AR}FvX8eudYGQtbiy?8|gae0wBQ#uz~y@T}Uk+R+G z>dnn-aJITOaVj%LIoBFwC`GtwjH$iL9<6r2!NWlSztp}xF=aR|QgbE+MXNvk3AQT2^}pUJiY0%BtW31eyH7NG z=g`X3rsot5elf#*E9--}g-A&+IL?KpvYOga^q<@s&yH@KyW9~n1?#!PRpY+2+0`x^ zj-pbGAIzFPBJ~P2yn$5zK{46a=)o|+s}BCRbP`H8A;Db)>#R&G2iUo3wKNy?4DJN0 zxHqtPIr*S=dLP8tYkz>d2TUE%RLYABR z^{_cwa}4n5M=fF$7yjE4f{|szXH@^>QW2sbcNSZHr{Ai?_(|!deA(=c7QSwK9@|Fu zoF$kJ9S(is`>tNoXkI%=)-Ha;eD8}3BQs)GY>?T2v(oX3vRcJ?{N|5UZ@2d5Z@%oQ z2Zhfa#8M#^3j_Qf3l|4-kFVeNVUA?+%*Mi?acPC<>fZMQuKwy$9k{q|>qs0RQhDHs z=8uioQW(5U&03QuUOFOGhGu?5LaX(jOne=4^#7vq4k+h~RjsF>pa5rjZ>FjQ|HM#` z(;_|fS@wZzQME{T@WE^yZG=&FWhI&?v2cdlKc=7IOA|TUC{YyU@wvD}IhA|;ur$R~lH#S$l+4d+r;GdJ z-MvWCR4eVcYn_3L*6}O{WE33^Jsgl)z@ZPDOMsM$fQ)28a%-5R(Y!x^|V9!MV5}4!Y8KP6epjeD0~P$E(<`bxu#Pmyw9vk0s%dl>FI>j_89{Fi z6}fwwN}tQBG0P=10X){A$-kt{nj9xfW+*8sb$KmCpv(Cih6&k?EKEP19K9rR8#?;^ zyv+5hg{eyyXJ(oE{c?w@M}$=dAnoG-&tCq?nntaS`rI(43OR?r3BL#OPyYP0#f&n_ zJ-N3PRQTTIzK1axcR`O6m^OAX%}$x4$zlLw@;RwH(L?Ti-*{`5KeW-vQT~#PmUeCB z<2A=fJ*4pJXx24D?!mYw{Q;AeVDcw6``Cd!4bW3Ew_1jYey$7MxEt~bCY+6R31|Pa78d$k zZ2ws!*WbenkrnekW@D98Wa<5YI$rB3wRm$5E)KL!{R4E{KE#E1dBJr~+ur<%bgOS_ z4X)F)m-1D+&Ypo`0)!7Z;atf+dQKT>QME-IK`BiF!KT5nEWm)u6>h>o|ViZRH{R&K}KG+54mG8x(%GM*Aj{ ze^fp)ky2qz_r(hwnNjq!wo6Bbm@2|Bg_xm7Hp>-1>e@vo_tAW9)tqgDb(I%iJw5s` zAvW=b-ZJZVg0_)Lk1(9C4UY5;2pZF$HXJO$IXAcU-T3Us^=qNRNV(VX~%1pt> zU)rjT(KGVBEc=kmvj2J39uyL*)HOdaO4_?e4mNNsD^7%g@;d1i;fJTLs>W5$j#qpP z?E^e6ysdnVp8g1Ezdn7LDG;oOP@*bO-H-svitC&2 zB#-A$4WGn^n_zs&vi%sze<=NiL2izx`BVJ zc_ChX40$O*h8ZY_8LPxW1m{N+;;PeaY6SofH!O%T1338gnXD$^vOh`=)7jx!tc*_n zGTo}po5v1Xp+Uq*h*KJn)%;wd-jati2bD`$GSQV6Uip1U^ z8`OJcko>vMpoPraU!gAeXcB#J>wsV2mruj->eLi9EYvb+C*;3Y1>P@JMK-zghce>DHQ*3{A(W}g3U$xr2w*-7NV`SFq4~?M{XZg?bO0&SYDxH&gVp?d4*oTBAm=xH!gCt%1wsbO=AmY|VuwTFb6c5xx3|7L(It!CA zqO#w`_g8rzx&{BuH9Y$^k5fFBL2V~_SvQtPzm0<%3GQMiE)un;a7o%bKbU)Fpg*-* z7~Z+E4wq#RXN$e|;LJenN(38=vuQh{zs+)u|5e^4uwv}P$QLd_${(_1{C{-TNI%@3 zROke?({`ggac)i0>=W4{y1=m6+Mm};52<(F0UZWa_4Oh-<3(0JAOf@eMX@>B#sOxi zS^i4pnY_vNF0Z5+_m9CDF0C|?10E^$k}HJXOdd{P=^^=Lv?^0K7;|XYuu&bYAQ;~H|QGHl^(A{~*F+tqB{o*yR9)qc1_y=pvWHz4%j z$#Cn#W*IC{7~ubml~s|YWAIt~ZP#qw`&j0uOdT$Yxg=}+PHA$Fi+f)9Rz&BiCRD9g zacRzRBrc22{egg%QM>Hw$%$Glk2C2rnKRin-K&E{i2_1UDFv#ywXiu4u0K(R@wDC> z7+Ya2i_fH%%M%koWf7UuQA>1lMu`;jNC$t_^Tm?YCjA_*XbUp0o9w0gj>#)Ve%k!q z-@Xz~8xU+aRbw|oR!iU_1mE$x7&MFvq0=0l)DADiIw6QwdNh5-R>2=|0SxTqz< zJA_ciCq=O`HORt@^W*dlZHM!(-8EARiiQZpdCSSLq+s!)UB|!fQ|j~FkyFXIUAGdW zsj%}fOPqDmTxNtIxzzP`9tkFJ_2{iBL(h-wmP{vS0Ev$IE6$--NI~Piz{|Mgq-M5Q zTcPSulRHw6i=5a%Osw~&Ptcoc1ZN~drj+?~=1gDTYkaw3ROC;Li1J&Ud^bAipZKqD zPg!a=er{#@4wV_#Y?3-JD;qL3 z-Q>RK#~5(AB6Z9g5Mc+m3$argPxs%c*~{NOPzzZCL1xG5jgpxanA{;>2rOMPy;dU; z7&EsCEBSj#$>(SbGIE0Z7c(K<>pGu6?a!Bq!ty+ms}wPpKl1bA<{nnRJoAvgMR&%o zQuDV4#zkLCVf@m-p9;sPxg#%Acho{; zhlRMm5J>Q_k+}{iCM_;cy>V{!Ki{AEf(h*I3cSG~iEeTVw!=~7nS*N2DLvlN%FM4dcuq~8ZJ0@eLj{6=+A7|(p8Br-&(X+$z7=kmbKO}CER69W1c3EtMb68%zPjcly)HS$;T56M;2kd*El9*ejKwW8yO+pQ;4z{^tsp=(FV=q< zG7m;Z=XpoVp^nKqw~>)aaae1YIY1ZL`kDQn8u`AvqTSuSBU@$tWMFE_`@^`V&~d8F zc#x6faor_vGuF=&=_j5zqrUSQizl^{+ANTX9o=N^T{SboF_*{VmrS4W8Wud}oMkVU zL#WliK9#O?-!lLL1<&wbMoysIs`Tcl?l2GxzK&eIQ)m2MKm6Fk7o?j^SVeZVzta8X zF{9sM>xJ#Yf9UHqFc3U>^?2NO=Ii2{sVCoS6A~hX3}NR@K+G8&B<*$Qthl_ zG7@_6C;w*a-gMcqXYzkh?d)&F#cY+R{x1KrU`AkD_`KSiJBlF+n^7TCPG!H*SZ{E3 zK2?rNEQ8^=r7=tA_MbfGwC6Sh59D{v$#KBolbvzOciv&@193HSuMU{Y;z0tz7%s?+ z&~I;+zgk3@-b%(i!p^BGdN=dAtXlk&jM)t)QFpf%PWz$J?CpWdviWjmI;-|St4Hlw zpv#PH=^<4+uWzxuy3kmFL?mb=%kL+QfryKf%?+`YyN z{YdK1a&`zZzK@PI>W5kyQV2|_b0eOV)D~${-TJLRb^tPD5{#ddZadFZch_LV(N4Xh zA=9HV^=A*!euWm}*#;mP8Ns`K!%Lx@Va9@BAx-f{_x=g{cLrdaK{V!E|S0ZDmDpSM5-hlIf?4t*dfe0xdVKp z;%wi8__){!&Eg*80)ZajBebqP{_l~IioxH%rJ^n_F%v@5AER6`(DGZNqW3@XkB*P@ zSr4*f^1b)|)dqF0$E{NW2m#<~xmTuEp;R*!7VUp9H&@coU)ygt zoW~0_Z_-U^@wkcqn8V7Vf zlhF%9W8dUq>kb&rsw<>u=>-*_#!Tz)K#`^3s2eX!W7_puV~4ze}~avX>ndXz5GyS*LUVun+Af zL>{*vT5!L$$`_pDx2UujUT5O+@cKJn&ou2A-55A52VPXacv&%O5JD(jthBA}UL8*w zj|j5<)n-^yp+Y)%dxx=X0vS>JV+DhgPvAx-m&PqP<^&ay(}i+h&u4Y%M|fMv(T~S2 z{D60aj-w5)jc?oxI1eaU%;nX>iS=31RotJmDltA`#~C%fvV0=&G{=(eMQ~*F-B&%h zsTvln{)cWkj{`w(l70nA(bTQ)X9)}OA04NjB-w`ru^{xqj_*GW*$|pjhxb`+ z8VSsbWPpo`j z)H73i39AN8h}Ial%a_k;TV)S<#GHb#*S1mS#7CXjTh3&FYB;eSp5Yt4ps2qdEw~ju z_ix=EInS?{%xF9JKJ|3ZZEtS<_3J%QhUofq1CM$lbd*I|62IpYB|}~woGpWrLFs+f z!(smAPhxyzmU4$ + + #FFFFFF + \ No newline at end of file diff --git a/example-app/android/app/src/main/res/values/strings.xml b/example-app/android/app/src/main/res/values/strings.xml new file mode 100644 index 0000000..05d8765 --- /dev/null +++ b/example-app/android/app/src/main/res/values/strings.xml @@ -0,0 +1,7 @@ + + + Native Audio Example + Native Audio Example + app.capgo.nativeaudio + app.capgo.nativeaudio + diff --git a/example-app/android/app/src/main/res/values/styles.xml b/example-app/android/app/src/main/res/values/styles.xml new file mode 100644 index 0000000..be874e5 --- /dev/null +++ b/example-app/android/app/src/main/res/values/styles.xml @@ -0,0 +1,22 @@ + + + + + + + + + + + \ No newline at end of file diff --git a/example-app/android/app/src/main/res/xml/file_paths.xml b/example-app/android/app/src/main/res/xml/file_paths.xml new file mode 100644 index 0000000..bd0c4d8 --- /dev/null +++ b/example-app/android/app/src/main/res/xml/file_paths.xml @@ -0,0 +1,5 @@ + + + + + \ No newline at end of file diff --git a/example-app/android/app/src/test/java/com/getcapacitor/myapp/ExampleUnitTest.java b/example-app/android/app/src/test/java/com/getcapacitor/myapp/ExampleUnitTest.java new file mode 100644 index 0000000..0297327 --- /dev/null +++ b/example-app/android/app/src/test/java/com/getcapacitor/myapp/ExampleUnitTest.java @@ -0,0 +1,18 @@ +package com.getcapacitor.myapp; + +import static org.junit.Assert.*; + +import org.junit.Test; + +/** + * Example local unit test, which will execute on the development machine (host). + * + * @see Testing documentation + */ +public class ExampleUnitTest { + + @Test + public void addition_isCorrect() throws Exception { + assertEquals(4, 2 + 2); + } +} diff --git a/example-app/android/build.gradle b/example-app/android/build.gradle new file mode 100644 index 0000000..f8f0e43 --- /dev/null +++ b/example-app/android/build.gradle @@ -0,0 +1,29 @@ +// Top-level build file where you can add configuration options common to all sub-projects/modules. + +buildscript { + + repositories { + google() + mavenCentral() + } + dependencies { + classpath 'com.android.tools.build:gradle:8.13.0' + classpath 'com.google.gms:google-services:4.4.4' + + // NOTE: Do not place your application dependencies here; they belong + // in the individual module build.gradle files + } +} + +apply from: "variables.gradle" + +allprojects { + repositories { + google() + mavenCentral() + } +} + +task clean(type: Delete) { + delete rootProject.buildDir +} diff --git a/example-app/android/capacitor.settings.gradle b/example-app/android/capacitor.settings.gradle new file mode 100644 index 0000000..f5a0d1d --- /dev/null +++ b/example-app/android/capacitor.settings.gradle @@ -0,0 +1,6 @@ +// DO NOT EDIT THIS FILE! IT IS GENERATED EACH TIME "capacitor update" IS RUN +include ':capacitor-android' +project(':capacitor-android').projectDir = new File('../node_modules/@capacitor/android/capacitor') + +include ':capgo-capacitor-native-audio' +project(':capgo-capacitor-native-audio').projectDir = new File('../../android') diff --git a/example-app/android/gradle.properties b/example-app/android/gradle.properties new file mode 100644 index 0000000..2e87c52 --- /dev/null +++ b/example-app/android/gradle.properties @@ -0,0 +1,22 @@ +# Project-wide Gradle settings. + +# IDE (e.g. Android Studio) users: +# Gradle settings configured through the IDE *will override* +# any settings specified in this file. + +# For more details on how to configure your build environment visit +# http://www.gradle.org/docs/current/userguide/build_environment.html + +# Specifies the JVM arguments used for the daemon process. +# The setting is particularly useful for tweaking memory settings. +org.gradle.jvmargs=-Xmx1536m + +# When configured, Gradle will run in incubating parallel mode. +# This option should only be used with decoupled projects. More details, visit +# http://www.gradle.org/docs/current/userguide/multi_project_builds.html#sec:decoupled_projects +# org.gradle.parallel=true + +# AndroidX package structure to make it clearer which packages are bundled with the +# Android operating system, and which are packaged with your app's APK +# https://developer.android.com/topic/libraries/support-library/androidx-rn +android.useAndroidX=true diff --git a/example-app/android/gradle/wrapper/gradle-wrapper.jar b/example-app/android/gradle/wrapper/gradle-wrapper.jar new file mode 100644 index 0000000000000000000000000000000000000000..1b33c55baabb587c669f562ae36f953de2481846 GIT binary patch literal 43764 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 '} + case $link in #( + /*) app_path=$link ;; #( + *) app_path=$APP_HOME$link ;; + esac +done + +# This is normally unused +# shellcheck disable=SC2034 +APP_BASE_NAME=${0##*/} +# Discard cd standard output in case $CDPATH is set (https://github.com/gradle/gradle/issues/25036) +APP_HOME=$( cd -P "${APP_HOME:-./}" > /dev/null && printf '%s\n' "$PWD" ) || exit + +# Use the maximum available, or set MAX_FD != -1 to use that value. +MAX_FD=maximum + +warn () { + echo "$*" +} >&2 + +die () { + echo + echo "$*" + echo + exit 1 +} >&2 + +# OS specific support (must be 'true' or 'false'). +cygwin=false +msys=false +darwin=false +nonstop=false +case "$( uname )" in #( + CYGWIN* ) cygwin=true ;; #( + Darwin* ) darwin=true ;; #( + MSYS* | MINGW* ) msys=true ;; #( + NONSTOP* ) nonstop=true ;; +esac + +CLASSPATH="\\\"\\\"" + + +# Determine the Java command to use to start the JVM. +if [ -n "$JAVA_HOME" ] ; then + if [ -x "$JAVA_HOME/jre/sh/java" ] ; then + # IBM's JDK on AIX uses strange locations for the executables + JAVACMD=$JAVA_HOME/jre/sh/java + else + JAVACMD=$JAVA_HOME/bin/java + fi + if [ ! -x "$JAVACMD" ] ; then + die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME + +Please set the JAVA_HOME variable in your environment to match the +location of your Java installation." + fi +else + JAVACMD=java + if ! command -v java >/dev/null 2>&1 + then + die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH. + +Please set the JAVA_HOME variable in your environment to match the +location of your Java installation." + fi +fi + +# Increase the maximum file descriptors if we can. +if ! "$cygwin" && ! "$darwin" && ! "$nonstop" ; then + case $MAX_FD in #( + max*) + # In POSIX sh, ulimit -H is undefined. That's why the result is checked to see if it worked. + # shellcheck disable=SC2039,SC3045 + MAX_FD=$( ulimit -H -n ) || + warn "Could not query maximum file descriptor limit" + esac + case $MAX_FD in #( + '' | soft) :;; #( + *) + # In POSIX sh, ulimit -n is undefined. That's why the result is checked to see if it worked. + # shellcheck disable=SC2039,SC3045 + ulimit -n "$MAX_FD" || + warn "Could not set maximum file descriptor limit to $MAX_FD" + esac +fi + +# Collect all arguments for the java command, stacking in reverse order: +# * args from the command line +# * the main class name +# * -classpath +# * -D...appname settings +# * --module-path (only if needed) +# * DEFAULT_JVM_OPTS, JAVA_OPTS, and GRADLE_OPTS environment variables. + +# For Cygwin or MSYS, switch paths to Windows format before running java +if "$cygwin" || "$msys" ; then + APP_HOME=$( cygpath --path --mixed "$APP_HOME" ) + CLASSPATH=$( cygpath --path --mixed "$CLASSPATH" ) + + JAVACMD=$( cygpath --unix "$JAVACMD" ) + + # Now convert the arguments - kludge to limit ourselves to /bin/sh + for arg do + if + case $arg in #( + -*) false ;; # don't mess with options #( + /?*) t=${arg#/} t=/${t%%/*} # looks like a POSIX filepath + [ -e "$t" ] ;; #( + *) false ;; + esac + then + arg=$( cygpath --path --ignore --mixed "$arg" ) + fi + # Roll the args list around exactly as many times as the number of + # args, so each arg winds up back in the position where it started, but + # possibly modified. + # + # NB: a `for` loop captures its iteration list before it begins, so + # changing the positional parameters here affects neither the number of + # iterations, nor the values presented in `arg`. + shift # remove old arg + set -- "$@" "$arg" # push replacement arg + done +fi + + +# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script. +DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"' + +# Collect all arguments for the java command: +# * DEFAULT_JVM_OPTS, JAVA_OPTS, and optsEnvironmentVar are not allowed to contain shell fragments, +# and any embedded shellness will be escaped. +# * For example: A user cannot expect ${Hostname} to be expanded, as it is an environment variable and will be +# treated as '${Hostname}' itself on the command line. + +set -- \ + "-Dorg.gradle.appname=$APP_BASE_NAME" \ + -classpath "$CLASSPATH" \ + -jar "$APP_HOME/gradle/wrapper/gradle-wrapper.jar" \ + "$@" + +# Stop when "xargs" is not available. +if ! command -v xargs >/dev/null 2>&1 +then + die "xargs is not available" +fi + +# Use "xargs" to parse quoted args. +# +# With -n1 it outputs one arg per line, with the quotes and backslashes removed. +# +# In Bash we could simply go: +# +# readarray ARGS < <( xargs -n1 <<<"$var" ) && +# set -- "${ARGS[@]}" "$@" +# +# but POSIX shell has neither arrays nor command substitution, so instead we +# post-process each arg (as a line of input to sed) to backslash-escape any +# character that might be a shell metacharacter, then use eval to reverse +# that process (while maintaining the separation between arguments), and wrap +# the whole thing up as a single "set" statement. +# +# This will of course break if any of these variables contains a newline or +# an unmatched quote. +# + +eval "set -- $( + printf '%s\n' "$DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS" | + xargs -n1 | + sed ' s~[^-[:alnum:]+,./:=@_]~\\&~g; ' | + tr '\n' ' ' + )" '"$@"' + +exec "$JAVACMD" "$@" diff --git a/example-app/android/gradlew.bat b/example-app/android/gradlew.bat new file mode 100644 index 0000000..5eed7ee --- /dev/null +++ b/example-app/android/gradlew.bat @@ -0,0 +1,94 @@ +@rem +@rem Copyright 2015 the original author or authors. +@rem +@rem Licensed under the Apache License, Version 2.0 (the "License"); +@rem you may not use this file except in compliance with the License. +@rem You may obtain a copy of the License at +@rem +@rem https://www.apache.org/licenses/LICENSE-2.0 +@rem +@rem Unless required by applicable law or agreed to in writing, software +@rem distributed under the License is distributed on an "AS IS" BASIS, +@rem WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +@rem See the License for the specific language governing permissions and +@rem limitations under the License. +@rem +@rem SPDX-License-Identifier: Apache-2.0 +@rem + +@if "%DEBUG%"=="" @echo off +@rem ########################################################################## +@rem +@rem Gradle startup script for Windows +@rem +@rem ########################################################################## + +@rem Set local scope for the variables with windows NT shell +if "%OS%"=="Windows_NT" setlocal + +set DIRNAME=%~dp0 +if "%DIRNAME%"=="" set DIRNAME=. +@rem This is normally unused +set APP_BASE_NAME=%~n0 +set APP_HOME=%DIRNAME% + +@rem Resolve any "." and ".." in APP_HOME to make it shorter. +for %%i in ("%APP_HOME%") do set APP_HOME=%%~fi + +@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script. +set DEFAULT_JVM_OPTS="-Xmx64m" "-Xms64m" + +@rem Find java.exe +if defined JAVA_HOME goto findJavaFromJavaHome + +set JAVA_EXE=java.exe +%JAVA_EXE% -version >NUL 2>&1 +if %ERRORLEVEL% equ 0 goto execute + +echo. 1>&2 +echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH. 1>&2 +echo. 1>&2 +echo Please set the JAVA_HOME variable in your environment to match the 1>&2 +echo location of your Java installation. 1>&2 + +goto fail + +:findJavaFromJavaHome +set JAVA_HOME=%JAVA_HOME:"=% +set JAVA_EXE=%JAVA_HOME%/bin/java.exe + +if exist "%JAVA_EXE%" goto execute + +echo. 1>&2 +echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME% 1>&2 +echo. 1>&2 +echo Please set the JAVA_HOME variable in your environment to match the 1>&2 +echo location of your Java installation. 1>&2 + +goto fail + +:execute +@rem Setup the command line + +set CLASSPATH= + + +@rem Execute Gradle +"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" -jar "%APP_HOME%\gradle\wrapper\gradle-wrapper.jar" %* + +:end +@rem End local scope for the variables with windows NT shell +if %ERRORLEVEL% equ 0 goto mainEnd + +:fail +rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of +rem the _cmd.exe /c_ return code! +set EXIT_CODE=%ERRORLEVEL% +if %EXIT_CODE% equ 0 set EXIT_CODE=1 +if not ""=="%GRADLE_EXIT_CONSOLE%" exit %EXIT_CODE% +exit /b %EXIT_CODE% + +:mainEnd +if "%OS%"=="Windows_NT" endlocal + +:omega diff --git a/example-app/android/settings.gradle b/example-app/android/settings.gradle new file mode 100644 index 0000000..3b4431d --- /dev/null +++ b/example-app/android/settings.gradle @@ -0,0 +1,5 @@ +include ':app' +include ':capacitor-cordova-android-plugins' +project(':capacitor-cordova-android-plugins').projectDir = new File('./capacitor-cordova-android-plugins/') + +apply from: 'capacitor.settings.gradle' \ No newline at end of file diff --git a/example-app/android/variables.gradle b/example-app/android/variables.gradle new file mode 100644 index 0000000..89f7fe8 --- /dev/null +++ b/example-app/android/variables.gradle @@ -0,0 +1,16 @@ +ext { + minSdkVersion = 24 + compileSdkVersion = 36 + targetSdkVersion = 36 + androidxActivityVersion = '1.11.0' + androidxAppCompatVersion = '1.8.0' + androidxCoordinatorLayoutVersion = '1.3.0' + androidxCoreVersion = '1.17.0' + androidxFragmentVersion = '1.8.9' + coreSplashScreenVersion = '1.2.0' + androidxWebkitVersion = '1.14.0' + junitVersion = '4.13.2' + androidxJunitVersion = '1.3.0' + androidxEspressoCoreVersion = '3.7.0' + cordovaAndroidVersion = '14.0.1' +} diff --git a/example-app/bun.lock b/example-app/bun.lock new file mode 100644 index 0000000..9a6e4f5 --- /dev/null +++ b/example-app/bun.lock @@ -0,0 +1,908 @@ +{ + "lockfileVersion": 1, + "configVersion": 1, + "workspaces": { + "": { + "name": "native-audio-example", + "dependencies": { + "@capacitor/core": "^8.5.2", + "@capgo/capacitor-native-audio": "..", + "react": "^18.3.1", + "react-dom": "^18.3.1", + }, + "devDependencies": { + "@capacitor/android": "^8.5.2", + "@capacitor/cli": "^8.5.2", + "@capacitor/ios": "^8.5.2", + "@types/react": "^18.3.12", + "@types/react-dom": "^18.3.1", + "@vitejs/plugin-react": "^6.0.0", + "typescript": "^6.0.3", + "vite": "^8.3.0", + }, + }, + }, + "packages": { + "@babel/code-frame": ["@babel/code-frame@7.29.0", "", { "dependencies": { "@babel/helper-validator-identifier": "^7.28.5", "js-tokens": "^4.0.0", "picocolors": "^1.1.1" } }, "sha512-9NhCeYjq9+3uxgdtp20LSiJXJvN0FeCtNGpJxuMFZ1Kv3cWUNb6DOhJwUvcVCzKGR66cw4njwM6hrJLqgOwbcw=="], + + "@babel/helper-validator-identifier": ["@babel/helper-validator-identifier@7.28.5", "", {}, "sha512-qSs4ifwzKJSV39ucNjsvc6WVHs6b7S03sOh2OcHF9UHfVPqWWALUsNUVzhSBiItjRZoLHx7nIarVjqKVusUZ1Q=="], + + "@capacitor/android": ["@capacitor/android@8.5.2", "", { "peerDependencies": { "@capacitor/core": "^8.5.0" } }, "sha512-rtiaz78egCcS+vs29wkWCL3C+RhazKMSygXcjutwWP8NmO6r5UBxOvGf3Wjz5+ahobyQ723tn9gCePwRwcNDZQ=="], + + "@capacitor/cli": ["@capacitor/cli@8.5.2", "", { "dependencies": { "@ionic/cli-framework-output": "^2.2.8", "@ionic/utils-subprocess": "^3.0.1", "@ionic/utils-terminal": "^2.3.5", "commander": "^12.1.0", "debug": "^4.4.0", "env-paths": "^2.2.0", "fs-extra": "^11.2.0", "kleur": "^4.1.5", "native-run": "^2.0.3", "open": "^8.4.0", "plist": "^3.1.0", "prompts": "^2.4.2", "rimraf": "^6.0.1", "semver": "^7.6.3", "tar": "^7.5.3", "tslib": "^2.8.1", "xcode": "^3.0.1", "xml2js": "^0.6.2" }, "bin": { "cap": "bin/capacitor", "capacitor": "bin/capacitor" } }, "sha512-O2kpA5ZPJUAmliDCcmpMf8xnJwMezxlFPUrlyOAjbL3U9MFNY3l4ZpPI/UXwvyPmR8ETcVF9pFr+VdWq61rqTQ=="], + + "@capacitor/core": ["@capacitor/core@8.5.2", "", { "dependencies": { "tslib": "^2.1.0" } }, "sha512-agnQbGdhGw/KZFuLf7H9SY2o+oE7upkr/WPQsYaokXP6f9chaE8iVmbKkfN6SVl4w3pmz7oZ3Ur1hbkmy1hx+w=="], + + "@capacitor/docgen": ["@capacitor/docgen@0.3.1", "", { "dependencies": { "colorette": "^2.0.20", "github-slugger": "^1.5.0", "minimist": "^1.2.8", "typescript": "~4.2.4" }, "bin": { "docgen": "bin/docgen" } }, "sha512-WBdAUquQC4hiZOVk1YbY5Rs3vlDrNdCGt3KGnMa2dc2UBa91Q7PQ/jLW/oZyfVIfiXWu7t1KUhhM3MyiZepUrQ=="], + + "@capacitor/ios": ["@capacitor/ios@8.5.2", "", { "peerDependencies": { "@capacitor/core": "^8.5.0" } }, "sha512-eOT2S67AfTFG7KN0T3oxwAajrJz4rSye+ODfvChiwrk0F/+kWufFM1qU6cDjGJUOfwdAoeuEpZyWHSwZlu4GFg=="], + + "@capgo/capacitor-native-audio": ["@capgo/capacitor-native-audio@file:..", { "devDependencies": { "@capacitor/android": "^8.0.0", "@capacitor/cli": "^8.0.0", "@capacitor/core": "^8.0.0", "@capacitor/docgen": "^0.3.1", "@capacitor/ios": "^8.0.0", "@ionic/eslint-config": "^0.4.0", "@ionic/prettier-config": "^4.0.0", "@ionic/swiftlint-config": "^2.0.0", "@types/node": "^24.10.1", "eslint": "^8.57.1", "eslint-plugin-import": "^2.31.0", "husky": "^9.1.7", "prettier": "^3.6.2", "prettier-plugin-java": "^2.7.7", "prettier-pretty-check": "^0.2.0", "rimraf": "^6.1.0", "rollup": "^4.53.2", "swiftlint": "^2.0.0", "typescript": "^5.9.3" }, "peerDependencies": { "@capacitor/core": ">=8.0.0" } }], + + "@chevrotain/cst-dts-gen": ["@chevrotain/cst-dts-gen@11.0.3", "", { "dependencies": { "@chevrotain/gast": "11.0.3", "@chevrotain/types": "11.0.3", "lodash-es": "4.17.21" } }, "sha512-BvIKpRLeS/8UbfxXxgC33xOumsacaeCKAjAeLyOn7Pcp95HiRbrpl14S+9vaZLolnbssPIUuiUd8IvgkRyt6NQ=="], + + "@chevrotain/gast": ["@chevrotain/gast@11.0.3", "", { "dependencies": { "@chevrotain/types": "11.0.3", "lodash-es": "4.17.21" } }, "sha512-+qNfcoNk70PyS/uxmj3li5NiECO+2YKZZQMbmjTqRI3Qchu8Hig/Q9vgkHpI3alNjr7M+a2St5pw5w5F6NL5/Q=="], + + "@chevrotain/regexp-to-ast": ["@chevrotain/regexp-to-ast@11.0.3", "", {}, "sha512-1fMHaBZxLFvWI067AVbGJav1eRY7N8DDvYCTwGBiE/ytKBgP8azTdgyrKyWZ9Mfh09eHWb5PgTSO8wi7U824RA=="], + + "@chevrotain/types": ["@chevrotain/types@11.0.3", "", {}, "sha512-gsiM3G8b58kZC2HaWR50gu6Y1440cHiJ+i3JUvcp/35JchYejb2+5MVeJK0iKThYpAa/P2PYFV4hoi44HD+aHQ=="], + + "@chevrotain/utils": ["@chevrotain/utils@11.0.3", "", {}, "sha512-YslZMgtJUyuMbZ+aKvfF3x1f5liK4mWNxghFRv7jqRR9C3R3fAOGTTKvxXDa2Y1s9zSbcpuO0cAxDYsc9SrXoQ=="], + + "@eslint-community/eslint-utils": ["@eslint-community/eslint-utils@4.9.1", "", { "dependencies": { "eslint-visitor-keys": "^3.4.3" }, "peerDependencies": { "eslint": "^6.0.0 || ^7.0.0 || >=8.0.0" } }, "sha512-phrYmNiYppR7znFEdqgfWHXR6NCkZEK7hwWDHZUjit/2/U0r6XvkDl0SYnoM51Hq7FhCGdLDT6zxCCOY1hexsQ=="], + + "@eslint-community/regexpp": ["@eslint-community/regexpp@4.12.2", "", {}, "sha512-EriSTlt5OC9/7SXkRSCAhfSxxoSUgBm33OH+IkwbdpgoqsSsUg7y3uh+IICI/Qg4BBWr3U2i39RpmycbxMq4ew=="], + + "@eslint/eslintrc": ["@eslint/eslintrc@2.1.4", "", { "dependencies": { "ajv": "^6.12.4", "debug": "^4.3.2", "espree": "^9.6.0", "globals": "^13.19.0", "ignore": "^5.2.0", "import-fresh": "^3.2.1", "js-yaml": "^4.1.0", "minimatch": "^3.1.2", "strip-json-comments": "^3.1.1" } }, "sha512-269Z39MS6wVJtsoUl10L60WdkhJVdPG24Q4eZTH3nnF6lpvSShEK3wQjDX9JRWAUPvPh7COouPpU9IrqaZFvtQ=="], + + "@eslint/js": ["@eslint/js@8.57.1", "", {}, "sha512-d9zaMRSTIKDLhctzH12MtXvJKSSUhaHcjV+2Z+GK+EEY7XKpP5yR4x+N3TAcHTcu963nIr+TMcCb4DBCYX1z6Q=="], + + "@humanwhocodes/config-array": ["@humanwhocodes/config-array@0.13.0", "", { "dependencies": { "@humanwhocodes/object-schema": "^2.0.3", "debug": "^4.3.1", "minimatch": "^3.0.5" } }, "sha512-DZLEEqFWQFiyK6h5YIeynKx7JlvCYWL0cImfSRXZ9l4Sg2efkFGTuFf6vzXjK1cq6IYkU+Eg/JizXw+TD2vRNw=="], + + "@humanwhocodes/module-importer": ["@humanwhocodes/module-importer@1.0.1", "", {}, "sha512-bxveV4V8v5Yb4ncFTT3rPSgZBOpCkjfK0y4oVVVJwIuDVBRMDXrPyXRL988i5ap9m9bnyEEjWfm5WkBmtffLfA=="], + + "@humanwhocodes/object-schema": ["@humanwhocodes/object-schema@2.0.3", "", {}, "sha512-93zYdMES/c1D69yZiKDBj0V24vqNzB/koF26KPaagAfd3P/4gUlh3Dys5ogAK+Exi9QyzlD8x/08Zt7wIKcDcA=="], + + "@ionic/cli-framework-output": ["@ionic/cli-framework-output@2.2.8", "", { "dependencies": { "@ionic/utils-terminal": "2.3.5", "debug": "^4.0.0", "tslib": "^2.0.1" } }, "sha512-TshtaFQsovB4NWRBydbNFawql6yul7d5bMiW1WYYf17hd99V6xdDdk3vtF51bw6sLkxON3bDQpWsnUc9/hVo3g=="], + + "@ionic/eslint-config": ["@ionic/eslint-config@0.4.0", "", { "dependencies": { "@typescript-eslint/eslint-plugin": "^5.58.0", "@typescript-eslint/parser": "^5.58.0", "eslint-config-prettier": "^8.8.0", "eslint-plugin-import": "^2.27.0" }, "peerDependencies": { "eslint": ">=7" } }, "sha512-L8OXY29D3iGqNtteFj0iz3eoZIVgokBiVjCO8WMssNZa4GTHjYsase0rC9ASXGefMnLJu6rbNl3Gbx7NNxJRZQ=="], + + "@ionic/prettier-config": ["@ionic/prettier-config@4.0.0", "", { "peerDependencies": { "prettier": "^2.4.0 || ^3.0.0" } }, "sha512-0DqL6CggVdgeJAWOLPUT73rF1VD5p0tVlCpC5GXz5vTIUBxNwsJ5085Q7wXjKiE5Odx3aOHGTcuRWCawFsLFag=="], + + "@ionic/swiftlint-config": ["@ionic/swiftlint-config@2.0.0", "", {}, "sha512-TXy76ALSKhUZzBziHz7aoEtSQwHofBIDRNzM9x4sndtC7fefbZsBw3UgGwXFTOc7hoj72EAGyqZNUhj9LlhaNQ=="], + + "@ionic/utils-array": ["@ionic/utils-array@2.1.6", "", { "dependencies": { "debug": "^4.0.0", "tslib": "^2.0.1" } }, "sha512-0JZ1Zkp3wURnv8oq6Qt7fMPo5MpjbLoUoa9Bu2Q4PJuSDWM8H8gwF3dQO7VTeUj3/0o1IB1wGkFWZZYgUXZMUg=="], + + "@ionic/utils-fs": ["@ionic/utils-fs@3.1.7", "", { "dependencies": { "@types/fs-extra": "^8.0.0", "debug": "^4.0.0", "fs-extra": "^9.0.0", "tslib": "^2.0.1" } }, "sha512-2EknRvMVfhnyhL1VhFkSLa5gOcycK91VnjfrTB0kbqkTFCOXyXgVLI5whzq7SLrgD9t1aqos3lMMQyVzaQ5gVA=="], + + "@ionic/utils-object": ["@ionic/utils-object@2.1.6", "", { "dependencies": { "debug": "^4.0.0", "tslib": "^2.0.1" } }, "sha512-vCl7sl6JjBHFw99CuAqHljYJpcE88YaH2ZW4ELiC/Zwxl5tiwn4kbdP/gxi2OT3MQb1vOtgAmSNRtusvgxI8ww=="], + + "@ionic/utils-process": ["@ionic/utils-process@2.1.12", "", { "dependencies": { "@ionic/utils-object": "2.1.6", "@ionic/utils-terminal": "2.3.5", "debug": "^4.0.0", "signal-exit": "^3.0.3", "tree-kill": "^1.2.2", "tslib": "^2.0.1" } }, "sha512-Jqkgyq7zBs/v/J3YvKtQQiIcxfJyplPgECMWgdO0E1fKrrH8EF0QGHNJ9mJCn6PYe2UtHNS8JJf5G21e09DfYg=="], + + "@ionic/utils-stream": ["@ionic/utils-stream@3.1.7", "", { "dependencies": { "debug": "^4.0.0", "tslib": "^2.0.1" } }, "sha512-eSELBE7NWNFIHTbTC2jiMvh1ABKGIpGdUIvARsNPMNQhxJB3wpwdiVnoBoTYp+5a6UUIww4Kpg7v6S7iTctH1w=="], + + "@ionic/utils-subprocess": ["@ionic/utils-subprocess@3.0.1", "", { "dependencies": { "@ionic/utils-array": "2.1.6", "@ionic/utils-fs": "3.1.7", "@ionic/utils-process": "2.1.12", "@ionic/utils-stream": "3.1.7", "@ionic/utils-terminal": "2.3.5", "cross-spawn": "^7.0.3", "debug": "^4.0.0", "tslib": "^2.0.1" } }, "sha512-cT4te3AQQPeIM9WCwIg8ohroJ8TjsYaMb2G4ZEgv9YzeDqHZ4JpeIKqG2SoaA3GmVQ3sOfhPM6Ox9sxphV/d1A=="], + + "@ionic/utils-terminal": ["@ionic/utils-terminal@2.3.5", "", { "dependencies": { "@types/slice-ansi": "^4.0.0", "debug": "^4.0.0", "signal-exit": "^3.0.3", "slice-ansi": "^4.0.0", "string-width": "^4.1.0", "strip-ansi": "^6.0.0", "tslib": "^2.0.1", "untildify": "^4.0.0", "wrap-ansi": "^7.0.0" } }, "sha512-3cKScz9Jx2/Pr9ijj1OzGlBDfcmx7OMVBt4+P1uRR0SSW4cm1/y3Mo4OY3lfkuaYifMNBW8Wz6lQHbs1bihr7A=="], + + "@isaacs/fs-minipass": ["@isaacs/fs-minipass@4.0.1", "", { "dependencies": { "minipass": "^7.0.4" } }, "sha512-wgm9Ehl2jpeqP3zw/7mo3kRHFp5MEDhqAdwy1fTGkHAwnkGOVsgpvQhL8B5n1qlb01jV3n/bI0ZfZp5lWA1k4w=="], + + "@nodelib/fs.scandir": ["@nodelib/fs.scandir@2.1.5", "", { "dependencies": { "@nodelib/fs.stat": "2.0.5", "run-parallel": "^1.1.9" } }, "sha512-vq24Bq3ym5HEQm2NKCr3yXDwjc7vTsEThRDnkp2DK9p1uqLR+DHurm/NOTo0KG7HYHU7eppKZj3MyqYuMBf62g=="], + + "@nodelib/fs.stat": ["@nodelib/fs.stat@2.0.5", "", {}, "sha512-RkhPPp2zrqDAQA/2jNhnztcPAlv64XdhIp7a7454A5ovI7Bukxgt7MX7udwAu3zg1DcpPU0rz3VV1SeaqvY4+A=="], + + "@nodelib/fs.walk": ["@nodelib/fs.walk@1.2.8", "", { "dependencies": { "@nodelib/fs.scandir": "2.1.5", "fastq": "^1.6.0" } }, "sha512-oGB+UxlgWcgQkgwo8GcEGwemoTFt3FIO9ababBmaGwXIoBKZ+GTy0pP185beGg7Llih/NSHSV2XAs1lnznocSg=="], + + "@oxc-project/types": ["@oxc-project/types@0.151.0", "", {}, "sha512-J1yXrIlNDZVzE3ada310xeAw7nH8yCAyLPuUIsjKatFPmfn5bS1oW+cM+QsGOtVWd5nhSpbwZWx/rue+r5Z+PA=="], + + "@rolldown/binding-android-arm-eabi": ["@rolldown/binding-android-arm-eabi@1.2.10", "", { "os": "android", "cpu": "arm" }, "sha512-bp9svZb+QurZeh+8H4BhrZkifEB0YBNvTVzNSJnJQkj4NrRwmQoDUCGP0vSN7PbvLeM7l1tK6GXL8mrTiH2myg=="], + + "@rolldown/binding-android-arm64": ["@rolldown/binding-android-arm64@1.2.10", "", { "os": "android", "cpu": "arm64" }, "sha512-wm6Dld3RXUAZ/gRWKyUy+4W1B5CB5UeFaOzsSWJWEdxZXHH8rCYiZ5dGe6oJmhsunAPWzL7FZV+VtvmN5Ye2eA=="], + + "@rolldown/binding-darwin-arm64": ["@rolldown/binding-darwin-arm64@1.2.10", "", { "os": "darwin", "cpu": "arm64" }, "sha512-UbEfXq/AqGNgRTV3ik+X/iR6mUxu2QdYAadwRxJWquUGnW6gDqdP1FtLtFXRow7RJx0ssRwi80XAPr4r+4DtsA=="], + + "@rolldown/binding-darwin-x64": ["@rolldown/binding-darwin-x64@1.2.10", "", { "os": "darwin", "cpu": "x64" }, "sha512-7f5h17q5KZVx/ji1vb8OTq31ch1O2I7K8NPIr44GkyWTApXMIsmhWqZfgpOH10xeauqghDAvGlZktasCkcF6Eg=="], + + "@rolldown/binding-freebsd-x64": ["@rolldown/binding-freebsd-x64@1.2.10", "", { "os": "freebsd", "cpu": "x64" }, "sha512-ynOk/eEYhC6ZB2xCGvKrEOwE58oBy9LnrAqtkrDF9Fz1VTaNdGZTsV0VarJdhPwb+sOJTGjCLwcuyRJZ1dnMcQ=="], + + "@rolldown/binding-linux-arm-gnueabihf": ["@rolldown/binding-linux-arm-gnueabihf@1.2.10", "", { "os": "linux", "cpu": "arm" }, "sha512-ERrAs185meZZhGan7a4l3RiiJK1ArSDlHdST++uvSxe+FDbR4TwUPahT/cbZJvaG6fIpDpF78surN+tX708Y4Q=="], + + "@rolldown/binding-linux-arm64-gnu": ["@rolldown/binding-linux-arm64-gnu@1.2.10", "", { "os": "linux", "cpu": "arm64" }, "sha512-KN7OHKD0J3jy1UzBwZWPxpwhODf9IARUIJcrH+yLYKOcmegZ8luEUM38lDP1bDVj40yP6PsSzCqOJF76vljFnQ=="], + + "@rolldown/binding-linux-arm64-musl": ["@rolldown/binding-linux-arm64-musl@1.2.10", "", { "os": "linux", "cpu": "arm64" }, "sha512-8l9wP8O+wa8zD6iw6egSfzVtu7oZVfH3hlUsMM4MwbLMhxleqeoXbZzjddyK3YyNlwLhqznq3tF7PkNJ8T/V2w=="], + + "@rolldown/binding-linux-ppc64-gnu": ["@rolldown/binding-linux-ppc64-gnu@1.2.10", "", { "os": "linux", "cpu": "ppc64" }, "sha512-SeXNKeQzA5kLhz/J0CH6ZP0/HJ3v1xm/0YbiYpE0kK7emfRC2OIGGIaE14xzkISEGv2aYuUSpiLiU5Gbq+OI0A=="], + + "@rolldown/binding-linux-s390x-gnu": ["@rolldown/binding-linux-s390x-gnu@1.2.10", "", { "os": "linux", "cpu": "s390x" }, "sha512-mtht0nR+y8/hart4175Ll15w7lY8dg7CtQ+j2FDNTsDRspOWTK/2V3l0aj9sIj7XmvqxT8Yli/wq22e7feTTWg=="], + + "@rolldown/binding-linux-x64-gnu": ["@rolldown/binding-linux-x64-gnu@1.2.10", "", { "os": "linux", "cpu": "x64" }, "sha512-FSM94nGd55NYo48usCyM/nHfUKRnqc9+b0vJNuKV0oCCpIp/OGims7rO1Nv/DkFkt0S/s2rxsJ2kkS8J3HcpeA=="], + + "@rolldown/binding-linux-x64-musl": ["@rolldown/binding-linux-x64-musl@1.2.10", "", { "os": "linux", "cpu": "x64" }, "sha512-C3YxNB16myRLs7o+B+6PnQ6jBsdIS4+AE4Ah8glVGhDpEv9AOvxhZ/1duAb4B0UGczEK/lBbccksd8VI+p6zfw=="], + + "@rolldown/binding-openharmony-arm64": ["@rolldown/binding-openharmony-arm64@1.2.10", "", { "os": "none", "cpu": "arm64" }, "sha512-571TlE/F1eeTjjdjYAMMMPs1Mfv3MtX6s3+ZKVU6HiUjZ5Njc6c/qzNy/8K3zALTZnaw3JQVYrHxvNfjm43KAg=="], + + "@rolldown/binding-win32-arm64-msvc": ["@rolldown/binding-win32-arm64-msvc@1.2.10", "", { "os": "win32", "cpu": "arm64" }, "sha512-QXW+ZWaiqs2c7Fi++D/SsW07LTPcUrncxcskJGfGNBoaLik1IU6fJymz4HsqwEO0u5Iq11yTO0B/mc4cPk7jrQ=="], + + "@rolldown/binding-win32-x64-msvc": ["@rolldown/binding-win32-x64-msvc@1.2.10", "", { "os": "win32", "cpu": "x64" }, "sha512-5FQFGgah17YeMtG1Yd5a+rMxQpTksyNXxRtKz06FVTaQw3RKYUJQbUoKk0/5jrXBpDo+7makNP7UHA2LQyH64A=="], + + "@rolldown/pluginutils": ["@rolldown/pluginutils@1.0.1", "", {}, "sha512-2j9bGt5Jh8hj+vPtgzPtl72j0yRxHAyumoo6TNfAjsLB04UtpSvPbPcDcBMxz7n+9CYB0c1GxQFxYRg2jimqGw=="], + + "@rollup/rollup-android-arm-eabi": ["@rollup/rollup-android-arm-eabi@4.59.0", "", { "os": "android", "cpu": "arm" }, "sha512-upnNBkA6ZH2VKGcBj9Fyl9IGNPULcjXRlg0LLeaioQWueH30p6IXtJEbKAgvyv+mJaMxSm1l6xwDXYjpEMiLMg=="], + + "@rollup/rollup-android-arm64": ["@rollup/rollup-android-arm64@4.59.0", "", { "os": "android", "cpu": "arm64" }, "sha512-hZ+Zxj3SySm4A/DylsDKZAeVg0mvi++0PYVceVyX7hemkw7OreKdCvW2oQ3T1FMZvCaQXqOTHb8qmBShoqk69Q=="], + + "@rollup/rollup-darwin-arm64": ["@rollup/rollup-darwin-arm64@4.59.0", "", { "os": "darwin", "cpu": "arm64" }, "sha512-W2Psnbh1J8ZJw0xKAd8zdNgF9HRLkdWwwdWqubSVk0pUuQkoHnv7rx4GiF9rT4t5DIZGAsConRE3AxCdJ4m8rg=="], + + "@rollup/rollup-darwin-x64": ["@rollup/rollup-darwin-x64@4.59.0", "", { "os": "darwin", "cpu": "x64" }, "sha512-ZW2KkwlS4lwTv7ZVsYDiARfFCnSGhzYPdiOU4IM2fDbL+QGlyAbjgSFuqNRbSthybLbIJ915UtZBtmuLrQAT/w=="], + + "@rollup/rollup-freebsd-arm64": ["@rollup/rollup-freebsd-arm64@4.59.0", "", { "os": "freebsd", "cpu": "arm64" }, "sha512-EsKaJ5ytAu9jI3lonzn3BgG8iRBjV4LxZexygcQbpiU0wU0ATxhNVEpXKfUa0pS05gTcSDMKpn3Sx+QB9RlTTA=="], + + "@rollup/rollup-freebsd-x64": ["@rollup/rollup-freebsd-x64@4.59.0", "", { "os": "freebsd", "cpu": "x64" }, "sha512-d3DuZi2KzTMjImrxoHIAODUZYoUUMsuUiY4SRRcJy6NJoZ6iIqWnJu9IScV9jXysyGMVuW+KNzZvBLOcpdl3Vg=="], + + "@rollup/rollup-linux-arm-gnueabihf": ["@rollup/rollup-linux-arm-gnueabihf@4.59.0", "", { "os": "linux", "cpu": "arm" }, "sha512-t4ONHboXi/3E0rT6OZl1pKbl2Vgxf9vJfWgmUoCEVQVxhW6Cw/c8I6hbbu7DAvgp82RKiH7TpLwxnJeKv2pbsw=="], + + "@rollup/rollup-linux-arm-musleabihf": ["@rollup/rollup-linux-arm-musleabihf@4.59.0", "", { "os": "linux", "cpu": "arm" }, "sha512-CikFT7aYPA2ufMD086cVORBYGHffBo4K8MQ4uPS/ZnY54GKj36i196u8U+aDVT2LX4eSMbyHtyOh7D7Zvk2VvA=="], + + "@rollup/rollup-linux-arm64-gnu": ["@rollup/rollup-linux-arm64-gnu@4.59.0", "", { "os": "linux", "cpu": "arm64" }, "sha512-jYgUGk5aLd1nUb1CtQ8E+t5JhLc9x5WdBKew9ZgAXg7DBk0ZHErLHdXM24rfX+bKrFe+Xp5YuJo54I5HFjGDAA=="], + + "@rollup/rollup-linux-arm64-musl": ["@rollup/rollup-linux-arm64-musl@4.59.0", "", { "os": "linux", "cpu": "arm64" }, "sha512-peZRVEdnFWZ5Bh2KeumKG9ty7aCXzzEsHShOZEFiCQlDEepP1dpUl/SrUNXNg13UmZl+gzVDPsiCwnV1uI0RUA=="], + + "@rollup/rollup-linux-loong64-gnu": ["@rollup/rollup-linux-loong64-gnu@4.59.0", "", { "os": "linux", "cpu": "none" }, "sha512-gbUSW/97f7+r4gHy3Jlup8zDG190AuodsWnNiXErp9mT90iCy9NKKU0Xwx5k8VlRAIV2uU9CsMnEFg/xXaOfXg=="], + + "@rollup/rollup-linux-loong64-musl": ["@rollup/rollup-linux-loong64-musl@4.59.0", "", { "os": "linux", "cpu": "none" }, "sha512-yTRONe79E+o0FWFijasoTjtzG9EBedFXJMl888NBEDCDV9I2wGbFFfJQQe63OijbFCUZqxpHz1GzpbtSFikJ4Q=="], + + "@rollup/rollup-linux-ppc64-gnu": ["@rollup/rollup-linux-ppc64-gnu@4.59.0", "", { "os": "linux", "cpu": "ppc64" }, "sha512-sw1o3tfyk12k3OEpRddF68a1unZ5VCN7zoTNtSn2KndUE+ea3m3ROOKRCZxEpmT9nsGnogpFP9x6mnLTCaoLkA=="], + + "@rollup/rollup-linux-ppc64-musl": ["@rollup/rollup-linux-ppc64-musl@4.59.0", "", { "os": "linux", "cpu": "ppc64" }, "sha512-+2kLtQ4xT3AiIxkzFVFXfsmlZiG5FXYW7ZyIIvGA7Bdeuh9Z0aN4hVyXS/G1E9bTP/vqszNIN/pUKCk/BTHsKA=="], + + "@rollup/rollup-linux-riscv64-gnu": ["@rollup/rollup-linux-riscv64-gnu@4.59.0", "", { "os": "linux", "cpu": "none" }, "sha512-NDYMpsXYJJaj+I7UdwIuHHNxXZ/b/N2hR15NyH3m2qAtb/hHPA4g4SuuvrdxetTdndfj9b1WOmy73kcPRoERUg=="], + + "@rollup/rollup-linux-riscv64-musl": ["@rollup/rollup-linux-riscv64-musl@4.59.0", "", { "os": "linux", "cpu": "none" }, "sha512-nLckB8WOqHIf1bhymk+oHxvM9D3tyPndZH8i8+35p/1YiVoVswPid2yLzgX7ZJP0KQvnkhM4H6QZ5m0LzbyIAg=="], + + "@rollup/rollup-linux-s390x-gnu": ["@rollup/rollup-linux-s390x-gnu@4.59.0", "", { "os": "linux", "cpu": "s390x" }, "sha512-oF87Ie3uAIvORFBpwnCvUzdeYUqi2wY6jRFWJAy1qus/udHFYIkplYRW+wo+GRUP4sKzYdmE1Y3+rY5Gc4ZO+w=="], + + "@rollup/rollup-linux-x64-gnu": ["@rollup/rollup-linux-x64-gnu@4.59.0", "", { "os": "linux", "cpu": "x64" }, "sha512-3AHmtQq/ppNuUspKAlvA8HtLybkDflkMuLK4DPo77DfthRb71V84/c4MlWJXixZz4uruIH4uaa07IqoAkG64fg=="], + + "@rollup/rollup-linux-x64-musl": ["@rollup/rollup-linux-x64-musl@4.59.0", "", { "os": "linux", "cpu": "x64" }, "sha512-2UdiwS/9cTAx7qIUZB/fWtToJwvt0Vbo0zmnYt7ED35KPg13Q0ym1g442THLC7VyI6JfYTP4PiSOWyoMdV2/xg=="], + + "@rollup/rollup-openbsd-x64": ["@rollup/rollup-openbsd-x64@4.59.0", "", { "os": "openbsd", "cpu": "x64" }, "sha512-M3bLRAVk6GOwFlPTIxVBSYKUaqfLrn8l0psKinkCFxl4lQvOSz8ZrKDz2gxcBwHFpci0B6rttydI4IpS4IS/jQ=="], + + "@rollup/rollup-openharmony-arm64": ["@rollup/rollup-openharmony-arm64@4.59.0", "", { "os": "none", "cpu": "arm64" }, "sha512-tt9KBJqaqp5i5HUZzoafHZX8b5Q2Fe7UjYERADll83O4fGqJ49O1FsL6LpdzVFQcpwvnyd0i+K/VSwu/o/nWlA=="], + + "@rollup/rollup-win32-arm64-msvc": ["@rollup/rollup-win32-arm64-msvc@4.59.0", "", { "os": "win32", "cpu": "arm64" }, "sha512-V5B6mG7OrGTwnxaNUzZTDTjDS7F75PO1ae6MJYdiMu60sq0CqN5CVeVsbhPxalupvTX8gXVSU9gq+Rx1/hvu6A=="], + + "@rollup/rollup-win32-ia32-msvc": ["@rollup/rollup-win32-ia32-msvc@4.59.0", "", { "os": "win32", "cpu": "ia32" }, "sha512-UKFMHPuM9R0iBegwzKF4y0C4J9u8C6MEJgFuXTBerMk7EJ92GFVFYBfOZaSGLu6COf7FxpQNqhNS4c4icUPqxA=="], + + "@rollup/rollup-win32-x64-gnu": ["@rollup/rollup-win32-x64-gnu@4.59.0", "", { "os": "win32", "cpu": "x64" }, "sha512-laBkYlSS1n2L8fSo1thDNGrCTQMmxjYY5G0WFWjFFYZkKPjsMBsgJfGf4TLxXrF6RyhI60L8TMOjBMvXiTcxeA=="], + + "@rollup/rollup-win32-x64-msvc": ["@rollup/rollup-win32-x64-msvc@4.59.0", "", { "os": "win32", "cpu": "x64" }, "sha512-2HRCml6OztYXyJXAvdDXPKcawukWY2GpR5/nxKp4iBgiO3wcoEGkAaqctIbZcNB6KlUQBIqt8VYkNSj2397EfA=="], + + "@rtsao/scc": ["@rtsao/scc@1.1.0", "", {}, "sha512-zt6OdqaDoOnJ1ZYsCYGt9YmWzDXl4vQdKTyJev62gFhRGKdx7mcT54V9KIjg+d2wi9EXsPvAPKe7i7WjfVWB8g=="], + + "@types/estree": ["@types/estree@1.0.8", "", {}, "sha512-dWHzHa2WqEXI/O1E9OjrocMTKJl2mSrEolh1Iomrv6U+JuNwaHXsXx9bLu5gG7BUWFIN0skIQJQ/L1rIex4X6w=="], + + "@types/fs-extra": ["@types/fs-extra@8.1.5", "", { "dependencies": { "@types/node": "*" } }, "sha512-0dzKcwO+S8s2kuF5Z9oUWatQJj5Uq/iqphEtE3GQJVRRYm/tD1LglU2UnXi2A8jLq5umkGouOXOR9y0n613ZwQ=="], + + "@types/json-schema": ["@types/json-schema@7.0.15", "", {}, "sha512-5+fP8P8MFNC+AyZCDxrB2pkZFPGzqQWUzpSeuuVLvm8VMcorNYavBqoFcxK8bQz4Qsbn4oUEEem4wDLfcysGHA=="], + + "@types/json5": ["@types/json5@0.0.29", "", {}, "sha512-dRLjCWHYg4oaA77cxO64oO+7JwCwnIzkZPdrrC71jQmQtlhM556pwKo5bUzqvZndkVbeFLIIi+9TC40JNF5hNQ=="], + + "@types/node": ["@types/node@24.12.0", "", { "dependencies": { "undici-types": "~7.16.0" } }, "sha512-GYDxsZi3ChgmckRT9HPU0WEhKLP08ev/Yfcq2AstjrDASOYCSXeyjDsHg4v5t4jOj7cyDX3vmprafKlWIG9MXQ=="], + + "@types/prop-types": ["@types/prop-types@15.7.15", "", {}, "sha512-F6bEyamV9jKGAFBEmlQnesRPGOQqS2+Uwi0Em15xenOxHaf2hv6L8YCVn3rPdPJOiJfPiCnLIRyvwVaqMY3MIw=="], + + "@types/react": ["@types/react@18.3.28", "", { "dependencies": { "@types/prop-types": "*", "csstype": "^3.2.2" } }, "sha512-z9VXpC7MWrhfWipitjNdgCauoMLRdIILQsAEV+ZesIzBq/oUlxk0m3ApZuMFCXdnS4U7KrI+l3WRUEGQ8K1QKw=="], + + "@types/react-dom": ["@types/react-dom@18.3.7", "", { "peerDependencies": { "@types/react": "^18.0.0" } }, "sha512-MEe3UeoENYVFXzoXEWsvcpg6ZvlrFNlOQ7EOsvhI3CfAXwzPfO8Qwuxd40nepsYKqyyVQnTdEfv68q91yLcKrQ=="], + + "@types/semver": ["@types/semver@7.7.1", "", {}, "sha512-FmgJfu+MOcQ370SD0ev7EI8TlCAfKYU+B4m5T3yXc1CiRN94g/SZPtsCkk506aUDtlMnFZvasDwHHUcZUEaYuA=="], + + "@types/slice-ansi": ["@types/slice-ansi@4.0.0", "", {}, "sha512-+OpjSaq85gvlZAYINyzKpLeiFkSC4EsC6IIiT6v6TLSU5k5U83fHGj9Lel8oKEXM0HqgrMVCjXPDPVICtxF7EQ=="], + + "@typescript-eslint/eslint-plugin": ["@typescript-eslint/eslint-plugin@5.62.0", "", { "dependencies": { "@eslint-community/regexpp": "^4.4.0", "@typescript-eslint/scope-manager": "5.62.0", "@typescript-eslint/type-utils": "5.62.0", "@typescript-eslint/utils": "5.62.0", "debug": "^4.3.4", "graphemer": "^1.4.0", "ignore": "^5.2.0", "natural-compare-lite": "^1.4.0", "semver": "^7.3.7", "tsutils": "^3.21.0" }, "peerDependencies": { "@typescript-eslint/parser": "^5.0.0", "eslint": "^6.0.0 || ^7.0.0 || ^8.0.0" } }, "sha512-TiZzBSJja/LbhNPvk6yc0JrX9XqhQ0hdh6M2svYfsHGejaKFIAGd9MQ+ERIMzLGlN/kZoYIgdxFV0PuljTKXag=="], + + "@typescript-eslint/parser": ["@typescript-eslint/parser@5.62.0", "", { "dependencies": { "@typescript-eslint/scope-manager": "5.62.0", "@typescript-eslint/types": "5.62.0", "@typescript-eslint/typescript-estree": "5.62.0", "debug": "^4.3.4" }, "peerDependencies": { "eslint": "^6.0.0 || ^7.0.0 || ^8.0.0" } }, "sha512-VlJEV0fOQ7BExOsHYAGrgbEiZoi8D+Bl2+f6V2RrXerRSylnp+ZBHmPvaIa8cz0Ajx7WO7Z5RqfgYg7ED1nRhA=="], + + "@typescript-eslint/scope-manager": ["@typescript-eslint/scope-manager@5.62.0", "", { "dependencies": { "@typescript-eslint/types": "5.62.0", "@typescript-eslint/visitor-keys": "5.62.0" } }, "sha512-VXuvVvZeQCQb5Zgf4HAxc04q5j+WrNAtNh9OwCsCgpKqESMTu3tF/jhZ3xG6T4NZwWl65Bg8KuS2uEvhSfLl0w=="], + + "@typescript-eslint/type-utils": ["@typescript-eslint/type-utils@5.62.0", "", { "dependencies": { "@typescript-eslint/typescript-estree": "5.62.0", "@typescript-eslint/utils": "5.62.0", "debug": "^4.3.4", "tsutils": "^3.21.0" }, "peerDependencies": { "eslint": "*" } }, "sha512-xsSQreu+VnfbqQpW5vnCJdq1Z3Q0U31qiWmRhr98ONQmcp/yhiPJFPq8MXiJVLiksmOKSjIldZzkebzHuCGzew=="], + + "@typescript-eslint/types": ["@typescript-eslint/types@5.62.0", "", {}, "sha512-87NVngcbVXUahrRTqIK27gD2t5Cu1yuCXxbLcFtCzZGlfyVWWh8mLHkoxzjsB6DDNnvdL+fW8MiwPEJyGJQDgQ=="], + + "@typescript-eslint/typescript-estree": ["@typescript-eslint/typescript-estree@5.62.0", "", { "dependencies": { "@typescript-eslint/types": "5.62.0", "@typescript-eslint/visitor-keys": "5.62.0", "debug": "^4.3.4", "globby": "^11.1.0", "is-glob": "^4.0.3", "semver": "^7.3.7", "tsutils": "^3.21.0" } }, "sha512-CmcQ6uY7b9y694lKdRB8FEel7JbU/40iSAPomu++SjLMntB+2Leay2LO6i8VnJk58MtE9/nQSFIH6jpyRWyYzA=="], + + "@typescript-eslint/utils": ["@typescript-eslint/utils@5.62.0", "", { "dependencies": { "@eslint-community/eslint-utils": "^4.2.0", "@types/json-schema": "^7.0.9", "@types/semver": "^7.3.12", "@typescript-eslint/scope-manager": "5.62.0", "@typescript-eslint/types": "5.62.0", "@typescript-eslint/typescript-estree": "5.62.0", "eslint-scope": "^5.1.1", "semver": "^7.3.7" }, "peerDependencies": { "eslint": "^6.0.0 || ^7.0.0 || ^8.0.0" } }, "sha512-n8oxjeb5aIbPFEtmQxQYOLI0i9n5ySBEY/ZEHHZqKQSFnxio1rv6dthascc9dLuwrL0RC5mPCxB7vnAVGAYWAQ=="], + + "@typescript-eslint/visitor-keys": ["@typescript-eslint/visitor-keys@5.62.0", "", { "dependencies": { "@typescript-eslint/types": "5.62.0", "eslint-visitor-keys": "^3.3.0" } }, "sha512-07ny+LHRzQXepkGg6w0mFY41fVUNBrL2Roj/++7V1txKugfjm/Ci/qSND03r2RhlJhJYMcTn9AhhSSqQp0Ysyw=="], + + "@ungap/structured-clone": ["@ungap/structured-clone@1.3.0", "", {}, "sha512-WmoN8qaIAo7WTYWbAZuG8PYEhn5fkz7dZrqTBZ7dtt//lL2Gwms1IcnQ5yHqjDfX8Ft5j4YzDM23f87zBfDe9g=="], + + "@vitejs/plugin-react": ["@vitejs/plugin-react@6.1.1", "", { "dependencies": { "@rolldown/pluginutils": "^1.0.1" }, "peerDependencies": { "@rolldown/plugin-babel": "^0.1.7 || ^0.2.0", "babel-plugin-react-compiler": "^1.0.0", "oxc-transform-react": "^0.145.0", "vite": "^8.0.0" }, "optionalPeers": ["@rolldown/plugin-babel", "babel-plugin-react-compiler", "oxc-transform-react"] }, "sha512-yxLaQV9gkhS8ezJqCM6+ndU7mDY6gqAg75NQ+0IjwEI8IYOmQCgkRwHKVSfWXW076DsqMo0Dk+0FK1U+M5RgFw=="], + + "@xmldom/xmldom": ["@xmldom/xmldom@0.8.11", "", {}, "sha512-cQzWCtO6C8TQiYl1ruKNn2U6Ao4o4WBBcbL61yJl84x+j5sOWWFU9X7DpND8XZG3daDppSsigMdfAIl2upQBRw=="], + + "acorn": ["acorn@8.16.0", "", { "bin": { "acorn": "bin/acorn" } }, "sha512-UVJyE9MttOsBQIDKw1skb9nAwQuR5wuGD3+82K6JgJlm/Y+KI92oNsMNGZCYdDsVtRHSak0pcV5Dno5+4jh9sw=="], + + "acorn-jsx": ["acorn-jsx@5.3.2", "", { "peerDependencies": { "acorn": "^6.0.0 || ^7.0.0 || ^8.0.0" } }, "sha512-rq9s+JNhf0IChjtDXxllJ7g41oZk5SlXtp0LHwyA5cejwn7vKmKp4pPri6YEePv2PU65sAsegbXtIinmDFDXgQ=="], + + "ajv": ["ajv@6.14.0", "", { "dependencies": { "fast-deep-equal": "^3.1.1", "fast-json-stable-stringify": "^2.0.0", "json-schema-traverse": "^0.4.1", "uri-js": "^4.2.2" } }, "sha512-IWrosm/yrn43eiKqkfkHis7QioDleaXQHdDVPKg0FSwwd/DuvyX79TZnFOnYpB7dcsFAMmtFztZuXPDvSePkFw=="], + + "ansi-regex": ["ansi-regex@5.0.1", "", {}, "sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ=="], + + "ansi-styles": ["ansi-styles@4.3.0", "", { "dependencies": { "color-convert": "^2.0.1" } }, "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg=="], + + "argparse": ["argparse@2.0.1", "", {}, "sha512-8+9WqebbFzpX9OR+Wa6O29asIogeRMzcGtAINdpMHHyAg10f05aSFVBbcEqGf/PXw1EjAZ+q2/bEBg3DvurK3Q=="], + + "array-buffer-byte-length": ["array-buffer-byte-length@1.0.2", "", { "dependencies": { "call-bound": "^1.0.3", "is-array-buffer": "^3.0.5" } }, "sha512-LHE+8BuR7RYGDKvnrmcuSq3tDcKv9OFEXQt/HpbZhY7V6h0zlUXutnAD82GiFx9rdieCMjkvtcsPqBwgUl1Iiw=="], + + "array-includes": ["array-includes@3.1.9", "", { "dependencies": { "call-bind": "^1.0.8", "call-bound": "^1.0.4", "define-properties": "^1.2.1", "es-abstract": "^1.24.0", "es-object-atoms": "^1.1.1", "get-intrinsic": "^1.3.0", "is-string": "^1.1.1", "math-intrinsics": "^1.1.0" } }, "sha512-FmeCCAenzH0KH381SPT5FZmiA/TmpndpcaShhfgEN9eCVjnFBqq3l1xrI42y8+PPLI6hypzou4GXw00WHmPBLQ=="], + + "array-union": ["array-union@2.1.0", "", {}, "sha512-HGyxoOTYUyCM6stUe6EJgnd4EoewAI7zMdfqO+kGjnlZmBDz/cR5pf8r/cR4Wq60sL/p0IkcjUEEPwS3GFrIyw=="], + + "array.prototype.findlastindex": ["array.prototype.findlastindex@1.2.6", "", { "dependencies": { "call-bind": "^1.0.8", "call-bound": "^1.0.4", "define-properties": "^1.2.1", "es-abstract": "^1.23.9", "es-errors": "^1.3.0", "es-object-atoms": "^1.1.1", "es-shim-unscopables": "^1.1.0" } }, "sha512-F/TKATkzseUExPlfvmwQKGITM3DGTK+vkAsCZoDc5daVygbJBnjEUCbgkAvVFsgfXfX4YIqZ/27G3k3tdXrTxQ=="], + + "array.prototype.flat": ["array.prototype.flat@1.3.3", "", { "dependencies": { "call-bind": "^1.0.8", "define-properties": "^1.2.1", "es-abstract": "^1.23.5", "es-shim-unscopables": "^1.0.2" } }, "sha512-rwG/ja1neyLqCuGZ5YYrznA62D4mZXg0i1cIskIUKSiqF3Cje9/wXAls9B9s1Wa2fomMsIv8czB8jZcPmxCXFg=="], + + "array.prototype.flatmap": ["array.prototype.flatmap@1.3.3", "", { "dependencies": { "call-bind": "^1.0.8", "define-properties": "^1.2.1", "es-abstract": "^1.23.5", "es-shim-unscopables": "^1.0.2" } }, "sha512-Y7Wt51eKJSyi80hFrJCePGGNo5ktJCslFuboqJsbf57CCPcm5zztluPlc4/aD8sWsKvlwatezpV4U1efk8kpjg=="], + + "arraybuffer.prototype.slice": ["arraybuffer.prototype.slice@1.0.4", "", { "dependencies": { "array-buffer-byte-length": "^1.0.1", "call-bind": "^1.0.8", "define-properties": "^1.2.1", "es-abstract": "^1.23.5", "es-errors": "^1.3.0", "get-intrinsic": "^1.2.6", "is-array-buffer": "^3.0.4" } }, "sha512-BNoCY6SXXPQ7gF2opIP4GBE+Xw7U+pHMYKuzjgCN3GwiaIR09UUeKfheyIry77QtrCBlC0KK0q5/TER/tYh3PQ=="], + + "astral-regex": ["astral-regex@2.0.0", "", {}, "sha512-Z7tMw1ytTXt5jqMcOP+OQteU1VuNK9Y02uuJtKQ1Sv69jXQKKg5cibLwGJow8yzZP+eAc18EmLGPal0bp36rvQ=="], + + "async-function": ["async-function@1.0.0", "", {}, "sha512-hsU18Ae8CDTR6Kgu9DYf0EbCr/a5iGL0rytQDobUcdpYOKokk8LEjVphnXkDkgpi0wYVsqrXuP0bZxJaTqdgoA=="], + + "at-least-node": ["at-least-node@1.0.0", "", {}, "sha512-+q/t7Ekv1EDY2l6Gda6LLiX14rU9TV20Wa3ofeQmwPFZbOMo9DXrLbOjFaaclkXKWidIaopwAObQDqwWtGUjqg=="], + + "available-typed-arrays": ["available-typed-arrays@1.0.7", "", { "dependencies": { "possible-typed-array-names": "^1.0.0" } }, "sha512-wvUjBtSGN7+7SjNpq/9M2Tg350UZD3q62IFZLbRAR1bSMlCo1ZaeW+BJ+D090e4hIIZLBcTDWe4Mh4jvUDajzQ=="], + + "balanced-match": ["balanced-match@1.0.2", "", {}, "sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw=="], + + "base64-js": ["base64-js@1.5.1", "", {}, "sha512-AKpaYlHn8t4SVbOHCy+b5+KKgvR4vrsD8vbvrbiQJps7fKDTkjkDry6ji0rUJjC0kzbNePLwzxq8iypo41qeWA=="], + + "big-integer": ["big-integer@1.6.52", "", {}, "sha512-QxD8cf2eVqJOOz63z6JIN9BzvVs/dlySa5HGSBH5xtR8dPteIRQnBxxKqkNTiT6jbDTF6jAfrd4oMcND9RGbQg=="], + + "bplist-creator": ["bplist-creator@0.1.0", "", { "dependencies": { "stream-buffers": "2.2.x" } }, "sha512-sXaHZicyEEmY86WyueLTQesbeoH/mquvarJaQNbjuOQO+7gbFcDEWqKmcWA4cOTLzFlfgvkiVxolk1k5bBIpmg=="], + + "bplist-parser": ["bplist-parser@0.3.2", "", { "dependencies": { "big-integer": "1.6.x" } }, "sha512-apC2+fspHGI3mMKj+dGevkGo/tCqVB8jMb6i+OX+E29p0Iposz07fABkRIfVUPNd5A5VbuOz1bZbnmkKLYF+wQ=="], + + "brace-expansion": ["brace-expansion@1.1.12", "", { "dependencies": { "balanced-match": "^1.0.0", "concat-map": "0.0.1" } }, "sha512-9T9UjW3r0UW5c1Q7GTwllptXwhvYmEzFhzMfZ9H7FQWt+uZePjZPjBP/W1ZEyZ1twGWom5/56TF4lPcqjnDHcg=="], + + "braces": ["braces@3.0.3", "", { "dependencies": { "fill-range": "^7.1.1" } }, "sha512-yQbXgO/OSZVD2IsiLlro+7Hf6Q18EJrKSEsdoMzKePKXct3gvD8oLcOQdIzGupr5Fj+EDe8gO/lxc1BzfMpxvA=="], + + "buffer-crc32": ["buffer-crc32@0.2.13", "", {}, "sha512-VO9Ht/+p3SN7SKWqcrgEzjGbRSJYTx+Q1pTQC0wrWqHx0vpJraQ6GtHx8tvcg1rlK1byhU5gccxgOgj7B0TDkQ=="], + + "call-bind": ["call-bind@1.0.8", "", { "dependencies": { "call-bind-apply-helpers": "^1.0.0", "es-define-property": "^1.0.0", "get-intrinsic": "^1.2.4", "set-function-length": "^1.2.2" } }, "sha512-oKlSFMcMwpUg2ednkhQ454wfWiU/ul3CkJe/PEHcTKuiX6RpbehUiFMXu13HalGZxfUwCQzZG747YXBn1im9ww=="], + + "call-bind-apply-helpers": ["call-bind-apply-helpers@1.0.2", "", { "dependencies": { "es-errors": "^1.3.0", "function-bind": "^1.1.2" } }, "sha512-Sp1ablJ0ivDkSzjcaJdxEunN5/XvksFJ2sMBFfq6x0ryhQV/2b/KwFe21cMpmHtPOSij8K99/wSfoEuTObmuMQ=="], + + "call-bound": ["call-bound@1.0.4", "", { "dependencies": { "call-bind-apply-helpers": "^1.0.2", "get-intrinsic": "^1.3.0" } }, "sha512-+ys997U96po4Kx/ABpBCqhA9EuxJaQWDQg7295H4hBphv3IZg0boBKuwYpt4YXp6MZ5AmZQnU/tyMTlRpaSejg=="], + + "callsites": ["callsites@3.1.0", "", {}, "sha512-P8BjAsXvZS+VIDUI11hHCQEv74YT67YUi5JJFNWIqL235sBmjX4+qx9Muvls5ivyNENctx46xQLQ3aTuE7ssaQ=="], + + "chalk": ["chalk@4.1.2", "", { "dependencies": { "ansi-styles": "^4.1.0", "supports-color": "^7.1.0" } }, "sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA=="], + + "chevrotain": ["chevrotain@11.0.3", "", { "dependencies": { "@chevrotain/cst-dts-gen": "11.0.3", "@chevrotain/gast": "11.0.3", "@chevrotain/regexp-to-ast": "11.0.3", "@chevrotain/types": "11.0.3", "@chevrotain/utils": "11.0.3", "lodash-es": "4.17.21" } }, "sha512-ci2iJH6LeIkvP9eJW6gpueU8cnZhv85ELY8w8WiFtNjMHA5ad6pQLaJo9mEly/9qUyCpvqX8/POVUTf18/HFdw=="], + + "chevrotain-allstar": ["chevrotain-allstar@0.3.1", "", { "dependencies": { "lodash-es": "^4.17.21" }, "peerDependencies": { "chevrotain": "^11.0.0" } }, "sha512-b7g+y9A0v4mxCW1qUhf3BSVPg+/NvGErk/dOkrDaHA0nQIQGAtrOjlX//9OQtRlSCy+x9rfB5N8yC71lH1nvMw=="], + + "chownr": ["chownr@3.0.0", "", {}, "sha512-+IxzY9BZOQd/XuYPRmrvEVjF/nqj5kgT4kEq7VofrDoM1MxoRjEWkrCC3EtLi59TVawxTAn+orJwFQcrqEN1+g=="], + + "color-convert": ["color-convert@2.0.1", "", { "dependencies": { "color-name": "~1.1.4" } }, "sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ=="], + + "color-name": ["color-name@1.1.4", "", {}, "sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA=="], + + "colorette": ["colorette@2.0.20", "", {}, "sha512-IfEDxwoWIjkeXL1eXcDiow4UbKjhLdq6/EuSVR9GMN7KVH3r9gQ83e73hsz1Nd1T3ijd5xv1wcWRYO+D6kCI2w=="], + + "commander": ["commander@12.1.0", "", {}, "sha512-Vw8qHK3bZM9y/P10u3Vib8o/DdkvA2OtPtZvD871QKjy74Wj1WSKFILMPRPSdUSx5RFK1arlJzEtA4PkFgnbuA=="], + + "concat-map": ["concat-map@0.0.1", "", {}, "sha512-/Srv4dswyQNBfohGpz9o6Yb3Gz3SrUDqBH5rTuhGR7ahtlbYKnVxw2bCFMRljaA7EXHaXZ8wsHdodFvbkhKmqg=="], + + "cosmiconfig": ["cosmiconfig@9.0.1", "", { "dependencies": { "env-paths": "^2.2.1", "import-fresh": "^3.3.0", "js-yaml": "^4.1.0", "parse-json": "^5.2.0" }, "peerDependencies": { "typescript": ">=4.9.5" }, "optionalPeers": ["typescript"] }, "sha512-hr4ihw+DBqcvrsEDioRO31Z17x71pUYoNe/4h6Z0wB72p7MU7/9gH8Q3s12NFhHPfYBBOV3qyfUxmr/Yn3shnQ=="], + + "cross-spawn": ["cross-spawn@7.0.6", "", { "dependencies": { "path-key": "^3.1.0", "shebang-command": "^2.0.0", "which": "^2.0.1" } }, "sha512-uV2QOWP2nWzsy2aMp8aRibhi9dlzF5Hgh5SHaB9OiTGEyDTiJJyx0uy51QXdyWbtAHNua4XJzUKca3OzKUd3vA=="], + + "csstype": ["csstype@3.2.3", "", {}, "sha512-z1HGKcYy2xA8AGQfwrn0PAy+PB7X/GSj3UVJW9qKyn43xWa+gl5nXmU4qqLMRzWVLFC8KusUX8T/0kCiOYpAIQ=="], + + "data-view-buffer": ["data-view-buffer@1.0.2", "", { "dependencies": { "call-bound": "^1.0.3", "es-errors": "^1.3.0", "is-data-view": "^1.0.2" } }, "sha512-EmKO5V3OLXh1rtK2wgXRansaK1/mtVdTUEiEI0W8RkvgT05kfxaH29PliLnpLP73yYO6142Q72QNa8Wx/A5CqQ=="], + + "data-view-byte-length": ["data-view-byte-length@1.0.2", "", { "dependencies": { "call-bound": "^1.0.3", "es-errors": "^1.3.0", "is-data-view": "^1.0.2" } }, "sha512-tuhGbE6CfTM9+5ANGf+oQb72Ky/0+s3xKUpHvShfiz2RxMFgFPjsXuRLBVMtvMs15awe45SRb83D6wH4ew6wlQ=="], + + "data-view-byte-offset": ["data-view-byte-offset@1.0.1", "", { "dependencies": { "call-bound": "^1.0.2", "es-errors": "^1.3.0", "is-data-view": "^1.0.1" } }, "sha512-BS8PfmtDGnrgYdOonGZQdLZslWIeCGFP9tpan0hi1Co2Zr2NKADsvGYA8XxuG/4UWgJ6Cjtv+YJnB6MM69QGlQ=="], + + "debug": ["debug@4.4.3", "", { "dependencies": { "ms": "^2.1.3" } }, "sha512-RGwwWnwQvkVfavKVt22FGLw+xYSdzARwm0ru6DhTVA3umU5hZc28V3kO4stgYryrTlLpuvgI9GiijltAjNbcqA=="], + + "deep-is": ["deep-is@0.1.4", "", {}, "sha512-oIPzksmTg4/MriiaYGO+okXDT7ztn/w3Eptv/+gSIdMdKsJo0u4CfYNFJPy+4SKMuCqGw2wxnA+URMg3t8a/bQ=="], + + "define-data-property": ["define-data-property@1.1.4", "", { "dependencies": { "es-define-property": "^1.0.0", "es-errors": "^1.3.0", "gopd": "^1.0.1" } }, "sha512-rBMvIzlpA8v6E+SJZoo++HAYqsLrkg7MSfIinMPFhmkorw7X+dOXVJQs+QT69zGkzMyfDnIMN2Wid1+NbL3T+A=="], + + "define-lazy-prop": ["define-lazy-prop@2.0.0", "", {}, "sha512-Ds09qNh8yw3khSjiJjiUInaGX9xlqZDY7JVryGxdxV7NPeuqQfplOpQ66yJFZut3jLa5zOwkXw1g9EI2uKh4Og=="], + + "define-properties": ["define-properties@1.2.1", "", { "dependencies": { "define-data-property": "^1.0.1", "has-property-descriptors": "^1.0.0", "object-keys": "^1.1.1" } }, "sha512-8QmQKqEASLd5nx0U1B1okLElbUuuttJ/AnYmRXbbbGDWh6uS208EjD4Xqq/I9wK7u0v6O08XhTWnt5XtEbR6Dg=="], + + "detect-libc": ["detect-libc@2.1.2", "", {}, "sha512-Btj2BOOO83o3WyH59e8MgXsxEQVcarkUOpEYrubB0urwnN10yQ364rsiByU11nZlqWYZm05i/of7io4mzihBtQ=="], + + "diff": ["diff@5.2.2", "", {}, "sha512-vtcDfH3TOjP8UekytvnHH1o1P4FcUdt4eQ1Y+Abap1tk/OB2MWQvcwS2ClCd1zuIhc3JKOx6p3kod8Vfys3E+A=="], + + "dir-glob": ["dir-glob@3.0.1", "", { "dependencies": { "path-type": "^4.0.0" } }, "sha512-WkrWp9GR4KXfKGYzOLmTuGVi1UWFfws377n9cc55/tb6DuqyF6pcQ5AbiHEshaDpY9v6oaSr2XCDidGmMwdzIA=="], + + "doctrine": ["doctrine@3.0.0", "", { "dependencies": { "esutils": "^2.0.2" } }, "sha512-yS+Q5i3hBf7GBkd4KG8a7eBNNWNGLTaEwwYWUijIYM7zrlYDM0BFXHjjPWlWZ1Rg7UaddZeIDmi9jF3HmqiQ2w=="], + + "dunder-proto": ["dunder-proto@1.0.1", "", { "dependencies": { "call-bind-apply-helpers": "^1.0.1", "es-errors": "^1.3.0", "gopd": "^1.2.0" } }, "sha512-KIN/nDJBQRcXw0MLVhZE9iQHmG68qAVIBg9CqmUYjmQIhgij9U5MFvrqkUL5FbtyyzZuOeOt0zdeRe4UY7ct+A=="], + + "elementtree": ["elementtree@0.1.7", "", { "dependencies": { "sax": "1.1.4" } }, "sha512-wkgGT6kugeQk/P6VZ/f4T+4HB41BVgNBq5CDIZVbQ02nvTVqAiVTbskxxu3eA/X96lMlfYOwnLQpN2v5E1zDEg=="], + + "emoji-regex": ["emoji-regex@8.0.0", "", {}, "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A=="], + + "env-paths": ["env-paths@2.2.1", "", {}, "sha512-+h1lkLKhZMTYjog1VEpJNG7NZJWcuc2DDk/qsqSTRRCOXiLjeQ1d1/udrUGhqMxUgAlwKNZ0cf2uqan5GLuS2A=="], + + "error-ex": ["error-ex@1.3.4", "", { "dependencies": { "is-arrayish": "^0.2.1" } }, "sha512-sqQamAnR14VgCr1A618A3sGrygcpK+HEbenA/HiEAkkUwcZIIB/tgWqHFxWgOyDh4nB4JCRimh79dR5Ywc9MDQ=="], + + "es-abstract": ["es-abstract@1.24.1", "", { "dependencies": { "array-buffer-byte-length": "^1.0.2", "arraybuffer.prototype.slice": "^1.0.4", "available-typed-arrays": "^1.0.7", "call-bind": "^1.0.8", "call-bound": "^1.0.4", "data-view-buffer": "^1.0.2", "data-view-byte-length": "^1.0.2", "data-view-byte-offset": "^1.0.1", "es-define-property": "^1.0.1", "es-errors": "^1.3.0", "es-object-atoms": "^1.1.1", "es-set-tostringtag": "^2.1.0", "es-to-primitive": "^1.3.0", "function.prototype.name": "^1.1.8", "get-intrinsic": "^1.3.0", "get-proto": "^1.0.1", "get-symbol-description": "^1.1.0", "globalthis": "^1.0.4", "gopd": "^1.2.0", "has-property-descriptors": "^1.0.2", "has-proto": "^1.2.0", "has-symbols": "^1.1.0", "hasown": "^2.0.2", "internal-slot": "^1.1.0", "is-array-buffer": "^3.0.5", "is-callable": "^1.2.7", "is-data-view": "^1.0.2", "is-negative-zero": "^2.0.3", "is-regex": "^1.2.1", "is-set": "^2.0.3", "is-shared-array-buffer": "^1.0.4", "is-string": "^1.1.1", "is-typed-array": "^1.1.15", "is-weakref": "^1.1.1", "math-intrinsics": "^1.1.0", "object-inspect": "^1.13.4", "object-keys": "^1.1.1", "object.assign": "^4.1.7", "own-keys": "^1.0.1", "regexp.prototype.flags": "^1.5.4", "safe-array-concat": "^1.1.3", "safe-push-apply": "^1.0.0", "safe-regex-test": "^1.1.0", "set-proto": "^1.0.0", "stop-iteration-iterator": "^1.1.0", "string.prototype.trim": "^1.2.10", "string.prototype.trimend": "^1.0.9", "string.prototype.trimstart": "^1.0.8", "typed-array-buffer": "^1.0.3", "typed-array-byte-length": "^1.0.3", "typed-array-byte-offset": "^1.0.4", "typed-array-length": "^1.0.7", "unbox-primitive": "^1.1.0", "which-typed-array": "^1.1.19" } }, "sha512-zHXBLhP+QehSSbsS9Pt23Gg964240DPd6QCf8WpkqEXxQ7fhdZzYsocOr5u7apWonsS5EjZDmTF+/slGMyasvw=="], + + "es-define-property": ["es-define-property@1.0.1", "", {}, "sha512-e3nRfgfUZ4rNGL232gUgX06QNyyez04KdjFrF+LTRoOXmrOgFKDg4BCdsjW8EnT69eqdYGmRpJwiPVYNrCaW3g=="], + + "es-errors": ["es-errors@1.3.0", "", {}, "sha512-Zf5H2Kxt2xjTvbJvP2ZWLEICxA6j+hAmMzIlypy4xcBg1vKVnx89Wy0GbS+kf5cwCVFFzdCFh2XSCFNULS6csw=="], + + "es-object-atoms": ["es-object-atoms@1.1.1", "", { "dependencies": { "es-errors": "^1.3.0" } }, "sha512-FGgH2h8zKNim9ljj7dankFPcICIK9Cp5bm+c2gQSYePhpaG5+esrLODihIorn+Pe6FGJzWhXQotPv73jTaldXA=="], + + "es-set-tostringtag": ["es-set-tostringtag@2.1.0", "", { "dependencies": { "es-errors": "^1.3.0", "get-intrinsic": "^1.2.6", "has-tostringtag": "^1.0.2", "hasown": "^2.0.2" } }, "sha512-j6vWzfrGVfyXxge+O0x5sh6cvxAog0a/4Rdd2K36zCMV5eJ+/+tOAngRO8cODMNWbVRdVlmGZQL2YS3yR8bIUA=="], + + "es-shim-unscopables": ["es-shim-unscopables@1.1.0", "", { "dependencies": { "hasown": "^2.0.2" } }, "sha512-d9T8ucsEhh8Bi1woXCf+TIKDIROLG5WCkxg8geBCbvk22kzwC5G2OnXVMO6FUsvQlgUUXQ2itephWDLqDzbeCw=="], + + "es-to-primitive": ["es-to-primitive@1.3.0", "", { "dependencies": { "is-callable": "^1.2.7", "is-date-object": "^1.0.5", "is-symbol": "^1.0.4" } }, "sha512-w+5mJ3GuFL+NjVtJlvydShqE1eN3h3PbI7/5LAsYJP/2qtuMXjfL2LpHSRqo4b4eSF5K/DH1JXKUAHSB2UW50g=="], + + "escape-string-regexp": ["escape-string-regexp@4.0.0", "", {}, "sha512-TtpcNJ3XAzx3Gq8sWRzJaVajRs0uVxA2YAkdb1jm2YkPz4G6egUFAyA3n5vtEIZefPk5Wa4UXbKuS5fKkJWdgA=="], + + "eslint": ["eslint@8.57.1", "", { "dependencies": { "@eslint-community/eslint-utils": "^4.2.0", "@eslint-community/regexpp": "^4.6.1", "@eslint/eslintrc": "^2.1.4", "@eslint/js": "8.57.1", "@humanwhocodes/config-array": "^0.13.0", "@humanwhocodes/module-importer": "^1.0.1", "@nodelib/fs.walk": "^1.2.8", "@ungap/structured-clone": "^1.2.0", "ajv": "^6.12.4", "chalk": "^4.0.0", "cross-spawn": "^7.0.2", "debug": "^4.3.2", "doctrine": "^3.0.0", "escape-string-regexp": "^4.0.0", "eslint-scope": "^7.2.2", "eslint-visitor-keys": "^3.4.3", "espree": "^9.6.1", "esquery": "^1.4.2", "esutils": "^2.0.2", "fast-deep-equal": "^3.1.3", "file-entry-cache": "^6.0.1", "find-up": "^5.0.0", "glob-parent": "^6.0.2", "globals": "^13.19.0", "graphemer": "^1.4.0", "ignore": "^5.2.0", "imurmurhash": "^0.1.4", "is-glob": "^4.0.0", "is-path-inside": "^3.0.3", "js-yaml": "^4.1.0", "json-stable-stringify-without-jsonify": "^1.0.1", "levn": "^0.4.1", "lodash.merge": "^4.6.2", "minimatch": "^3.1.2", "natural-compare": "^1.4.0", "optionator": "^0.9.3", "strip-ansi": "^6.0.1", "text-table": "^0.2.0" }, "bin": { "eslint": "bin/eslint.js" } }, "sha512-ypowyDxpVSYpkXr9WPv2PAZCtNip1Mv5KTW0SCurXv/9iOpcrH9PaqUElksqEB6pChqHGDRCFTyrZlGhnLNGiA=="], + + "eslint-config-prettier": ["eslint-config-prettier@8.10.2", "", { "peerDependencies": { "eslint": ">=7.0.0" }, "bin": { "eslint-config-prettier": "bin/cli.js" } }, "sha512-/IGJ6+Dka158JnP5n5YFMOszjDWrXggGz1LaK/guZq9vZTmniaKlHcsscvkAhn9y4U+BU3JuUdYvtAMcv30y4A=="], + + "eslint-import-resolver-node": ["eslint-import-resolver-node@0.3.9", "", { "dependencies": { "debug": "^3.2.7", "is-core-module": "^2.13.0", "resolve": "^1.22.4" } }, "sha512-WFj2isz22JahUv+B788TlO3N6zL3nNJGU8CcZbPZvVEkBPaJdCV4vy5wyghty5ROFbCRnm132v8BScu5/1BQ8g=="], + + "eslint-module-utils": ["eslint-module-utils@2.12.1", "", { "dependencies": { "debug": "^3.2.7" } }, "sha512-L8jSWTze7K2mTg0vos/RuLRS5soomksDPoJLXIslC7c8Wmut3bx7CPpJijDcBZtxQ5lrbUdM+s0OlNbz0DCDNw=="], + + "eslint-plugin-import": ["eslint-plugin-import@2.32.0", "", { "dependencies": { "@rtsao/scc": "^1.1.0", "array-includes": "^3.1.9", "array.prototype.findlastindex": "^1.2.6", "array.prototype.flat": "^1.3.3", "array.prototype.flatmap": "^1.3.3", "debug": "^3.2.7", "doctrine": "^2.1.0", "eslint-import-resolver-node": "^0.3.9", "eslint-module-utils": "^2.12.1", "hasown": "^2.0.2", "is-core-module": "^2.16.1", "is-glob": "^4.0.3", "minimatch": "^3.1.2", "object.fromentries": "^2.0.8", "object.groupby": "^1.0.3", "object.values": "^1.2.1", "semver": "^6.3.1", "string.prototype.trimend": "^1.0.9", "tsconfig-paths": "^3.15.0" }, "peerDependencies": { "eslint": "^2 || ^3 || ^4 || ^5 || ^6 || ^7.2.0 || ^8 || ^9" } }, "sha512-whOE1HFo/qJDyX4SnXzP4N6zOWn79WhnCUY/iDR0mPfQZO8wcYE4JClzI2oZrhBnnMUCBCHZhO6VQyoBU95mZA=="], + + "eslint-scope": ["eslint-scope@7.2.2", "", { "dependencies": { "esrecurse": "^4.3.0", "estraverse": "^5.2.0" } }, "sha512-dOt21O7lTMhDM+X9mB4GX+DZrZtCUJPL/wlcTqxyrx5IvO0IYtILdtrQGQp+8n5S0gwSVmOf9NQrjMOgfQZlIg=="], + + "eslint-visitor-keys": ["eslint-visitor-keys@3.4.3", "", {}, "sha512-wpc+LXeiyiisxPlEkUzU6svyS1frIO3Mgxj1fdy7Pm8Ygzguax2N3Fa/D/ag1WqbOprdI+uY6wMUl8/a2G+iag=="], + + "espree": ["espree@9.6.1", "", { "dependencies": { "acorn": "^8.9.0", "acorn-jsx": "^5.3.2", "eslint-visitor-keys": "^3.4.1" } }, "sha512-oruZaFkjorTpF32kDSI5/75ViwGeZginGGy2NoOSg3Q9bnwlnmDm4HLnkl0RE3n+njDXR037aY1+x58Z/zFdwQ=="], + + "esquery": ["esquery@1.7.0", "", { "dependencies": { "estraverse": "^5.1.0" } }, "sha512-Ap6G0WQwcU/LHsvLwON1fAQX9Zp0A2Y6Y/cJBl9r/JbW90Zyg4/zbG6zzKa2OTALELarYHmKu0GhpM5EO+7T0g=="], + + "esrecurse": ["esrecurse@4.3.0", "", { "dependencies": { "estraverse": "^5.2.0" } }, "sha512-KmfKL3b6G+RXvP8N1vr3Tq1kL/oCFgn2NYXEtqP8/L3pKapUA4G8cFVaoF3SU323CD4XypR/ffioHmkti6/Tag=="], + + "estraverse": ["estraverse@5.3.0", "", {}, "sha512-MMdARuVEQziNTeJD8DgMqmhwR11BRQ/cBP+pLtYdSTnf3MIO8fFeiINEbX36ZdNlfU/7A9f3gUw49B3oQsvwBA=="], + + "esutils": ["esutils@2.0.3", "", {}, "sha512-kVscqXk4OCp68SZ0dkgEKVi6/8ij300KBWTJq32P/dYeWTSwK41WyTxalN1eRmA5Z9UU/LX9D7FWSmV9SAYx6g=="], + + "fast-deep-equal": ["fast-deep-equal@3.1.3", "", {}, "sha512-f3qQ9oQy9j2AhBe/H9VC91wLmKBCCU/gDOnKNAYG5hswO7BLKj09Hc5HYNz9cGI++xlpDCIgDaitVs03ATR84Q=="], + + "fast-glob": ["fast-glob@3.3.3", "", { "dependencies": { "@nodelib/fs.stat": "^2.0.2", "@nodelib/fs.walk": "^1.2.3", "glob-parent": "^5.1.2", "merge2": "^1.3.0", "micromatch": "^4.0.8" } }, "sha512-7MptL8U0cqcFdzIzwOTHoilX9x5BrNqye7Z/LuC7kCMRio1EMSyqRK3BEAUD7sXRq4iT4AzTVuZdhgQ2TCvYLg=="], + + "fast-json-stable-stringify": ["fast-json-stable-stringify@2.1.0", "", {}, "sha512-lhd/wF+Lk98HZoTCtlVraHtfh5XYijIjalXck7saUtuanSDyLMxnHhSXEDJqHxD7msR8D0uCmqlkwjCV8xvwHw=="], + + "fast-levenshtein": ["fast-levenshtein@2.0.6", "", {}, "sha512-DCXu6Ifhqcks7TZKY3Hxp3y6qphY5SJZmrWMDrKcERSOXWQdMhU9Ig/PYrzyw/ul9jOIyh0N4M0tbC5hodg8dw=="], + + "fastq": ["fastq@1.20.1", "", { "dependencies": { "reusify": "^1.0.4" } }, "sha512-GGToxJ/w1x32s/D2EKND7kTil4n8OVk/9mycTc4VDza13lOvpUZTGX3mFSCtV9ksdGBVzvsyAVLM6mHFThxXxw=="], + + "fd-slicer": ["fd-slicer@1.1.0", "", { "dependencies": { "pend": "~1.2.0" } }, "sha512-cE1qsB/VwyQozZ+q1dGxR8LBYNZeofhEdUNGSMbQD3Gw2lAzX9Zb3uIU6Ebc/Fmyjo9AWWfnn0AUCHqtevs/8g=="], + + "fdir": ["fdir@6.5.0", "", { "peerDependencies": { "picomatch": "^3 || ^4" }, "optionalPeers": ["picomatch"] }, "sha512-tIbYtZbucOs0BRGqPJkshJUYdL+SDH7dVM8gjy+ERp3WAUjLEFJE+02kanyHtwjWOnwrKYBiwAmM0p4kLJAnXg=="], + + "file-entry-cache": ["file-entry-cache@6.0.1", "", { "dependencies": { "flat-cache": "^3.0.4" } }, "sha512-7Gps/XWymbLk2QLYK4NzpMOrYjMhdIxXuIvy2QBsLE6ljuodKvdkWs/cpyJJ3CVIVpH0Oi1Hvg1ovbMzLdFBBg=="], + + "fill-range": ["fill-range@7.1.1", "", { "dependencies": { "to-regex-range": "^5.0.1" } }, "sha512-YsGpe3WHLK8ZYi4tWDg2Jy3ebRz2rXowDxnld4bkQB00cc/1Zw9AWnC0i9ztDJitivtQvaI9KaLyKrc+hBW0yg=="], + + "find-up": ["find-up@5.0.0", "", { "dependencies": { "locate-path": "^6.0.0", "path-exists": "^4.0.0" } }, "sha512-78/PXT1wlLLDgTzDs7sjq9hzz0vXD+zn+7wypEe4fXQxCmdmqfGsEPQxmiCSQI3ajFV91bVSsvNtrJRiW6nGng=="], + + "flat-cache": ["flat-cache@3.2.0", "", { "dependencies": { "flatted": "^3.2.9", "keyv": "^4.5.3", "rimraf": "^3.0.2" } }, "sha512-CYcENa+FtcUKLmhhqyctpclsq7QF38pKjZHsGNiSQF5r4FtoKDWabFDl3hzaEQMvT1LHEysw5twgLvpYYb4vbw=="], + + "flatted": ["flatted@3.4.0", "", {}, "sha512-kC6Bb+ooptOIvWj5B63EQWkF0FEnNjV2ZNkLMLZRDDduIiWeFF4iKnslwhiWxjAdbg4NzTNo6h0qLuvFrcx+Sw=="], + + "for-each": ["for-each@0.3.5", "", { "dependencies": { "is-callable": "^1.2.7" } }, "sha512-dKx12eRCVIzqCxFGplyFKJMPvLEWgmNtUrpTiJIR5u97zEhRG8ySrtboPHZXx7daLxQVrl643cTzbab2tkQjxg=="], + + "fs-extra": ["fs-extra@11.3.4", "", { "dependencies": { "graceful-fs": "^4.2.0", "jsonfile": "^6.0.1", "universalify": "^2.0.0" } }, "sha512-CTXd6rk/M3/ULNQj8FBqBWHYBVYybQ3VPBw0xGKFe3tuH7ytT6ACnvzpIQ3UZtB8yvUKC2cXn1a+x+5EVQLovA=="], + + "fs.realpath": ["fs.realpath@1.0.0", "", {}, "sha512-OO0pH2lK6a0hZnAdau5ItzHPI6pUlvI7jMVnxUQRtw4owF2wk8lOSabtGDCTP4Ggrg2MbGnWO9X8K1t4+fGMDw=="], + + "fsevents": ["fsevents@2.3.3", "", { "os": "darwin" }, "sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw=="], + + "function-bind": ["function-bind@1.1.2", "", {}, "sha512-7XHNxH7qX9xG5mIwxkhumTox/MIRNcOgDrxWsMt2pAr23WHp6MrRlN7FBSFpCpr+oVO0F744iUgR82nJMfG2SA=="], + + "function.prototype.name": ["function.prototype.name@1.1.8", "", { "dependencies": { "call-bind": "^1.0.8", "call-bound": "^1.0.3", "define-properties": "^1.2.1", "functions-have-names": "^1.2.3", "hasown": "^2.0.2", "is-callable": "^1.2.7" } }, "sha512-e5iwyodOHhbMr/yNrc7fDYG4qlbIvI5gajyzPnb5TCwyhjApznQh1BMFou9b30SevY43gCJKXycoCBjMbsuW0Q=="], + + "functions-have-names": ["functions-have-names@1.2.3", "", {}, "sha512-xckBUXyTIqT97tq2x2AMb+g163b5JFysYk0x4qxNFwbfQkmNZoiRHb6sPzI9/QV33WeuvVYBUIiD4NzNIyqaRQ=="], + + "generator-function": ["generator-function@2.0.1", "", {}, "sha512-SFdFmIJi+ybC0vjlHN0ZGVGHc3lgE0DxPAT0djjVg+kjOnSqclqmj0KQ7ykTOLP6YxoqOvuAODGdcHJn+43q3g=="], + + "get-intrinsic": ["get-intrinsic@1.3.0", "", { "dependencies": { "call-bind-apply-helpers": "^1.0.2", "es-define-property": "^1.0.1", "es-errors": "^1.3.0", "es-object-atoms": "^1.1.1", "function-bind": "^1.1.2", "get-proto": "^1.0.1", "gopd": "^1.2.0", "has-symbols": "^1.1.0", "hasown": "^2.0.2", "math-intrinsics": "^1.1.0" } }, "sha512-9fSjSaos/fRIVIp+xSJlE6lfwhES7LNtKaCBIamHsjr2na1BiABJPo0mOjjz8GJDURarmCPGqaiVg5mfjb98CQ=="], + + "get-proto": ["get-proto@1.0.1", "", { "dependencies": { "dunder-proto": "^1.0.1", "es-object-atoms": "^1.0.0" } }, "sha512-sTSfBjoXBp89JvIKIefqw7U2CCebsc74kiY6awiGogKtoSGbgjYE/G/+l9sF3MWFPNc9IcoOC4ODfKHfxFmp0g=="], + + "get-symbol-description": ["get-symbol-description@1.1.0", "", { "dependencies": { "call-bound": "^1.0.3", "es-errors": "^1.3.0", "get-intrinsic": "^1.2.6" } }, "sha512-w9UMqWwJxHNOvoNzSJ2oPF5wvYcvP7jUvYzhp67yEhTi17ZDBBC1z9pTdGuzjD+EFIqLSYRweZjqfiPzQ06Ebg=="], + + "github-slugger": ["github-slugger@1.5.0", "", {}, "sha512-wIh+gKBI9Nshz2o46B0B3f5k/W+WI9ZAv6y5Dn5WJ5SK1t0TnDimB4WE5rmTD05ZAIn8HALCZVmCsvj0w0v0lw=="], + + "glob": ["glob@13.0.6", "", { "dependencies": { "minimatch": "^10.2.2", "minipass": "^7.1.3", "path-scurry": "^2.0.2" } }, "sha512-Wjlyrolmm8uDpm/ogGyXZXb1Z+Ca2B8NbJwqBVg0axK9GbBeoS7yGV6vjXnYdGm6X53iehEuxxbyiKp8QmN4Vw=="], + + "glob-parent": ["glob-parent@6.0.2", "", { "dependencies": { "is-glob": "^4.0.3" } }, "sha512-XxwI8EOhVQgWp6iDL+3b0r86f4d6AX6zSU55HfB4ydCEuXLXc5FcYeOu+nnGftS4TEju/11rt4KJPTMgbfmv4A=="], + + "globals": ["globals@13.24.0", "", { "dependencies": { "type-fest": "^0.20.2" } }, "sha512-AhO5QUcj8llrbG09iWhPU2B204J1xnPeL8kQmVorSsy+Sjj1sk8gIyh6cUocGmH4L0UuhAJy+hJMRA4mgA4mFQ=="], + + "globalthis": ["globalthis@1.0.4", "", { "dependencies": { "define-properties": "^1.2.1", "gopd": "^1.0.1" } }, "sha512-DpLKbNU4WylpxJykQujfCcwYWiV/Jhm50Goo0wrVILAv5jOr9d+H+UR3PhSCD2rCCEIg0uc+G+muBTwD54JhDQ=="], + + "globby": ["globby@11.1.0", "", { "dependencies": { "array-union": "^2.1.0", "dir-glob": "^3.0.1", "fast-glob": "^3.2.9", "ignore": "^5.2.0", "merge2": "^1.4.1", "slash": "^3.0.0" } }, "sha512-jhIXaOzy1sb8IyocaruWSn1TjmnBVs8Ayhcy83rmxNJ8q2uWKCAj3CnJY+KpGSXCueAPc0i05kVvVKtP1t9S3g=="], + + "gopd": ["gopd@1.2.0", "", {}, "sha512-ZUKRh6/kUFoAiTAtTYPZJ3hw9wNxx+BIBOijnlG9PnrJsCcSjs1wyyD6vJpaYtgnzDrKYRSqf3OO6Rfa93xsRg=="], + + "graceful-fs": ["graceful-fs@4.2.11", "", {}, "sha512-RbJ5/jmFcNNCcDV5o9eTnBLJ/HszWV0P73bc+Ff4nS/rJj+YaS6IGyiOL0VoBYX+l1Wrl3k63h/KrH+nhJ0XvQ=="], + + "graphemer": ["graphemer@1.4.0", "", {}, "sha512-EtKwoO6kxCL9WO5xipiHTZlSzBm7WLT627TqC/uVRd0HKmq8NXyebnNYxDoBi7wt8eTWrUrKXCOVaFq9x1kgag=="], + + "has-bigints": ["has-bigints@1.1.0", "", {}, "sha512-R3pbpkcIqv2Pm3dUwgjclDRVmWpTJW2DcMzcIhEXEx1oh/CEMObMm3KLmRJOdvhM7o4uQBnwr8pzRK2sJWIqfg=="], + + "has-flag": ["has-flag@4.0.0", "", {}, "sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ=="], + + "has-property-descriptors": ["has-property-descriptors@1.0.2", "", { "dependencies": { "es-define-property": "^1.0.0" } }, "sha512-55JNKuIW+vq4Ke1BjOTjM2YctQIvCT7GFzHwmfZPGo5wnrgkid0YQtnAleFSqumZm4az3n2BS+erby5ipJdgrg=="], + + "has-proto": ["has-proto@1.2.0", "", { "dependencies": { "dunder-proto": "^1.0.0" } }, "sha512-KIL7eQPfHQRC8+XluaIw7BHUwwqL19bQn4hzNgdr+1wXoU0KKj6rufu47lhY7KbJR2C6T6+PfyN0Ea7wkSS+qQ=="], + + "has-symbols": ["has-symbols@1.1.0", "", {}, "sha512-1cDNdwJ2Jaohmb3sg4OmKaMBwuC48sYni5HUw2DvsC8LjGTLK9h+eb1X6RyuOHe4hT0ULCW68iomhjUoKUqlPQ=="], + + "has-tostringtag": ["has-tostringtag@1.0.2", "", { "dependencies": { "has-symbols": "^1.0.3" } }, "sha512-NqADB8VjPFLM2V0VvHUewwwsw0ZWBaIdgo+ieHtK3hasLz4qeCRjYcqfB6AQrBggRKppKF8L52/VqdVsO47Dlw=="], + + "hasown": ["hasown@2.0.2", "", { "dependencies": { "function-bind": "^1.1.2" } }, "sha512-0hJU9SCPvmMzIBdZFqNPXWa6dqh7WdH0cII9y+CyS8rG3nL48Bclra9HmKhVVUHyPWNH5Y7xDwAB7bfgSjkUMQ=="], + + "husky": ["husky@9.1.7", "", { "bin": { "husky": "bin.js" } }, "sha512-5gs5ytaNjBrh5Ow3zrvdUUY+0VxIuWVL4i9irt6friV+BqdCfmV11CQTWMiBYWHbXhco+J1kHfTOUkePhCDvMA=="], + + "ignore": ["ignore@5.3.2", "", {}, "sha512-hsBTNUqQTDwkWtcdYI2i06Y/nUBEsNEDJKjWdigLvegy8kDuJAS8uRlpkkcQpyEXL0Z/pjDy5HBmMjRCJ2gq+g=="], + + "import-fresh": ["import-fresh@3.3.1", "", { "dependencies": { "parent-module": "^1.0.0", "resolve-from": "^4.0.0" } }, "sha512-TR3KfrTZTYLPB6jUjfx6MF9WcWrHL9su5TObK4ZkYgBdWKPOFoSoQIdEuTuR82pmtxH2spWG9h6etwfr1pLBqQ=="], + + "imurmurhash": ["imurmurhash@0.1.4", "", {}, "sha512-JmXMZ6wuvDmLiHEml9ykzqO6lwFbof0GG4IkcGaENdCRDDmMVnny7s5HsIgHCbaq0w2MyPhDqkhTUgS2LU2PHA=="], + + "inflight": ["inflight@1.0.6", "", { "dependencies": { "once": "^1.3.0", "wrappy": "1" } }, "sha512-k92I/b08q4wvFscXCLvqfsHCrjrF7yiXsQuIVvVE7N82W3+aqpzuUdBbfhWcy/FZR3/4IgflMgKLOsvPDrGCJA=="], + + "inherits": ["inherits@2.0.4", "", {}, "sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ=="], + + "ini": ["ini@4.1.3", "", {}, "sha512-X7rqawQBvfdjS10YU1y1YVreA3SsLrW9dX2CewP2EbBJM4ypVNLDkO5y04gejPwKIY9lR+7r9gn3rFPt/kmWFg=="], + + "internal-slot": ["internal-slot@1.1.0", "", { "dependencies": { "es-errors": "^1.3.0", "hasown": "^2.0.2", "side-channel": "^1.1.0" } }, "sha512-4gd7VpWNQNB4UKKCFFVcp1AVv+FMOgs9NKzjHKusc8jTMhd5eL1NqQqOpE0KzMds804/yHlglp3uxgluOqAPLw=="], + + "is-array-buffer": ["is-array-buffer@3.0.5", "", { "dependencies": { "call-bind": "^1.0.8", "call-bound": "^1.0.3", "get-intrinsic": "^1.2.6" } }, "sha512-DDfANUiiG2wC1qawP66qlTugJeL5HyzMpfr8lLK+jMQirGzNod0B12cFB/9q838Ru27sBwfw78/rdoU7RERz6A=="], + + "is-arrayish": ["is-arrayish@0.2.1", "", {}, "sha512-zz06S8t0ozoDXMG+ube26zeCTNXcKIPJZJi8hBrF4idCLms4CG9QtK7qBl1boi5ODzFpjswb5JPmHCbMpjaYzg=="], + + "is-async-function": ["is-async-function@2.1.1", "", { "dependencies": { "async-function": "^1.0.0", "call-bound": "^1.0.3", "get-proto": "^1.0.1", "has-tostringtag": "^1.0.2", "safe-regex-test": "^1.1.0" } }, "sha512-9dgM/cZBnNvjzaMYHVoxxfPj2QXt22Ev7SuuPrs+xav0ukGB0S6d4ydZdEiM48kLx5kDV+QBPrpVnFyefL8kkQ=="], + + "is-bigint": ["is-bigint@1.1.0", "", { "dependencies": { "has-bigints": "^1.0.2" } }, "sha512-n4ZT37wG78iz03xPRKJrHTdZbe3IicyucEtdRsV5yglwc3GyUfbAfpSeD0FJ41NbUNSt5wbhqfp1fS+BgnvDFQ=="], + + "is-boolean-object": ["is-boolean-object@1.2.2", "", { "dependencies": { "call-bound": "^1.0.3", "has-tostringtag": "^1.0.2" } }, "sha512-wa56o2/ElJMYqjCjGkXri7it5FbebW5usLw/nPmCMs5DeZ7eziSYZhSmPRn0txqeW4LnAmQQU7FgqLpsEFKM4A=="], + + "is-callable": ["is-callable@1.2.7", "", {}, "sha512-1BC0BVFhS/p0qtw6enp8e+8OD0UrK0oFLztSjNzhcKA3WDuJxxAPXzPuPtKkjEY9UUoEWlX/8fgKeu2S8i9JTA=="], + + "is-core-module": ["is-core-module@2.16.1", "", { "dependencies": { "hasown": "^2.0.2" } }, "sha512-UfoeMA6fIJ8wTYFEUjelnaGI67v6+N7qXJEvQuIGa99l4xsCruSYOVSQ0uPANn4dAzm8lkYPaKLrrijLq7x23w=="], + + "is-data-view": ["is-data-view@1.0.2", "", { "dependencies": { "call-bound": "^1.0.2", "get-intrinsic": "^1.2.6", "is-typed-array": "^1.1.13" } }, "sha512-RKtWF8pGmS87i2D6gqQu/l7EYRlVdfzemCJN/P3UOs//x1QE7mfhvzHIApBTRf7axvT6DMGwSwBXYCT0nfB9xw=="], + + "is-date-object": ["is-date-object@1.1.0", "", { "dependencies": { "call-bound": "^1.0.2", "has-tostringtag": "^1.0.2" } }, "sha512-PwwhEakHVKTdRNVOw+/Gyh0+MzlCl4R6qKvkhuvLtPMggI1WAHt9sOwZxQLSGpUaDnrdyDsomoRgNnCfKNSXXg=="], + + "is-docker": ["is-docker@2.2.1", "", { "bin": { "is-docker": "cli.js" } }, "sha512-F+i2BKsFrH66iaUFc0woD8sLy8getkwTwtOBjvs56Cx4CgJDeKQeqfz8wAYiSb8JOprWhHH5p77PbmYCvvUuXQ=="], + + "is-extglob": ["is-extglob@2.1.1", "", {}, "sha512-SbKbANkN603Vi4jEZv49LeVJMn4yGwsbzZworEoyEiutsN3nJYdbO36zfhGJ6QEDpOZIFkDtnq5JRxmvl3jsoQ=="], + + "is-finalizationregistry": ["is-finalizationregistry@1.1.1", "", { "dependencies": { "call-bound": "^1.0.3" } }, "sha512-1pC6N8qWJbWoPtEjgcL2xyhQOP491EQjeUo3qTKcmV8YSDDJrOepfG8pcC7h/QgnQHYSv0mJ3Z/ZWxmatVrysg=="], + + "is-fullwidth-code-point": ["is-fullwidth-code-point@3.0.0", "", {}, "sha512-zymm5+u+sCsSWyD9qNaejV3DFvhCKclKdizYaJUuHA83RLjb7nSuGnddCHGv0hk+KY7BMAlsWeK4Ueg6EV6XQg=="], + + "is-generator-function": ["is-generator-function@1.1.2", "", { "dependencies": { "call-bound": "^1.0.4", "generator-function": "^2.0.0", "get-proto": "^1.0.1", "has-tostringtag": "^1.0.2", "safe-regex-test": "^1.1.0" } }, "sha512-upqt1SkGkODW9tsGNG5mtXTXtECizwtS2kA161M+gJPc1xdb/Ax629af6YrTwcOeQHbewrPNlE5Dx7kzvXTizA=="], + + "is-glob": ["is-glob@4.0.3", "", { "dependencies": { "is-extglob": "^2.1.1" } }, "sha512-xelSayHH36ZgE7ZWhli7pW34hNbNl8Ojv5KVmkJD4hBdD3th8Tfk9vYasLM+mXWOZhFkgZfxhLSnrwRr4elSSg=="], + + "is-map": ["is-map@2.0.3", "", {}, "sha512-1Qed0/Hr2m+YqxnM09CjA2d/i6YZNfF6R2oRAOj36eUdS6qIV/huPJNSEpKbupewFs+ZsJlxsjjPbc0/afW6Lw=="], + + "is-negative-zero": ["is-negative-zero@2.0.3", "", {}, "sha512-5KoIu2Ngpyek75jXodFvnafB6DJgr3u8uuK0LEZJjrU19DrMD3EVERaR8sjz8CCGgpZvxPl9SuE1GMVPFHx1mw=="], + + "is-number": ["is-number@7.0.0", "", {}, "sha512-41Cifkg6e8TylSpdtTpeLVMqvSBEVzTttHvERD741+pnZ8ANv0004MRL43QKPDlK9cGvNp6NZWZUBlbGXYxxng=="], + + "is-number-object": ["is-number-object@1.1.1", "", { "dependencies": { "call-bound": "^1.0.3", "has-tostringtag": "^1.0.2" } }, "sha512-lZhclumE1G6VYD8VHe35wFaIif+CTy5SJIi5+3y4psDgWu4wPDoBhF8NxUOinEc7pHgiTsT6MaBb92rKhhD+Xw=="], + + "is-path-inside": ["is-path-inside@3.0.3", "", {}, "sha512-Fd4gABb+ycGAmKou8eMftCupSir5lRxqf4aD/vd0cD2qc4HL07OjCeuHMr8Ro4CoMaeCKDB0/ECBOVWjTwUvPQ=="], + + "is-regex": ["is-regex@1.2.1", "", { "dependencies": { "call-bound": "^1.0.2", "gopd": "^1.2.0", "has-tostringtag": "^1.0.2", "hasown": "^2.0.2" } }, "sha512-MjYsKHO5O7mCsmRGxWcLWheFqN9DJ/2TmngvjKXihe6efViPqc274+Fx/4fYj/r03+ESvBdTXK0V6tA3rgez1g=="], + + "is-set": ["is-set@2.0.3", "", {}, "sha512-iPAjerrse27/ygGLxw+EBR9agv9Y6uLeYVJMu+QNCoouJ1/1ri0mGrcWpfCqFZuzzx3WjtwxG098X+n4OuRkPg=="], + + "is-shared-array-buffer": ["is-shared-array-buffer@1.0.4", "", { "dependencies": { "call-bound": "^1.0.3" } }, "sha512-ISWac8drv4ZGfwKl5slpHG9OwPNty4jOWPRIhBpxOoD+hqITiwuipOQ2bNthAzwA3B4fIjO4Nln74N0S9byq8A=="], + + "is-string": ["is-string@1.1.1", "", { "dependencies": { "call-bound": "^1.0.3", "has-tostringtag": "^1.0.2" } }, "sha512-BtEeSsoaQjlSPBemMQIrY1MY0uM6vnS1g5fmufYOtnxLGUZM2178PKbhsk7Ffv58IX+ZtcvoGwccYsh0PglkAA=="], + + "is-symbol": ["is-symbol@1.1.1", "", { "dependencies": { "call-bound": "^1.0.2", "has-symbols": "^1.1.0", "safe-regex-test": "^1.1.0" } }, "sha512-9gGx6GTtCQM73BgmHQXfDmLtfjjTUDSyoxTCbp5WtoixAhfgsDirWIcVQ/IHpvI5Vgd5i/J5F7B9cN/WlVbC/w=="], + + "is-typed-array": ["is-typed-array@1.1.15", "", { "dependencies": { "which-typed-array": "^1.1.16" } }, "sha512-p3EcsicXjit7SaskXHs1hA91QxgTw46Fv6EFKKGS5DRFLD8yKnohjF3hxoju94b/OcMZoQukzpPpBE9uLVKzgQ=="], + + "is-weakmap": ["is-weakmap@2.0.2", "", {}, "sha512-K5pXYOm9wqY1RgjpL3YTkF39tni1XajUIkawTLUo9EZEVUFga5gSQJF8nNS7ZwJQ02y+1YCNYcMh+HIf1ZqE+w=="], + + "is-weakref": ["is-weakref@1.1.1", "", { "dependencies": { "call-bound": "^1.0.3" } }, "sha512-6i9mGWSlqzNMEqpCp93KwRS1uUOodk2OJ6b+sq7ZPDSy2WuI5NFIxp/254TytR8ftefexkWn5xNiHUNpPOfSew=="], + + "is-weakset": ["is-weakset@2.0.4", "", { "dependencies": { "call-bound": "^1.0.3", "get-intrinsic": "^1.2.6" } }, "sha512-mfcwb6IzQyOKTs84CQMrOwW4gQcaTOAWJ0zzJCl2WSPDrWk/OzDaImWFH3djXhb24g4eudZfLRozAvPGw4d9hQ=="], + + "is-wsl": ["is-wsl@2.2.0", "", { "dependencies": { "is-docker": "^2.0.0" } }, "sha512-fKzAra0rGJUUBwGBgNkHZuToZcn+TtXHpeCgmkMJMMYx1sQDYaCSyjJBSCa2nH1DGm7s3n1oBnohoVTBaN7Lww=="], + + "isarray": ["isarray@2.0.5", "", {}, "sha512-xHjhDr3cNBK0BzdUJSPXZntQUx/mwMS5Rw4A7lPJ90XGAO6ISP/ePDNuo0vhqOZU+UD5JoodwCAAoZQd3FeAKw=="], + + "isexe": ["isexe@2.0.0", "", {}, "sha512-RHxMLp9lnKHGHRng9QFhRCMbYAcVpn69smSGcq3f36xjgVVWThj4qqLbTLlq7Ssj8B+fIQ1EuCEGI2lKsyQeIw=="], + + "java-parser": ["java-parser@3.0.1", "", { "dependencies": { "chevrotain": "11.0.3", "chevrotain-allstar": "0.3.1", "lodash": "4.17.21" } }, "sha512-sDIR7u9b7O2JViNUxiZRhnRz7URII/eE7g2B+BmGxDeS6Ex3OYAcCyz5oh0H4LQ+hL/BS8OJTz8apMy9xtGmrQ=="], + + "js-tokens": ["js-tokens@4.0.0", "", {}, "sha512-RdJUflcE3cUzKiMqQgsCu06FPu9UdIJO0beYbPhHN4k6apgJtifcoCtT9bcxOpYBtpD2kCM6Sbzg4CausW/PKQ=="], + + "js-yaml": ["js-yaml@4.1.1", "", { "dependencies": { "argparse": "^2.0.1" }, "bin": { "js-yaml": "bin/js-yaml.js" } }, "sha512-qQKT4zQxXl8lLwBtHMWwaTcGfFOZviOJet3Oy/xmGk2gZH677CJM9EvtfdSkgWcATZhj/55JZ0rmy3myCT5lsA=="], + + "json-buffer": ["json-buffer@3.0.1", "", {}, "sha512-4bV5BfR2mqfQTJm+V5tPPdf+ZpuhiIvTuAB5g8kcrXOZpTT/QwwVRWBywX1ozr6lEuPdbHxwaJlm9G6mI2sfSQ=="], + + "json-parse-even-better-errors": ["json-parse-even-better-errors@2.3.1", "", {}, "sha512-xyFwyhro/JEof6Ghe2iz2NcXoj2sloNsWr/XsERDK/oiPCfaNhl5ONfp+jQdAZRQQ0IJWNzH9zIZF7li91kh2w=="], + + "json-schema-traverse": ["json-schema-traverse@0.4.1", "", {}, "sha512-xbbCH5dCYU5T8LcEhhuh7HJ88HXuW3qsI3Y0zOZFKfZEHcpWiHU/Jxzk629Brsab/mMiHQti9wMP+845RPe3Vg=="], + + "json-stable-stringify-without-jsonify": ["json-stable-stringify-without-jsonify@1.0.1", "", {}, "sha512-Bdboy+l7tA3OGW6FjyFHWkP5LuByj1Tk33Ljyq0axyzdk9//JSi2u3fP1QSmd1KNwq6VOKYGlAu87CisVir6Pw=="], + + "json5": ["json5@1.0.2", "", { "dependencies": { "minimist": "^1.2.0" }, "bin": { "json5": "lib/cli.js" } }, "sha512-g1MWMLBiz8FKi1e4w0UyVL3w+iJceWAFBAaBnnGKOpNa5f8TLktkbre1+s6oICydWAm+HRUGTmI+//xv2hvXYA=="], + + "jsonfile": ["jsonfile@6.2.0", "", { "dependencies": { "universalify": "^2.0.0" }, "optionalDependencies": { "graceful-fs": "^4.1.6" } }, "sha512-FGuPw30AdOIUTRMC2OMRtQV+jkVj2cfPqSeWXv1NEAJ1qZ5zb1X6z1mFhbfOB/iy3ssJCD+3KuZ8r8C3uVFlAg=="], + + "keyv": ["keyv@4.5.4", "", { "dependencies": { "json-buffer": "3.0.1" } }, "sha512-oxVHkHR/EJf2CNXnWxRLW6mg7JyCCUcG0DtEGmL2ctUo1PNTin1PUil+r/+4r5MpVgC/fn1kjsx7mjSujKqIpw=="], + + "kleur": ["kleur@4.1.5", "", {}, "sha512-o+NO+8WrRiQEE4/7nwRJhN1HWpVmJm511pBHUxPLtp0BUISzlBplORYSmTclCnJvQq2tKu/sgl3xVpkc7ZWuQQ=="], + + "levn": ["levn@0.4.1", "", { "dependencies": { "prelude-ls": "^1.2.1", "type-check": "~0.4.0" } }, "sha512-+bT2uH4E5LGE7h/n3evcS/sQlJXCpIp6ym8OWJ5eV6+67Dsql/LaaT7qJBAt2rzfoa/5QBGBhxDix1dMt2kQKQ=="], + + "lightningcss": ["lightningcss@1.33.0", "", { "dependencies": { "detect-libc": "^2.0.3" }, "optionalDependencies": { "lightningcss-android-arm64": "1.33.0", "lightningcss-darwin-arm64": "1.33.0", "lightningcss-darwin-x64": "1.33.0", "lightningcss-freebsd-x64": "1.33.0", "lightningcss-linux-arm-gnueabihf": "1.33.0", "lightningcss-linux-arm64-gnu": "1.33.0", "lightningcss-linux-arm64-musl": "1.33.0", "lightningcss-linux-x64-gnu": "1.33.0", "lightningcss-linux-x64-musl": "1.33.0", "lightningcss-win32-arm64-msvc": "1.33.0", "lightningcss-win32-x64-msvc": "1.33.0" } }, "sha512-WkUDrojuJs0xkgGf2udWxa3yGBRxPtxUkB79i6aCZLRgc7PM8fZe9TosfPDcvEpQZbuFASnHYmRLBLUbmLOIIA=="], + + "lightningcss-android-arm64": ["lightningcss-android-arm64@1.33.0", "", { "os": "android", "cpu": "arm64" }, "sha512-gEpRTalKdosp4Bb8qWtc2iOgE5SeIHlpS1up9bFq2wAyYhl1UdTObYiHe98zEM9SQvSoqQZ1IQD0JNpg3Ml5pg=="], + + "lightningcss-darwin-arm64": ["lightningcss-darwin-arm64@1.33.0", "", { "os": "darwin", "cpu": "arm64" }, "sha512-Sciaz8eenNTKn9b3t7+xr0ipTp9YxKQY4npwQ3mrRuL0BAVHBLyZxofhaKBAVtzmtRZ/zTyo0/to4B1uWG/Djg=="], + + "lightningcss-darwin-x64": ["lightningcss-darwin-x64@1.33.0", "", { "os": "darwin", "cpu": "x64" }, "sha512-Z5UPAxzrjlWNNyGy6i65cJzzvgJ5D3T6wMvs+gWpY9d7qRhANrxqAp6LhxIgZhWEw18RfJTGcRxjuLIBr+m8XQ=="], + + "lightningcss-freebsd-x64": ["lightningcss-freebsd-x64@1.33.0", "", { "os": "freebsd", "cpu": "x64" }, "sha512-QQM/Ti/hQajJwCY+RiWuCZ9sdtI/XQk7nDK5vC8kkdwixezOlDgvDx7+RT+QjK6FcFT4MpsuoBnHIo/O3StRRg=="], + + "lightningcss-linux-arm-gnueabihf": ["lightningcss-linux-arm-gnueabihf@1.33.0", "", { "os": "linux", "cpu": "arm" }, "sha512-N7FVBe6iS24MlM6R/4RBTxGhQheZGs7tiQ9U32UtF75NzP5Q7xWPRqLBCKxlRQRk3rY1jCIPLzx7WzOhuUIRLQ=="], + + "lightningcss-linux-arm64-gnu": ["lightningcss-linux-arm64-gnu@1.33.0", "", { "os": "linux", "cpu": "arm64" }, "sha512-j2v/itmy4HlNxlc6voKXYgBqNi0Ng2LShg4z7GufpEgs05P+2suBVyi9I6YHq5uoVFx9ETin3eCEhLVyXGQnKg=="], + + "lightningcss-linux-arm64-musl": ["lightningcss-linux-arm64-musl@1.33.0", "", { "os": "linux", "cpu": "arm64" }, "sha512-yiO5ROMuYQgXbC60yjZU5CYSFZGKXL0HFATXt9mHJn1+zW55oCtMI9NfcVhYLMFDL7gV7oBPon/EmMMGg2OvtQ=="], + + "lightningcss-linux-x64-gnu": ["lightningcss-linux-x64-gnu@1.33.0", "", { "os": "linux", "cpu": "x64" }, "sha512-ar+Ju7LmcN0Jo4FpL4hpFybwNG9/3A/Br5KW2n2jyODg3MEZXaDYADdemoNS+BDNfMgKvylJLj4S5tyRActuAg=="], + + "lightningcss-linux-x64-musl": ["lightningcss-linux-x64-musl@1.33.0", "", { "os": "linux", "cpu": "x64" }, "sha512-RYiYbkokw0trfKqqzfF55lginwEPrD3OJDfTuJzFs1MK6iFnDenaz1fqLLtX4ITG3OktJQXOeTaw1awrBAlZPw=="], + + "lightningcss-win32-arm64-msvc": ["lightningcss-win32-arm64-msvc@1.33.0", "", { "os": "win32", "cpu": "arm64" }, "sha512-1K+MPfLSFVpphzpdbfkhlWk6wBrTObBzS2T6db10PNOZgR9GoVsAWzwNyuhUYYbTp23j+4RrncfujZ4uAzXvwA=="], + + "lightningcss-win32-x64-msvc": ["lightningcss-win32-x64-msvc@1.33.0", "", { "os": "win32", "cpu": "x64" }, "sha512-OlEICDx/Xl0FqSp4bry8zFnCvGpig3Gl4gCquvYwHuqJKEC1+n9NgDniFvqHGmMv1ZkqDJrDqKKSykTDX+ehuA=="], + + "lines-and-columns": ["lines-and-columns@1.2.4", "", {}, "sha512-7ylylesZQ/PV29jhEDl3Ufjo6ZX7gCqJr5F7PKrqc93v7fzSymt1BpwEU8nAUXs8qzzvqhbjhK5QZg6Mt/HkBg=="], + + "locate-path": ["locate-path@6.0.0", "", { "dependencies": { "p-locate": "^5.0.0" } }, "sha512-iPZK6eYjbxRu3uB4/WZ3EsEIMJFMqAoopl3R+zuq0UjcAm/MO6KCweDgPfP3elTztoKP3KtnVHxTn2NHBSDVUw=="], + + "lodash": ["lodash@4.17.21", "", {}, "sha512-v2kDEe57lecTulaDIuNTPy3Ry4gLGJ6Z1O3vE1krgXZNrsQ+LFTGHVxVjcXPs17LhbZVGedAJv8XZ1tvj5FvSg=="], + + "lodash-es": ["lodash-es@4.17.21", "", {}, "sha512-mKnC+QJ9pWVzv+C4/U3rRsHapFfHvQFoFB92e52xeyGMcX6/OlIl78je1u8vePzYZSkkogMPJ2yjxxsb89cxyw=="], + + "lodash.merge": ["lodash.merge@4.6.2", "", {}, "sha512-0KpjqXRVvrYyCsX1swR/XTK0va6VQkQM6MNo7PqW77ByjAhoARA8EfrP1N4+KlKj8YS0ZUCtRT/YUuhyYDujIQ=="], + + "loose-envify": ["loose-envify@1.4.0", "", { "dependencies": { "js-tokens": "^3.0.0 || ^4.0.0" }, "bin": { "loose-envify": "cli.js" } }, "sha512-lyuxPGr/Wfhrlem2CL/UcnUc1zcqKAImBDzukY7Y5F/yQiNdko6+fRLevlw1HgMySw7f611UIY408EtxRSoK3Q=="], + + "lru-cache": ["lru-cache@11.2.6", "", {}, "sha512-ESL2CrkS/2wTPfuend7Zhkzo2u0daGJ/A2VucJOgQ/C48S/zB8MMeMHSGKYpXhIjbPxfuezITkaBH1wqv00DDQ=="], + + "math-intrinsics": ["math-intrinsics@1.1.0", "", {}, "sha512-/IXtbwEk5HTPyEwyKX6hGkYXxM9nbj64B+ilVJnC/R6B0pH5G4V3b0pVbL7DBj4tkhBAppbQUlf6F6Xl9LHu1g=="], + + "merge2": ["merge2@1.4.1", "", {}, "sha512-8q7VEgMJW4J8tcfVPy8g09NcQwZdbwFEqhe/WZkoIzjn/3TGDwtOCYtXGxA3O8tPzpczCCDgv+P2P5y00ZJOOg=="], + + "micromatch": ["micromatch@4.0.8", "", { "dependencies": { "braces": "^3.0.3", "picomatch": "^2.3.1" } }, "sha512-PXwfBhYu0hBCPw8Dn0E+WDYb7af3dSLVWKi3HGv84IdF4TyFoC0ysxFd0Goxw7nSv4T/PzEJQxsYsEiFCKo2BA=="], + + "minimatch": ["minimatch@3.1.5", "", { "dependencies": { "brace-expansion": "^1.1.7" } }, "sha512-VgjWUsnnT6n+NUk6eZq77zeFdpW2LWDzP6zFGrCbHXiYNul5Dzqk2HHQ5uFH2DNW5Xbp8+jVzaeNt94ssEEl4w=="], + + "minimist": ["minimist@1.2.8", "", {}, "sha512-2yyAR8qBkN3YuheJanUpWC5U3bb5osDywNB8RzDVlDwDHbocAJveqqj1u8+SVD7jkWT4yvsHCpWqqWqAxb0zCA=="], + + "minipass": ["minipass@7.1.3", "", {}, "sha512-tEBHqDnIoM/1rXME1zgka9g6Q2lcoCkxHLuc7ODJ5BxbP5d4c2Z5cGgtXAku59200Cx7diuHTOYfSBD8n6mm8A=="], + + "minizlib": ["minizlib@3.1.0", "", { "dependencies": { "minipass": "^7.1.2" } }, "sha512-KZxYo1BUkWD2TVFLr0MQoM8vUUigWD3LlD83a/75BqC+4qE0Hb1Vo5v1FgcfaNXvfXzr+5EhQ6ing/CaBijTlw=="], + + "ms": ["ms@2.1.3", "", {}, "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA=="], + + "nanoid": ["nanoid@3.3.19", "", { "bin": { "nanoid": "bin/nanoid.cjs" } }, "sha512-Y2tUNy4ouw6tq5oDSKeQYGOyhkUBhNOcGV/02KC+6kd9eDGqdZd++mjMiIDilrBYvjEnCYvVtsuHCuP+okSfug=="], + + "native-run": ["native-run@2.0.3", "", { "dependencies": { "@ionic/utils-fs": "^3.1.7", "@ionic/utils-terminal": "^2.3.4", "bplist-parser": "^0.3.2", "debug": "^4.3.4", "elementtree": "^0.1.7", "ini": "^4.1.1", "plist": "^3.1.0", "split2": "^4.2.0", "through2": "^4.0.2", "tslib": "^2.6.2", "yauzl": "^2.10.0" }, "bin": { "native-run": "bin/native-run" } }, "sha512-U1PllBuzW5d1gfan+88L+Hky2eZx+9gv3Pf6rNBxKbORxi7boHzqiA6QFGSnqMem4j0A9tZ08NMIs5+0m/VS1Q=="], + + "natural-compare": ["natural-compare@1.4.0", "", {}, "sha512-OWND8ei3VtNC9h7V60qff3SVobHr996CTwgxubgyQYEpg290h9J0buyECNNJexkFm5sOajh5G116RYA1c8ZMSw=="], + + "natural-compare-lite": ["natural-compare-lite@1.4.0", "", {}, "sha512-Tj+HTDSJJKaZnfiuw+iaF9skdPpTo2GtEly5JHnWV/hfv2Qj/9RKsGISQtLh2ox3l5EAGw487hnBee0sIJ6v2g=="], + + "object-inspect": ["object-inspect@1.13.4", "", {}, "sha512-W67iLl4J2EXEGTbfeHCffrjDfitvLANg0UlX3wFUUSTx92KXRFegMHUVgSqE+wvhAbi4WqjGg9czysTV2Epbew=="], + + "object-keys": ["object-keys@1.1.1", "", {}, "sha512-NuAESUOUMrlIXOfHKzD6bpPu3tYt3xvjNdRIQ+FeT0lNb4K8WR70CaDxhuNguS2XG+GjkyMwOzsN5ZktImfhLA=="], + + "object.assign": ["object.assign@4.1.7", "", { "dependencies": { "call-bind": "^1.0.8", "call-bound": "^1.0.3", "define-properties": "^1.2.1", "es-object-atoms": "^1.0.0", "has-symbols": "^1.1.0", "object-keys": "^1.1.1" } }, "sha512-nK28WOo+QIjBkDduTINE4JkF/UJJKyf2EJxvJKfblDpyg0Q+pkOHNTL0Qwy6NP6FhE/EnzV73BxxqcJaXY9anw=="], + + "object.fromentries": ["object.fromentries@2.0.8", "", { "dependencies": { "call-bind": "^1.0.7", "define-properties": "^1.2.1", "es-abstract": "^1.23.2", "es-object-atoms": "^1.0.0" } }, "sha512-k6E21FzySsSK5a21KRADBd/NGneRegFO5pLHfdQLpRDETUNJueLXs3WCzyQ3tFRDYgbq3KHGXfTbi2bs8WQ6rQ=="], + + "object.groupby": ["object.groupby@1.0.3", "", { "dependencies": { "call-bind": "^1.0.7", "define-properties": "^1.2.1", "es-abstract": "^1.23.2" } }, "sha512-+Lhy3TQTuzXI5hevh8sBGqbmurHbbIjAi0Z4S63nthVLmLxfbj4T54a4CfZrXIrt9iP4mVAPYMo/v99taj3wjQ=="], + + "object.values": ["object.values@1.2.1", "", { "dependencies": { "call-bind": "^1.0.8", "call-bound": "^1.0.3", "define-properties": "^1.2.1", "es-object-atoms": "^1.0.0" } }, "sha512-gXah6aZrcUxjWg2zR2MwouP2eHlCBzdV4pygudehaKXSGW4v2AsRQUK+lwwXhii6KFZcunEnmSUoYp5CXibxtA=="], + + "once": ["once@1.4.0", "", { "dependencies": { "wrappy": "1" } }, "sha512-lNaJgI+2Q5URQBkccEKHTQOPaXdUxnZZElQTZY0MFUAuaEqe1E+Nyvgdz/aIyNi6Z9MzO5dv1H8n58/GELp3+w=="], + + "open": ["open@8.4.2", "", { "dependencies": { "define-lazy-prop": "^2.0.0", "is-docker": "^2.1.1", "is-wsl": "^2.2.0" } }, "sha512-7x81NCL719oNbsq/3mh+hVrAWmFuEYUqrq/Iw3kUzH8ReypT9QQ0BLoJS7/G9k6N81XjW4qHWtjWwe/9eLy1EQ=="], + + "optionator": ["optionator@0.9.4", "", { "dependencies": { "deep-is": "^0.1.3", "fast-levenshtein": "^2.0.6", "levn": "^0.4.1", "prelude-ls": "^1.2.1", "type-check": "^0.4.0", "word-wrap": "^1.2.5" } }, "sha512-6IpQ7mKUxRcZNLIObR0hz7lxsapSSIYNZJwXPGeF0mTVqGKFIXj1DQcMoT22S3ROcLyY/rz0PWaWZ9ayWmad9g=="], + + "own-keys": ["own-keys@1.0.1", "", { "dependencies": { "get-intrinsic": "^1.2.6", "object-keys": "^1.1.1", "safe-push-apply": "^1.0.0" } }, "sha512-qFOyK5PjiWZd+QQIh+1jhdb9LpxTF0qs7Pm8o5QHYZ0M3vKqSqzsZaEB6oWlxZ+q2sJBMI/Ktgd2N5ZwQoRHfg=="], + + "p-limit": ["p-limit@3.1.0", "", { "dependencies": { "yocto-queue": "^0.1.0" } }, "sha512-TYOanM3wGwNGsZN2cVTYPArw454xnXj5qmWF1bEoAc4+cU/ol7GVh7odevjp1FNHduHc3KZMcFduxU5Xc6uJRQ=="], + + "p-locate": ["p-locate@5.0.0", "", { "dependencies": { "p-limit": "^3.0.2" } }, "sha512-LaNjtRWUBY++zB5nE/NwcaoMylSPk+S+ZHNB1TzdbMJMny6dynpAGt7X/tl/QYq3TIeE6nxHppbo2LGymrG5Pw=="], + + "package-json-from-dist": ["package-json-from-dist@1.0.1", "", {}, "sha512-UEZIS3/by4OC8vL3P2dTXRETpebLI2NiI5vIrjaD/5UtrkFX/tNbwjTSRAGC/+7CAo2pIcBaRgWmcBBHcsaCIw=="], + + "parent-module": ["parent-module@1.0.1", "", { "dependencies": { "callsites": "^3.0.0" } }, "sha512-GQ2EWRpQV8/o+Aw8YqtfZZPfNRWZYkbidE9k5rpl/hC3vtHHBfGm2Ifi6qWV+coDGkrUKZAxE3Lot5kcsRlh+g=="], + + "parse-json": ["parse-json@5.2.0", "", { "dependencies": { "@babel/code-frame": "^7.0.0", "error-ex": "^1.3.1", "json-parse-even-better-errors": "^2.3.0", "lines-and-columns": "^1.1.6" } }, "sha512-ayCKvm/phCGxOkYRSCM82iDwct8/EonSEgCSxWxD7ve6jHggsFl4fZVQBPRNgQoKiuV/odhFrGzQXZwbifC8Rg=="], + + "path-exists": ["path-exists@4.0.0", "", {}, "sha512-ak9Qy5Q7jYb2Wwcey5Fpvg2KoAc/ZIhLSLOSBmRmygPsGwkVVt0fZa0qrtMz+m6tJTAHfZQ8FnmB4MG4LWy7/w=="], + + "path-is-absolute": ["path-is-absolute@1.0.1", "", {}, "sha512-AVbw3UJ2e9bq64vSaS9Am0fje1Pa8pbGqTTsmXfaIiMpnr5DlDhfJOuLj9Sf95ZPVDAUerDfEk88MPmPe7UCQg=="], + + "path-key": ["path-key@3.1.1", "", {}, "sha512-ojmeN0qd+y0jszEtoY48r0Peq5dwMEkIlCOu6Q5f41lfkswXuKtYrhgoTpLnyIcHm24Uhqx+5Tqm2InSwLhE6Q=="], + + "path-parse": ["path-parse@1.0.7", "", {}, "sha512-LDJzPVEEEPR+y48z93A0Ed0yXb8pAByGWo/k5YYdYgpY2/2EsOsksJrq7lOHxryrVOn1ejG6oAp8ahvOIQD8sw=="], + + "path-scurry": ["path-scurry@2.0.2", "", { "dependencies": { "lru-cache": "^11.0.0", "minipass": "^7.1.2" } }, "sha512-3O/iVVsJAPsOnpwWIeD+d6z/7PmqApyQePUtCndjatj/9I5LylHvt5qluFaBT3I5h3r1ejfR056c+FCv+NnNXg=="], + + "path-type": ["path-type@4.0.0", "", {}, "sha512-gDKb8aZMDeD/tZWs9P6+q0J9Mwkdl6xMV8TjnGP3qJVJ06bdMgkbBlLU8IdfOsIsFz2BW1rNVT3XuNEl8zPAvw=="], + + "pend": ["pend@1.2.0", "", {}, "sha512-F3asv42UuXchdzt+xXqfW1OGlVBe+mxa2mqI0pg5yAHZPvFmY3Y6drSf/GQ1A86WgWEN9Kzh/WrgKa6iGcHXLg=="], + + "picocolors": ["picocolors@1.1.1", "", {}, "sha512-xceH2snhtb5M9liqDsmEw56le376mTZkEX/jEb/RxNFyegNul7eNslCXP9FDj/Lcu0X8KEyMceP2ntpaHrDEVA=="], + + "picomatch": ["picomatch@4.0.7", "", {}, "sha512-qcJu88Q2IWqJsDD529JKMdwGm/dvInW4HvQnRwiH9JtihJvzGOscDtHE3x1pBKeUOTysQ8kVmLnJ2kJu7yhcGA=="], + + "plist": ["plist@3.1.0", "", { "dependencies": { "@xmldom/xmldom": "^0.8.8", "base64-js": "^1.5.1", "xmlbuilder": "^15.1.1" } }, "sha512-uysumyrvkUX0rX/dEVqt8gC3sTBzd4zoWfLeS29nb53imdaXVvLINYXTI2GNqzaMuvacNx4uJQ8+b3zXR0pkgQ=="], + + "possible-typed-array-names": ["possible-typed-array-names@1.1.0", "", {}, "sha512-/+5VFTchJDoVj3bhoqi6UeymcD00DAwb1nJwamzPvHEszJ4FpF6SNNbUbOS8yI56qHzdV8eK0qEfOSiodkTdxg=="], + + "postcss": ["postcss@8.5.28", "", { "dependencies": { "nanoid": "^3.3.18", "picocolors": "^1.1.1", "source-map-js": "^1.2.1" } }, "sha512-RRuzqDtt5Y9h3quz5hWhK+TPnsmVs6WwSU6LkJMeY4HstUEDuYTG8UJSdawMRzmzAtV+KEoG8N3Qg2qLy5vM/A=="], + + "prelude-ls": ["prelude-ls@1.2.1", "", {}, "sha512-vkcDPrRZo1QZLbn5RLGPpg/WmIQ65qoWWhcGKf/b5eplkkarX0m9z8ppCat4mlOqUsWpyNuYgO3VRyrYHSzX5g=="], + + "prettier": ["prettier@3.8.1", "", { "bin": { "prettier": "bin/prettier.cjs" } }, "sha512-UOnG6LftzbdaHZcKoPFtOcCKztrQ57WkHDeRD9t/PTQtmT0NHSeWWepj6pS0z/N7+08BHFDQVUrfmfMRcZwbMg=="], + + "prettier-plugin-java": ["prettier-plugin-java@2.8.1", "", { "dependencies": { "java-parser": "3.0.1" }, "peerDependencies": { "prettier": "^3.0.0" } }, "sha512-tkteH5OSCEb0E7wKnhhUSitr1pGUCUt9M//CwerSNhoalL/qv0jXTeSVBPZ36KC+kZl3nbq4dxh144NuGchACg=="], + + "prettier-pretty-check": ["prettier-pretty-check@0.2.0", "", { "dependencies": { "diff": "^5.2.0" }, "bin": { "prettier-pretty-check": "index.js" } }, "sha512-gVmwxYvm1Qii1H6eULNcNchlruyXyKkluP1LBhUaqdSvvACc8FZ99zTWzqQHJrBu9qUrYmNRysPmnYSm9c7G6Q=="], + + "prompts": ["prompts@2.4.2", "", { "dependencies": { "kleur": "^3.0.3", "sisteransi": "^1.0.5" } }, "sha512-NxNv/kLguCA7p3jE8oL2aEBsrJWgAakBpgmgK6lpPWV+WuOmY6r2/zbAVnP+T8bQlA0nzHXSJSJW0Hq7ylaD2Q=="], + + "punycode": ["punycode@2.3.1", "", {}, "sha512-vYt7UD1U9Wg6138shLtLOvdAu+8DsC/ilFtEVHcH+wydcSpNE20AfSOduf6MkRFahL5FY7X1oU7nKVZFtfq8Fg=="], + + "queue-microtask": ["queue-microtask@1.2.3", "", {}, "sha512-NuaNSa6flKT5JaSYQzJok04JzTL1CA6aGhv5rfLW3PgqA+M2ChpZQnAC8h8i4ZFkBS8X5RqkDBHA7r4hej3K9A=="], + + "react": ["react@18.3.1", "", { "dependencies": { "loose-envify": "^1.1.0" } }, "sha512-wS+hAgJShR0KhEvPJArfuPVN1+Hz1t0Y6n5jLrGQbkb4urgPE/0Rve+1kMB1v/oWgHgm4WIcV+i7F2pTVj+2iQ=="], + + "react-dom": ["react-dom@18.3.1", "", { "dependencies": { "loose-envify": "^1.1.0", "scheduler": "^0.23.2" }, "peerDependencies": { "react": "^18.3.1" } }, "sha512-5m4nQKp+rZRb09LNH59GM4BxTh9251/ylbKIbpe7TpGxfJ+9kv6BLkLBXIjjspbgbnIBNqlI23tRnTWT0snUIw=="], + + "readable-stream": ["readable-stream@3.6.2", "", { "dependencies": { "inherits": "^2.0.3", "string_decoder": "^1.1.1", "util-deprecate": "^1.0.1" } }, "sha512-9u/sniCrY3D5WdsERHzHE4G2YCXqoG5FTHUiCC4SIbr6XcLZBY05ya9EKjYek9O5xOAwjGq+1JdGBAS7Q9ScoA=="], + + "reflect.getprototypeof": ["reflect.getprototypeof@1.0.10", "", { "dependencies": { "call-bind": "^1.0.8", "define-properties": "^1.2.1", "es-abstract": "^1.23.9", "es-errors": "^1.3.0", "es-object-atoms": "^1.0.0", "get-intrinsic": "^1.2.7", "get-proto": "^1.0.1", "which-builtin-type": "^1.2.1" } }, "sha512-00o4I+DVrefhv+nX0ulyi3biSHCPDe+yLv5o/p6d/UVlirijB8E16FtfwSAi4g3tcqrQ4lRAqQSoFEZJehYEcw=="], + + "regexp.prototype.flags": ["regexp.prototype.flags@1.5.4", "", { "dependencies": { "call-bind": "^1.0.8", "define-properties": "^1.2.1", "es-errors": "^1.3.0", "get-proto": "^1.0.1", "gopd": "^1.2.0", "set-function-name": "^2.0.2" } }, "sha512-dYqgNSZbDwkaJ2ceRd9ojCGjBq+mOm9LmtXnAnEGyHhN/5R7iDW2TRw3h+o/jCFxus3P2LfWIIiwowAjANm7IA=="], + + "resolve": ["resolve@1.22.11", "", { "dependencies": { "is-core-module": "^2.16.1", "path-parse": "^1.0.7", "supports-preserve-symlinks-flag": "^1.0.0" }, "bin": { "resolve": "bin/resolve" } }, "sha512-RfqAvLnMl313r7c9oclB1HhUEAezcpLjz95wFH4LVuhk9JF/r22qmVP9AMmOU4vMX7Q8pN8jwNg/CSpdFnMjTQ=="], + + "resolve-from": ["resolve-from@4.0.0", "", {}, "sha512-pb/MYmXstAkysRFx8piNI1tGFNQIFA3vkE3Gq4EuA1dF6gHp/+vgZqsCGJapvy8N3Q+4o7FwvquPJcnZ7RYy4g=="], + + "reusify": ["reusify@1.1.0", "", {}, "sha512-g6QUff04oZpHs0eG5p83rFLhHeV00ug/Yf9nZM6fLeUrPguBTkTQOdpAWWspMh55TZfVQDPaN3NQJfbVRAxdIw=="], + + "rimraf": ["rimraf@6.1.3", "", { "dependencies": { "glob": "^13.0.3", "package-json-from-dist": "^1.0.1" }, "bin": { "rimraf": "dist/esm/bin.mjs" } }, "sha512-LKg+Cr2ZF61fkcaK1UdkH2yEBBKnYjTyWzTJT6KNPcSPaiT7HSdhtMXQuN5wkTX0Xu72KQ1l8S42rlmexS2hSA=="], + + "rolldown": ["rolldown@1.2.10", "", { "dependencies": { "@oxc-project/types": "=0.151.0", "@rolldown/pluginutils": "^1.0.0" }, "optionalDependencies": { "@rolldown/binding-android-arm-eabi": "1.2.10", "@rolldown/binding-android-arm64": "1.2.10", "@rolldown/binding-darwin-arm64": "1.2.10", "@rolldown/binding-darwin-x64": "1.2.10", "@rolldown/binding-freebsd-x64": "1.2.10", "@rolldown/binding-linux-arm-gnueabihf": "1.2.10", "@rolldown/binding-linux-arm64-gnu": "1.2.10", "@rolldown/binding-linux-arm64-musl": "1.2.10", "@rolldown/binding-linux-ppc64-gnu": "1.2.10", "@rolldown/binding-linux-s390x-gnu": "1.2.10", "@rolldown/binding-linux-x64-gnu": "1.2.10", "@rolldown/binding-linux-x64-musl": "1.2.10", "@rolldown/binding-openharmony-arm64": "1.2.10", "@rolldown/binding-win32-arm64-msvc": "1.2.10", "@rolldown/binding-win32-x64-msvc": "1.2.10" }, "bin": { "rolldown": "./bin/cli.mjs" } }, "sha512-OxkA08pSryMK7B3XiFA09B4OJ1xJMPgIYCBMY2xchzpqgBGsV1o0DetPAE+Sl3N3L4oCPiEzmHVSOj7iR04Zog=="], + + "rollup": ["rollup@4.59.0", "", { "dependencies": { "@types/estree": "1.0.8" }, "optionalDependencies": { "@rollup/rollup-android-arm-eabi": "4.59.0", "@rollup/rollup-android-arm64": "4.59.0", "@rollup/rollup-darwin-arm64": "4.59.0", "@rollup/rollup-darwin-x64": "4.59.0", "@rollup/rollup-freebsd-arm64": "4.59.0", "@rollup/rollup-freebsd-x64": "4.59.0", "@rollup/rollup-linux-arm-gnueabihf": "4.59.0", "@rollup/rollup-linux-arm-musleabihf": "4.59.0", "@rollup/rollup-linux-arm64-gnu": "4.59.0", "@rollup/rollup-linux-arm64-musl": "4.59.0", "@rollup/rollup-linux-loong64-gnu": "4.59.0", "@rollup/rollup-linux-loong64-musl": "4.59.0", "@rollup/rollup-linux-ppc64-gnu": "4.59.0", "@rollup/rollup-linux-ppc64-musl": "4.59.0", "@rollup/rollup-linux-riscv64-gnu": "4.59.0", "@rollup/rollup-linux-riscv64-musl": "4.59.0", "@rollup/rollup-linux-s390x-gnu": "4.59.0", "@rollup/rollup-linux-x64-gnu": "4.59.0", "@rollup/rollup-linux-x64-musl": "4.59.0", "@rollup/rollup-openbsd-x64": "4.59.0", "@rollup/rollup-openharmony-arm64": "4.59.0", "@rollup/rollup-win32-arm64-msvc": "4.59.0", "@rollup/rollup-win32-ia32-msvc": "4.59.0", "@rollup/rollup-win32-x64-gnu": "4.59.0", "@rollup/rollup-win32-x64-msvc": "4.59.0", "fsevents": "~2.3.2" }, "bin": { "rollup": "dist/bin/rollup" } }, "sha512-2oMpl67a3zCH9H79LeMcbDhXW/UmWG/y2zuqnF2jQq5uq9TbM9TVyXvA4+t+ne2IIkBdrLpAaRQAvo7YI/Yyeg=="], + + "run-parallel": ["run-parallel@1.2.0", "", { "dependencies": { "queue-microtask": "^1.2.2" } }, "sha512-5l4VyZR86LZ/lDxZTR6jqL8AFE2S0IFLMP26AbjsLVADxHdhB/c0GUsH+y39UfCi3dzz8OlQuPmnaJOMoDHQBA=="], + + "safe-array-concat": ["safe-array-concat@1.1.3", "", { "dependencies": { "call-bind": "^1.0.8", "call-bound": "^1.0.2", "get-intrinsic": "^1.2.6", "has-symbols": "^1.1.0", "isarray": "^2.0.5" } }, "sha512-AURm5f0jYEOydBj7VQlVvDrjeFgthDdEF5H1dP+6mNpoXOMo1quQqJ4wvJDyRZ9+pO3kGWoOdmV08cSv2aJV6Q=="], + + "safe-buffer": ["safe-buffer@5.2.1", "", {}, "sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ=="], + + "safe-push-apply": ["safe-push-apply@1.0.0", "", { "dependencies": { "es-errors": "^1.3.0", "isarray": "^2.0.5" } }, "sha512-iKE9w/Z7xCzUMIZqdBsp6pEQvwuEebH4vdpjcDWnyzaI6yl6O9FHvVpmGelvEHNsoY6wGblkxR6Zty/h00WiSA=="], + + "safe-regex-test": ["safe-regex-test@1.1.0", "", { "dependencies": { "call-bound": "^1.0.2", "es-errors": "^1.3.0", "is-regex": "^1.2.1" } }, "sha512-x/+Cz4YrimQxQccJf5mKEbIa1NzeCRNI5Ecl/ekmlYaampdNLPalVyIcCZNNH3MvmqBugV5TMYZXv0ljslUlaw=="], + + "sax": ["sax@1.5.0", "", {}, "sha512-21IYA3Q5cQf089Z6tgaUTr7lDAyzoTPx5HRtbhsME8Udispad8dC/+sziTNugOEx54ilvatQ9YCzl4KQLPcRHA=="], + + "scheduler": ["scheduler@0.23.2", "", { "dependencies": { "loose-envify": "^1.1.0" } }, "sha512-UOShsPwz7NrMUqhR6t0hWjFduvOzbtv7toDH1/hIrfRNIDBnnBWd0CwJTGvTpngVlmwGCdP9/Zl/tVrDqcuYzQ=="], + + "semver": ["semver@7.7.4", "", { "bin": { "semver": "bin/semver.js" } }, "sha512-vFKC2IEtQnVhpT78h1Yp8wzwrf8CM+MzKMHGJZfBtzhZNycRFnXsHk6E5TxIkkMsgNS7mdX3AGB7x2QM2di4lA=="], + + "set-function-length": ["set-function-length@1.2.2", "", { "dependencies": { "define-data-property": "^1.1.4", "es-errors": "^1.3.0", "function-bind": "^1.1.2", "get-intrinsic": "^1.2.4", "gopd": "^1.0.1", "has-property-descriptors": "^1.0.2" } }, "sha512-pgRc4hJ4/sNjWCSS9AmnS40x3bNMDTknHgL5UaMBTMyJnU90EgWh1Rz+MC9eFu4BuN/UwZjKQuY/1v3rM7HMfg=="], + + "set-function-name": ["set-function-name@2.0.2", "", { "dependencies": { "define-data-property": "^1.1.4", "es-errors": "^1.3.0", "functions-have-names": "^1.2.3", "has-property-descriptors": "^1.0.2" } }, "sha512-7PGFlmtwsEADb0WYyvCMa1t+yke6daIG4Wirafur5kcf+MhUnPms1UeR0CKQdTZD81yESwMHbtn+TR+dMviakQ=="], + + "set-proto": ["set-proto@1.0.0", "", { "dependencies": { "dunder-proto": "^1.0.1", "es-errors": "^1.3.0", "es-object-atoms": "^1.0.0" } }, "sha512-RJRdvCo6IAnPdsvP/7m6bsQqNnn1FCBX5ZNtFL98MmFF/4xAIJTIg1YbHW5DC2W5SKZanrC6i4HsJqlajw/dZw=="], + + "shebang-command": ["shebang-command@2.0.0", "", { "dependencies": { "shebang-regex": "^3.0.0" } }, "sha512-kHxr2zZpYtdmrN1qDjrrX/Z1rR1kG8Dx+gkpK1G4eXmvXswmcE1hTWBWYUzlraYw1/yZp6YuDY77YtvbN0dmDA=="], + + "shebang-regex": ["shebang-regex@3.0.0", "", {}, "sha512-7++dFhtcx3353uBaq8DDR4NuxBetBzC7ZQOhmTQInHEd6bSrXdiEyzCvG07Z44UYdLShWUyXt5M/yhz8ekcb1A=="], + + "side-channel": ["side-channel@1.1.0", "", { "dependencies": { "es-errors": "^1.3.0", "object-inspect": "^1.13.3", "side-channel-list": "^1.0.0", "side-channel-map": "^1.0.1", "side-channel-weakmap": "^1.0.2" } }, "sha512-ZX99e6tRweoUXqR+VBrslhda51Nh5MTQwou5tnUDgbtyM0dBgmhEDtWGP/xbKn6hqfPRHujUNwz5fy/wbbhnpw=="], + + "side-channel-list": ["side-channel-list@1.0.0", "", { "dependencies": { "es-errors": "^1.3.0", "object-inspect": "^1.13.3" } }, "sha512-FCLHtRD/gnpCiCHEiJLOwdmFP+wzCmDEkc9y7NsYxeF4u7Btsn1ZuwgwJGxImImHicJArLP4R0yX4c2KCrMrTA=="], + + "side-channel-map": ["side-channel-map@1.0.1", "", { "dependencies": { "call-bound": "^1.0.2", "es-errors": "^1.3.0", "get-intrinsic": "^1.2.5", "object-inspect": "^1.13.3" } }, "sha512-VCjCNfgMsby3tTdo02nbjtM/ewra6jPHmpThenkTYh8pG9ucZ/1P8So4u4FGBek/BjpOVsDCMoLA/iuBKIFXRA=="], + + "side-channel-weakmap": ["side-channel-weakmap@1.0.2", "", { "dependencies": { "call-bound": "^1.0.2", "es-errors": "^1.3.0", "get-intrinsic": "^1.2.5", "object-inspect": "^1.13.3", "side-channel-map": "^1.0.1" } }, "sha512-WPS/HvHQTYnHisLo9McqBHOJk2FkHO/tlpvldyrnem4aeQp4hai3gythswg6p01oSoTl58rcpiFAjF2br2Ak2A=="], + + "signal-exit": ["signal-exit@3.0.7", "", {}, "sha512-wnD2ZE+l+SPC/uoS0vXeE9L1+0wuaMqKlfz9AMUo38JsyLSBWSFcHR1Rri62LZc12vLr1gb3jl7iwQhgwpAbGQ=="], + + "simple-plist": ["simple-plist@1.3.1", "", { "dependencies": { "bplist-creator": "0.1.0", "bplist-parser": "0.3.1", "plist": "^3.0.5" } }, "sha512-iMSw5i0XseMnrhtIzRb7XpQEXepa9xhWxGUojHBL43SIpQuDQkh3Wpy67ZbDzZVr6EKxvwVChnVpdl8hEVLDiw=="], + + "sisteransi": ["sisteransi@1.0.5", "", {}, "sha512-bLGGlR1QxBcynn2d5YmDX4MGjlZvy2MRBDRNHLJ8VI6l6+9FUiyTFNJ0IveOSP0bcXgVDPRcfGqA0pjaqUpfVg=="], + + "slash": ["slash@3.0.0", "", {}, "sha512-g9Q1haeby36OSStwb4ntCGGGaKsaVSjQ68fBxoQcutl5fS1vuY18H3wSt3jFyFtrkx+Kz0V1G85A4MyAdDMi2Q=="], + + "slice-ansi": ["slice-ansi@4.0.0", "", { "dependencies": { "ansi-styles": "^4.0.0", "astral-regex": "^2.0.0", "is-fullwidth-code-point": "^3.0.0" } }, "sha512-qMCMfhY040cVHT43K9BFygqYbUPFZKHOg7K73mtTWJRb8pyP3fzf4Ixd5SzdEJQ6MRUg/WBnOLxghZtKKurENQ=="], + + "source-map-js": ["source-map-js@1.2.1", "", {}, "sha512-UXWMKhLOwVKb728IUtQPXxfYU+usdybtUrK/8uGE8CQMvrhOpwvzDBwj0QhSL7MQc7vIsISBG8VQ8+IDQxpfQA=="], + + "split2": ["split2@4.2.0", "", {}, "sha512-UcjcJOWknrNkF6PLX83qcHM6KHgVKNkV62Y8a5uYDVv9ydGQVwAHMKqHdJje1VTWpljG0WYpCDhrCdAOYH4TWg=="], + + "stop-iteration-iterator": ["stop-iteration-iterator@1.1.0", "", { "dependencies": { "es-errors": "^1.3.0", "internal-slot": "^1.1.0" } }, "sha512-eLoXW/DHyl62zxY4SCaIgnRhuMr6ri4juEYARS8E6sCEqzKpOiE521Ucofdx+KnDZl5xmvGYaaKCk5FEOxJCoQ=="], + + "stream-buffers": ["stream-buffers@2.2.0", "", {}, "sha512-uyQK/mx5QjHun80FLJTfaWE7JtwfRMKBLkMne6udYOmvH0CawotVa7TfgYHzAnpphn4+TweIx1QKMnRIbipmUg=="], + + "string-width": ["string-width@4.2.3", "", { "dependencies": { "emoji-regex": "^8.0.0", "is-fullwidth-code-point": "^3.0.0", "strip-ansi": "^6.0.1" } }, "sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g=="], + + "string.prototype.trim": ["string.prototype.trim@1.2.10", "", { "dependencies": { "call-bind": "^1.0.8", "call-bound": "^1.0.2", "define-data-property": "^1.1.4", "define-properties": "^1.2.1", "es-abstract": "^1.23.5", "es-object-atoms": "^1.0.0", "has-property-descriptors": "^1.0.2" } }, "sha512-Rs66F0P/1kedk5lyYyH9uBzuiI/kNRmwJAR9quK6VOtIpZ2G+hMZd+HQbbv25MgCA6gEffoMZYxlTod4WcdrKA=="], + + "string.prototype.trimend": ["string.prototype.trimend@1.0.9", "", { "dependencies": { "call-bind": "^1.0.8", "call-bound": "^1.0.2", "define-properties": "^1.2.1", "es-object-atoms": "^1.0.0" } }, "sha512-G7Ok5C6E/j4SGfyLCloXTrngQIQU3PWtXGst3yM7Bea9FRURf1S42ZHlZZtsNque2FN2PoUhfZXYLNWwEr4dLQ=="], + + "string.prototype.trimstart": ["string.prototype.trimstart@1.0.8", "", { "dependencies": { "call-bind": "^1.0.7", "define-properties": "^1.2.1", "es-object-atoms": "^1.0.0" } }, "sha512-UXSH262CSZY1tfu3G3Secr6uGLCFVPMhIqHjlgCUtCCcgihYc/xKs9djMTMUOb2j1mVSeU8EU6NWc/iQKU6Gfg=="], + + "string_decoder": ["string_decoder@1.3.0", "", { "dependencies": { "safe-buffer": "~5.2.0" } }, "sha512-hkRX8U1WjJFd8LsDJ2yQ/wWWxaopEsABU1XfkM8A+j0+85JAGppt16cr1Whg6KIbb4okU6Mql6BOj+uup/wKeA=="], + + "strip-ansi": ["strip-ansi@6.0.1", "", { "dependencies": { "ansi-regex": "^5.0.1" } }, "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A=="], + + "strip-bom": ["strip-bom@3.0.0", "", {}, "sha512-vavAMRXOgBVNF6nyEEmL3DBK19iRpDcoIwW+swQ+CbGiu7lju6t+JklA1MHweoWtadgt4ISVUsXLyDq34ddcwA=="], + + "strip-json-comments": ["strip-json-comments@3.1.1", "", {}, "sha512-6fPc+R4ihwqP6N/aIv2f1gMH8lOVtWQHoqC4yK6oSDVVocumAsfCqjkXnqiYMhmMwS/mEHLp7Vehlt3ql6lEig=="], + + "supports-color": ["supports-color@7.2.0", "", { "dependencies": { "has-flag": "^4.0.0" } }, "sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw=="], + + "supports-preserve-symlinks-flag": ["supports-preserve-symlinks-flag@1.0.0", "", {}, "sha512-ot0WnXS9fgdkgIcePe6RHNk1WA8+muPa6cSjeR3V8K27q9BB1rTE3R1p7Hv0z1ZyAc8s6Vvv8DIyWf681MAt0w=="], + + "swiftlint": ["swiftlint@2.0.0", "", { "dependencies": { "@ionic/utils-fs": "^3.1.7", "@ionic/utils-subprocess": "^3.0.1", "cosmiconfig": "^9.0.0" }, "bin": { "node-swiftlint": "bin.js" } }, "sha512-MMVuyZ4/6WcIJlk0z6GM0pZjRuwnyUJqRPbJBFW3oACN/qjAvRbolCWEu+zE2MycF/cEgqfUpI+oLECNfjfOJA=="], + + "tar": ["tar@7.5.10", "", { "dependencies": { "@isaacs/fs-minipass": "^4.0.0", "chownr": "^3.0.0", "minipass": "^7.1.2", "minizlib": "^3.1.0", "yallist": "^5.0.0" } }, "sha512-8mOPs1//5q/rlkNSPcCegA6hiHJYDmSLEI8aMH/CdSQJNWztHC9WHNam5zdQlfpTwB9Xp7IBEsHfV5LKMJGVAw=="], + + "text-table": ["text-table@0.2.0", "", {}, "sha512-N+8UisAXDGk8PFXP4HAzVR9nbfmVJ3zYLAWiTIoqC5v5isinhr+r5uaO8+7r3BMfuNIufIsA7RdpVgacC2cSpw=="], + + "through2": ["through2@4.0.2", "", { "dependencies": { "readable-stream": "3" } }, "sha512-iOqSav00cVxEEICeD7TjLB1sueEL+81Wpzp2bY17uZjZN0pWZPuo4suZ/61VujxmqSGFfgOcNuTZ85QJwNZQpw=="], + + "tinyglobby": ["tinyglobby@0.2.17", "", { "dependencies": { "fdir": "^6.5.0", "picomatch": "^4.0.4" } }, "sha512-wXR/dYpcqKmfWpEdZjiKJOwCNFndD0DMnrW/cYjVGttEkBfVgcLFHoNrlj47mjOVic9yyNu65alsgF4NQyTa2g=="], + + "to-regex-range": ["to-regex-range@5.0.1", "", { "dependencies": { "is-number": "^7.0.0" } }, "sha512-65P7iz6X5yEr1cwcgvQxbbIw7Uk3gOy5dIdtZ4rDveLqhrdJP+Li/Hx6tyK0NEb+2GCyneCMJiGqrADCSNk8sQ=="], + + "tree-kill": ["tree-kill@1.2.2", "", { "bin": { "tree-kill": "cli.js" } }, "sha512-L0Orpi8qGpRG//Nd+H90vFB+3iHnue1zSSGmNOOCh1GLJ7rUKVwV2HvijphGQS2UmhUZewS9VgvxYIdgr+fG1A=="], + + "tsconfig-paths": ["tsconfig-paths@3.15.0", "", { "dependencies": { "@types/json5": "^0.0.29", "json5": "^1.0.2", "minimist": "^1.2.6", "strip-bom": "^3.0.0" } }, "sha512-2Ac2RgzDe/cn48GvOe3M+o82pEFewD3UPbyoUHHdKasHwJKjds4fLXWf/Ux5kATBKN20oaFGu+jbElp1pos0mg=="], + + "tslib": ["tslib@2.8.1", "", {}, "sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w=="], + + "tsutils": ["tsutils@3.21.0", "", { "dependencies": { "tslib": "^1.8.1" }, "peerDependencies": { "typescript": ">=2.8.0 || >= 3.2.0-dev || >= 3.3.0-dev || >= 3.4.0-dev || >= 3.5.0-dev || >= 3.6.0-dev || >= 3.6.0-beta || >= 3.7.0-dev || >= 3.7.0-beta" } }, "sha512-mHKK3iUXL+3UF6xL5k0PEhKRUBKPBCv/+RkEOpjRWxxx27KKRBmmA60A9pgOUvMi8GKhRMPEmjBRPzs2W7O1OA=="], + + "type-check": ["type-check@0.4.0", "", { "dependencies": { "prelude-ls": "^1.2.1" } }, "sha512-XleUoc9uwGXqjWwXaUTZAmzMcFZ5858QA2vvx1Ur5xIcixXIP+8LnFDgRplU30us6teqdlskFfu+ae4K79Ooew=="], + + "type-fest": ["type-fest@0.20.2", "", {}, "sha512-Ne+eE4r0/iWnpAxD852z3A+N0Bt5RN//NjJwRd2VFHEmrywxf5vsZlh4R6lixl6B+wz/8d+maTSAkN1FIkI3LQ=="], + + "typed-array-buffer": ["typed-array-buffer@1.0.3", "", { "dependencies": { "call-bound": "^1.0.3", "es-errors": "^1.3.0", "is-typed-array": "^1.1.14" } }, "sha512-nAYYwfY3qnzX30IkA6AQZjVbtK6duGontcQm1WSG1MD94YLqK0515GNApXkoxKOWMusVssAHWLh9SeaoefYFGw=="], + + "typed-array-byte-length": ["typed-array-byte-length@1.0.3", "", { "dependencies": { "call-bind": "^1.0.8", "for-each": "^0.3.3", "gopd": "^1.2.0", "has-proto": "^1.2.0", "is-typed-array": "^1.1.14" } }, "sha512-BaXgOuIxz8n8pIq3e7Atg/7s+DpiYrxn4vdot3w9KbnBhcRQq6o3xemQdIfynqSeXeDrF32x+WvfzmOjPiY9lg=="], + + "typed-array-byte-offset": ["typed-array-byte-offset@1.0.4", "", { "dependencies": { "available-typed-arrays": "^1.0.7", "call-bind": "^1.0.8", "for-each": "^0.3.3", "gopd": "^1.2.0", "has-proto": "^1.2.0", "is-typed-array": "^1.1.15", "reflect.getprototypeof": "^1.0.9" } }, "sha512-bTlAFB/FBYMcuX81gbL4OcpH5PmlFHqlCCpAl8AlEzMz5k53oNDvN8p1PNOWLEmI2x4orp3raOFB51tv9X+MFQ=="], + + "typed-array-length": ["typed-array-length@1.0.7", "", { "dependencies": { "call-bind": "^1.0.7", "for-each": "^0.3.3", "gopd": "^1.0.1", "is-typed-array": "^1.1.13", "possible-typed-array-names": "^1.0.0", "reflect.getprototypeof": "^1.0.6" } }, "sha512-3KS2b+kL7fsuk/eJZ7EQdnEmQoaho/r6KUef7hxvltNA5DR8NAUM+8wJMbJyZ4G9/7i3v5zPBIMN5aybAh2/Jg=="], + + "typescript": ["typescript@6.0.3", "", { "bin": { "tsc": "bin/tsc", "tsserver": "bin/tsserver" } }, "sha512-y2TvuxSZPDyQakkFRPZHKFm+KKVqIisdg9/CZwm9ftvKXLP8NRWj38/ODjNbr43SsoXqNuAisEf1GdCxqWcdBw=="], + + "unbox-primitive": ["unbox-primitive@1.1.0", "", { "dependencies": { "call-bound": "^1.0.3", "has-bigints": "^1.0.2", "has-symbols": "^1.1.0", "which-boxed-primitive": "^1.1.1" } }, "sha512-nWJ91DjeOkej/TA8pXQ3myruKpKEYgqvpw9lz4OPHj/NWFNluYrjbz9j01CJ8yKQd2g4jFoOkINCTW2I5LEEyw=="], + + "undici-types": ["undici-types@7.16.0", "", {}, "sha512-Zz+aZWSj8LE6zoxD+xrjh4VfkIG8Ya6LvYkZqtUQGJPZjYl53ypCaUwWqo7eI0x66KBGeRo+mlBEkMSeSZ38Nw=="], + + "universalify": ["universalify@2.0.1", "", {}, "sha512-gptHNQghINnc/vTGIk0SOFGFNXw7JVrlRUtConJRlvaw6DuX0wO5Jeko9sWrMBhh+PsYAZ7oXAiOnf/UKogyiw=="], + + "untildify": ["untildify@4.0.0", "", {}, "sha512-KK8xQ1mkzZeg9inewmFVDNkg3l5LUhoq9kN6iWYB/CC9YMG8HA+c1Q8HwDe6dEX7kErrEVNVBO3fWsVq5iDgtw=="], + + "uri-js": ["uri-js@4.4.1", "", { "dependencies": { "punycode": "^2.1.0" } }, "sha512-7rKUyy33Q1yc98pQ1DAmLtwX109F7TIfWlW1Ydo8Wl1ii1SeHieeh0HHfPeL2fMXK6z0s8ecKs9frCuLJvndBg=="], + + "util-deprecate": ["util-deprecate@1.0.2", "", {}, "sha512-EPD5q1uXyFxJpCrLnCc1nHnq3gOa6DZBocAIiI2TaSCA7VCJ1UJDMagCzIkXNsUYfD1daK//LTEQ8xiIbrHtcw=="], + + "uuid": ["uuid@7.0.3", "", { "bin": { "uuid": "dist/bin/uuid" } }, "sha512-DPSke0pXhTZgoF/d+WSt2QaKMCFSfx7QegxEWT+JOuHF5aWrKEn0G+ztjuJg/gG8/ItK+rbPCD/yNv8yyih6Cg=="], + + "vite": ["vite@8.3.0", "", { "dependencies": { "lightningcss": "^1.33.0", "picomatch": "^4.0.7", "postcss": "^8.5.28", "rolldown": "~1.2.6", "tinyglobby": "^0.2.17" }, "optionalDependencies": { "fsevents": "~2.3.3" }, "peerDependencies": { "@types/node": "^20.19.0 || >=22.12.0", "@vitejs/devtools": "^0.7.1", "esbuild": "^0.27.0 || ^0.28.0", "jiti": ">=1.21.0", "less": "^4.0.0", "sass": "^1.70.0", "sass-embedded": "^1.70.0", "stylus": ">=0.54.8", "sugarss": "^5.0.0", "terser": "^5.16.0", "tsx": "^4.8.1", "yaml": "^2.4.2" }, "optionalPeers": ["@types/node", "@vitejs/devtools", "esbuild", "jiti", "less", "sass", "sass-embedded", "stylus", "sugarss", "terser", "tsx", "yaml"], "bin": { "vite": "bin/vite.js" } }, "sha512-lhZBVvEHefgE+HQZC9O7EBJgCU/nVzFNl7vkS4RE0APtWLP02/8QVIkQtzBxPquh7lq5/78NHipTj7ODQ6XuyQ=="], + + "which": ["which@2.0.2", "", { "dependencies": { "isexe": "^2.0.0" }, "bin": { "node-which": "./bin/node-which" } }, "sha512-BLI3Tl1TW3Pvl70l3yq3Y64i+awpwXqsGBYWkkqMtnbXgrMD+yj7rhW0kuEDxzJaYXGjEW5ogapKNMEKNMjibA=="], + + "which-boxed-primitive": ["which-boxed-primitive@1.1.1", "", { "dependencies": { "is-bigint": "^1.1.0", "is-boolean-object": "^1.2.1", "is-number-object": "^1.1.1", "is-string": "^1.1.1", "is-symbol": "^1.1.1" } }, "sha512-TbX3mj8n0odCBFVlY8AxkqcHASw3L60jIuF8jFP78az3C2YhmGvqbHBpAjTRH2/xqYunrJ9g1jSyjCjpoWzIAA=="], + + "which-builtin-type": ["which-builtin-type@1.2.1", "", { "dependencies": { "call-bound": "^1.0.2", "function.prototype.name": "^1.1.6", "has-tostringtag": "^1.0.2", "is-async-function": "^2.0.0", "is-date-object": "^1.1.0", "is-finalizationregistry": "^1.1.0", "is-generator-function": "^1.0.10", "is-regex": "^1.2.1", "is-weakref": "^1.0.2", "isarray": "^2.0.5", "which-boxed-primitive": "^1.1.0", "which-collection": "^1.0.2", "which-typed-array": "^1.1.16" } }, "sha512-6iBczoX+kDQ7a3+YJBnh3T+KZRxM/iYNPXicqk66/Qfm1b93iu+yOImkg0zHbj5LNOcNv1TEADiZ0xa34B4q6Q=="], + + "which-collection": ["which-collection@1.0.2", "", { "dependencies": { "is-map": "^2.0.3", "is-set": "^2.0.3", "is-weakmap": "^2.0.2", "is-weakset": "^2.0.3" } }, "sha512-K4jVyjnBdgvc86Y6BkaLZEN933SwYOuBFkdmBu9ZfkcAbdVbpITnDmjvZ/aQjRXQrv5EPkTnD1s39GiiqbngCw=="], + + "which-typed-array": ["which-typed-array@1.1.20", "", { "dependencies": { "available-typed-arrays": "^1.0.7", "call-bind": "^1.0.8", "call-bound": "^1.0.4", "for-each": "^0.3.5", "get-proto": "^1.0.1", "gopd": "^1.2.0", "has-tostringtag": "^1.0.2" } }, "sha512-LYfpUkmqwl0h9A2HL09Mms427Q1RZWuOHsukfVcKRq9q95iQxdw0ix1JQrqbcDR9PH1QDwf5Qo8OZb5lksZ8Xg=="], + + "word-wrap": ["word-wrap@1.2.5", "", {}, "sha512-BN22B5eaMMI9UMtjrGd5g5eCYPpCPDUy0FJXbYsaT5zYxjFOckS53SQDE3pWkVoWpHXVb3BrYcEN4Twa55B5cA=="], + + "wrap-ansi": ["wrap-ansi@7.0.0", "", { "dependencies": { "ansi-styles": "^4.0.0", "string-width": "^4.1.0", "strip-ansi": "^6.0.0" } }, "sha512-YVGIj2kamLSTxw6NsZjoBxfSwsn0ycdesmc4p+Q21c5zPuZ1pl+NfxVdxPtdHvmNVOQ6XSYG4AUtyt/Fi7D16Q=="], + + "wrappy": ["wrappy@1.0.2", "", {}, "sha512-l4Sp/DRseor9wL6EvV2+TuQn63dMkPjZ/sp9XkghTEbV9KlPS1xUsZ3u7/IQO4wxtcFB4bgpQPRcR3QCvezPcQ=="], + + "xcode": ["xcode@3.0.1", "", { "dependencies": { "simple-plist": "^1.1.0", "uuid": "^7.0.3" } }, "sha512-kCz5k7J7XbJtjABOvkc5lJmkiDh8VhjVCGNiqdKCscmVpdVUpEAyXv1xmCLkQJ5dsHqx3IPO4XW+NTDhU/fatA=="], + + "xml2js": ["xml2js@0.6.2", "", { "dependencies": { "sax": ">=0.6.0", "xmlbuilder": "~11.0.0" } }, "sha512-T4rieHaC1EXcES0Kxxj4JWgaUQHDk+qwHcYOCFHfiwKz7tOVPLq7Hjq9dM1WCMhylqMEfP7hMcOIChvotiZegA=="], + + "xmlbuilder": ["xmlbuilder@15.1.1", "", {}, "sha512-yMqGBqtXyeN1e3TGYvgNgDVZ3j84W4cwkOXQswghol6APgZWaff9lnbvN7MHYJOiXsvGPXtjTYJEiC9J2wv9Eg=="], + + "yallist": ["yallist@5.0.0", "", {}, "sha512-YgvUTfwqyc7UXVMrB+SImsVYSmTS8X/tSrtdNZMImM+n7+QTriRXyXim0mBrTXNeqzVF0KWGgHPeiyViFFrNDw=="], + + "yauzl": ["yauzl@2.10.0", "", { "dependencies": { "buffer-crc32": "~0.2.3", "fd-slicer": "~1.1.0" } }, "sha512-p4a9I6X6nu6IhoGmBqAcbJy1mlC4j27vEPZX9F4L4/vZT3Lyq1VkFHw/V/PUcB9Buo+DG3iHkT0x3Qya58zc3g=="], + + "yocto-queue": ["yocto-queue@0.1.0", "", {}, "sha512-rVksvsnNCdJ/ohGc6xgPwyN8eheCxsiLM8mxuE/t/mOVqJewPuO1miLpTHQiRgTKCLexL4MeAFVagts7HmNZ2Q=="], + + "@capacitor/docgen/typescript": ["typescript@4.2.4", "", { "bin": { "tsc": "bin/tsc", "tsserver": "bin/tsserver" } }, "sha512-V+evlYHZnQkaz8TRBuxTA92yZBPotr5H+WhQ7bD3hZUndx5tGOa1fuCgeSjxAzM1RiN5IzvadIXTVefuuwZCRg=="], + + "@capgo/capacitor-native-audio/typescript": ["typescript@5.9.3", "", { "bin": { "tsc": "bin/tsc", "tsserver": "bin/tsserver" } }, "sha512-jl1vZzPDinLr9eUt3J/t7V6FgNEw9QjvBPdysz9KfQDD41fQrC2Y4vKQdiaUpFT4bXlb1RHhLpp8wtm6M5TgSw=="], + + "@ionic/utils-fs/fs-extra": ["fs-extra@9.1.0", "", { "dependencies": { "at-least-node": "^1.0.0", "graceful-fs": "^4.2.0", "jsonfile": "^6.0.1", "universalify": "^2.0.0" } }, "sha512-hcg3ZmepS30/7BSFqRvoo3DOMQu7IjqxO5nCDt+zM9XWjb33Wg7ziNT+Qvqbuc3+gWpzO02JubVyk2G4Zvo1OQ=="], + + "@typescript-eslint/utils/eslint-scope": ["eslint-scope@5.1.1", "", { "dependencies": { "esrecurse": "^4.3.0", "estraverse": "^4.1.1" } }, "sha512-2NxwbF/hZ0KpepYN0cNbo+FN6XoK7GaHlQhgx/hIZl6Va0bF45RQOOwhLIy8lQDbuCiadSLCBnH2CFYquit5bw=="], + + "elementtree/sax": ["sax@1.1.4", "", {}, "sha512-5f3k2PbGGp+YtKJjOItpg3P99IMD84E4HOvcfleTb5joCHNXYLsR9yWFPOYGgaeMPDubQILTCMdsFb2OMeOjtg=="], + + "eslint-import-resolver-node/debug": ["debug@3.2.7", "", { "dependencies": { "ms": "^2.1.1" } }, "sha512-CFjzYYAi4ThfiQvizrFQevTTXHtnCqWfe7x1AhgEscTz6ZbLbfoLRLPugTQyBth6f8ZERVUSyWHFD/7Wu4t1XQ=="], + + "eslint-module-utils/debug": ["debug@3.2.7", "", { "dependencies": { "ms": "^2.1.1" } }, "sha512-CFjzYYAi4ThfiQvizrFQevTTXHtnCqWfe7x1AhgEscTz6ZbLbfoLRLPugTQyBth6f8ZERVUSyWHFD/7Wu4t1XQ=="], + + "eslint-plugin-import/debug": ["debug@3.2.7", "", { "dependencies": { "ms": "^2.1.1" } }, "sha512-CFjzYYAi4ThfiQvizrFQevTTXHtnCqWfe7x1AhgEscTz6ZbLbfoLRLPugTQyBth6f8ZERVUSyWHFD/7Wu4t1XQ=="], + + "eslint-plugin-import/doctrine": ["doctrine@2.1.0", "", { "dependencies": { "esutils": "^2.0.2" } }, "sha512-35mSku4ZXK0vfCuHEDAwt55dg2jNajHZ1odvF+8SSr82EsZY4QmXfuWso8oEd8zRhVObSN18aM0CjSdoBX7zIw=="], + + "eslint-plugin-import/semver": ["semver@6.3.1", "", { "bin": { "semver": "bin/semver.js" } }, "sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA=="], + + "fast-glob/glob-parent": ["glob-parent@5.1.2", "", { "dependencies": { "is-glob": "^4.0.1" } }, "sha512-AOIgSQCepiJYwP3ARnGx+5VnTu2HBYdzbGP45eLw1vr3zB3vZLeyed1sC9hnbcOc9/SrMyM5RPQrkGz4aS9Zow=="], + + "flat-cache/rimraf": ["rimraf@3.0.2", "", { "dependencies": { "glob": "^7.1.3" }, "bin": { "rimraf": "bin.js" } }, "sha512-JZkJMZkAGFFPP2YqXZXPbMlMBgsxzE8ILs4lMIX/2o0L9UBw9O/Y3o6wFw/i9YLapcUJWwqbi3kdxIPdC62TIA=="], + + "glob/minimatch": ["minimatch@10.2.4", "", { "dependencies": { "brace-expansion": "^5.0.2" } }, "sha512-oRjTw/97aTBN0RHbYCdtF1MQfvusSIBQM0IZEgzl6426+8jSC0nF1a/GmnVLpfB9yyr6g6FTqWqiZVbxrtaCIg=="], + + "micromatch/picomatch": ["picomatch@2.3.1", "", {}, "sha512-JU3teHTNjmE2VCGFzuY8EXzCDVwEqB2a8fsIvwaStHhAWJEeVd1o1QD80CU6+ZdEXXSLbSsuLwJjkCBWqRQUVA=="], + + "prompts/kleur": ["kleur@3.0.3", "", {}, "sha512-eTIzlVOSUR+JxdDFepEYcBMtZ9Qqdef+rnzWdRZuMbOywu5tO2w2N7rqjoANZ5k9vywhL6Br1VRjUIgTQx4E8w=="], + + "simple-plist/bplist-parser": ["bplist-parser@0.3.1", "", { "dependencies": { "big-integer": "1.6.x" } }, "sha512-PyJxiNtA5T2PlLIeBot4lbp7rj4OadzjnMZD/G5zuBNt8ei/yCU7+wW0h2bag9vr8c+/WuRWmSxbqAl9hL1rBA=="], + + "tsutils/tslib": ["tslib@1.14.1", "", {}, "sha512-Xni35NKzjgMrwevysHTCArtLDpPvye8zV/0E4EyYn43P7/7qvQwPh9BGkHewbMulVntbigmcT7rdX3BNo9wRJg=="], + + "xml2js/xmlbuilder": ["xmlbuilder@11.0.1", "", {}, "sha512-fDlsI/kFEx7gLvbecc0/ohLG50fugQp8ryHzMTuW9vSa1GJ0XYWKnhsUx7oie3G98+r56aTQIUB4kht42R3JvA=="], + + "@typescript-eslint/utils/eslint-scope/estraverse": ["estraverse@4.3.0", "", {}, "sha512-39nnKffWz8xN1BU/2c79n9nB9HDzo0niYUqx6xyqUnyoAnQyyWpOTdZEeiCch8BBu515t4wp9ZmgVfVhn9EBpw=="], + + "flat-cache/rimraf/glob": ["glob@7.2.3", "", { "dependencies": { "fs.realpath": "^1.0.0", "inflight": "^1.0.4", "inherits": "2", "minimatch": "^3.1.1", "once": "^1.3.0", "path-is-absolute": "^1.0.0" } }, "sha512-nFR0zLpU2YCaRxwoCJvL6UvCH2JFyFVIvwTLsIf21AuHlMskA1hhTdk+LlYJtOlYt9v6dvszD2BGRqBL+iQK9Q=="], + + "glob/minimatch/brace-expansion": ["brace-expansion@5.0.4", "", { "dependencies": { "balanced-match": "^4.0.2" } }, "sha512-h+DEnpVvxmfVefa4jFbCf5HdH5YMDXRsmKflpf1pILZWRFlTbJpxeU55nJl4Smt5HQaGzg1o6RHFPJaOqnmBDg=="], + + "glob/minimatch/brace-expansion/balanced-match": ["balanced-match@4.0.4", "", {}, "sha512-BLrgEcRTwX2o6gGxGOCNyMvGSp35YofuYzw9h1IMTRmKqttAZZVU67bdb9Pr2vUHA8+j3i2tJfjO6C6+4myGTA=="], + } +} diff --git a/example-app/bunfig.toml b/example-app/bunfig.toml new file mode 100644 index 0000000..641e878 --- /dev/null +++ b/example-app/bunfig.toml @@ -0,0 +1,2 @@ +[install] +linker = "isolated" diff --git a/example-app/capacitor.config.ts b/example-app/capacitor.config.ts new file mode 100644 index 0000000..5caea73 --- /dev/null +++ b/example-app/capacitor.config.ts @@ -0,0 +1,13 @@ +import type { CapacitorConfig } from '@capacitor/cli'; + +const config: CapacitorConfig = { + appId: 'app.capgo.nativemap', + appName: 'Capgo Native Map', + webDir: 'dist', + bundledWebRuntime: false, + server: { + androidScheme: 'https', + }, +}; + +export default config; diff --git a/example-app/index.html b/example-app/index.html new file mode 100644 index 0000000..cd4dbd6 --- /dev/null +++ b/example-app/index.html @@ -0,0 +1,19 @@ + + + + + + + + + +@capgo/capacitor-native-audio + + +

    + + + diff --git a/example-app/ios/.gitignore b/example-app/ios/.gitignore new file mode 100644 index 0000000..f470299 --- /dev/null +++ b/example-app/ios/.gitignore @@ -0,0 +1,13 @@ +App/build +App/Pods +App/output +App/App/public +DerivedData +xcuserdata + +# Cordova plugins for Capacitor +capacitor-cordova-ios-plugins + +# Generated Config files +App/App/capacitor.config.json +App/App/config.xml diff --git a/example-app/ios/App/App.xcodeproj/project.pbxproj b/example-app/ios/App/App.xcodeproj/project.pbxproj new file mode 100644 index 0000000..7b5992e --- /dev/null +++ b/example-app/ios/App/App.xcodeproj/project.pbxproj @@ -0,0 +1,380 @@ +// !$*UTF8*$! +{ + archiveVersion = 1; + classes = { + }; + objectVersion = 60; + objects = { + +/* Begin PBXBuildFile section */ + 2FAD9763203C412B000D30F8 /* config.xml in Resources */ = {isa = PBXBuildFile; fileRef = 2FAD9762203C412B000D30F8 /* config.xml */; }; + 4D22ABE92AF431CB00220026 /* CapApp-SPM in Frameworks */ = {isa = PBXBuildFile; productRef = 4D22ABE82AF431CB00220026 /* CapApp-SPM */; }; + 50379B232058CBB4000EE86E /* capacitor.config.json in Resources */ = {isa = PBXBuildFile; fileRef = 50379B222058CBB4000EE86E /* capacitor.config.json */; }; + 504EC3081FED79650016851F /* AppDelegate.swift in Sources */ = {isa = PBXBuildFile; fileRef = 504EC3071FED79650016851F /* AppDelegate.swift */; }; + 504EC30D1FED79650016851F /* Main.storyboard in Resources */ = {isa = PBXBuildFile; fileRef = 504EC30B1FED79650016851F /* Main.storyboard */; }; + 504EC30F1FED79650016851F /* Assets.xcassets in Resources */ = {isa = PBXBuildFile; fileRef = 504EC30E1FED79650016851F /* Assets.xcassets */; }; + 504EC3121FED79650016851F /* LaunchScreen.storyboard in Resources */ = {isa = PBXBuildFile; fileRef = 504EC3101FED79650016851F /* LaunchScreen.storyboard */; }; + 50B271D11FEDC1A000F3C39B /* public in Resources */ = {isa = PBXBuildFile; fileRef = 50B271D01FEDC1A000F3C39B /* public */; }; + 8A37553416F54B05B9496449 /* SceneDelegate.swift in Sources */ = {isa = PBXBuildFile; fileRef = 1E48BEE0478545B69113EF4B /* SceneDelegate.swift */; }; +/* End PBXBuildFile section */ + +/* Begin PBXFileReference section */ + 2FAD9762203C412B000D30F8 /* config.xml */ = {isa = PBXFileReference; lastKnownFileType = text.xml; path = config.xml; sourceTree = ""; }; + 50379B222058CBB4000EE86E /* capacitor.config.json */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.json; path = capacitor.config.json; sourceTree = ""; }; + 504EC3041FED79650016851F /* App.app */ = {isa = PBXFileReference; explicitFileType = wrapper.application; includeInIndex = 0; path = App.app; sourceTree = BUILT_PRODUCTS_DIR; }; + 504EC3071FED79650016851F /* AppDelegate.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = AppDelegate.swift; sourceTree = ""; }; + 504EC30C1FED79650016851F /* Base */ = {isa = PBXFileReference; lastKnownFileType = file.storyboard; name = Base; path = Base.lproj/Main.storyboard; sourceTree = ""; }; + 504EC30E1FED79650016851F /* Assets.xcassets */ = {isa = PBXFileReference; lastKnownFileType = folder.assetcatalog; path = Assets.xcassets; sourceTree = ""; }; + 504EC3111FED79650016851F /* Base */ = {isa = PBXFileReference; lastKnownFileType = file.storyboard; name = Base; path = Base.lproj/LaunchScreen.storyboard; sourceTree = ""; }; + 504EC3131FED79650016851F /* Info.plist */ = {isa = PBXFileReference; lastKnownFileType = text.plist.xml; path = Info.plist; sourceTree = ""; }; + 50B271D01FEDC1A000F3C39B /* public */ = {isa = PBXFileReference; lastKnownFileType = folder; path = public; sourceTree = ""; }; + 958DCC722DB07C7200EA8C5F /* debug.xcconfig */ = {isa = PBXFileReference; lastKnownFileType = text.xcconfig; name = debug.xcconfig; path = ../debug.xcconfig; sourceTree = SOURCE_ROOT; }; + 1E48BEE0478545B69113EF4B /* SceneDelegate.swift */ = {isa = PBXFileReference; name = "SceneDelegate.swift"; path = "SceneDelegate.swift"; sourceTree = ""; fileEncoding = 4; lastKnownFileType = sourcecode.swift; explicitFileType = undefined; includeInIndex = 0; }; +/* End PBXFileReference section */ + +/* Begin PBXFrameworksBuildPhase section */ + 504EC3011FED79650016851F /* Frameworks */ = { + isa = PBXFrameworksBuildPhase; + buildActionMask = 2147483647; + files = ( + 4D22ABE92AF431CB00220026 /* CapApp-SPM in Frameworks */, + ); + runOnlyForDeploymentPostprocessing = 0; + }; +/* End PBXFrameworksBuildPhase section */ + +/* Begin PBXGroup section */ + 504EC2FB1FED79650016851F = { + isa = PBXGroup; + children = ( + 958DCC722DB07C7200EA8C5F /* debug.xcconfig */, + 504EC3061FED79650016851F /* App */, + 504EC3051FED79650016851F /* Products */, + ); + sourceTree = ""; + }; + 504EC3051FED79650016851F /* Products */ = { + isa = PBXGroup; + children = ( + 504EC3041FED79650016851F /* App.app */, + ); + name = Products; + sourceTree = ""; + }; + 504EC3061FED79650016851F /* App */ = { + isa = PBXGroup; + children = ( + 50379B222058CBB4000EE86E /* capacitor.config.json */, + 504EC3071FED79650016851F /* AppDelegate.swift */, + 504EC30B1FED79650016851F /* Main.storyboard */, + 504EC30E1FED79650016851F /* Assets.xcassets */, + 504EC3101FED79650016851F /* LaunchScreen.storyboard */, + 504EC3131FED79650016851F /* Info.plist */, + 2FAD9762203C412B000D30F8 /* config.xml */, + 50B271D01FEDC1A000F3C39B /* public */, + 1E48BEE0478545B69113EF4B /* SceneDelegate.swift */, + ); + path = App; + sourceTree = ""; + }; +/* End PBXGroup section */ + +/* Begin PBXNativeTarget section */ + 504EC3031FED79650016851F /* App */ = { + isa = PBXNativeTarget; + buildConfigurationList = 504EC3161FED79650016851F /* Build configuration list for PBXNativeTarget "App" */; + buildPhases = ( + 504EC3001FED79650016851F /* Sources */, + 504EC3011FED79650016851F /* Frameworks */, + 504EC3021FED79650016851F /* Resources */, + ); + buildRules = ( + ); + dependencies = ( + ); + name = App; + packageProductDependencies = ( + 4D22ABE82AF431CB00220026 /* CapApp-SPM */, + ); + productName = App; + productReference = 504EC3041FED79650016851F /* App.app */; + productType = "com.apple.product-type.application"; + }; +/* End PBXNativeTarget section */ + +/* Begin PBXProject section */ + 504EC2FC1FED79650016851F /* Project object */ = { + isa = PBXProject; + attributes = { + LastSwiftUpdateCheck = 920; + LastUpgradeCheck = 920; + TargetAttributes = { + 504EC3031FED79650016851F = { + CreatedOnToolsVersion = 9.2; + LastSwiftMigration = 1100; + ProvisioningStyle = Automatic; + }; + }; + }; + buildConfigurationList = 504EC2FF1FED79650016851F /* Build configuration list for PBXProject "App" */; + compatibilityVersion = "Xcode 8.0"; + developmentRegion = en; + hasScannedForEncodings = 0; + knownRegions = ( + en, + Base, + ); + mainGroup = 504EC2FB1FED79650016851F; + packageReferences = ( + D4C12C0A2AAA248700AAC8A2 /* XCLocalSwiftPackageReference "CapApp-SPM" */, + ); + productRefGroup = 504EC3051FED79650016851F /* Products */; + projectDirPath = ""; + projectRoot = ""; + targets = ( + 504EC3031FED79650016851F /* App */, + ); + }; +/* End PBXProject section */ + +/* Begin PBXResourcesBuildPhase section */ + 504EC3021FED79650016851F /* Resources */ = { + isa = PBXResourcesBuildPhase; + buildActionMask = 2147483647; + files = ( + 504EC3121FED79650016851F /* LaunchScreen.storyboard in Resources */, + 50B271D11FEDC1A000F3C39B /* public in Resources */, + 504EC30F1FED79650016851F /* Assets.xcassets in Resources */, + 50379B232058CBB4000EE86E /* capacitor.config.json in Resources */, + 504EC30D1FED79650016851F /* Main.storyboard in Resources */, + 2FAD9763203C412B000D30F8 /* config.xml in Resources */, + ); + runOnlyForDeploymentPostprocessing = 0; + }; +/* End PBXResourcesBuildPhase section */ + +/* Begin PBXSourcesBuildPhase section */ + 504EC3001FED79650016851F /* Sources */ = { + isa = PBXSourcesBuildPhase; + buildActionMask = 2147483647; + files = ( + 504EC3081FED79650016851F /* AppDelegate.swift in Sources */, + 8A37553416F54B05B9496449 /* SceneDelegate.swift in Sources */, + ); + runOnlyForDeploymentPostprocessing = 0; + }; +/* End PBXSourcesBuildPhase section */ + +/* Begin PBXVariantGroup section */ + 504EC30B1FED79650016851F /* Main.storyboard */ = { + isa = PBXVariantGroup; + children = ( + 504EC30C1FED79650016851F /* Base */, + ); + name = Main.storyboard; + sourceTree = ""; + }; + 504EC3101FED79650016851F /* LaunchScreen.storyboard */ = { + isa = PBXVariantGroup; + children = ( + 504EC3111FED79650016851F /* Base */, + ); + name = LaunchScreen.storyboard; + sourceTree = ""; + }; +/* End PBXVariantGroup section */ + +/* Begin XCBuildConfiguration section */ + 504EC3141FED79650016851F /* Debug */ = { + isa = XCBuildConfiguration; + baseConfigurationReference = 958DCC722DB07C7200EA8C5F /* debug.xcconfig */; + buildSettings = { + ALWAYS_SEARCH_USER_PATHS = NO; + CLANG_ANALYZER_NONNULL = YES; + CLANG_ANALYZER_NUMBER_OBJECT_CONVERSION = YES_AGGRESSIVE; + CLANG_CXX_LANGUAGE_STANDARD = "gnu++14"; + CLANG_CXX_LIBRARY = "libc++"; + CLANG_ENABLE_MODULES = YES; + CLANG_ENABLE_OBJC_ARC = YES; + CLANG_WARN_BLOCK_CAPTURE_AUTORELEASING = YES; + CLANG_WARN_BOOL_CONVERSION = YES; + CLANG_WARN_COMMA = YES; + CLANG_WARN_CONSTANT_CONVERSION = YES; + CLANG_WARN_DIRECT_OBJC_ISA_USAGE = YES_ERROR; + CLANG_WARN_DOCUMENTATION_COMMENTS = YES; + CLANG_WARN_EMPTY_BODY = YES; + CLANG_WARN_ENUM_CONVERSION = YES; + CLANG_WARN_INFINITE_RECURSION = YES; + CLANG_WARN_INT_CONVERSION = YES; + CLANG_WARN_NON_LITERAL_NULL_CONVERSION = YES; + CLANG_WARN_OBJC_LITERAL_CONVERSION = YES; + CLANG_WARN_OBJC_ROOT_CLASS = YES_ERROR; + CLANG_WARN_RANGE_LOOP_ANALYSIS = YES; + CLANG_WARN_STRICT_PROTOTYPES = YES; + CLANG_WARN_SUSPICIOUS_MOVE = YES; + CLANG_WARN_UNGUARDED_AVAILABILITY = YES_AGGRESSIVE; + CLANG_WARN_UNREACHABLE_CODE = YES; + CLANG_WARN__DUPLICATE_METHOD_MATCH = YES; + CODE_SIGN_IDENTITY = "iPhone Developer"; + COPY_PHASE_STRIP = NO; + DEBUG_INFORMATION_FORMAT = dwarf; + ENABLE_STRICT_OBJC_MSGSEND = YES; + ENABLE_TESTABILITY = YES; + GCC_C_LANGUAGE_STANDARD = gnu11; + GCC_DYNAMIC_NO_PIC = NO; + GCC_NO_COMMON_BLOCKS = YES; + GCC_OPTIMIZATION_LEVEL = 0; + GCC_PREPROCESSOR_DEFINITIONS = ( + "DEBUG=1", + "$(inherited)", + ); + GCC_WARN_64_TO_32_BIT_CONVERSION = YES; + GCC_WARN_ABOUT_RETURN_TYPE = YES_ERROR; + GCC_WARN_UNDECLARED_SELECTOR = YES; + GCC_WARN_UNINITIALIZED_AUTOS = YES_AGGRESSIVE; + GCC_WARN_UNUSED_FUNCTION = YES; + GCC_WARN_UNUSED_VARIABLE = YES; + IPHONEOS_DEPLOYMENT_TARGET = 15.0; + MTL_ENABLE_DEBUG_INFO = YES; + ONLY_ACTIVE_ARCH = YES; + SDKROOT = iphoneos; + SWIFT_ACTIVE_COMPILATION_CONDITIONS = DEBUG; + SWIFT_OPTIMIZATION_LEVEL = "-Onone"; + }; + name = Debug; + }; + 504EC3151FED79650016851F /* Release */ = { + isa = XCBuildConfiguration; + buildSettings = { + ALWAYS_SEARCH_USER_PATHS = NO; + CLANG_ANALYZER_NONNULL = YES; + CLANG_ANALYZER_NUMBER_OBJECT_CONVERSION = YES_AGGRESSIVE; + CLANG_CXX_LANGUAGE_STANDARD = "gnu++14"; + CLANG_CXX_LIBRARY = "libc++"; + CLANG_ENABLE_MODULES = YES; + CLANG_ENABLE_OBJC_ARC = YES; + CLANG_WARN_BLOCK_CAPTURE_AUTORELEASING = YES; + CLANG_WARN_BOOL_CONVERSION = YES; + CLANG_WARN_COMMA = YES; + CLANG_WARN_CONSTANT_CONVERSION = YES; + CLANG_WARN_DIRECT_OBJC_ISA_USAGE = YES_ERROR; + CLANG_WARN_DOCUMENTATION_COMMENTS = YES; + CLANG_WARN_EMPTY_BODY = YES; + CLANG_WARN_ENUM_CONVERSION = YES; + CLANG_WARN_INFINITE_RECURSION = YES; + CLANG_WARN_INT_CONVERSION = YES; + CLANG_WARN_NON_LITERAL_NULL_CONVERSION = YES; + CLANG_WARN_OBJC_LITERAL_CONVERSION = YES; + CLANG_WARN_OBJC_ROOT_CLASS = YES_ERROR; + CLANG_WARN_RANGE_LOOP_ANALYSIS = YES; + CLANG_WARN_STRICT_PROTOTYPES = YES; + CLANG_WARN_SUSPICIOUS_MOVE = YES; + CLANG_WARN_UNGUARDED_AVAILABILITY = YES_AGGRESSIVE; + CLANG_WARN_UNREACHABLE_CODE = YES; + CLANG_WARN__DUPLICATE_METHOD_MATCH = YES; + CODE_SIGN_IDENTITY = "iPhone Developer"; + COPY_PHASE_STRIP = NO; + DEBUG_INFORMATION_FORMAT = "dwarf-with-dsym"; + ENABLE_NS_ASSERTIONS = NO; + ENABLE_STRICT_OBJC_MSGSEND = YES; + GCC_C_LANGUAGE_STANDARD = gnu11; + GCC_NO_COMMON_BLOCKS = YES; + GCC_WARN_64_TO_32_BIT_CONVERSION = YES; + GCC_WARN_ABOUT_RETURN_TYPE = YES_ERROR; + GCC_WARN_UNDECLARED_SELECTOR = YES; + GCC_WARN_UNINITIALIZED_AUTOS = YES_AGGRESSIVE; + GCC_WARN_UNUSED_FUNCTION = YES; + GCC_WARN_UNUSED_VARIABLE = YES; + IPHONEOS_DEPLOYMENT_TARGET = 15.0; + MTL_ENABLE_DEBUG_INFO = NO; + SDKROOT = iphoneos; + SWIFT_COMPILATION_MODE = wholemodule; + SWIFT_OPTIMIZATION_LEVEL = "-O"; + VALIDATE_PRODUCT = YES; + }; + name = Release; + }; + 504EC3171FED79650016851F /* Debug */ = { + isa = XCBuildConfiguration; + baseConfigurationReference = 958DCC722DB07C7200EA8C5F /* debug.xcconfig */; + buildSettings = { + ASSETCATALOG_COMPILER_APPICON_NAME = AppIcon; + CODE_SIGN_STYLE = Automatic; + CURRENT_PROJECT_VERSION = 1; + INFOPLIST_FILE = App/Info.plist; + IPHONEOS_DEPLOYMENT_TARGET = 15.0; + LD_RUNPATH_SEARCH_PATHS = ( + "$(inherited)", + "@executable_path/Frameworks", + ); + MARKETING_VERSION = 1.0; + OTHER_SWIFT_FLAGS = "$(inherited) \"-D\" \"COCOAPODS\" \"-DDEBUG\""; + PRODUCT_BUNDLE_IDENTIFIER = app.capgo.nativeaudio; + PRODUCT_NAME = "$(TARGET_NAME)"; + SWIFT_ACTIVE_COMPILATION_CONDITIONS = DEBUG; + SWIFT_VERSION = 5.0; + TARGETED_DEVICE_FAMILY = "1,2"; + }; + name = Debug; + }; + 504EC3181FED79650016851F /* Release */ = { + isa = XCBuildConfiguration; + buildSettings = { + ASSETCATALOG_COMPILER_APPICON_NAME = AppIcon; + CODE_SIGN_STYLE = Automatic; + CURRENT_PROJECT_VERSION = 1; + INFOPLIST_FILE = App/Info.plist; + IPHONEOS_DEPLOYMENT_TARGET = 15.0; + LD_RUNPATH_SEARCH_PATHS = ( + "$(inherited)", + "@executable_path/Frameworks", + ); + MARKETING_VERSION = 1.0; + PRODUCT_BUNDLE_IDENTIFIER = app.capgo.nativeaudio; + PRODUCT_NAME = "$(TARGET_NAME)"; + SWIFT_ACTIVE_COMPILATION_CONDITIONS = ""; + SWIFT_VERSION = 5.0; + TARGETED_DEVICE_FAMILY = "1,2"; + }; + name = Release; + }; +/* End XCBuildConfiguration section */ + +/* Begin XCConfigurationList section */ + 504EC2FF1FED79650016851F /* Build configuration list for PBXProject "App" */ = { + isa = XCConfigurationList; + buildConfigurations = ( + 504EC3141FED79650016851F /* Debug */, + 504EC3151FED79650016851F /* Release */, + ); + defaultConfigurationIsVisible = 0; + defaultConfigurationName = Release; + }; + 504EC3161FED79650016851F /* Build configuration list for PBXNativeTarget "App" */ = { + isa = XCConfigurationList; + buildConfigurations = ( + 504EC3171FED79650016851F /* Debug */, + 504EC3181FED79650016851F /* Release */, + ); + defaultConfigurationIsVisible = 0; + defaultConfigurationName = Release; + }; +/* End XCConfigurationList section */ + +/* Begin XCLocalSwiftPackageReference section */ + D4C12C0A2AAA248700AAC8A2 /* XCLocalSwiftPackageReference "CapApp-SPM" */ = { + isa = XCLocalSwiftPackageReference; + relativePath = "CapApp-SPM"; + }; +/* End XCLocalSwiftPackageReference section */ + +/* Begin XCSwiftPackageProductDependency section */ + 4D22ABE82AF431CB00220026 /* CapApp-SPM */ = { + isa = XCSwiftPackageProductDependency; + package = D4C12C0A2AAA248700AAC8A2 /* XCLocalSwiftPackageReference "CapApp-SPM" */; + productName = "CapApp-SPM"; + }; +/* End XCSwiftPackageProductDependency section */ + }; + rootObject = 504EC2FC1FED79650016851F /* Project object */; +} diff --git a/example-app/ios/App/App.xcodeproj/project.xcworkspace/xcshareddata/IDEWorkspaceChecks.plist b/example-app/ios/App/App.xcodeproj/project.xcworkspace/xcshareddata/IDEWorkspaceChecks.plist new file mode 100644 index 0000000..18d9810 --- /dev/null +++ b/example-app/ios/App/App.xcodeproj/project.xcworkspace/xcshareddata/IDEWorkspaceChecks.plist @@ -0,0 +1,8 @@ + + + + + IDEDidComputeMac32BitWarning + + + diff --git a/example-app/ios/App/App/AppDelegate.swift b/example-app/ios/App/App/AppDelegate.swift new file mode 100644 index 0000000..d3091c4 --- /dev/null +++ b/example-app/ios/App/App/AppDelegate.swift @@ -0,0 +1,58 @@ +import UIKit +import Capacitor + +@UIApplicationMain +class AppDelegate: UIResponder, UIApplicationDelegate { + + var window: UIWindow? + + func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool { + // Override point for customization after application launch. + return true + } + + func applicationWillResignActive(_ application: UIApplication) { + // Sent when the application is about to move from active to inactive state. This can occur for certain types of temporary interruptions (such as an incoming phone call or SMS message) or when the user quits the application and it begins the transition to the background state. + // Use this method to pause ongoing tasks, disable timers, and invalidate graphics rendering callbacks. Games should use this method to pause the game. + } + + func applicationDidEnterBackground(_ application: UIApplication) { + // Use this method to release shared resources, save user data, invalidate timers, and store enough application state information to restore your application to its current state in case it is terminated later. + // If your application supports background execution, this method is called instead of applicationWillTerminate: when the user quits. + } + + func applicationWillEnterForeground(_ application: UIApplication) { + // Called as part of the transition from the background to the active state; here you can undo many of the changes made on entering the background. + } + + func applicationDidBecomeActive(_ application: UIApplication) { + // Restart any tasks that were paused (or not yet started) while the application was inactive. If the application was previously in the background, optionally refresh the user interface. + } + + func applicationWillTerminate(_ application: UIApplication) { + // Called when the application is about to terminate. Save data if appropriate. See also applicationDidEnterBackground:. + } + + func application(_ app: UIApplication, open url: URL, options: [UIApplication.OpenURLOptionsKey: Any] = [:]) -> Bool { + // Called when the app was launched with a url. Feel free to add additional processing here, + // but if you want the App API to support tracking app url opens, make sure to keep this call + return ApplicationDelegateProxy.shared.application(app, open: url, options: options) + } + + func application(_ application: UIApplication, continue userActivity: NSUserActivity, restorationHandler: @escaping ([UIUserActivityRestoring]?) -> Void) -> Bool { + // Called when the app was launched with an activity, including Universal Links. + // Feel free to add additional processing here, but if you want the App API to support + // tracking app url opens, make sure to keep this call + return ApplicationDelegateProxy.shared.application(application, continue: userActivity, restorationHandler: restorationHandler) + } + + + func application(_ application: UIApplication, + configurationForConnecting connectingSceneSession: UISceneSession, + options: UIScene.ConnectionOptions) -> UISceneConfiguration { + let config = UISceneConfiguration(name: "Default Configuration", + sessionRole: connectingSceneSession.role) + config.delegateClass = SceneDelegate.self + return config + } +} diff --git a/example-app/ios/App/App/Assets.xcassets/AppIcon.appiconset/AppIcon-512@2x.png b/example-app/ios/App/App/Assets.xcassets/AppIcon.appiconset/AppIcon-512@2x.png new file mode 100644 index 0000000000000000000000000000000000000000..adf6ba01dbe256605c5152ac1fd78ae99aaa2a8d GIT binary patch literal 110522 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 C`SD)> literal 0 HcmV?d00001 diff --git a/example-app/ios/App/App/Assets.xcassets/AppIcon.appiconset/Contents.json b/example-app/ios/App/App/Assets.xcassets/AppIcon.appiconset/Contents.json new file mode 100644 index 0000000..9b7d382 --- /dev/null +++ b/example-app/ios/App/App/Assets.xcassets/AppIcon.appiconset/Contents.json @@ -0,0 +1,14 @@ +{ + "images" : [ + { + "filename" : "AppIcon-512@2x.png", + "idiom" : "universal", + "platform" : "ios", + "size" : "1024x1024" + } + ], + "info" : { + "author" : "xcode", + "version" : 1 + } +} diff --git a/example-app/ios/App/App/Assets.xcassets/Contents.json b/example-app/ios/App/App/Assets.xcassets/Contents.json new file mode 100644 index 0000000..da4a164 --- /dev/null +++ b/example-app/ios/App/App/Assets.xcassets/Contents.json @@ -0,0 +1,6 @@ +{ + "info" : { + "version" : 1, + "author" : "xcode" + } +} \ No newline at end of file diff --git a/example-app/ios/App/App/Assets.xcassets/Splash.imageset/Contents.json b/example-app/ios/App/App/Assets.xcassets/Splash.imageset/Contents.json new file mode 100644 index 0000000..d7d96a6 --- /dev/null +++ b/example-app/ios/App/App/Assets.xcassets/Splash.imageset/Contents.json @@ -0,0 +1,23 @@ +{ + "images" : [ + { + "idiom" : "universal", + "filename" : "splash-2732x2732-2.png", + "scale" : "1x" + }, + { + "idiom" : "universal", + "filename" : "splash-2732x2732-1.png", + "scale" : "2x" + }, + { + "idiom" : "universal", + "filename" : "splash-2732x2732.png", + "scale" : "3x" + } + ], + "info" : { + "version" : 1, + "author" : "xcode" + } +} \ No newline at end of file diff --git a/example-app/ios/App/App/Assets.xcassets/Splash.imageset/splash-2732x2732-1.png b/example-app/ios/App/App/Assets.xcassets/Splash.imageset/splash-2732x2732-1.png new file mode 100644 index 0000000000000000000000000000000000000000..33ea6c970f2df1db62a624a55e5bbcc4ee07bbdf GIT binary patch literal 41273 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 literal 0 HcmV?d00001 diff --git a/example-app/ios/App/App/Assets.xcassets/Splash.imageset/splash-2732x2732-2.png b/example-app/ios/App/App/Assets.xcassets/Splash.imageset/splash-2732x2732-2.png new file mode 100644 index 0000000000000000000000000000000000000000..33ea6c970f2df1db62a624a55e5bbcc4ee07bbdf GIT binary patch literal 41273 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 literal 0 HcmV?d00001 diff --git a/example-app/ios/App/App/Assets.xcassets/Splash.imageset/splash-2732x2732.png b/example-app/ios/App/App/Assets.xcassets/Splash.imageset/splash-2732x2732.png new file mode 100644 index 0000000000000000000000000000000000000000..33ea6c970f2df1db62a624a55e5bbcc4ee07bbdf GIT binary patch literal 41273 zcmeHvcT|&E*ykHSBNh;JqzD9IP*5R&N{28KWdx+DfKoy+A~p0*5(h_Mq|A&6C{o0s z4IrrW790>}s47hX2}MA_5F#akkYwMy(b@0Y^X=~0{cF#j_^9ymWWx9d1}tXhO$0N5J<3{VjPZXQ0^5P5g3r0=1E(An$eEP{IDp zMfHmTCfJ)^KSl*%FGX2i_K5QF(7mpJGLkol&;t$lVME;HBm8{*gY_Z|6(GBMV4M4E zq=G!uCB(;2;Ro&m#AvJsh>WhaZ+AWT|*nGeg>(o zrK+x>r>>)?sUiRMr2sxH==u#kTlD#_&jSBusBkkRBtQ>|3=a=i3qPfX3-Uy2=<4bs z)isftnyO$A)!<0~5Vr_b|6s*$7SPyWk07sr5HFm+JlCR|J1#WDPyrk%Zwh_^|C;p= z{t6Qa7&5{w0I8v-&Ycp}@w&&q{Q^RRe4&S5_dsHOv3^+pkYKQ{#=m_7ZsJ04!8dXL z6Vv~G{GT2GLVNMzzt8wD$KvPr?<0ak&V_-~_zK8>**o}hWB?Xviw(ww26`9jKleUTPW*qLzXu&kypOx=Hcbfor21L_yQK~7J@ZY;I5jghNh~f z?q!WLdg{7*n(C_RT6*g0ysj5<*S&5;{@YatTw1XAWsTE%8oGMwr~Xq{&}FW>g}D81 zJ74$EyMYVxa|0*r<>%&!MF#kLD#-r}qn-)Q7Z(IR7#!WH|M>e0CMMQFxEo%+;0M9B zrf20ZoHNnV(ACmX)l}1fhI{d%-Ua{Q5I27h>;<%;0tk+pm)CVY>~(kSDJ?fmRjh}m zuIgz`4_#Gv53TE}ZaOz^Xlb}>VX>z*zkMH#^9bd-z_;&T|3Cb`Rgf1Lf^NS5*LJvp z$@Lw*AH9OXRgL@_I+w74Ut7Lj@{qgexp{EIz)-=1yZ+eg3SWQi^?!{3&usWjENJw9 z;TODa!MGbC;ch|LA3Q;{{;KogZD z`?U!?a^tct_eI`YLxY^uw)y^dMVjIvVJ{Qf3NPt!XGAAj-Q*8!@N4y@?%YKCa(r}$akrvSez9|1lBd<6Ii@Dbo6z(;_O03U(>ZxCoTne3{L zSm>r@hi}9pOg~L$(dZoK@uq4j6O_Nic(an~Wu_drNe`O6*2I{t3p_2(LO`I#BWqjZltZ*$)!bsmZXBi9N@>B>s(W`by^`W$t5K<&Rq;(12&xucPo z9@P*22i3KmKUj>_oqL7WCDJVci;s|<9GEaYtr%; zMJDm$zyV!u-w0g6a1`|k*di)wC;?l?0h=f1(GN=59~fiXr{<@Bo}WqVOj$gHsA5_H zAqdW62ArVV_sFO!8k{pRKK%mMNPv@5{UHwHtP^5vyc;G=?43Z>9YPvbtpY~I0`fhA zT1}sWQFI1Y=Qk*nTk#L7zQEO3kWWj{P3AV6dC_T-=-#K+ZK~^%rcv zok$;gSx_YfU?q22j}k)h(X$crfLe3n2pMR}GNA;oRgR1K=jyr*%fXUY zq$^DGT=;%J^D=XGD4P&$k$45mT3@2QwNJ4ZnFJ#Osn(J0WfLd8G#`VcOG*9;t;v4K zZ=Y!Q0-49xf`4x8D+SUT2ETNx!}HSWy^Yj%?`MtQaI&843Qu{{06<})0fx!7Cuzk> zX34hHSog9VT%fC_G34Ytr~9!PZ^*ui*^w98Hlo!-A}M>&8qa5&%~fY#wnOG;iw_(L z#Rr377_oN_W^oGeCqIBo4r&SKEst-r8XfVFDWd5ko~vi0w*9vU?go}01Foq=t0iZ| zc~4!MB8_A5ct7)`E)v(0*^_2>MXQMw;L! zVPd4w59l>7_`t5)dZZT8eb{pMKL=yfOg71gFk}#5lBCitiJDKVOO6-mowCzo- zxvI%`Bo@l9gSoxE>6vV6*Jz$-8$S?zk7XT53Q~31{$f+M=k)=g`%#?cxb0O>;Ew0j znu<#TbQ7-I0B3o@>D~p~{r@Y0-xf^*whbdR9f3pDPfBxMrH*kQ==#(ty9V7b-5lhEfUDA0vnWX$jKRBGnt~ z4KVEZWqagPgHJN8KDZ82jH-XFRSAo{a`4UhgJrunDJ*epvFh~x@MHlCE`0#5COiH*ZS^W5>|&;Znr4Kv-f9zlzp16-m{ z;isz8ft%VI`!=ada z;yBG=?z7_eg{Mbvc0tb=2&=x7WdJ_a)GO#4r6WEkRL>AN2q+k;B8#`Hl3w1T** z4s{e_0os{9!Gwg&E$Y&7n0hKa0egfPq>x|rS4@wO(3+S)_0YKXJ^K9cc8gl8ea$M+ zqE{{ua7?SH?*P*y3&_O1AcQd265QVZRILG1msNoHg?bmlBVgQb4mK!VfR+sg20BV4 zP+<)mM-BYR2CK%7OZils4bihtZ51dKYNdn;o(K)4HN5a)mpwOpM&9(7ca1v6vy}na zT48S!$anQkvx><*g38VNNNXIC&!uF!7qK?O<@C0K!bm|#K&DWe4q#$W;1{Yt-38J# zosL|4K$;icS*^6w?7csxZ=$(A;aA8DMBAZQh(NSND&lFV4h-WS?Y&idV)jG&t{*Zmq7l`*;h))3u2RCU4@o$9Z=O+@{^t~pgV$aj6jU?XSh0GtYwiID9=44` zg;qBXUs0I44MjwZJj4+JB(D7hR7bU=m{Jb&6FUg7&rqE?$!a(iL`tP2O|sY<#NiUs zsEcBkw;kut^JMAGjFHd}ohUUm_0JVc<<;n`2;JCea8q36g~lxhp4{zD1M1lRX$i%F zQ{{|l92MtGwELC%Vy#=ffRq+FNRVRZ>a*Zj#>f-kk{2nh;4SG7A+2Mn)H}6j(su}i z{RE@j*qT_#@nI@M?!XAJq%e1a&`cg#={-y{=cqg->DN|SUHN<$cdp&0UobNW5Th+- z`3*E&L)p_DJ2{tgs5=;=-J9k0r1T+^^#WLW#1DtXtw-n4SDjAm=h#`o z#Fl-a-xs)+OxV4<=L~Zl;B3}S1#9P?xv@jbOg|4U;{Lb#BfTS#ry%S~)^BpGxoy$= zxQPS|ySI+rXL~9a|69)Pj{`OHIR=Z7fLP#HMqT|d_!vvDU3yKx%z2EqB;34pXEt)w zmpFB4aj`Qf`>oOGt}j>Gx5gLhXm>|H%UJ2CKu;0Gw+k2Sw0+{=$epJ|>EUX+*8M2ts5*cZzCS&brN+{`W0Af2@%W9Nc z`%eF~(7y2Lo*maV5srqoDv^y25EgQhPwh3Be)@FSRSssx;Ui$z%=UZ#(=!9oXBj!y zEU)6#)%2;WX2_4CxzCf45%&jD zhSga{3WdAFottIx?L{ds8-O> z#Z5OaRu&t%?2wH~uPDZp4o-OwTr}g3sr3kti|=duw^um*vQ#^#7oI%yZoA+&!{LJE zgaqYT$+A8BZMuWTR+Fp8#_kAq9oMdGSSm>;F_Tz&1K+vNXG%ZoJ79sh+@UH{zo41@3VK)T-maPlJ$~>@EFl&rwKR#pDt^&Ef&S{8sjnVCgwP);+ zuhzpA+;2uwsf7ZOOGNTsAi-^?F_>*G-yGq~@$Ds1M14y7)5v4N!=OP1p?mTC$S(n07-#s!gT4Sin=ADd8SSY@ygkSDd;;zu- zeqpW?trSPk+=!X7bs~fhEx26si;)T>7qM_%lW)uxvZObkU6shon9A^G`^UIt2W6)E z-@0=X6k466XbM6154CP(wAU%14ALO+7q~tSriG7yy6V%NsaLk2nd9Yh5au3CTm9UL zl)Jn3z7R?|Cz5wEcC*0nZ`;R+ayx;{+LOY!hNOj6T`Hr0bFdW~Si0x-9d~#-yCIe} zXyDGdPDb0`uY2Zf#S!co}0fI(c;WX7el5=)1U~C--L=y{Cp7 zSe9X{LZJ=<^6ojXl^MvT0~luIrc4R$5Ow4Vr2y@TBw0eV+~Qbu zO*m_Jf$TWaX3l#n*s8-5C3bAt=tqwFcnPhmAYy$ns15sJ9znTL&7 zy51R+oyM08h_hm0H{{S`SFTwRR8_%D`ApZl5rVaVe8)@S(Dy;MJd5d2T9;bfzx`f^ z^P4i(xg2ReOG*;HC7va+HJb8SY29{i=T@=mf!9YVrpz?Mr+Zdn93@;;K8f}l8GZi! zfR4J_>r?x)3|ZoB4FKnZ>GTY04M6Mw5vk*8b2%GNtIqkHp7K|J)A+t_~fnv?uNVao>B=>9anCV;w2XsnG0Ttnla%8=8wHTRw>o+Tbj#v5}Qx`NCG>w+#qyJU(bcTe~TS_V3M)*Wd- zcL%O_I8`kx(&jOlW7J+2WlmyYv}=B5Lq*v-zV;d3S;1)idd$Xw!0Ei_TT}I4g%@6% zQZn`;^{(9D=tPRXnJ*{3a`TstUP`-X->W_Sod;57J5F)KWDgX85rf%=vMA<15nHr^ zj9CBQs2%5Eh2O#4tJRFFoZA9zn3uPsT3w0K(K+zfMXc0ZGF&cgp;TFQ+Pa4P52I|r z-fo24!5A#ag#ObZQ{JX9{ds{g4ra`+D50}09Zfz%hfr!l>W|*lrafOw!K9Q2Uu8{$ z;-bGc6jqZMU$TLjqwOrH5^4?j*c7;T|KR3hg>()xLrXRstP3bZhU0n3uR@f_WRLA? z&RPrS-NJfq%6QT$ruy#@I~|1nLj3bB_B^bLsT`^=@OXGuB|lzjaRqmJcITG+ZolKk zR|!YvxYKTRJHYil;?;iG;BW~hicTn#*yC{6bCMosH_K^gIE(UY7?leK`cc*6o}x!j z*2h0TMRCm(Qb*_xGCN~TdL(>SfzhWZUd5#Cdx&-Kf?AnPOGp?sn}i=?n^sfQ%8%d& zlrd48O;?8IPmQ8kdvLEZHk#F1AK56|bdKFj-d4;;FN!!e6FvrLpK7$GK zIZ6F^1B%1&zdFKDcG_G2h>1g4_A>+LJ{#CX&-Ho?yNz`Ay_(NWJti0ZYd;qV z-nQYmYCudq$=Yhh5+aFL(cUHW6 znQfob|9UsYdc0A~+zY_)O+f@yZTTLAi$)jB# zXDa3{{l>b4FxX@K`) zu^RnoFBXVypIA-C#?HH^3bIiW-Aixv$Q)ALNGNRU)X>FEykzuiEnh!z;7x|Oq{xRD zzY2`DD0kL!l2Bw#$`wWe_BgfjmBtU8P_I;s^fdFO(zQmy`{m?xK}pe^l+Cq!ve4?fX+LXPoRQqkId%u9*wq)euW=4nsHO;;o7znw zg7wyOywx$`txj}S5MV{PUhGYeEpKW*SU>hBEbAd-d>_WnUUF>4zT~Hbgt`^G7_SOl zqUIpm$63w~|F)(eV~map1eUws576p8 zXG%^jP1CC?dXm{5&+xVRC=tO=im;C35tu!$QKwkjT^gBibyT3#Q7MZ8mUsbDxKfRi zk?>YRK(YwRWqHDfY~5qJt{zHTiz8H!L(0 zRw*Z}E?eCh3044daZi%WCD2Lb9Jtn&m3Oz{pj)?&>EpFG0-@|{E~Fd085p1CPGp4* zmbDC64E1@`XzGLvS!AM6XxOacXKK&e3f51Q$~~PP&cw(;&Q@g{?$43+kcnvL^ zZcW^zD6~;b3W{-2AkzJE-~l(hymPCqTi~>JEP+~HRQSsbK(W+BC|Fh-=hE$X{8H`oEV%ugZ?}GpVLf!N zRsE7h{wsQhIah~wK;3@tU(h4&K1*@F-^V`)%9#Ir;Zylodb48F(D36E3{FOilXPh)kQb#RSvT(jS zUmgV0{#vEAd&JYPgXUKPc!xJ~NiT|Kg8Mr*Pn8EbgC)fmC4bAB>$&C>kfX@~xhg_A(dj!7V;de`$7A?)s@Cu925UuEtMAXS(oUq4H=h;#Xcg4`r1e z;=DaJMGxC-!L0``$ECJhH+If7a`Dqqa_4|bEuteb=jH2h)RG~q&7+L1{*3vvZ%*xb zw81L6X~m02Z~&CQw8n*Ogv2c0qYawgF`}0&#ePafn%w2gVR8}Hi$N>fVIK@p@j};b zPX1N9VIV5MbxK5u^R8;09xsh}vR4sS*ok{0kYDD$uiJn~ZNJOgrGMZN0=%LhtVdmY zlCIT8$b3LrAXbQBKPY3gqdlUBV|=qqXR4P8a;+;dtE$6tPQ^AOCVLkH&VD#4q;7ff zU5Zg=#cEG|#8f0SSl3q&%}1<&yT*J!I_V;(ToAt;g!HpN`C+A5u*H7BBLYk=OZ1$I zYL0Kd;tn-$FI^@S-?0!XD_2MkKs9_$5&DE&jCd2~kO-2z63^^Kh=xU8ard@iYRf^& z6Ok*FiD?p^biAOS$_!y;OA{)pM-uih`(Qn_2PqfEn6_j2JF5u?D5lvQ%EWqznN-+G zG8Qyh#;x!HC(@^dG{U*Yw5KtBdGoQ5 zOXoA#z>>7hhMwqT$&ks@xvi1nP<+onL2)yG+%{sn>ecm~*pp;`vQ20Qw2vEmLfg1Z zgO?mA2^8{coBL;1M$f}!7<;0~??kiWVZNhtO94OUh$cjU32PQSAhfBP@*}Y~WmG{R z_V*w5dVcV`ZJc!2+#q<^fICxlC<_)LgDkbssaUwYQBoPJkRQsS|IW6p$o+*yVHpVL zoljDPx$6e1{3>ccHg7;&?WUlUZJ+Gz*Xa;X@BFOF#@-KdupIwGYVrBA%g~C*{{=0y zj^+sNRd>epVsFhKEPriIUwVVzCT3#j(9xSuR>P%d$HuG->#31|MGi z{-IP`yZfJ?bvQ4M??ZjY?4G};cXFR~$ANg8O(sSHbVI4O<2yB|6kLWTAu*wtwMWJ8 z%x$gByko-NRn+o6T_T1h8c%lsjRurKDSE3|{hBH56-T@_+J;oqu-@lQZ$9l(NHA&S zG!>oPM;p@sr3JNoHBo7Lx+NG`Z5v*XYmdq8t|A6TBa&a6$_^emW|JY)y8RT5eiVI@ zy>(2K`hbgr!->#FS9!3tG6@!Z!i%)qsMDbX2M{*igW}a{)s#(6FK#7t`F9NdMMZF1 zEJDtDE76bnH7~Atd8;k-D;ZLbI#TgI+lbwqGmC>P6k2Iw1}QOMa{q11ZRvS7NHGf$ zbK`D?+=!3~=F!aK#deTKFn!JF?Oa8W#C`UdUtO~ z7s%WVg%t|JUyRnCEBC|s&~p!6RK|iihKT4*_*#)Jowq-xeq9KsjENK^E2GXiUXKpu zCrB?cc;4sMh|rRaaJLX{5At7dUKbNv^(AhuOYXmUO3<()@w%2iMq9nRy zcuKL$35#5p>=8_G>my`80fJAu8mc_rxZGa1@`F^EX`1-FWfoVK17c!aWtNNpn{ra% z<%Wgc8-C1DP8Md(k~K=NAYc*XUT1dq<5dNLnU@7M$yin(#qyh!aNRrg`de9|vZTgs z=aPeQGPrlA--2Ny@?WHa=_^!$Fuo1F1^lQ+lErLg*Bvlviz=I2wc?~+TAqK;05x2i zph!xMMQezKs)>9aCdL9lxA!Rshy?~#tO9d4*m|fS1fX6arXJ(feVceFDidLlkA4J2 z67d#fdu7rYuiwJZ5A?k0hZ&_s|J-;oma?j`PQ1f@6K2pl$H*S$M9$2455(7$2!ge* z*TZJTjiN@kCG9T3Kvz@ZX248{j?{T9B3Ids>#T^4U9QYEf9H|dEaKSpykPAPBk1*2 zjquirntl7$y2spR#tp!`-1EEBR8sZ_x>3Pc{XTAC!>qA6(%w1M_U01-v-@0>iGn-_ z5q%5R)twznV-djX)OWG^7F2388~Z7#;u(dC$YOTi@StWQQY*UC^<+L&G;qLza`n@k zhOC^x&7(f(#NgCd92T$A_fD^xcLTxzgp{<=7#RI%gCy05lG+JaR4mnbj*r#ihD985 zUtB%vs#cKd75BISg=x_yk0>jt#hg$`(Sxh^f*YZIh1xwpq))Gk@mEL^OCv2$(B+*T za;=MO_xi#Bw*=mHmy|6h<;RS>L3ewdQ^4X72H& z)u(S$POfsQ(TU1fow}1aW}-$;^?S+SDbi=TN_P8mU;p^^em`NNbRdm;eo8SESL)`NQkC{AS*5A<7pB zFQ!|+TwUs3_LU@jPJ%1b#!XXS84!buW;nldCr@PZitRD`G0d>-QgYS-;LYf#?v=1V zyXY5#9iyr3n5FrROIoXdccW{Gxd}lv_-NkX=HE0uEaQ`&tjtU&x~lYI#f^KqNLiG;V;jyIfna}9tag&JSeG(kf7kBq+Oez{*Vl&wP=}j1ELCizgPxa zoxNN%?ctfa`~;-3NjFdEa!mwbPN;S5hUf1bTMIM&W+!>UIR=Zk8t1WFu?+Oy*-%Y zbolyK>Lu7>gE%6*WXlTW*de)tm;&3Zd6;CHljBV%PfAJ8~GJCbloEcg8dAS4## ziQrCssT=In6FYq4;d^!OV56PIg-cbzW6WYGLkx)F2@gYP>?E;TDtd4A>Xo6Urze&v z3D-m%cH|8XIj~z|W6qQdtUN$Pj|jDX+$xXQv~^-FFFslFpT*PTI;1&^x3$t;kEOkS zB5YF*$>GinUe?&WJzP6Oj#2ctDxhih{DXt{JYg&u{7BkcK=TseIGjL+>iP^X(aKMv z`hhxo0r|pE7+99}bZ;tpo4<1)G~>R&;ujUA>GlBI_XhndVb!JC{?1$|bZU61M&mU0HRn*|OxQm(bP zV4Xlu4~u4*Cy$;#=qqw_mc98?Bi(?a36<1RzJoSr*QHvv4!f6H;R&=mZR9vkcmK&G zooIWhvDQy-?p7zx7DqDUF92vz+OsXv8l-nx=U}aL?lyOY^Lu2NcwU-Bad?%@T~IKDT>;Y)-?E2(e?9F~vfy*IgtgdwxBo zyu|7Ll6c94GyVzn@nDx;y>*wmpzC~15r^jm4BoA(lVCD@W_o#MO$I_EmbD(Iv zt%#R%brPX%uLrzVDE8(qnFZb?%ZUCcnBOn>$#898>Cnl{r>`@_b);w`>>fdLzyhL) zSBJ^6%k|``AMUdk@P+SpmXZ$0NQxAXc~avIk3nw0ya91sLIR^4l|o=L1NGB4IR$7{ z8$~mz!X>%@qhYW)={>UBX672O`UTdO$ucnm+QEwJ3)5Y$oQs`=+(p#=S0kXy1$XHP=5>Ha zwWm-UlLvqg;F-sl*@&5rFKL8O2kpYyG{Y;xd%X?@1k0Kug-qg zwT%m&$G#}ocTV})2bYmHz#B}~9ztM5LsFns5xiU2P!fb1p~k_E^POp74A|RP=Tpat?4`T-SBmGyQoH~Vf zQ8Kld?0*WFYuIquiL1zfu}!>4RU^TU+c&;%RbM5%C_Vq^7skSqi+}|?%6Eerh zMQ`XcnJikGG}P@axXjA)W{u1psZ zd{M&0f4C=Zv>`!XGj?+XiX4Ofe0^trjfFAk>{Ux#(fLH3Xg&NgA&IjA7nu#@I*Z^{ z?g<;wbcF8TnSn>PLX21Mi$R?iX5%E4nX|Uq(uno|n5z+RT8M-4zFsro6kMsOxa)%#sL0 zujcQOY?;=}`bd!7tXO|*fQ|(+5Yj0{8>hC9RSgOaQt}mJ*LxA4`f^f8>lxEtkotU= z`&Cis9Kuh6_4!Uvea+QY*OKTj0c>cDO0aVi+9!b;e;-`<3OTBfF&eCLaL+0id%h%f zE2b~#ZZ%$c``DL$P6bM}0#5QOx4u2Fw30zto1zZ-bMF-LpQR5OB?-A(zcE%(5eMnp zN7iMG%U+0JBl^T`;yX)~yq(W0rb&y@>L8S4M0xeC`_vC9$XG=el7__gJUMIRgh2bs zQ}no3^@{ZBaX|E(KpyXO4rgJ0q-wsrx;&~fa*h3SRWryp2VxJ%fwcWE7!R4rfmA?wveyhr;mPwc#C^T~p<% zE$AwQnCcOART=B)BbERfJe1p>5gS-d?v@*zdR2MoY)POc_fP;xk%GKu(iN;+R_i?# zQZEx&vB!UOy9k7=HUQc+ZGb|)r4-RE6x7)>1cDv!OA`P6OU~Fx8%4{)AHnpQdy1na z>S}A&{(Su9_T)KU-xIvP%`w!ln1#c%t>gqPLDxkNQpp=VXdq1Ve+Um)pWAL4yASi` zF5L;Pd;~gwhx~B74YnjOm>_<}1Js`td(;iT=5#S^6KO(^9gi(yS_a$9_C9NB_OhY%h0HQEdjo=m(jzU!nZY%Rw z?w{P3>shEY1Ge}b`S3t4!FLLNDDXpp9|{lx{7~SB0zVY^p}<9euOGig0$(-rlZtPy zz)z+43FKE_;Pd0Rpx{>(_(hkmzQE^4K0osL5ki0;3j9#uhXOwoKm_;#i7$}8QUQNg z;O`3jU4g$V@OK6N6$E|-=_?cR1=4?6Vc#|ARQe$B*9vbgOc%~sqMx31{pr5}7WQ#E literal 0 HcmV?d00001 diff --git a/example-app/ios/App/App/Base.lproj/LaunchScreen.storyboard b/example-app/ios/App/App/Base.lproj/LaunchScreen.storyboard new file mode 100644 index 0000000..e7ae5d7 --- /dev/null +++ b/example-app/ios/App/App/Base.lproj/LaunchScreen.storyboard @@ -0,0 +1,32 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/example-app/ios/App/App/Base.lproj/Main.storyboard b/example-app/ios/App/App/Base.lproj/Main.storyboard new file mode 100644 index 0000000..b44df7b --- /dev/null +++ b/example-app/ios/App/App/Base.lproj/Main.storyboard @@ -0,0 +1,19 @@ + + + + + + + + + + + + + + + + + + + diff --git a/example-app/ios/App/App/Info.plist b/example-app/ios/App/App/Info.plist new file mode 100644 index 0000000..4e194dc --- /dev/null +++ b/example-app/ios/App/App/Info.plist @@ -0,0 +1,70 @@ + + + + + CAPACITOR_DEBUG + $(CAPACITOR_DEBUG) + CFBundleDevelopmentRegion + en + CFBundleDisplayName + Native Audio Example + CFBundleExecutable + $(EXECUTABLE_NAME) + CFBundleIdentifier + $(PRODUCT_BUNDLE_IDENTIFIER) + CFBundleInfoDictionaryVersion + 6.0 + CFBundleName + $(PRODUCT_NAME) + CFBundlePackageType + APPL + CFBundleShortVersionString + $(MARKETING_VERSION) + CFBundleVersion + $(CURRENT_PROJECT_VERSION) + LSRequiresIPhoneOS + + UILaunchStoryboardName + LaunchScreen + UIMainStoryboardFile + Main + UIRequiredDeviceCapabilities + + armv7 + + UISupportedInterfaceOrientations + + UIInterfaceOrientationPortrait + UIInterfaceOrientationLandscapeLeft + UIInterfaceOrientationLandscapeRight + + UISupportedInterfaceOrientations~ipad + + UIInterfaceOrientationPortrait + UIInterfaceOrientationPortraitUpsideDown + UIInterfaceOrientationLandscapeLeft + UIInterfaceOrientationLandscapeRight + + UIViewControllerBasedStatusBarAppearance + + UIApplicationSceneManifest + + UIApplicationSupportsMultipleScenes + + UISceneConfigurations + + UIWindowSceneSessionRoleApplication + + + UISceneConfigurationName + Default Configuration + UISceneDelegateClassName + $(PRODUCT_MODULE_NAME).SceneDelegate + UISceneStoryboardFile + Main + + + + + + \ No newline at end of file diff --git a/example-app/ios/App/App/SceneDelegate.swift b/example-app/ios/App/App/SceneDelegate.swift new file mode 100644 index 0000000..f352e1e --- /dev/null +++ b/example-app/ios/App/App/SceneDelegate.swift @@ -0,0 +1,24 @@ +import UIKit +import Capacitor + +class SceneDelegate: UIResponder, UIWindowSceneDelegate { + var window: UIWindow? + + func scene(_ scene: UIScene, willConnectTo session: UISceneSession, options connectionOptions: UIScene.ConnectionOptions) { + guard let windowScene = scene as? UIWindowScene else { return } + + window = UIWindow(windowScene: windowScene) + window?.rootViewController = CAPBridgeViewController() + window?.makeKeyAndVisible() + + SceneDelegateProxy.shared.scene(scene, willConnectTo: session, options: connectionOptions) + } + + func scene(_ scene: UIScene, openURLContexts URLContexts: Set) { + SceneDelegateProxy.shared.scene(scene, openURLContexts: URLContexts) + } + + func scene(_ scene: UIScene, continue userActivity: NSUserActivity) { + SceneDelegateProxy.shared.scene(scene, continue: userActivity) + } +} diff --git a/example-app/ios/App/CapApp-SPM/.gitignore b/example-app/ios/App/CapApp-SPM/.gitignore new file mode 100644 index 0000000..3b29812 --- /dev/null +++ b/example-app/ios/App/CapApp-SPM/.gitignore @@ -0,0 +1,9 @@ +.DS_Store +/.build +/Packages +/*.xcodeproj +xcuserdata/ +DerivedData/ +.swiftpm/config/registries.json +.swiftpm/xcode/package.xcworkspace/contents.xcworkspacedata +.netrc diff --git a/example-app/ios/App/CapApp-SPM/Package.swift b/example-app/ios/App/CapApp-SPM/Package.swift new file mode 100644 index 0000000..6b92024 --- /dev/null +++ b/example-app/ios/App/CapApp-SPM/Package.swift @@ -0,0 +1,27 @@ +// swift-tools-version: 5.9 +import PackageDescription + +// DO NOT MODIFY THIS FILE - managed by Capacitor CLI commands +let package = Package( + name: "CapApp-SPM", + platforms: [.iOS(.v15)], + products: [ + .library( + name: "CapApp-SPM", + targets: ["CapApp-SPM"]) + ], + dependencies: [ + .package(url: "https://github.com/ionic-team/capacitor-swift-pm.git", from: "8.0.0"), + .package(name: "CapgoCapacitorNativeAudio", path: "../../../node_modules/.bun/@capgo+capacitor-native-audio@file+../node_modules/@capgo/capacitor-native-audio") + ], + targets: [ + .target( + name: "CapApp-SPM", + dependencies: [ + .product(name: "Capacitor", package: "capacitor-swift-pm"), + .product(name: "Cordova", package: "capacitor-swift-pm"), + .product(name: "CapgoCapacitorNativeAudio", package: "CapgoCapacitorNativeAudio") + ] + ) + ] +) diff --git a/example-app/ios/App/CapApp-SPM/README.md b/example-app/ios/App/CapApp-SPM/README.md new file mode 100644 index 0000000..5e22a2f --- /dev/null +++ b/example-app/ios/App/CapApp-SPM/README.md @@ -0,0 +1,5 @@ +# CapApp-SPM + +This SPM is used to host SPM dependencies for you Capacitor project + +Do not modify the contents of it or there may be unintended consequences. diff --git a/example-app/ios/App/CapApp-SPM/Sources/CapApp-SPM/CapApp-SPM.swift b/example-app/ios/App/CapApp-SPM/Sources/CapApp-SPM/CapApp-SPM.swift new file mode 100644 index 0000000..945afec --- /dev/null +++ b/example-app/ios/App/CapApp-SPM/Sources/CapApp-SPM/CapApp-SPM.swift @@ -0,0 +1 @@ +public let isCapacitorApp = true diff --git a/example-app/ios/debug.xcconfig b/example-app/ios/debug.xcconfig new file mode 100644 index 0000000..53ce18d --- /dev/null +++ b/example-app/ios/debug.xcconfig @@ -0,0 +1 @@ +CAPACITOR_DEBUG = true diff --git a/example-app/package.json b/example-app/package.json new file mode 100644 index 0000000..5656c39 --- /dev/null +++ b/example-app/package.json @@ -0,0 +1,32 @@ +{ + "name": "native-map-example", + "version": "0.0.1", + "private": true, + "type": "module", + "scripts": { + "dev": "vite", + "build": "tsc && vite build", + "preview": "vite preview", + "sync": "bunx cap sync", + "sync:ios": "bunx cap sync ios", + "sync:android": "bunx cap sync android", + "ios": "bunx cap run ios", + "android": "bunx cap run android" + }, + "dependencies": { + "@capacitor/core": "^8.5.2", + "@capgo/capacitor-native-map": "..", + "react": "^18.3.1", + "react-dom": "^18.3.1" + }, + "devDependencies": { + "@capacitor/android": "^8.5.2", + "@capacitor/cli": "^8.5.2", + "@capacitor/ios": "^8.5.2", + "@types/react": "^18.3.12", + "@types/react-dom": "^18.3.1", + "@vitejs/plugin-react": "^6.0.0", + "typescript": "^6.0.3", + "vite": "^8.3.0" + } +} diff --git a/example-app/public/audio/beep.wav b/example-app/public/audio/beep.wav new file mode 100644 index 0000000000000000000000000000000000000000..9c382b1a98e9ce5a606a427c8baedd713d55a386 GIT binary patch literal 52964 zcmeI*^>>r!`v>r(P0}WfyW1n!kl}1FR&>CC;ts=y+t49H#*hzggCZ;LI&4VCV8aXv3?wfB-U6AfaK$dk~uz%}1fPs-KVdEAcL9$Pk;XPD-Z z2M8}d8n4E#W98UsjKJF9zvCkbm=u~I^H9rKtJZ$mG1k?ufpWZ1zRx+> z-NdW(>w@jV6QYM=u0;FP?%HH#bp0brlfrHEa8WnbcJ^y7RiGC&mB2EZ;+b-hnyy`> zd#q0x=ui~836DVDBTdjz`A?)LT8QpPn8;vw8MMMU+Mv?k*0$FiP+1jhxn8OfGlXW| z3C`FOHuDOjjOL@R$*JmYq=(hys;|c9RecpvhqwW;uchaE*KJ1w`&H{$OJlRl)QB8Q z+``-8ru?ZY$9~7+*a+N(?yB&&8t z=1pCD%8>#ZeNxdqCY#-lyOw`acvE~$x?et7DN|q2Ai5R$>xSpX`_LA+9dZ{@<=>7e z=m1oT{*E+7eu6JSw~ZBssd~0A!rBOJqTz;%}FW`0>j&=wYODW~d6 zGuE14lI;@ls(X=rp>=_ueTO`+Tngt;cAD+9WtMr6X*9W!!0`ci7`u{xj&qnD>x}<} zPbb=wjZB@)KUkhyOYI*V>sC;Y2IpE>gO4@88<=WVKGvHFwx%VWOM}D0DXn@N6x`EC}DIO zuIR_=0-BNP^Gc_@K*o|}g#`Z$cN$yGdQ>!-PAxn@X<7dwGrg9Vx|>)S>lhV=Gl7(k z9D9qQcm-ZcFvtj*H8r*@v-)j|9Y&YO z{g3yq|8dYAmR1dkS5&7`L(;di`rHO;xNrdDLNT?Z7iS&svf!!cUrD8GpJIrrM!iz& z(tTzaU>pp!h9mGgq#EgrPC&<@ZBQ372YCkz;ieE`OzSV|x@d2z`Ko@3`LdOgg`(kt z#=H>w7^`n_l)j}9rQWX}o=w#5OLeWTjopoI3oi)H@GtQma+A)sjtjP~)*AD_rYEG6 zK#0w_6n}#Kh8@8kVSIcIt{^@TH_5vuhq;M$mrd!o?_B8~=KaRsKR7MCC;BF)te%~E zUfV3YyFN>qSojYeE?&m^n@!`j5)2THl9b7sDPqcUbwll5ol`F`sv#Qu7@mTdkW0E9i%CMF_kwf0xtvBNABvYTMj|Cm+&o@74G!a5=rG(J`3Etg!}2GqFUmvDB06Lad;qF2t~d13 z2eh*_|EaXfzVb=Z$>K6$V}6`-sbnmZR&PhDKaHAI56Bd z-*dthbBwk-teY$Y&0m^&l8cEKcn{ozUBC`t7cno^3xAC-C%z?1O~cJQEkWyKd)9Hu zwZb#e_g!FqXkX+-6)!P1d9y~ASyAWA^(nYQ6Bf;6-YubU+wsQ;=Zfb@hszr(&8o$k zxVB8c#c;}a1X=(ak@E;2?U#R!p{O2xgmgg;z%L<_@u^|AzLV~;rnP#V^0xfFln_4` zp5ZU#wr0DTTZ@{}pB7A@Wa{>0TGf6^{*ow-F{8H7^T0Eo*~4}Za^A4FwSBPcH7_>( zNFF1i_;|b)yP5wyPGX<17WhSc0HGuqCaL)w%KW)?MNNc zHUG^!25o_o$VB8JoP%UgiP5Crs?%wAs=Z1`(Op(1=`KPADef)yES9YJHhoB8n6kcJ zpS@Q*KEOKczXkbcK9FNQhN92Y-ki&c7p1F*&{! zZ$$Wrm*jg>&fMF2!`9j1cAj>x^)B+S3YLeTMj7$4>JzDg^yKV|`qtF)!g~6s;>)Zw zyB%+`V6|wIWQAlG>)uB0&sJi}!&aV^cMwn;a<@-v1bW&YDq1g`MUlzg;%(M{={5+Ack+_LeCig3jt4cKww2*$HVXbi$G#ut22N62@P5$#3i8e;xAw!XCZ~&q} zRfa$Hvvpa`EcKttTDd}IkcdSI{zL9sb~~1}Xf<6^c!Scf-kVup+c@d+2jxvEiO>koK7xR!vlFknNFd z5zP~H;}vo4v8ENX8K(=oQ1SW&S$_IjYD~2#{vmogyg9hWztwxy9d-6{+_w$1GAxAY z9T_H?5<74e{ycx@J&ZlTO7P{lfOtWiCoh@)Gpnp?Y{iaq&S~ya@8|w@!Lso3=*?Iz zF(`GZR+wE97sJV$31k7J!<`?*R%2T?c47czyytlX%UYS-&N=xIg)l!hwdaR`ny z%irB6q219OvJ0Uiec(CJTw{MjiT<<})vQ-NS0rUjDP0^EJmPKUbStSU-pgoBdqtg+ z%Vo>c9c!G``{Ki@kO(c5^w)dUp24n@4vGD!wZBDeW}9^65aJ5n634Jp`IB`6OJU>i zAbx~cM9wp9GrzJlvt6+Fa#G#zJokN-f&W6;NbA_L#PcLl`%5NNH<)s#Ku`av=o1rV zf6qP0uN3|(ekQ#rU#4uVuGF;A{ZIeU@X`1L+6#Y$JV3PQko?K&j|$OC2#PF*k3$!X zy9~qiS?y06kE*3|qWnkca`7}_S3ZaPv}7q$UsOpOQ4q^*u0t|^*UU_+6Ij);$jZ>n zz#QKO&utgOIoqDF?zfCH_cRS4e;ZN}eL>ID+sgHTBg|H5? z`yA!2sh+;RUV)LJ6_Kk|iFnuK!J2G(eBF~=^MXCJB%_R3QR3!k_}zpf#3Q6#-?Q}BKkF&LViJFaC>+p zG|bq_5Y(;LQZ?gL6^dsvLh@d8SFnROl*28#Q#_85E!<0OmV2C?n5NfUtey~us^a1Q zf=~Q!yfOD@uGNm1ZH=|1rNCTGmXO_v<9H+dUHnmVbk#peudafZZe%Uhb(2b zH}<*CChnXk=!*mx;pWlrW0w-t)acs#8Myv`lz72#`pqIPYZUt+_Z2@XtQV)GnEa@+ zOl{W;)t%Lw3}GV)orJ$do+C*9R82w?TW1OAHQNL zD6us8uBKIHe;tq$ASXahfSdq10dfN51jq@H6Cfu*PJo;MIRSD4wugSkaGfZPC(8H$TUWf`nL*5DOAw zK|(A@hy@9;AR!hc#DauakPr*HbwIZc=+*(bZk{y7mNK9P14$1>6iTz;5N9!;O-D4xVyVUa1xxLfx+F~-614Ma0?RL6MhiEf-(PX`|X!rN7g!h)~;Q(tGXI^OtT05UxtZ`yVKuS@IfGC84x&j4}^@0j)j9qKtw`D zNli!3#LC9W%_kr%A}%2%Bd@5erlGBCU~Fn(ZRg3TN8w|`EMP0E7e*5|AYT$XW()3FF;6T$U1LuKp0#ySomciBwBty+3r~o zib@l!vB^_VRp!fa!rq;QZZhENX-$qD=OO3P zeHetAhYkV)39Gri@rQvy5hJ@J`_p}Nb&y>24fOf=Ulw$sba6E20NWq(XQyrdI1n|4 zLJhO))c21Crp_{pOynUW6|k+qSt5{wY&vE*cE^E}*FhA6v)6(JhXy`1o(L@bC7H{F zx?ttx$7sc}{M`36oBbBMY6~XUHpd2fQm{~2UZ79WhEx#?+ z`S6qZ=vqwh&l9FudX}McTbp*%OP(wlBj)sO%?acP5rLbR?v2rmq1C+0=#J+sKg4KH zmrUOM$k%+C^EA-b$!slV{=($vrvFx!u7v}!CdqhMt#x-3<&&$VWUgPXSTQr}zm?Bu z-mcX23-@37yX)&ei#&h-ck_Qk35vo8l0m-040$oWOiIB=aHY(g0KpQ9l#b-rhw7bN z{zM}ZjQ;V}B>b}p4(Kx_tFC=2@+76qp}a~i4~Z_LNrN$c^}=tN4xhlNxu1srAui*H?*nMgYX(%FQWsOmYGT;93q zuXofO5HI#?jkUg;W3LxmA@ViKSmY(p+iFTA)e|k4ZsRKL#Cy?2`2-uRP6xS%0%r7@BgXtk z8m=ESwZiJQ~(Z z7v}NNx~^OEM~M^?2#ExPHY%!ns9VFXo<5!p?Z^meiUFeC)fHus?!%-Sb6K~b5;h9H zwJJJ%o3jWN%{4IHR#f@%x>q+^Og~HZJxL}zAQ_vcn#h8l%Eo)x{^RM8%XiE7!go-N zhioEkg>=02$ZA!)nm76MTOzLUQ9ZWBfPrJ<>*|7cE`y7wVc)DbfTuwK{y7bb5)bjD z7%t=aF$BRP7oAMvPtay2Ai!0@28Vx29>V!GGACNTiB&YHBJ*G1q+{h;&^wZD1@;u; zT)_Osyl?FFWI;j4NrCKtZ>MXqqnBgVYv-@_2dtm15Bq^q6%d4N3nqtufkx!0kf$Ps zSxb0{Q_%$VHiImSq)Mm|y+D+InB%{kDf*Y1mc8t#AJ&!V{Q|oz8#<+!vSd7D-AWEh|sf>^B^P!5H%kRq-BRy_|{$2e%m z<9~Sw+_*`uUi*oz9QHfoDZ7^5WZj`IT#2J2c)l7OgmJA173Cn>9N0_ zGZ2J8PiX9;Kw0Gktt#Op9aAs$)vIE(TV4;2QB~Mk^GzB^8vr98E&Ek6IG{90AUZ1h9$ps{G92B=f zX@Y_=+ZmPbbMqA@vsDljc9*+yN8)cxzGJVlAG%v)E?Mzx;mPLn(p@5~r982&-!$Ce zku*&IIGf8=wTY9_Qv~MWA-BQIsr&rZ@Soo$A9qj3fdyu~T=lAt0XnFYA-N^IWLICX zE4VDBLjBE_ z0(a7bPJki^`EO{(hOvYv6k|gu57?7(6EVpd_+$wpD)C~9U_8bXxJV}K0ip?3vg<4a z`-5I}!*~Q;xU2(0A#-T3&Yy;pen2+Oq_qL+R@1^36{RcuPGleZ3!>ecd91tybg@tC|C zHppFLQ{r_qIR^bUX9r)dZZ<0CW;D7d?R+ce$C#ZFlKCez0y&&C%o!wZ8k30+le5 zJ+^>*+?YcFONNQMe3rRStl$@|a2c>dVn-B*2fxRo@9#1u=8;;w`MJR5RnN8 zgD$@J70t!;hYs5N3!^@d?Mt-j5!zIgphEvl>G-`T}&$) z_hrN6^XHMsS~*L~C^({D8d@MCe#KQp&OOmkH`Ga+n=mesz-oPU|408jrPY89y!W~( z&X#t3+_~7CziMtus#5Y+wYhz5{Nu$QgHKtinZHohDRy!Kt{PeL<&IrxGIAIj2sF$m zgM{nppp*TC^3M`ZFu*>BOUr=?0ZK{*r?$z)_|3ZdnvU{YI}P=IIVHat1TyFNkhUF# z`8pP0kr6oEhNff41ud2?E_@wL6-g|3?lZbkfifg-L==n74b5>=A8dyeClWTE_N6=r zP@TCGjR`sOgFFPy#ogX0o-d^WSN-BFd+#UeW1$b~i~R7#zThW>TE+(bZ_&e$LqaL} zc@^88(n(pb(z$pL5lXu>Qu6@j93Cg0hOm%s9FHHpj=dA)j}W!PKWo0bU&2%3ds}wgzfzN~hN26$sJshJIhB2tOKv$! zOAWo99J~R6&@61AS#*5lf*>CA@wZVn(FZ5?f3#E#={F<)IJ>h)Q90Q)LYTxmQlQ&rf?qVi>f|G1@bL?ChN(ew%z#;L zVh&5JAW4mI@tMr3fDFC4o^LfbBtZji#U2&GR_lYuoMCfebF_>gA>#lE5wjT#dF3z3 zteJ<8A+ChgT9j2CADai*57?S87(CS+XQP&lY;`#KD%F%r8xilYxVCCJ^ruf-5XeIL zn(w;9o=b1Pf{DI0Y>#u#W&y$$J3%<)f&tW$(kX*t?b_g#&nx?7VDUA+`jLbzOhC*Q8CE;eG ztmd9s5x(7Xx$;T4Y!_Ec z2Nr8PUqm=9hF`qS-okE&}Ru%@N{abW&|Q><&h17`RCqN<&`tylraO;SCR@k?bXhdGaI;3jN! z2?=Bk*`~ro;M8r%Dr?E7DCol27DJ=Bc*^UnNR@0DI+tIkmDj@GQG3kDYMNDtGdEv0 zM2|Dh?DLw7s^AL>NVfUWU=Jm5qXgN;s~r}-pm zIDCyq9Z!F^*4D=NF8$Fdr@%C@bLkoI$j9APq(`oE?e+plOpW>_QgtveoNJg(-NLof z;hH#K)%FcgO_-o2`ZACZ^xx6JSUw5pBPz{e>P)WFt~ite^RD;?;~cL)nJ8njM^g7w zcX>g(&kb@Dt9NQaD$M)c9YigqJsIA7no{qZ@g`yAIybgHutX zP*4NDwZAwfv5d+RRm2U-mmPZ95zbh>ykINC2#!Kd>WVD~p!4~A`|z?ma3ji4TcGvb zz{pa84nk9jpxW*>ghdpMh2@_CgglcnLGowo8`;&jPFy{DJg=HydyW%y;{M-KxAMR9SosCkaKzUpfl z&qmu^cD}!H5^g|#%Vf#^u0DzPH0ksA9o4rVQX&TzNFo9Z)k9fs^F)LU9i~Rr`OCnd zZewe&1lbQ!fxqpLL(OVtPxoGjHUir-4n198h80i9F{Z* zda?$_xs0UX7lOw(6@Q}y1leA}(>5RutY2&ZI&{XudZ{32NKFkkLrK^{W%`bVDsObR zlrWxC@DHFJ7)rxmfCRZGENVCk98N9qnl-JPG&wSye>sD0W5xQL(tSLnB z_+U6w_>7%wJ>~GwfppN3c!E3!kQxFmu2vM#UX47n7tBJWB+)`%{&bPF^cQgTuv5)f zS9|}x-*g1H_91&Dp!mFX7$zDFU(&I7MNC}@=zY?lY_w4Eia-}zbN)}-%4+nv8y+|09(RWBRT(WS< zC@qJE8K8FKQJ&d+=7QRu;_6Xzj*h>6UcYX?{OVy|FfC9*`^0oLtLrj*^M`WCcA4wQ zQl)z+O8$x^F$(V62R@G$m(GkOx2VA^DA82HNyy|x(_nF}XxLDjth9>jHa6|8Te@8g zD-2tjp*xZ)_*smzrT<8g#9UBq_!C$en#(31MWx?_9p>ZApo8*;(ge_BaPi0)*lag@ zu)|5*`CeGlQ|rpb?Q1)lTV+I&i=-g4TfV#lZl4EW$qknYq8ao{!G2-8GI7FY_h_<^ z+%EZlzH|i!=G0p`Hp!TfV}40vTkA&9tZCeAr&|8xDF+O^;r>;L*lmWKnrTvE!zvRf*2<@r8=uv z0ek9l3VIF983U6};Ns@^)C1Uit8<(57MpkjnCm?c0Ij5FGdOGnixSA7R!5^jz)UZj z%k*azO!RH(#xw*P=U?(GB)mMzJ=i2$>{E5(&Y8}kO(+m3_CEuDIoi*4hn`Mf(|M1jCE!R)1+JQLmVV< zHr9Vsy@8?J>Kh&NzBbWC3;O90VF?-5v^|mNvlS+8e9kQ{(x%_p%FNl?mPZVf3G zA~#YR9$oKk=@Hi6SBl4*%T0{liT)M#W2^BY93c zQ?66E>nEx%7SfgP0tWX*1pCMM>CyLkq%mgsV_iVsB1Q!xJJq+wg8-LlXfX$Ey?lko z!ZCp1887wb=^3)(+8^xzbC%WY$5`!DM9e!Q)5CHSi1L1+FNC)-c&)P3`JcPlK#^R+ zb;eIL1#6->26$4UMk~ctR3F<{4mZ@=u71>LtNxy7(Kk4it1~Pv-M$sHWN{wyV9l43AXb$*cNK%F$*PjR=n|0s?XC!T6XHhxnr?kuq{bN#0Z6ZX(NDFc zlRU_S<9|}xjuhUY@ZO)@&!+$Y9w@%7jhhX7o&|TR5G~FLt2(kwJkmcxORjLL<^%D< z_uqr87aS<~y5c+$Sw=9<+u~NlD#EFO-x7y-l12MKd4zQ``Q0qeD^OR*3#*NuGpEjn ze^lLufmNOLmjmPO^`gb+ZTF)I7t6IZC3?0ra^3nfDym#T^n|wf`I)sgHU`7L#qHH% z)lrD>yt#2WnAXxfpVCI)y03|`16+oNwnff@>W8M*W>}a2B3eQ9>pS*DRD;&+E8y3~ zo*mQyssAap^yZ^iDc@BeDlY1~o$Xds!LtaMn58nzWj=p*2G>g2MB-V7VbxEVX2U(D z+--lrJS$A1&=}tGEH@HrrjO7EfQx%ip5+HE~_D0UPe#lCq3?Ubcz)m^z< zxGnVKcmH|EPtSHtSwHq;N~GYWI4Xo4elEaY;_#d1r?k2F7N-4dBLik8W6p2++#j7C zDlhWF6xCil;Zu0La#|E)Gduw+;Hdb8i?^ogd$(Vt&yxr@ZW|KJlR6D(SuW~uyjdo< z*w93{G8w->dq;F8(@cB$1}klXNW8|k5Q#`uJ`IbB`R0YZV%Z!1#hO3x+0tvTst2#o z$Y*8Ju(JBXBR;HO8^CU%4u$sTlB;&ej4H%VG9}HL3Eyo<(*)o1yK?aT&JnG<>>)E# z`8M;N(cJf4>}=^r_jSg!*1P4yl^2oZ)rn>PlOc|S4@XEKTqts8(=UDtEaLc)yd4U` zI7k`u654-x!{k$D|C#vz@kJJ8s~bl}QFi7#pxUk}<~lIfr)c9Vm*-2Mp`1qI64PyP z{YTYH7&zKlzgOF+PGOAW**3x$VyXF8_H^2klW=y#7G3{Da`{!~T>c+?!jh0xidJUn z@?ccL7ryq?EBa>!*6<>jtGK&zsZqZv=iz}C5q<4mJuh;_(2H0Z1fGFA37O$hkd5c; zrcDi@@RW`y`iB>B>^I>ie1TKN2pYnIkPtiRUo_iG$%dQY1U*2GF!$2YFpLz(K(3raZ>d~x+>)&I@w&Zk3WkJjyO>8q2j z(AQ?jx>FQ3?0=dO|AJAD<=V_y0OMK+vabK6X9g86}H;9Xcr_7n9d)F)mH7**?Ty! zz&|D|>BIxJ2#^JNOPS{_63`09iZ!XXPf5*x@vN`%TWxR>g5bmR-@;rl*6#OxjYwDQreN;Vc?_^_d<`T2QMq^V8!I9 zG;rw72^QV2(v5iH-#$Ffhe5)MO6SLamj~fgR~>c!S$29JTmY+p1X`1}c~F?;XegrS zo#|boswSn*sRd1`dX~wXQc?o)46kG~BH8;W(lXFBuJ#vHkcbCbdB!U@soB__=5n!} z@R7;TbVs5`@-LZ?vaE8QQesVHYik1+7N^@r;D}d-{u?L85~(s9`o>nBT%k|PE&H?$ zFXno<;rZ2<+?`g+a2sTfG@0kxXL_s&POCJviqNC_XglDkJW=$eKh*F zNqthjHTyyaCia{(0*J`<_mwP9Dq$DbA7z>u5f9R8(obhcNWbsWIdA@)Glr89NvQnu zrQbkcLp{S|(Yyl%#g}w8^~sQIbwf=%`7I6-j*cARqG35Omja0ab%(edG)(VlG~Zf? zUq%t*3-X=lihd zfI&eZSQ;ChVEsI3gw5vt=J|&`hcoOlVf`$aqH%U$6q;%KYHZq8d$g(0oy(+BEP>8_ z>?rWN0^B}`esoQ)BS;%c8CuGjGZH2K%~bX}79NxZLaskv+lvD!->l$)b0zTiQ^~%> z&N~SlEd(sBVbk#Wc>q8JfDMwdASjuW zd`?G=g>}}3Gtdz_Av+3IRE}(R3!|1>CU{rf8JZ~D!{z-@?Bgem_lW6Gf@JJ0xZQpD z;zQ@zGw>94p@=N5LAm7WsrljKqI>B#jdC|m0wirHIPN&xH&)=iMVHy7jUb`$)28Hz z8B>|6a`h1h22Lj7ltLK}nIvJ`*rg65)DwIAS0Hl-6#kRw$iNR{pl880%FvSkA5|Yf zC=+`Bxl!c*r^qb+%!*D$*io+CEZIX(_P0bIPRkT4<=MMppi*3s0`hvgwDFH61Q z)U2QGWy4??JpWJBMncfhc9hNEY|)M()qmK=%^R|^*d9lCE{i%)pHv&3o6%kA8ox5k z-ojUN*h9|bKObsR7PdN&y0EneZ+;empaX#B552u6rv31=oqk}PtJK|sl_V*m_VzFw zh2vCILoPbrVTY;Jld+{jBPV$5#3rZLFny#n#isBJTL_34KKAQEAcdsnf48I$yQeh9en}1)nUPTy| zEK$tqfWPb(hAZctheE95_C!9b*13#6aFpzdTpYYo^&X-K+ef-<DgV*ppIa*{GWO6%^(K8HL_upGdaFg&4Vlpe4bA$XBOJo? zez}mjaNrVAS-C5~#AE@SwCO`v&m1~T|Xj%+;P z?1~`@GB@;FR(#kF-4qjdx=g;3o~tZb-YWhJ{|UfAC~~(=B*^ zVzALw{rzt0^lj$NulWPCkMTaJv+c{E4PhU5eB{CTBII*~5qDmP0`2Ky$JOXRfQ~>Y z_on)VCK=9(jzPdHRx#W~b?YWqr7g7dlfJ&X*S+f<&SAW?1REuDxqWxJL5RYzVjChm zHQ{$!r#LP}GUp7qnD1z)TxWFrKMHf^(xv|zN&O?6bEPhvMT)(LVB*+MSXf{lpfTfKUo zB=T^0uvPaHa_VoQtD~ya?VpPTPfYKR@2Q2GB}SbGqyPGb^ReRcoCyh!C%3KofUm0k zTpMo;G!&bg>Rqi|z>K!#St~GYwvn9$O#6ArT}G>`?}lwl-?{-SAWjB*vY_v_`FdTr z76Eoi*^fp7Ls)S(jtK5-%7n2B;x5OYkGc3spU?4_n9-&ivUeRyY4df=)CK)+vKivZ ztj(R{LLsmHT0+*yE2{I)e+WE@jsedkNNE}cV!)?O5_0Nr7;SjJA^@dqK_=;^tDtroY#|E|DO=5kTY4M<97AXzv*96~PsEZ!cJG6A>?-=lf9i{@DbO2GLazf(4JKoil$;3^+7Kzf(cVXJY(wFCUddXOK zz#rvjXcR>fBU8p4ss{&}kcy!p9}D#;xyc2E77SK+*2dcXNm=>Z9OW=~ z(fi(YX$gH_J5uPT>Wv#tfX7E9L0K>hQXI{!dt6E4>*)K?(Vp$|UkNGgpIr8fUSBMd z_a}0=J_=)0>>o9M2^?ftD$z&qaxM52TZyfmZe}$RCa9FPFE)VczqS+X?>R}0o0>ve ztaOgd{2)x}_&W1fgY0Uut5!F=!JL8llIShVk))ov9cB&_7V4(Wyw;69^DD^ow!)$+ z_9Z{iiE^JwKG#A>HIg{&X!v_(>b#k~+1MxvwCy(8LzGlf7TF~QA118+0ki`GGwQ7# zV@c_BwLK``9QmyZ^7$CCbxYo^;|#i8o1a{V*?^E>6sm#5omxix(*o>N zF)>OXv;I?wNXI$;Jgy~UkMYGk033H{ZXg(2>uqQV;%HQfwtnX?sJwN{E$Htcv}(t| zkf$kBayZAsdD9|wiHhz6oXUCsqjhc zNTVV;fnvE#9>wBfX>0k*^cQf9{{>o5nsMRR*-8f0_~cyw!B?7;uY#Z?d(TW|GI zM{>eg(X83!+??o*pYcg^SGgteVR3eU`%3vjY+qsj%3@>xnV|aJ8&!i!_J&UE&Yveh z+k-180+V_nN_PNMggn!U!j6=a2eT7sbxF*f9tsb8`Nj`2!ygMKF;#Mg@-I zw1_6XjD7tP0qmUi8rBbCo zb9(B_z!3Y{d>H7F54lNAX;82V<4N3)#YDFa@u^_C7G((azZPhM}Y9E5XR5k!pscu1CuZK63*+ywjCDRdluGuik{gQ0%27 zi4N#7c`30zP$0!47vM}#`4F;<6QN2_yswT>^rz$^Q3U!^p?x-pKT&Z(_r{wPSU(J+%=q58Kf4(O10JW+g8)?k`_XpF`_#JC)wX4JBxDe>=s!#N4FZem8y>5; zvuU7;H{0%N5-R@f=-4ga@@Hu1$jMpZWO+Y5!y#ibw58-b;cf3QWa33I3dein*P4)+ z)LOGWYr!TAGMOSt&SI_}rVnfT{a^01&G7>7)P_vC1~_?f>8y8;7=MmJ%u6lEx?95= z#W&t^P@6ntAOOC$ysuSCg5k$$R=Fu=>QOOC^!ds=DASa-y*<;CsceBXc*$&Eqod4! zuB1ctQ|+@?Rg!-L?NBQN$Y)@?H4jXmC;)>Bd8Vs@4KYrly#-K>%SO67+ZzT7bYO`q z*LURA(rP>@#>GsTFy&6l{*K6hX>18n@r89?ybdVe6U?>eqt-)1W*GX4Z#hoU4B4K&GYnjrJ^=;0)7{ z48#gPd@uN6@hxOxQI?1ZRb1nt-~tD7-){%Xov~y zt5x#g1~3^W2jY_>wn5U=V!XuFl7LLmQ6`XU_+G?f$#e6V7E?)K|8v?mFmSKl*GCh# z0Ha;;em8V!!fJKnlm0$i8sZb-*kYlm9H#F)-Zmj=Bt53WV{5prFHP#YYyvb!SXBe) z53%{^6#Q7fWjmlU%~bN8y?@L*k~F%REc2N!k-nU0*P{NJ4!UHad{x&;=QL}@f;@h6 z5Sn-acy!(uQ6Lf(9XL->SS=DTrrK4q_=Npjn1tTM?MEFryP=|7Nz-%}rZMQ+bp>2~o-(bJ&D{d_8^ zF?#IWbhr?@x_vxq(U3#P^oe7NJvl6>CAWK{xP*|ew^+zc{}p9}rmSCwx^8&>8?kRr zgBjsT^FZDr_?!koIs3@A&JT|D z4`U_7W%F5KPhaI8Kp(7AK?nK78zcet&$9iPB_!5g*0!S`yf0?|QFRUm#<4VX)0dnu z+Y3^2!Nxpjfr_w3Qa)iO2YsSmwuO zZ*GM#qI_8KpAO0f;tpgRzLdyoPdR}6;kva?jOu3aX+$^=a5*@g4xvnpn7e3u50R^N z!)j>2FCx%_y$v8Y*%K0bPj(*H;==FjT+rSU#Z7he$2cIqcL=5+U#fR|);Sqwt~M#L zm*d*GcEAS#AqVg^Fj^C1;0SrO@n8uc38D+4A{Wq$LO~elkjM$-G8x!#nl1(tg-rvM zetY(caC5b#8!|tV?Id-K2zVgyNkKT85LU=$0kO5Qo5) z0&m*&pW8%?(F@Vs!lrb+qm9Y0fBVZeKfd6vP#7w2<6=!3LL$V%Y2L~xM= zYr3J7_4L)~g4N~4((MoJVv?yfZOg`hd%3|C}Cmz!MZX%Z{>5xq>AtE8y2AQ9-1L9=g`B$fYfq0ftB3sST?F4?%P}>DS2q z?$)?ODYsn_t8Xhw=#F?6fwp>5yFd0ZRB>~s*AP3EeZnKlZ$SPKcl9Ok@blCBh}ZF= ztT5L@mg||psE&{#HltS&(aEvCx#-JeTGy&^IXpk%*^RN$?}kBB)|a2pB!6o^1%!Tp z$QeXqxX=;qQ9d%Rr67f{+6W2|8!}+6==hR19B1I8y>|;{emi@HQKE5KntOXa*OGt3 z)j~^Wh&=|JF-?80r>gy*tp~ zU7xj$_Qyy4ThQ)rv=wJ|^UE&&0WBZK$Y3(%jK~wpd3o~8TTe=YIXl^~2m@EvBwFcr zbG%x%)MHv6vpX%JXYHfJU~>&VaH<<5S#M6JY(Mhr(e^fUbzLnZY?hbLJI9sGu9E*T z(%m@>Gm7b4ajAHE2PgqK5O8%}P-MbT#i;^M91@Zv`SHS0#%lpl3|0A|Z7DZUr3?6Q zw$Y!p@{@UL#g7U}42Gf3NR?z?Yt!k6=fv!uCrlIC^p~MWK)bX>%QXm8_Dxi^lZIpp zNvaU!STkWt;8`E#0#2{MLPdkswXAH*N7ucPLgr6*zUOmRFWIC9;ffT2yIL{-5RE=) znzoiyzRXmP*Yf55{d97iyOvURr+d?**OT+6>R15BF&j}Ha{N|NX}v*TI@uP5RkgG1 z<-2FPhwq5s1;~Om)hF~H;mY3$r$WtW?2Y-Oggi8=T)G~}3T#33M$2qxZRMNTy%|ReL9D>PvWlP1S|{RW5ozL^KraY zWS}Rq=RXI-hv{XtVbt(_zJYDmWwu~+_$=FM{oHUazIpU+|pn`}gZ zCZ?f@zZE)k0~1j2z>)}F5M2|U--~RE*BTF@FK9E?0;`VNw0CaFj}Y&)d%fw725)e` zYak}P4j3IC!tV2}n?PMtCY(Gtqxcs5wC92q_KNg2k@}zLD_>#uArX3+e4FO@s1S}# z=E74e@ouN4A#+D>Q15%wY&o~6Sy_YMTn^dX)SMQo?9>xW@6sy+)|bCJ8IYtJ&ZffG zzdEH-i;|&S#cHKv*VeLP!x0r^Pn`$_?x00krvHipuOY5>hgs{ow!Zb+i9d!9EKbUt z*(h}!&GOu{JKVp6cpCL`tSU-w=+2gZy1b?gDAt`Z&fB)(Nai5)E+?*cg>U?!tuIYs zb|$g!G}>1st9)5|>ed8gEP#aQBQThKFdBq)kTxSJm@)nnD$^-r`$&<2lasd6A)0}O z3g|^s8Rm`4o&6+s`u1kn*0QI7aXx8e?S;tP&GE|URJZ044PNu#%6XdoJqRqK_w87a z`#^nH?bLSP9P)SnMq}&~y$Ts;M`VS4$t(K)v{2mN&9jR>Oy36D-lvgdHdLS22LG8W z|1nwbT$fs3-1KA1=jjl*KfApW2GUKfcb|Z{2+FBGYWzpzI|vx`z3RUxjy#*ia87a+ zDUcF_RV#G-1-izbA((K~)1|fv4nSIRW zYP_qfC8xCp?-FyDyb^2^1E+#ozaclyZ$(w%w?ZChU7W&Hp zt^rCrkJ7gL#(44Sw*P!-%-@cVv`+AcH$A->o}b1<_7_80E*lH}bGk|Ljk9mtAb38D z18^oOJ~={}>yL8$-+(Dz^TarGyElp^m8-UH?Uc3S3%2d!rQ#d{KkZ)gi42;>y+l|z z8J506H5?dSb=}Yuri3D&T77FH67-ct7Lp0UO_8llOrl~S)JW_v+IWG zUYZnt@nSK^aRUZd^Dn`7`X<4!iV%E~B%(<|pE*1RGyy;|AzAd>gNG&Rduc#Pc^C@& zs|UKvkBSJ(BM8BUR9oj_YzF@gVc^1uXQO22lG3d(9ApAo8Kan^0(Zz3sD zGd@2DzL##1{NCB3fQ*7^v;(Mz7VI)Veq?KqM8d$ak=Lfpm3yYk6=7Vix%nzn6NiOC zF!TWZ%JKM7>$XhsjI&A@gVVR5IY&4;Qq_-JG3NcCE=z5F{oWf_5g&pfW5r+91V|Os zX^Zr`!)3wZmh;6DZ++n*@SUq=gf;Jc0byNhR7z^kA23t7oO!s?zhJin0~?zdx@o)K z8`Q4Py6jq#c9bif?x}C_;2%F{)&Jl=?66&n3%a03_Nb%~D8*{+*-^2w3qRwe}Wv~{HS`&m$0SZ!JK?TF) zKpZ+l(5-s~Iq6NgNG!`KYCIku0N+|$oyAsD^h2Rq!t?4wb}tK)(er=VUx^5FO3$>W zqxyO*=r?&_4CIJ_ zIl6s>1abH&NW0e3}R!K zThpqAOD(LM`3{FghHvExOd}+sr#m9aPC;xx7C}kG9D<(c`3GN?>~W5AjRs6Tzto}n z^L6jL(r&~{EadgU8V6-Z->9MsCu0|e*j4_8;*yfp`%z4XPkxS3(Q}9Y}kt!<6KIG!mXG&q)9UO)Vk$)J^QIm z8o2oik^v#%=U*XBj-e=N+(T!RV`b%99g&gUP|!del2I4jFs7-Ca_NTt{Vt8K!rY9| z08(&aXUWyeer@0OTpqoRzL#Cwgw}(_rMW3s)Kqy`hRmtw?k@13F|z1opUm%^- zNTia$)sNhLEgD=CGK-6#(188)a(Hj(?tmfO{hDIIpQlYwN1wmzBW~8ugJSxOJ@t&` zAKh>qhQRr&NC^;hM*18~6#iPUFHOh9{xW?LFB?H9TobCM4ELBMxl+PSi3&#oNf3&1 zn-Zf$aOG(2%a=(b9_B+E-bo|Qwt>n85cLSe&N)DI!e((T5mtkQk*8y2e;%GWkA@1) z^JJSeW%E{8=*DvVx^X0X?^>PthYK(oy&Zcnb`+F3>Mpc+TTwBK?w7{K`-l|kTS-xRaJg5HrKUR$;|UR%9PaN zQ{oHB^cNM`_VC5q>=y=VF4JG;QeeWZhrrW-*~6f<@x#LZ1aJx}nUmhjz={KTl!94X zJs+a_aus(+w=H$@hMRc)CuRb73>#DALv!#5vH2mQ0Qe&g0-*%_J&y7owM&RekQoUp zAEh*@4>U}TOfkcN3W^EAy5z`fpn3^gES4eOT@>Q?D`gE+PRs4YeiyA|tJ%A`Z9H;j zsX*AHT6HIwxdc@s;L`$)b2jnU9&4%yuKP8F}pDbx?DBMNWj|YM^<_R7_ z{{En1))ZPrCj7aG7s20BPxW15+ll;GT-%GT=7IYeTC%tWVpG=Btdqs(pN4P%3U%Q*yH(T0@kU-&+Rfjym;-2#e4mF0tZrEygu z`H{w_j*45VS&jWoLLp+h4zKP|bE0I0u%9V*%3OcBHqFBSunQ_@|MYtKWva5jWfyxe zhwpQ;yy7v|mo>W}Zuai?J-HnyI+H^g{Q9OWvi{8o=XFDf9pT0unf1PT=}mpJnfuiX zfSoMWd{N!ks9D`(n(<@Co3J7&6=WU^&nD1g9$`#g!Z>%(dlodzh%tFHbVct&I#)&x zw7%+J0$5*a*v)b8bWceR@KuTISHW1)EW=`$6F%~Ipf#er!bvYNdt>0sB@qA*E}EOZ0_Kh=oN5=Jp=_WyBp)U{5t7eC z@r4lbP3Ox4hz)g&?I_cb-R6;ZszNhPgvkij7<(0QWS~c~R`IaF@LnIF`d*dTkvW)K zI|ZcPin}!#YR!N|3>D(qS~BTH{*0$}#KK{wt?!gc8U8Nk({o2?!1W(b)2Km!Cw}m0 z>tyS!sKZ(r5x4EJkH0_v)O-Jf7l2<45z93i4^{OMc>%c<7e!cou-T%Sn+N=LB`g*6 zfC;>=75pRnTcs?gx;kY?5elwu-h?6a^b*nF0eI};J0(?fy#nc@ji)yQrSwl7AQU7J z29giPD2idMrzgUD!kZ9vLWVvP`ra;6ui<~EJI_HVM^0alMI#Q}Sc6d9d?X3NOEpfn zlWqA4+=OGtxJn2PbS>DB-da;!p^E$;mcGI*s`mMNfu*~VknZm8?k;KRP*6acUAnuw zI|UIzU}*{I5+9V7QW{~2J-_w)zW>0vuKS#sx#!F$rc0bu1Rak;Pem{BYp?K5yDfi7 z36=m-xfF`R9gD1$P-Kq(w@fcBjaauxX+kesE5 z2LM1Z9Ry*+2Z3{l1CKc}s5}f#>22_aZ1$aC#rVQn88Uf+1-)Qp6o=Q=~%rmcH-Zm7=?7#jq7 z-Rz9K^MJO;3e3j=Io?Ykn*e|tZJ~mqo3ZlmDYGPPt7e%zbgNIyo>3boMt!EV>c^pS z&=%;JYg60bVuD?M{-c*OdykP+LtU)N3(Sz`%x8Q%{gCIecQNR!Z>(D6b4DT#o;Oh_JeFU(u9@UAd0r;zhjqMnIo*y_4ewW{5_y%+fKk$|jh#>2 z!s#dxQo~j@nq~`y^T^^W5%K^e56=#Q#S$gkVq%_6~ z$)}A3C9w{Y%SQR?S#H~N;EWrMn_TxsZ@piOd^9X=AlNcdRaIoB(F)D5x-0nIR##RI zn+$VRFsj(5J9`r2)r4O#eERDr-UZZSgEqk6ysx@MBMIrQYS`9#Y9ypAr^b@lh%@Ew zaT5}@;ZLph>1AZEkHeWHLHLssM6bXX63mgV_40#FG*Uq$D{S`W7@yD#3KSB{E%D+l zbsA&bL~Vlems9XGk{~Bftg9)E+1z$3`w>1s%T4Y;e^@urLkxM+QeK6vDm85n;tgJc zA{?%;YSg?+{UiU2kBnLdsiaTylXFEWu^*AwMjl3ot2ckeLs_unp(58(Ed9I`Bz7T) zkO!_U`InVR&q53nTniw1c2Ap6r1jrgNjB$T3I&l@`-^GEi$J2SYCpnnDZxQQ8hds8u7qVY zP-_4%S8sTeEBg?vqW$!${&w*x7&wsxuKwxW;LEN#=x$Lf_0@y*23SP%_-cV}jQy^v z1%VM`7#|RsvA-2#wp4&agr-T zr2Ba%i>5#Y^NfoY2xELBo=t@<%xAA4)%W>_0iy42LJfe@!L}Fj3pE$?DxX{RD}p64jxxP77jW)jJ>R1jbyMuiCAhEKML( zp=W&ta-GxHNiDTfH2^HM$gT|-Dm&%=9MC%FT7wE&01bhzbldM1d5DGM@Nlk01<`b+ zNQG4S6W8VRo<%53(u+>WsDCG}0A1>vn*RGhYap~ySJM-VggaH{5PAo$82pPEA0JZ-9&g4cz7WOQebtrzF7B_ ze*6?@tTcgpK-W}Rw>-VNu^P?%0r*5ZFpyI97_hmCFmVPr)21KWc0kg=?w0slx8Q)q z@amy<1DFdq;)ksp3RMJ~32`jLfZ~za?iP}tJBp&EWBC@w$YRmOL-TTESw<+J&6rK) zb}mVYd_3ifKq?EJ+^-p|$X(C+WJ4d&jVL=pVHi$UA`;>wYo}_#1+yB^QhiVf>Wq(S z9U-C%S0=uEKk6%%k0F7&8mop{aCM%2BCwj3kh^+M#u!0usRgTlTmU+ zxY!wUKdIU8e0V|t{27d2Wqf+%D7B>lGKp~d1MJ6kE4U{Dc0Y^gzlIh%{92NI8vj*vooDw>snY1K zm?{m3dv{bd1{@yVwF?Qznb%OL%D?|tOIM*_6IWwn6Eg|3Xe&Z@=PJVWvi}WcMeu*i z7Sr~j;0%H4JnWktb-)sV(Ii|<4E7y&4YFcO@mnLq=pA^?e*pn}6Wl>d$9IQk8uQ?EKeBbJ%0tOL% z$_2>^GrZPIqNUJb!MIj4<`lw>AjSXdtniZ5x$s#-xX#OgTz6fv)f-59+#KSD9ursM zyM+QlC4Fltq?A4)eZwZN&a*F?ACKl3VpgVMLe76V=dJaZk1&SgPWz)zkGADlN7t_#l7)M(V+e)y&7&T1WYH8luw!xRyk>s#-!*E}R~a)JSo zn?h&5-q(rFzO}}GukJ{7YuESoQHBDQr;+tziLYV_=Rp><-nigDUir;}tAKyfEN$ zpY%j{ZPWXSei6T?rBw6kZ!o3Or+<-f1p@cDt}N+Sc^Jk>^*bLs6FXGcHM80>mQWpw zW(`yu>=Av%3t~&UCzAPsW3##vnKUnQ^qogO z#>m&R$?o>`k3{s-*XY6kRdvtpYf3Y#cV(xQdyrE?1VFT~5gkyjXtkBd*^-y&`N-g5RbuWwv>Qd_BO-*TKQrXYsaUMv*N#81~}< z36kApyi_Tl(AG6A!xr$dvQf3eJM74^8x~&d5B!>a-7}Phy=pyMN~s`DNKEs~ZVfn- zP>Y5H-24FSdA*$qE!lD}Rqf|Fr$At55GFe@nZ_Vy6ft9!UCT@EibT3b z{}|TCprkZ9aDtC5t8pkj5(t0<|K~pPvJj1R7>^V?S(^RF>h5QhMv%+i-r~!g!=VfbQ>(j z1SQIA#XbzAP<&=Po3Tj3DD|YGR3a*`sOxc}f4?c9fyYcmUi+u)2DqeO1S_CUq;qn? z*diFjhly}p%H2}yGx}w;NHQX#OQ3p8nMW&Ria*b-T=AH1P-lm;CzqKprA1=#58S=+ z1d`YoQjb?j1eW%*nwRk+m(nU5GU5|ae6{OJLfITt6(V!A{dvKY)DxdMj^Gz_pb!ab ze#+@6b$&hVnmH-p1j2uB_n3odyFmst@XHIe+WyjbY$?K$j#5%L<~NH<5dqZRs94~K zFIw&=uD4^GZieIw9bbcX#GKUs_pb^Ce|1~&G?vpabe1M`f8|OXQDyaeM`v4`{KP+I znAY^tz?A{b=)R%(BiT$+Yo1|%xs){^Urddwa%`GKA+{k4yIu#hP>_yqZY)0p3&t6+ z(NvWgSmL<^GEGf~2#pn;#*DMSs4YJBNqpVG!%R4NwfO~q^d)DS=SitNXjGDGgGph~ z!uhmCAw5PiewaEW57bV{?uXv|TIxr89oxuWO&c`Yz|==ASnBV;E9xw)SWfh@fF z2DvKRFGC*sF%cCD=hf(;(jga=N6T=lYPeXKTJ6bHrAJldWANPoLCc}c^5@JT-US8j z3`e!6k+naCHv@~BVYqo`f{8HtmpR#aM|DMrdkmF{hCgigbbw8%{vt((=o1%==2=p+-7 zY|V$lEVNL05%!7Ac-h>n<}KIlM7;TyLf>dZ`BHX$(u33z_E}f$vG0_I`9Fz$)tz%% zW6Zr_Pkoz^dnL9f8o1rRljRqdqoTHkv_H*1*ziYKj;0gkeCz*KO%*LhzwZ@wVzz&> zZKT%GR;bUF{NLB z6J*%mOGHRe`@B&DuR+;8U+R@bMUKYwH*!$W-QFpv<34<8T%rY%?H(%B#*Thn?9e6R z>I{8;JiApvHHA;v%lOBA%^OZK|2zw;+Nhik9w}=Up6`vc>y)*x?uw$8YrH*}9#nc} z`w_U2f9gYO!#0sbn164fod~2uy>W>;n9S(f_=zE=_PJ4-A+{x5CPA>-U`?vlgbnb~ zan@UcD10R9&Mj)hkj|B78 z57@~o*fpTRfP$maV_v=G^>(ppAx4Uv*vC(K*a;K?ipsWyqUaPjJtilZbTqu%m-&*C zP&XhMxIHG956_+v zVK#r#%3xHO)vmd;wPq|V9RbsjQCj>gWMS4@c)`=^3tZLA0hb3iK#4r^xPTl77E5iq zet5_u1!`h^v8l9Mf?I17>X%$X>cBJbD`%5O_6LJrX&G1dXR5(JA98QHHAALZj$Jbw z!ygIr!Fcpb;|^L%_GnXu@&L~B;f{$1`Bttq$RgR`n9X|U`K(5D?=Mgw6G#FTx9Z#c z&@*-pay8Hr&CFYZ>>>PrMf)!ZjNxYPN$4GKyC2-*a8O5rU18ZG7tCml6uiXc1pc%t zc=P^SjG2DxDQ<-OX=5LLaN(cB0ui~}lS4N|yoSazPhkH zI+R(RZJ*|hDEjgmy6VTI=JX2W1@atqeHj$MGYl_SKa!hzQ9Q8hG3I0eh6G_scKnhvF+?65%#rF>1UI`pi}|7*gTh%`c)$06QLvZ=I&|sxH|x zbe`YJpVOKI=6R4}mGfld8xG1pUpb?D zq2QOtxxv%lQ zMPxyckvmgm`n4s^f-@UWL&0x{!vg69M{FcQ$W)kcY4H^;cD=%ZrwnaymSq_iYeY7} zEP|O#Re&ThFm31q>5L6dQJWpWC0e?EjePDeR5zEGzSf~k$w~%d3dAOoNvA^iO9E~b zpFS{@<3?iHhV!=%6~}{mG=JQB*RSjo!+tj&YzW2lznPAr5#*?{7-|;>M$c@MqEYqe zn1>l9g*6$iP?YwUTcNp8SBGtqpIkw|A`;x14_O+l*HIHUXTfB@ueZ+t%d-dH`e6FU z+kfQ;*;1vT;9C?Ya-X}A_`O<7pAFu>>4Ud%%0%`#^Y_FBy4^Q#4MJKm|dveuTjm|j_>vnTo{QYM@(FG=a zdgXO3R$)l2Eu};k~T5z~x z(tCV9Br5bjN&cmqdC0TGKrM8wCx=8=V#W%q78maAVv5GD@m zEgrY4cLqtxM{z^fbdi}4ad_X-!7l=D^W9@2U5eIM?eUednOw&vY<1D`(s9wBPyhOz zOrrPvdhhzWX9N$2gfCA!W^tQS!mhZC@8IBz09r=o*zVZXUM)mY3etT0be|SX4_|zS zfWQf^V92BU4dCE_Yunp?O6LpT;FD7&peSe=<_PY+T{ZP#jh+-`QKkr})Ts-ub2F;K zUHg}+Yf!KhvX%-_Xt@4LOmRMekOWm&HV>pRI_I1`#pQ(V??Apv)|#8HQz^~mBtybp zH#i=jkF#97%(HO3I9$(xfI*K^T~4=a8|IjazFKhnX6Tn zBFphm+_n6el3}b|1i|ZX;;>SeQ?qxzFmYP^YLx4Lio?CAF6e7yb!vo38azg-Ln#z@ zLPy)*H1eVuh!|E0Me2!2e=j3E51OUK3fz>IQ6`|&*YNu6JmoMW|APDk(cA@S7t0<2 z$9w?n-+KVym&}O@l=DQ4CV2MG>s5cV_^8vm+Hl6mUzkVb_i`s6x=uC&@Rpv}n`fEFC&e)65;I}`wdS0~k5uE7i z%jGtZk2xCB!V7_)!B3I3+X{f}A*~4jgavOsm6y3v?`63PDGzzjHR=>)raX6KgwoJM zf;QRp&5LEf_l#hs$DU7YOnJ9QWUy}I5>8r*!W83Lw8Pqnz~=7U90W7)Xhyqc@-GrL zKwup=Gf#`mK)2Y!VCTaW!kCJGJ}TSRR869>t<_7bYhpI~=8S+o;C-_~fRdru#C57y z!r)Ewj#cpI*r}EbH%90a}p+)%I1$n#ZsB~_Tyw8Rm39d|*w-y&4gR}>!mns(? z-~nw+SNmM$dZ^tG;$a%%IEe42BvneIc{AaCr`#0zvnmtYt##LTafo(N*tPqmJqSxV ze}%Xw0S#ktSuK^;VXMN?aH|u=I|(J(c$|$wGyzrxtvQEe|E9$NeDNy2^%{oi1}rU3 zDh%@e;g$J_r>yi+3yT`@#%4bdn{g%2Hz;(U3hW}i&XRHWLOEv-p$S}t_fS9d70&vS zimiJ0mF&!S>K3uf%J)3pIef%f=p^GQKQnJtw746?3v}xq^ zjV#(W7)T?*g9N0YSm#yW-8Ky&Qq0xhRjE&Pj(hjfy_l+6i{}b9Q!B!U@pK&95h_`~ zV2@Rv8}J#i`qXywptkB^pQwoQxg~V>_(MOF`7a9;W!!)?X?R~*#M9%P%%Nt=)bir2 zO4#evsrqWPF*8+(gyk%Rimgew9a6Euys&l6mNtc)N^==>%#8n2QeH+&qhSz`%`5Ot z*e6iUq{xkOp(_^-=lz6JyZT9O`@d0H)`P|2FPq!le8J&A`MQ)-qsV|qG@;ufeVFvP8ud$$({_aSSXld7Z`e*ljk#i>OEXb;OM9nX#B>T*TB8V`l$Q5sQF z_%FBN^Jt3jku1yNU~xxHICxfn!)p&%^pIYsv6dm7}I z&JzHEu*3ZCs>dlAft9}wX+Hz7ojj!Um+PWSTo?ZPbE4&c z*{T^C4+)>U=S0Mypb3MY@%jqWo>HN4;BZks=RjVb=p1-Z9kNno7VY!K?ukHYA3e#| zglA9R2M)$eeibdtvTvwQR;VtZzr$$feEZ$MwtD$JToaeG+Y+j%?0~VeTOt)A7kClc zYeQ2x=ux}aLX3U8+!yXF?CilU|1;&K3A=Bh$#Uj+=3$%Hr{yQi`*YypTsf48K`^OW z=6)&Iet02=&ItaA6x8d?AfB!y=1}`n>{0pBw17Pk-C~m84n`R?tla3YCG?WC|8})p z;Xgr^zio8i>O%ZTq^kId=?#S!-mS0v(BNVf=?;;5c=K)P)f6fd0}9EcVJnqSy%N#x z!TK4@V!}f$$#WF&g(Ef#_K8ZII%1;5U!QsoAgv|9XV7G`99s+L2A1(fItAp?DE$j zDElG~3h3ll`nVgml7|AONt2XQ0Z|o4Z!6k(yZB2(bW7jWnX`v8Tm(GP!(omx$MYf&ZreMZymd*v5Kk$%y>W z5EY3EB~=g!>N+$JXfvkKbGm16lR-`m^LS}HNk9S^qON%F!a2dTvb7Oe7@T+*?GDN+$tyX&%IV!8VEXAE_2b1)^7ZfY_|M!C3^{?iVWbG=T`+Ntcz^zZ00~c2!)7f2s={3 z53P4%6pC3d;ifp7SV0CdOg}PIOl6M7S8B5xkBp8V$C16C`yoBq@>auwiiiaFL)Xuq zcYY*L{Lzc==s7~Ude-0l5L&2CM7w?P;J_TYcOi1tGS3a3qr!Q@Z6tzyz@W$MHGA`p zDR%%}p@r=}^XB60zWbi?@uPVj+^`&V=GEji^=qsh?)C|E#-g|Cl!u^gtc0B@h7t)E zhGlV5&I%*RHUHOA&iu*Rd_cjWKKv*79DCV<;Nf+U79JoO@RWmWC*Cl`bLcq`DK3r^ zp}OueetAhm9!`dVx>6E7UdTh7W7|tF`uQCj{-1*>_b+5L$udbubOWgn0f7yT%{&ck zEsU!h`yF=mk)EIWEjqW1gt(qvF|sNun541#+C-THLGw{43A1lzrHg4dV!zTGxW=du z_Wt={ep8Cca&fhpl>9e1j!kzt)59?3Skt>rstta2zhYzSx3;$W8tL48ppO;506GLg zD{-~lJqSw~h-!7T3@<8)_XJ2THot9?AK-4WJHp{%JuTtq+=~pOf&U$7|IGWi8P6s7 z26gb5gNv4-#QC>f3E~9!4Wf!pzxRr)WL>J zk@*Ze0I_3YJbu)msYIYFDx=4hZOsUR@jstx3JnRKORC&Hnh&N}irM|5ow*GUJX(V9 zT#!%?4^-Qo^45Jj=8{!)y69MZ!4_-Uf*Ujv8ABeml)1h8ZFd&IofJIK6>wEu1T5ox zz^K^07aa;?LOpy%yw_}GXltC=Udb@pr(y$H5)tB z!&WS^6eld9suA)Z@K7LdBk_eHNtqxv;6MGp5G9%~T(SGD=bVFAr2kTN9fStAG4TvU z0=T>Pi4NzM#Io8}Eic)(wP`%N@=8STvW>w4rc8rWESVblqiP0|h68jqhH<4u7#)`rAJ&~t^0-7+u_uo`3VTa1T5?|CQrNfA^m3h{t=Ipp zx2Mz66;?9qYOPuMCewMg>Wgr)>NSPH7lj{WH6n2%l(A+8=#OYp%N;iL>lRcJJM5gB z$D9q+D7fEv{kFgj%GcvW(X_@7t_xePB`7i%lfQYA6Tm?3c&L&nk(Xb;6gvBhG+SDS zX<^J$|Mq79fxHWf>Leoa6{k^t4$>`JqDIs0Bz|Ii$2a#C9@;Yy7QM4u|j17jC@T&n%&M64^PzN zTl+29v-feVt!G}fuhx4;fmU~b{{T{og-)0R!bZu7d7jtC`Aw0D2Ssi8L$@N2JL{C= z$JxUH>)je)F4&vvNOmo{S&Eu{Tm&BU+Jt2)hhP{?{(edAxPG0G9kBbm(uqh!11V-c z0 zoc{Ydmys5cv7C}4ecJ(KGG|ig#!HXeyJM%J+q-eoqxMk-eq6mfng3Gt4vIEnY_=r$ zD&7d&W5$6gh>+Z0@0E)pl0JRxo?QIcB6gF0W#0cE%)D3v*t>0-mq&WS!-uU9AyQxv zQlf5-)|d~b-eaoxHlct*TnH{o5{{CgcGQt%XT;xiH|GLgTeq>(Gqe3dJCoMwbO~KI zx>zeLEGy%>PO|aq_C^jZ_qB7PWA?Sk_~`HEEBya1A<`aQ0fYb%;V&c2aMX+xLM*nR ziYP@!{Ln;>xLuHzCr=>xdy&w}@Wi~+pLb}SYS(iy=_w;Ku~Og7nH7DysI=>-W1P zX;?)7B6343@rL(AdNl?`G(*w^i$KhWd%l871RiZi8rVSf;@+-$)f`w!cw!CxGNE)H zG;u@jWMawl2sl;=B#`4|A!2ITnfmc(fNP}1`5?BKK-Rl(43wu-fk4m>TSmrymhe+6 z;Rxz@dXd_+eQuN$dD`7zkBBB0L*JS~XfwBo$+w|tw>vB{(vIH$)lw+hfu+e(VB|Mj zoEIL>2R29vkB!cdIU@&&muM9B-uxtI)G^AkMMTV7il}3Wnq^zm^#`jV+qKTxP)i!7 z!o|10S`iDnH;*vH`)V)M*|<7};j!vcBcwrqWXVp2OGSsu-ZN`;@EfWZG(i zSFC7nbU#4GAhUxCqNnyUU~fzmp?a0f+zk%<;bbvoFc?qszf+=k5jR6lR94f$$r~|! zcvPdNA`X?zu0lsjD-p_DJrB{YS0ysOC8!DE5S^ugEWNT2ty5yaPDN5RlVY?R(~e;KB`ZWimtA0mgSV5S2Jf_k+|xR zZ>8xZ00CS#qNg(nbSjr3l%X8i;amb7$EaX?5mFYmN9n`Q|1)g)2|`;!N_d`mxS5VO z&N%Go6R!9gy^_Ocl+FGf7L&7=u66DAEaq=0_P}1?WAQjQ)3qjH^=zQ7qa+S%xO~Rr znS9aI-y#p9G>;Oow&hj(VIjU1k0?*=<@fTcYK^)i&TCGE10pfZ9_EGt2*C`G?2T<2 zNC}7Aw~9JKPxFt{{6wS-LQp{xG_(Jr+=QT>gr9Ouyce~#DWp#~`PxCg5{b9)$n?;M zcw0eBx~z&5)zLZ+n^)Q%o4;}Fa&I69wr%E3H`omCtGK$)&W#y%iE`bTo(YDiDhr|$ zV;q(wD>Sx~nQC5b?Lr)e5a*w=r^_0!8exGO$2DZ%BwK zbw;bR9N85NrNuYYU&f&Dpg`!2pXCQ@u4h4Z7H5gRU0+VR4_i{I%G?St9Bj3wq? z(XUbEbU$e#?(sk<;1`-#q&iZH(L@-{-Z(T2m9eS{1mlV$NETXk3GiXs7(P0--chZ`0<(HtJD00J~80f4ghq-9t5w7gd)U zcSkP_Uvg}iH%d+w;x8dwZY>ND;cB!GTD_Xq+1T3k6?3-S5b4(RHr{X~F>TH}yY^pN zRyR8z0qQrmqJimQ;<4B4;4A_W54R_R{#Pz^(404-@rI zT16Q`sXDrw8f2o%bKk#zHup69`>~Fdt`E%w?N_j62)x+|Q9NRwv$2FuVwyzu6 zvKz&#jf=ws12b>tj%7Q(H$caH)msYGRkluBywg-$a#*|Mp9miyv*pVqRxWIfw@O;9 z`-ONoiWn$^Is~g^KI=pb&|de6n)+k(Pt=N~c#C!<<$x%szgeW(G8?}bVbUS#%>E^;~@h96Wy8s2Rz z4HYSX-&TKCc@$H_K25$ExQqiY?!j$_#oe{&d zPB^X;*?WAG-lQwi|Z;gWFd#af+>7Cbqmd za2ZP;N}2030FY5ibl_;@R$v*Tw}e+fwxx`S=Zg(aIT93K>0F;7_6I>D*l^T9%wNBx-RJau zbD*Gn2_s;U`-?-5=HmN;8v>T(9DdSGA}#qw+|w-dn(Z1}C&sdm_K=0cH6iqcAcC6=7%k^MEU$}(Gu1+ zg75=Nh{%)+W^i1ZBCKu&rYo_JH-=SEXsl5GHd+Rh!-W}170FN+JT68oWR>#^oG37X0b|0LG?a2>gD29vI&<5C@Dfn3q=%m7PIq9_WeAl&>+6L;b} z2PY~+L5Ah8kwgyJDmX$!;K3+md^`)I04zlk+1!rpa;tx-dJP4`T$X486Yun6qyXod zIAWU;)8-F-M=XgaPceKd4`Z*o;YLF7V7~X+_-77pUyp0A_Zx+3sBkzKTHPXU9=cC8 zE8iHSonuOpNQLf6#lU?tc+RBkWci4Rq8XaTxP11`u8MlArZOZ2MW~cNzN;}eRX#Lp z3=7s~p)Pp!n5cJ9GqMOjyYOS=0m}HaYlh)GzWeLz5Q<8+VBg2{8l*EyhctIJtm{<( zexx#u?~nqCqP?|nEYV;Dg`w2fcRksAubNCL={|jr3wcJ+(%r))F8WzwkUD2cLw&cS(kq-uG`kBDVHk<=C5una^$>_J$8V!RLs1&% z5M>g+>&tg++Xic_+^cS)G8j-X(p31_hIC`2bOaVG)oE{&)Xf!7vlb_%AQx8=Yw%gW z=b^x5jN{D>THoD;Zy(i^}U10LF)RI4o^#wgguMGXeco|#pDH7UYo8U4cV z=gXsk>M4aarepcIEeb8wxt~XU#V=y2f!Xl5wp)c#$Ewj(kzX!H>V_WNKtfUYj27}e z(ay~fb|BZey~T7AUBc$#N<`m7S5oZPcS04NYKeY=hMNsU|J{_8Y&t5Ip zpPTWcx0ze32Tdo9`9Xh-gRPycndj#W1;2N)P-pJAcWmd>WqUhE!dXDx32iQhhb-ef@&~TJ=(_~UgM|y)^`0=oaWbyN_&~`IGIJ1 z4!hw|1&swX1j+B+nZ{#4P2O_APSsMt zOXff-z9gM!Z_?QdG@RpJuC*|w?F-7y*`k&w1qasg{Z_-+{BPtHE#q_RC$DKkXCg(V z{?CM+TAeW?S234oGJc-|A$VP?^qc12o;=CB zPfte=T_}yUUswI5uiu}Tf-+G|?A(}hXuZq4X?kPAVkD3(fdci7PxBnd#2lRW_|PRJ z>S&STBW_mo8CukNDgevXN)qbW%*_qc1-|SKv3?6u6Ei7W;RN^*-%%8hN~=tD9j!7l zf`Y+n4E|@?IA9_w69LByYzBop6dNqWt3*O-4Kj$)fziK`@CZU@K&twJD(`eukyE98 zE8>1b;}%s*M#1bR|LCq|907)|U_8gxD087mJML)=xREsxSzUFO@nno~)DMXZ{aIoe zYt#;9g+VfOMq*O|V+1>3wR3e^dgqUM_EpDQ1?iDoI&O7M#fUF#sj zzX%~x*0ax%Yc@9FLthcL{FJVQrSQr1jXv=@NnoM?gi^@;p`1{4(Begagk~f;ZF;-7 zO0nviP~(Y;lH-ilbb3sQ@cYGfB4MBE1C$odUB!@xxKH?ou3V}nr}^j=+E zR(d`($K(mKfqwc)-}TUoP)QQ_ZrNSY9FV!r5wh2I{2#)n=<(uA%I2zWF4S^2L>^#b zp8&;!eqw|8y)ot!jLf_e>Zy7yBr}fpsk}CNuFh5d-QFuW=&VSwU14RQ{=U|nBX1PR zdYNX+G559z#YulutJlem0{9x6DQ%d&n9#F%o~>ox64iEs(FwJIVF2%$KL*(J!6s)kvaUhL}E=Ts?aI+k zH^5etDu5~42wA0To`Y6=)wet~9RLJ>wy)Y+-Vv4|RI%Cbv!=@S&hBByv}FhrD`1<% z64+fQq9wlx?2wOq&SG^wMAKubGc-&-qzO{ZaqiYqMkwLFPC_KeJNVvQJoL?n>$Jq;(Gmgd^S^tOw7~{Vc9VklQ5ER%LGto>*ve39 zqF{{-zy3sUzjX6e^W+svi5mm2{YaUp)^WoimUnX>L2+d!1j{-#<5gt6W; z6#I1j7Wid%umoqjyiH?0E6Z1o8(Zz){aG-8#A?c&{)-2XyBZk>c?If?A)$Z+8={O7 zL){(MZ51kyquBmydbP7N;7ErEL_6$*KcpjRu{D8NkdTE-V!u_T$1Vsp5LLB0i|CC4mMS9U!?;ADVA0ACq=1YoRe z1IB$ogCy%zh#{jbzx=5G2&mBq6WT8{4{`3P(Tk{$b8ojM zWm$Bxvu~T%yBFBMS3Vxi@u76zAnwZ$Qos_Dj8Tn>MiQ`PfN^K<2#t`Nl6VGEQ+Ng? zFz6f1*K)LuE!=Wg@eu9Q{+gOUqGT_tL(#hxiief%a@~7=g@=pY?)>)YVuHDg^}io< zXu^Yrk-ryK>!UxuGYsqv_WAo3!k4Ww1_N&Yq|7~e&{X2^zq?$mgiQ}zi$QLPVTfAb z3UzaT5F}_E27Pb9M7{4*c8Nk^I;~bt~qP$I}dyVBGUR}NgJ1W+c zF&M?*)GY1FqG}3}v*HKrCPhQ%BITcGU@#y9Q3yf~v`4X_d@tWc#XkeZ=_E~2MGxvx zyd%?-!a74oxNglZ_Zun9D3t&>P5!V7Go-Iuy3;ub{La;=D6q=H09|U+6W@kNFb0X= za#u)_9d{)+$WYU8v2Xg(OZYDu7c@%2r!Is4FsPp&NVN z1hwyqfvWukI+GnuNHB2|p6|%#d8wXRr|fT^hw)oP9&|PRz>oAhTOv>8yHCJWzcWY? zq0TZ7?N`_7xizbQZ?!Ul?cWA?KglnGpsFb4iMyG!tQHn^p%Tq6dDoPEdXO49PDmj*Z1uz>81l<+mx^Esn z>EIgUj+1HN@dO|?*KUDz_c&d=I6Z9mC(bB3eT`89brQ6!f@Rg8~vlsjvQ$OgXdG585niZ|s zx8J8&E;(|UPYex){)Xp8+N!Ks1&(hdQGFMc`bTqoc!DFYIz-1OjQsqWV(F12+|-`a4A zq|X0K#^b7e{aQ1x{%^CT7&9(C>mCJDJa?KwZ(8wnh1O!`VcvyFPubZ=`~N(>RSNtH zR!ggA;xYIh~F+m027EN{Oyb4nAaFVf|UHjf3(IXR(vweB$%f*=@gD7E`EGf7i)V z*mrs0{tNrls}{uORoPX|CV({db8Z8KK$wb*2JB9Qaq4^)AJEmAP_|RBxpM0S@Gc9= zE;E~4Ndm%1_|ek(@X=wlRltJ&18@(i0SREy4vXRY z<9$KZ&ET1u`x-5RjjDl4w86thmpxgE#>K_P=)SW%Rd0Kd9dj(K}a6Z^NFQ0IN3P}q)1VY$%;CPp^(~9l=KcWT>({IG$5TJKZ=A2 zWv(Vu=EJSw+|zkhsGAB!kdC3jLIx{!RUPb@T1S=jUQZ4aEKZO34sjv4kTNdm48JhC zR24o&1j!=;Y;UY)!_NQ>FqF*m)Au(Q__13@V6*9uwDtx<%urA@hlI8e)E$4XCOd;z z=@5#Zyx9}3O>2O?nWoJrAm*UU|5K8y{)Y7P;B`2ot6tjvJZAZ9$XMqwb+*WQ!1Me7u63a<=y?<}VgYlhhSh3%PghsW^01f;=Qy7f046eX}FNHdv|F#fK zbbv_lFu9SF@|850HBRX)r1P{gorZs-224=^7Cl&hEBN3cz7q^k?3t&nbnf@)Qaj^ub2*q8Zep@lj%zglvunu-1K zKn5b4mvo@#e7@&fc7+mLbGGcAYjpszZM&bao1MKH?Vdf5B&LA_cLz{zdyp^2+j13= zen{Dn6B(5As=PB`g+~MoA-YUCl}3^@_X@wOL%4E6D|lH;OnN+0#50K{9uKBth0t@&h|Dcpi0%Ea!*?xHE7=aPX#UsW`&7q+q;>f^6qRdb3 zq<_d$psuuo8}o{FJsaIVwBqCXnU4}Hd+*l3Ya#_2O#l!6 zHUFc`^Zkq0AU85PbeCMqL{u#TSIsUP{Q^0k3o_jHK>U%oxnfd>ePD7Z9C8I;_13ES z+>6Eb+U>SQBxR1KRI^b5n42!{c?=-rf86#P2oKD_3LLs5`5a+z%3OPb`>ZqmauZB~ z^;{6!V!QZ)|L~n;(}Bku?=j%?!J^M2;Nc>hQW%z{OC7Pfc8t2ta#lgX|NDWC^Y;Uy z3rDQEXY$W10=aj5^_#)?zeu>j0uQ+wEd^D%nXpm!J6~9lWmM_6Y&UJQ6MJ^W<;d7E z#~bR_zi_L3-r&o_L`KIKhS9vvhee4d@1Rb@JGN_P|F*&dMbG=y@}S_yOYmmr6fNs^ zqSE0T&YRKN6Ri#`P@fJRIX!#QYfn2#~pgZTz?6j(%$o&WS;kk`0ggeOO$1n|EAg5 z^;{nQ^!qYygoYFiH**2%mrOBLO(oZS2Ovb1-XHs~AHi<<5CG(sngsQ8ivEK>`?gE$ zvwIMk0()|%B9s=*8I`nK2c@do3wj!mlC=HEzMh}%3i^;oCS}O2ZOqZA-AUhplK<#X ze0f_7(vR+q*Juc3&lP=v9aW7+)cLV{{N*LL>JK-)@)DSVRFdosazQ4*bM6eIUSBV=EQqAL z(2sHskbItP`?BzHneD^FKwDIC(T~}}pNJwD&?i0mMhhl>#xD0Fw1JA@ZX0Bw&M~tF zyAm!f(*iSi3f2ghw_-tmc-Z3^U9)jwI~o)^j*L;6Swxc7Iq5A#;>#O_&r%P4?tH&@ zh|mm?bW08x*!X;1mSX$)U(vpYf}gosoDe2!7@;Fq*6e!{R#dqDc5Y+LBs&&O?z3hC zMr=mxht^DE9Z3_PWGB)^>|na@w&r3oK@u9#MMuOBSGhT@yaA5Q zzxybqu1^kWhnqd*!rp*BmUH8K!VsxZHWPslxtn{%vZ<^vUD|*N9CofEvzR>;>2|8BzPNApe!%W(MzldDGligmw`~n`-pr<;pnGN61 zD>lJMn9Wi^soZ|KQa~sj?+xDl7fg~uy>><{qnchDzi%Psy{c35k)&+BK*lpae6`U2 zXb#3NNk9k+Xqpy4k@Gn0e??BL~^e=lAanEd92KVANT)i916f6!S$S05fkE5#$ zi?Z9I!!Y#FA>G|6-QC^7(2XD=Au)7!Bi$*8s0bnr(j_1u-7WReym!3+=GQ#WdCxxk z?6daTYh^!TaV)M*;P~oK(q|6ibiSm{c)kpo`uk476{#r{SgTE;;hcTGJ1p~H7(z@K zGCjW%5l?ZUs3w%2G`B1tQKVz_rT4;T_B0Xh0BX=dNZ8I51&1(w?-q)SaAwY1IMjsa zA#(IfLk+6iuLKZb_L61u_^=SkA6csxDu2&r8aui?hcSdk#V%@UKh&^DdYg|C&?=l{ zcByi<6t3e-&!{z$xeQ^WAe$xf<`ngN_ zx6qBhAS5KbyVyRkU^l$(Qe=aujXV|5JiM}kx9CVBlA+B{fP&jX({YjiqyI!pIs>9 zy@nuGAaBT28_#iiROoG#z&EUU_sON)hG!!Ro&vdId)V$%K^=q^OlPXIE11(SbgKZe z8xxX)kja;Lg28hAnbTRy1@6Hw8s{8k8rp1n(!aAta>~-#{`5V98qH>*`g6q-KLTRt zUShU2oswemvfrw!Cn-&HMJ5-@ClawyPCwTkg!FbIzyM(K5}_tqNDl*c{(XWwD^L`d z!`Vb)kJV92>X*&HYD2qRvh-@LD)4QQmJ#=4MDetqhsUV!ch@-e#CBt+2VW)CEyO+jHnRh6odt4fmJ_it( z{!Xn^(#_)@_YN8MYV{LE$ zRwJ>sqhtLU{V+NekwQv-3TVH_w#RdECJk^w7cZ4L{C)&jggqS#rg3novL9GlPKA;G zL^rX*XH5N=2Kp0$0sEJKFue+oyG3F@Bm5E7InyKTw)X3i%}}T&WzG5@1Oyvt7Lxk^;<}v3!&c zeZuuK7n^=UQe$BJ_SK@YUrit^J66F4Q-mawUWM3)*?5Itc5k7F@!ec>F0g|9?KpVMM4GIqY};^-5Vb%D=Eih&3%B2ApaQriZ}b~+y1Qhr$H8zYh1}XIF5h+*UxL?c_c; z#Y#F_7?9M;n|0x?z&_%9as(gnI0()GT~FWEzCQbOKCdCl5dc7#qT_>jTy&rXAdIlw zo?Hc5&zglqHB*_+v-gr#MzBe04l3TGv0DE!u5>YrAj0gbYLPX5mp(TU2jtXI_hZt* zaWQlSKKAoPt*)~rr%1(7;COeHZP!sO=U%Es`?H6)6R^=e{t_Q$w#i^q7&S898W|N6 z6LT8PdZByc<+qnO0y@JV6R;@BvY76v<_FE2zKL4y$1e41GF37miP*T~UZTlVfmxj$ zBF>Q+O!ZVavU4kI^k^p=eJMB1V5V;t-A-+?-e2Oim@P6ZUq5LBA-+$*Wrh6X%_R+D zeRqSb8xB!SCKDSH+b#VroDH{L-Qk>IHCrDs3;Co00)naDOB~}l3xHrS<;U(2E*zm0y>F+0>-&gN2aUtoR_JRhDF_+4c~w^+>RqNnUueeJZk! z8rXjOHhqvqVp<{Wk7-f^_wwuWbh;aTTY{1}wXv7c-<+616^i@4utFw~GV*H9aE6~f zcIw~!TK8m=e@FEZj@*f0ooi>b+3v>Y+c(7Frj=SZD3Q{!CDmWYd^X^HTBvSz+_9&i zmh2F%T=C^$Lmlf7OF44qsRhm^y1qVp#sWpp_J{=oA|R-h6B5O!zXsjCFv7JB0W%6Bh#f5TQx*C(3a00KK|w_BZ95 ze|k`zUIij&yne8WUHcZSu&4_s$hY$l^Z9{on1XDG*M~yNWS1kJ0b-O>c^$`VGJ)@j zNhSs3e(?rHwpg-AylBHeSDb?ING}QBOeO8ZNb5dqbpoN;x%T|$=mFRX4@K-M42D=_ zfu}NE3EOTg5lWch$6r{{^q|~~5>Iu`|Aqrkx@w|oRt89`S{(XBxk2+bo>jjq&IL)J zPeaAW>F6THHXCTeS~B-#`z^pl&Ibwjb64sUuA zQ<$g${BMI0x^B3R3lAoF`xZM(llDm;@$L|}>ZbjMau&jbC+j#0HzEVI$SH@|GV-A! zffLK1^{=^WirB#JiSCBs3n1gdbg!liH!{5Ue%*N+ zUuc)x=uj(M(tgxHfyO*Bci<%wL~@dZjGWCdEi~-bOe)P9c@VkieiEVKU;FN^Z*4LZvBJH6 z6EJf;%@;R*@Kyw>P237pLr#GaFCLYGDK9(JL$t=iRZ};6a%NTxy7KjS!h;jN9;2)dM{ zm!xOg`wT-!Ht{;tVlxD!#e)>p;orq5@@K~g7HM07HB2UJ_x6heG4$>gU1SZzlps@2 z6N7L(unFF|g~oCiyicxDw>erzxB>sFOFp1Z7{tpH^hNX8p64M86-LV^t&Wrg8)d14 zC!x2thdECnjI4j!r`6UG(CUpBS;BtP>)1>biC7dCNg$BP)PU8+Gawsy_WZinbuldZ zxN)}oZ_h73Kpb$o)v;FJWwJ-+$)+{D!L#K{trKIwY=JW7&Mqa6S`rC<-MbHTW+8-s zU`gWGi3sIdYkC`XB_h7i`GESADF3=qZ`8HdQTzzYe+8KQtDU`d;KAiJpYmz>%6n4lkwyvyN>~lfTC?}e;N^Zqf*Ye9$~NgW-8-I8;UnFtT%SxZ>6qv%j#W?^)C_@ z;Se4tqa%_0eM?laGv`AOe92@8?Qo8M_ zR1>mlRpJ3wFpG^gImJn=9a6PrIg`H3|1m@b6e`E1a2;9D(2RTn}13r%=-e*OIIEVJ1bApx3@zV-_zE2DYu2T zQ>x^v@~*mu1upKaE`I2<8k0lhJ;)y_=f=?*ibX?pYg2$tV^p>_Ns6-l^^6}(zgc-n z?NN#0b!d^_#xL9$AedR5eWaRz`fa4WS9hBmzEU5)VcA=|`M>>{36eHN&lCx-WA1}W zJRF3o15vTq1fK6-$T$kXQ|qM~3iCrtz~Op2=-pX8Vcl7I7)Yd6s*zz~vSVy`cB})K z7_yqA_-{X1$-FbR#QJkWfbzqp2tG8Pr&(DRU$>N=%W>!1`FS$Ag8@lyPqfih%I{-7 zRijYxTSKon>kP0VXLV`Bj=6e~P-7UL7Q0y!0GQd~a-6DFSOPbh)YDj$?)aOhYxD}Z zLtP3(^oO6Q>-T zTK~AbLFD*oi~=11LT86QcaB@64qotx+_w(>d39dL$zJzqZ9dxMka%dy?;;-QUnCsD zA!$Ynt~?UAW>tt;uJAYlI%S005B7mk=CNcpH59}PR$+*!WX<++B)d zko>sSL^AQz+BDR(@6P00pxit8sL>Q36xK3hv*OqCVb9c7PprPK`ND}6H@^M|xaaXv zcyceM9|$EO<~C==&l*+FA+a$hY6!QDa#MF;)YTDo$i5J*Ea}&IgCc;eVV1Uz)P=^| z+f0wfw!<5oG$Olag++hRhlG)rI9$YnR-BV_Qw}UVHv(uh4^jJbwO_7-5iAx|%pM3e zuKM+NF3_=nV1#mgE>VdMi>SXR@>`T4$7lsCCf#BMvwD@DupHjsC}CfS(;>_stmkuu zGP!!b!(vhl$*iIi*OJcG?T4THeKI*hy%A zf8Tbc1pLBvbq#%*i@Eyn;~5y|0EDOw4CV}nDi?HqCAKV$-nHF+J#s1;z2`1=Z$tZF z1#bt7$dD=F@R{My_PxQ$cISvklDjF^AL%td^>x+8M;JBldmh~wJFI1-W>YBoyxY_Mi=3gu*OgT+#sM+m(std|9J7H4E8OZ8B>`;4=EltJ3O&L$VZu9aav~2OJ>2Gp^4||&)*M?7J_ui=Qrfh^hF%8~%DP4y?t16=jCOH$Z1Rzk6sg(=A{1L6m(qE`EM16)?JA4sjS zv}AId*MFP#Y(v9>-xbMojs)VV^4(QodGSzEq73w1pnf9Nm6KcYea0Rlki zQ`bBQL+Ns-lYJ0ogqJ&)Tdi87QGL}Z1(P(0Vr(_2AKSnR z8bUMakJlaXC1GiaHQpzy<(@;g1{_h6ii_~-)wz>Q}<4PKWaWhVhuLU8c@x{+w z(LpB(c?Aa6hD7kB%8sMZTaUwN>67YvI4!h<{jVd)whJz^MysMrByJVc$iKXTPR4 z;CLUb)xvD&-WwKr0}S*H{CK+IPL4;!2dEnvE<)E9OYVsjTNtIFoYhpi`rHa>Ft#%$&6;#SOrcFbQY!ZmRb7?6-qOm|@{x)%}(49l6^q;6CM z9e8?|Yi#sxpI;8`RrZnxg_9EU?PIXP(-O$derb4GmQ|>&PknEXRQO%*n-JG*X>g{x zyx=(4v@D%fdY}5bD+7C`82mi#9J&v{?j?V0$O88(fPkZM%@6)#Ln{b~@_o^Cf=a&0 zBD@Y)9fOdxm@Nr|Y&rEWS!s;$p@U8DcJBfIB4K#8niUh*F=-2hfF~+EOmEW|f4Vfd zf3u6H%WM4r)9p`1##g;&Of@w%7ym*!IC(V1YM1I;S{$OP&cN&8P`a3E#%g+5RIEeK zV?fMv?*W=1nJN=9;`X0Mnl!+ZKJ=Jn!HU(rbTP8iYt~Pk!K+Mg@l8)?mKS)gAcc_V zSpVdNt@r7mWBa`#$$QE1O$l7V75+5uikWxeUIfi?_B3F?S>W4g_!kLF=#VdZGqVAC zx0;n=XCpjKMtZnpci(=S8)o%uwA*YABI;+i<2{cWftXGnfCBH(7n|p)LQ%Z;ePC&9X-6KtUp@|*fU61KB2mrlmSOFqGPQawt0!vqLtc| z`u9<}#!=%eC6)1Za48<aT&30En z=tsJX=~>>S?3EQpFGKXlSTZ|1H@#HaWC>CME24F)St-^;bZu^Hbf^Kk9iPbG5>a$D zh)m#a5LAsSl;nUFf5%+q*j0wT!E;Dqv%B3GLW?)&TnoFSqw^8L*H-zGC9CoSUpl?T z7^yHsD=?DC+U+dx0$n#Y z9bdUafKC=oMvEq!D2nSmg)Rll^S`S+P421U&gjE-g;5GAstx+hxyt^g?c$O8O9`Hw zUV=NfuAR!t1dRSB;9%`CRO|EWHBHT@R?durn`5mgD5ClWAxG#HLSMTI=zO09dFw?h z#75I6k-g$%3`d1WFhh~}5~0Fs0)%0|KgwtsqLH%V3$8I|Y)=o%?ivy{yBuBRG6iD7 zT7^sMW+BM<^vr*~mIQHyvaiug{1Y)*@9sATsIz1 zUO8-3*BzMtZN7Nq6QhQscX$`)(ZRYbou9otdO}&+Qd2>oHw2Osz~b6RL{S5#laq&JU*la?dG>qPxNLY`SBO zCez4@dy+XxfU(?!>I0ol7RTrGFK#qEj>)M|Wldu1o)K#!Q6=6P65(m_SHV%bZrOcb z?kIjPEHY4uVqtmE6tVz4a*~pp7|63b)|ym=al%R`(`lfjM8~to zjsV07D!k~!M5|o_{X}9`kdd>}tw&|sV&!Fxb$Ww5Lg-K=Aa_579BD0~faz2j>W{e6y@h9g1+r@X^BiMd*J%4y{tTp!1mNYPHBCBS=mb~3@__Hk* z1L1!!CaVIsQBX;JJM7olB6~R@-6aynn-}p>ljQV7*Y!P+f$ZOZKN@qLCY}3xmow~z zjz5v>-gL3kNjKI5wejN5Egp|AU;kw*=|OcfBWvwNCC(GUw0U>Xg2ar0LqM*vYZ>F*q0c0C&>oM}V&1494hp0y-YM?~&P z3yqaU5y!S>*C&xQM$F1T&~?<+9OQfs$^?OBKp-jHyPj@LJZwQgw;q-D{ zasu4-k?Yl0+)tYou9?oppaooPy!Af~IujL>ka$Amo%PuneUbJt%W7V0cu%Q33#x3v zEPvV&(3~&+}N17AousMD}DAGJUD&p{TE1IW0FYEbjc|jtKXq)38)Gdm&*!D z>&kZi-i@!z0D{YWfX?x_ii1;iw8*R*8uplp{27_a!^=5sc>g>4dcW2hWg6`47HnyC zD8kCFk^ivwNaIG>b2Wz#0e~kS;0c<4a-exH5M$q{`qSA6TStX-nbNgKHz{rq;t{4e zNJ^N`>hPMky96SqClEF#Pc09M!r%V6fnpiU87CN4LL5q;%<+2!mrNwu2;vzYhQeJ2 zgYK%bBwA!gjeD9ib zh67;|=2`i66LLMeb|Zb5tAhjMQ^b3<%-*!R1*6XosjA-gK<;{et@M&+z@hJ!>ZOow z(43~ct%bh4@Acf3Sw@qo9%_ zk+3;&N3sV%3|@NZi6liKm;JFAjo^bTVP#SKepvA4KP~y$sCGLO0V*0}QWP|9d!gKr z)Mx9Zbi-^dL04%I{-VI)^+8R1L`pB{ z&6~*h587g6RefD%He~~>m~dKd=#kGQq)32%IEoM#%p+tKRw7$9H2wYfu@~3a8eFdP zy}+ggbI#;$8gDAl1Y~eLsO&U5PTLyPRDY|zx+nVQs+A%X0M4GcMFjb|BlBxP>Me>0?T$ zAYyKyDhtt-uEmqBXRJ&5U3~LA829b4O6smo`(ms-3L@m19*x{Ik)P;l1%iO!AQ5Vu zD)kyo**f|)IURyB&%RX3$oYWgFMVM=);1nOA-wWEw;FlUBmZt81leNLa8}>lGS)uc z%-z{0Kv!2>S5p%IAd>CCH-l~4_#hN-2sPL_lsa_uap_|dQ7Qk9 zN%(EZD?~--FQ$M!**VtJZg2Qe#+8CPV)nqstP@)-Y#lkl4rfn)aq}>q%k1s>B)=3j z3En_VRDA5#lpGCi%g#s&ibN@58+j1wYe?{LC`1e+TnE%@gldV`O3S-XYtM=VBSu2~ z?A9|IkxJh@EB=?5fIFht>%jfifNB#QH?KkEOOeiDrz>l*tZy#q^5?73pkEcC&7mJG zRQz=L|IBw8WQY|~b{cj5imkDR8-bPF+88bG_b)~ehgW?aW>Z26Bl-u?awQwV|BYl_ z8Gm}s9rCU%JLwDG6uW3d06`Z)##;OgL0QFTm310W@2fWdu0lu-&uE$xDxFV@|9S7h zOByyz&%5UTuG56&_OKW1T-tx0V`#egmQC2NTxN3xQ~xMisCp$cOt5kEF<;TF&fM{Y z^xYF|r@I6_wjc~0k2H|BTJyY^+7SfaBFl|1fnx9z4X!o+i-biG3W<~6>>I;2W5)YX z7t~-vE=}DNgo0dL#({4Gl^|U~HRdo1UmI&=(fx6Cbysi;%dG4~DXWni>X$*I0s}S) zpS<2#wM62PxY5ug00pV52fjGUq0=NE8tQmofGPU%dp@FAi6B6l#!JTCL0u3==qnMa zZt!Dpi)P9Eq;08@&s3-+w1@<8-?bT}4dh4@jrDw*J5^WRo}Dq2T4n5EJ34!`=nzig z4OLxHOdYiv%N+I7No=JeQYU@z6pU>FgP{WCTxZYcJ{D%`L{19kCfnD=#x4o@oQ8ve9u=_eRaG;P`I7_>+1A z3$8Vp|M2#ut#Fgo1Ti%I}OShA4sk4}vSTzw)QfR(Z)|@nepn!;Ucc&NPFrp9p3$8=6F?0>& z2~Eyyc|IC2@@FIS#~uV)5k5BSYryahVBYJ$UI&M@z5f>p2mx4Gy4L|W1KuL4Y33bsL_D@EZnaJq&VfeazY*(0p0w0Z`u2^Thc?wi~V<>6Lhw0hkg6BPkY;OL`zMeK!@ypJF@raMdD!hby_YMTb< znK!INhcQJ^JxRmvrPr0t+ifO7o)|$Y@#Nr&P0RO-;&aeV1$t}=nPL10Vsr)cA2S2Y zl9_yBwbmq|CKiI}uj4U4#&En;J#`R~4qP5t9y|e0NgHcpvI!JZmdvE+3hi3|tt;{o z>#0PDg*t-qI@2P#)G09!==2Z|uOz(4IRl|@BiDOLR7?57q|ZJgwa0l@9E<-EU``{j z8a*zpqp~Ck4WtadEymsywB8mXA+%atwgOEl3Zxy-?N8vTpoka{UtH_(J*l%j$ zZKxVIbbq6x$8+_KCNALXR}m?X&6NPZ^W`1V_e?9>sUVO-fkAs_f2{FF9|=Bep-fEr zxz>4q!y&fq)5R09v%R>(3$Jbv#B>*f?a81jPg4J`K=~?L+lUlRMNK66QMi5~w8r1| zZ11@mi|4JoB-%X#rPkXSWJ&yEzD@x6C4;VGMc}DcVqPKuvI0x9N?3#~kxeIy8dzI7 zmrOIU6?C-vU~a^YVOVorTXNp}@P({aQ|Say{-#mXPXEQhV8S$}*Iv}Pde-&e)3Gw| zXm1W5WhF}QU+>cgV+znhk&xMag|NLoiBa~Up`wYgqcHLD)-GDuKPhs<7o*Gkep}Go zxD5s7VSbgW{dBwfEY6xdko&;=@a&@9iHmRv zi@gM-C+|Wh#akvhs&*M$dVIo=>-sXr(|`D3P;hAQ_TqWQW*EZXE2gR;=WfemvB;;h zvbui?*`=qRclN?UOpg@s+@Y99I1f=8%Wft>>3Xgt>Y=g%*n1$!f7Ay zC;kcfbYae>(eS7>S5i{av5Qj=!hfCz0o5M!DKa&4o94=(1n~_CCkJp{ZeSCo`NZU4 zMQt9i)7E^|E=2U@L!ZCdtRZGYKUPRnexn3_EEag z8a+@IZXH1iW#lgvvRqe?wN%U`;;#Yjw28X;vKO9!p>{x(rK>HqkO3gz@| zXz|5@m?eG5I-cT-dE9QA%%)$M1Tr6B^l+uX3W)ca4*+JBAT6m6h z7VFBKawr^=!va(NR!;rj${=1Xt76bzK{2mk4-PJZe@Xio9TKExps)FI#5FqJ-8rq2 zNYYrz{pT{BWd?#P`T3RJpTGbY?t$L)Jj^4>#~rXKTgeHT_Cr13)O0(57$N3WL5?uV z5%kiBD&x^5qvrFfW@V7ks)+J7>?5k`t0ECoW{xB_*w~5lb93ot`!% zuYUq#GP%xP#9SpPcn5bp1h^s^irAuJ{%w{#MUrCPq6Jdu5QhL%yP0)prjXjK=MYGH z{bOk??v1oRMlBmLxZSWG)(nZmhl0D8DxyAG&kod$TAR!4zmqCc24)f{(TK{6eckt z1Oq)UTxN}r_KGz;vZTha)9iK8QUAB!7B^j)>>B9JyparGJC5GXtvA19^UXP z?Mt-F(2fc0!S&{*r29g@W-Pi>C}D*&vQ3MpyAg90YGkT|=f#S>+$+Y^5R~bj8iO<+ za`fTtrH3ECkLA$QR)rzMq$yEg*sq^aZ^b(i2-$YN(BHfUe^*LP+~*=-0T`n6o7Kzy z(BI`hm9=n04n|@{CIJ(HcI%>Aksk$ zB{*6!s&@((-|_h2+N`olcMdL|*KqVRw<5|YNj(V`Z<4eZME{cZ9UOwJXQ#BLHDKW^`sgKLVo zzFY5|P02YvXMO(lQX|quQH#c_Wo4eaoH1M|GFD=Qvy~v?O;Q$O_+6|i@V^Tc+xDlf z-0U&j#|3lWEA_*Tszy2esje(m+gRty&}7e2J#-R$N#baFMXI$6F2 zX4+v+Sos*2E0MDCwsS-rM{R>pt{D}x;&i|FHu7O+o$9EkcmQ`L3wx5dd)RRb9pApb z?kY}YtrpY4#E??8;?Pow8$zc11YMUKas9+3pk4MchLXj^pP^$KPOEln96E1bYbc1KJ_XJ!v;8hpg7lBTP#L=@

    i`V#?l3 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

      *8jry8i&^4$0Bz8zz1{%p`10uS5|`1<$dlbD9x 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 qi$@c8;11Vu`6dXC0&{}! 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 { + const mapRef = useRef(null); + const nativeMapRef = useRef(null); + const [status, setStatus] = useState('Initializing map...'); + const [error, setError] = useState(null); + + useEffect(() => { + let destroyed = false; + + const init = async () => { + if (!mapRef.current) { + return; + } + if (Capacitor.getPlatform() !== 'ios' && !API_KEY) { + setError('Set VITE_GOOGLE_MAPS_API_KEY for web and Android builds.'); + setStatus('Missing API key'); + return; + } + + try { + const map = await NativeMap.create({ + id: 'demo-map', + element: mapRef.current, + apiKey: API_KEY, + config: { + center: DEFAULT_CENTER, + zoom: 12, + }, + }); + + if (destroyed) { + await map.destroy(); + return; + } + + nativeMapRef.current = map; + await map.addMarker({ + coordinate: DEFAULT_CENTER, + title: 'Hello', + snippet: 'Capgo Native Map', + }); + await map.setCamera({ + coordinate: { lat: 37.7849, lng: -122.4094 }, + zoom: 14, + animate: true, + }); + setStatus('Map ready with marker and camera move.'); + setError(null); + } catch (e) { + setError(e instanceof Error ? e.message : String(e)); + setStatus('Failed to load map'); + } + }; + + init(); + + return () => { + destroyed = true; + nativeMapRef.current?.destroy().catch(() => undefined); + nativeMapRef.current = null; + }; + }, []); + + return ( +
        +

        @capgo/capacitor-native-map

        +

        Google Maps on Android, Apple MapKit on iOS, Google Maps JS on web.

        +

        {status}

        + {error &&

        {error}

        } +
        +
        + ); +}; + +export default App; diff --git a/example-app/src/index.css b/example-app/src/index.css new file mode 100644 index 0000000..065089b --- /dev/null +++ b/example-app/src/index.css @@ -0,0 +1,37 @@ +/* Capacitor example app defaults */ +html { + -webkit-text-size-adjust: 100%; + text-size-adjust: 100%; + touch-action: manipulation; + padding: env(safe-area-inset-top) env(safe-area-inset-right) env(safe-area-inset-bottom) env(safe-area-inset-left); +} + +body { + overscroll-behavior: none; + -webkit-tap-highlight-color: transparent; +} + +:root { + color-scheme: light; + font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', sans-serif; + line-height: 1.5; + font-weight: 400; + color: #0f172a; + background-color: #f1f5f9; +} + +* { + box-sizing: border-box; +} + +body { + margin: 0; + min-height: 100vh; + background: linear-gradient(160deg, #e0f2fe 0%, #f8fafc 100%); +} + +#root { + max-width: 960px; + margin: 0 auto; + padding: 3rem 1.5rem; +} diff --git a/example-app/src/main.tsx b/example-app/src/main.tsx new file mode 100644 index 0000000..a2bf01b --- /dev/null +++ b/example-app/src/main.tsx @@ -0,0 +1,10 @@ +import React from 'react'; +import ReactDOM from 'react-dom/client'; +import App from './App'; +import './index.css'; + +ReactDOM.createRoot(document.getElementById('root') as HTMLElement).render( + + + +); diff --git a/example-app/src/vite-env.d.ts b/example-app/src/vite-env.d.ts new file mode 100644 index 0000000..11f02fe --- /dev/null +++ b/example-app/src/vite-env.d.ts @@ -0,0 +1 @@ +/// diff --git a/example-app/supabase/.branches/_current_branch b/example-app/supabase/.branches/_current_branch new file mode 100644 index 0000000..88d050b --- /dev/null +++ b/example-app/supabase/.branches/_current_branch @@ -0,0 +1 @@ +main \ No newline at end of file diff --git a/example-app/supabase/.temp/cli-latest b/example-app/supabase/.temp/cli-latest new file mode 100644 index 0000000..75788de --- /dev/null +++ b/example-app/supabase/.temp/cli-latest @@ -0,0 +1 @@ +v2.40.7 \ No newline at end of file diff --git a/example-app/tsconfig.json b/example-app/tsconfig.json new file mode 100644 index 0000000..c569f01 --- /dev/null +++ b/example-app/tsconfig.json @@ -0,0 +1,24 @@ +{ + "compilerOptions": { + "ignoreDeprecations": "6.0", + "target": "ESNext", + "useDefineForClassFields": true, + "lib": ["DOM", "DOM.Iterable", "ESNext"], + "allowJs": false, + "skipLibCheck": true, + "esModuleInterop": false, + "allowSyntheticDefaultImports": true, + "strict": true, + "forceConsistentCasingInFileNames": true, + "module": "ESNext", + "moduleResolution": "Node", + "resolveJsonModule": true, + "isolatedModules": true, + "noEmit": true, + "jsx": "react-jsx" + }, + "include": ["src"], + "references": [ + { "path": "./tsconfig.node.json" } + ] +} diff --git a/example-app/tsconfig.node.json b/example-app/tsconfig.node.json new file mode 100644 index 0000000..b007a3c --- /dev/null +++ b/example-app/tsconfig.node.json @@ -0,0 +1,10 @@ +{ + "compilerOptions": { + "composite": true, + "module": "ESNext", + "moduleResolution": "Node", + "resolveJsonModule": true, + "allowSyntheticDefaultImports": true + }, + "include": ["vite.config.ts", "capacitor.config.ts"] +} diff --git a/example-app/vite.config.ts b/example-app/vite.config.ts new file mode 100644 index 0000000..207e79b --- /dev/null +++ b/example-app/vite.config.ts @@ -0,0 +1,9 @@ +import react from '@vitejs/plugin-react'; +import { defineConfig } from 'vite'; + +export default defineConfig({ + plugins: [react()], + server: { + host: true, + }, +}); diff --git a/ios/.gitignore b/ios/.gitignore new file mode 100644 index 0000000..afb34f8 --- /dev/null +++ b/ios/.gitignore @@ -0,0 +1,8 @@ +.DS_Store +.build +/Packages +xcuserdata/ +DerivedData/ +.swiftpm/configuration/registries.json +.swiftpm/xcode/package.xcworkspace/contents.xcworkspacedata +.netrc \ No newline at end of file diff --git a/ios/Sources/NativeMapPlugin/Appearance.swift b/ios/Sources/NativeMapPlugin/Appearance.swift new file mode 100644 index 0000000..cb442bc --- /dev/null +++ b/ios/Sources/NativeMapPlugin/Appearance.swift @@ -0,0 +1,234 @@ +import Foundation +import MapKit +import UIKit +import Capacitor + +// MARK: - Map appearance, location, gestures & padding (#8, #10) +// +// Split out of Overlays.swift to keep both files within SwiftLint's length +// budget. Map type + appearance toggles, the user-location dot, gesture toggles, +// and edge padding - the per-map methods plus their bridge entry points. + +extension NativeMapConfig { + /// Parses a `{ top, left, right, bottom }` object into edge insets, defaulting + /// missing sides to 0. Pure, so it can be unit-tested. + static func parsePadding(_ value: Any?) -> UIEdgeInsets { + guard let obj = value as? JSObject else { return .zero } + return UIEdgeInsets( + top: CGFloat(obj["top"] as? Double ?? 0), + left: CGFloat(obj["left"] as? Double ?? 0), + bottom: CGFloat(obj["bottom"] as? Double ?? 0), + right: CGFloat(obj["right"] as? Double ?? 0) + ) + } +} + +extension Map { + + func setMapType(_ type: String) { + DispatchQueue.main.async { self.mapView.mapType = Map.mapType(from: type) } + } + + /// The current base map imagery as a JS `MapType` string. Must be called on the + /// main thread. + func currentMapType() -> String { + Map.mapTypeString(from: mapView.mapType) + } + + func setCurrentLocation(_ enabled: Bool) { + DispatchQueue.main.async { self.mapView.showsUserLocation = enabled } + } + + /// Apply the create-time appearance toggles from a config in one pass. Must + /// be called on the main thread (invoked from `render()`); the runtime setters + /// below each target a single property. + func applyAppearance(_ config: NativeMapConfig) { + mapView.showsTraffic = config.showsTraffic + mapView.pointOfInterestFilter = config.showsPointsOfInterest ? .includingAll : .excludingAll + mapView.showsCompass = config.showsCompass + mapView.showsScale = config.showsScale + mapView.showsBuildings = config.showsBuildings + mapView.overrideUserInterfaceStyle = Map.userInterfaceStyle(from: config.colorScheme) + } + + func setTraffic(_ enabled: Bool) { + DispatchQueue.main.async { self.mapView.showsTraffic = enabled } + } + + func setPointsOfInterest(_ enabled: Bool) { + DispatchQueue.main.async { + self.mapView.pointOfInterestFilter = enabled ? .includingAll : .excludingAll + } + } + + func setCompass(_ enabled: Bool) { + DispatchQueue.main.async { self.mapView.showsCompass = enabled } + } + + func setScale(_ enabled: Bool) { + DispatchQueue.main.async { self.mapView.showsScale = enabled } + } + + func setColorScheme(_ scheme: String) { + DispatchQueue.main.async { + self.mapView.overrideUserInterfaceStyle = Map.userInterfaceStyle(from: scheme) + } + } + + /// Toggle user gestures; nil leaves that gesture unchanged. + func setGestures(scroll: Bool?, zoom: Bool?, rotate: Bool?, pitch: Bool?) { + DispatchQueue.main.async { + if let scroll = scroll { self.mapView.isScrollEnabled = scroll } + if let zoom = zoom { self.mapView.isZoomEnabled = zoom } + if let rotate = rotate { self.mapView.isRotateEnabled = rotate } + if let pitch = pitch { self.mapView.isPitchEnabled = pitch } + } + } + + func setPadding(_ insets: UIEdgeInsets) { + DispatchQueue.main.async { + self.mapView.layoutMargins = insets + self.contentInsets = insets + } + } + + static func mapType(from string: String) -> MKMapType { + switch string.lowercased() { + case "satellite": return .satellite + case "hybrid": return .hybrid + case "satelliteflyover": return .satelliteFlyover + case "hybridflyover": return .hybridFlyover + case "mutedstandard": return .mutedStandard + default: return .standard + } + } + + /// Inverse of `mapType(from:)` - the JS `MapType` string for an `MKMapType`. + static func mapTypeString(from type: MKMapType) -> String { + switch type { + case .satellite: return "satellite" + case .hybrid: return "hybrid" + case .satelliteFlyover: return "satelliteFlyover" + case .hybridFlyover: return "hybridFlyover" + case .mutedStandard: return "mutedStandard" + default: return "standard" + } + } + + /// Maps a `colorScheme` string to a `UIUserInterfaceStyle`; anything other + /// than "light"/"dark" follows the system. Pure, so it can be unit-tested. + static func userInterfaceStyle(from string: String) -> UIUserInterfaceStyle { + switch string.lowercased() { + case "light": return .light + case "dark": return .dark + default: return .unspecified + } + } +} + +// MARK: - Plugin: appearance / gestures / padding bridge + +extension NativeMapPlugin { + + @objc func setMapType(_ call: CAPPluginCall) { + guard let id = call.getString("id"), let map = maps[id] else { + call.reject("map not found", PluginError.mapNotFound) + return + } + guard let type = call.getString("mapType") else { + call.reject("mapType is required", PluginError.invalidArgument) + return + } + map.setMapType(type) + call.resolve() + } + + @objc func getMapType(_ call: CAPPluginCall) { + guard let id = call.getString("id"), let map = maps[id] else { + call.reject("map not found", PluginError.mapNotFound) + return + } + runOnMainSync { + let mapType = map.currentMapType() + call.resolve(["mapType": mapType, "type": mapType]) + } + } + + @objc func enableCurrentLocation(_ call: CAPPluginCall) { + guard let id = call.getString("id"), let map = maps[id] else { + call.reject("map not found", PluginError.mapNotFound) + return + } + map.setCurrentLocation(call.getBool("enabled", true)) + call.resolve() + } + + @objc func setTrafficEnabled(_ call: CAPPluginCall) { + guard let id = call.getString("id"), let map = maps[id] else { + call.reject("map not found", PluginError.mapNotFound) + return + } + map.setTraffic(call.getBool("enabled", true)) + call.resolve() + } + + @objc func setPointsOfInterestEnabled(_ call: CAPPluginCall) { + guard let id = call.getString("id"), let map = maps[id] else { + call.reject("map not found", PluginError.mapNotFound) + return + } + map.setPointsOfInterest(call.getBool("enabled", true)) + call.resolve() + } + + @objc func setCompassEnabled(_ call: CAPPluginCall) { + guard let id = call.getString("id"), let map = maps[id] else { + call.reject("map not found", PluginError.mapNotFound) + return + } + map.setCompass(call.getBool("enabled", true)) + call.resolve() + } + + @objc func setScaleEnabled(_ call: CAPPluginCall) { + guard let id = call.getString("id"), let map = maps[id] else { + call.reject("map not found", PluginError.mapNotFound) + return + } + map.setScale(call.getBool("enabled", true)) + call.resolve() + } + + @objc func setColorScheme(_ call: CAPPluginCall) { + guard let id = call.getString("id"), let map = maps[id] else { + call.reject("map not found", PluginError.mapNotFound) + return + } + map.setColorScheme(call.getString("colorScheme") ?? "default") + call.resolve() + } + + @objc func setGestures(_ call: CAPPluginCall) { + guard let id = call.getString("id"), let map = maps[id] else { + call.reject("map not found", PluginError.mapNotFound) + return + } + let gestures = call.getObject("gestures") ?? [:] + map.setGestures( + scroll: gestures["scroll"] as? Bool, + zoom: gestures["zoom"] as? Bool, + rotate: gestures["rotate"] as? Bool, + pitch: gestures["pitch"] as? Bool + ) + call.resolve() + } + + @objc func setPadding(_ call: CAPPluginCall) { + guard let id = call.getString("id"), let map = maps[id] else { + call.reject("map not found", PluginError.mapNotFound) + return + } + map.setPadding(NativeMapConfig.parsePadding(call.getObject("padding"))) + call.resolve() + } +} diff --git a/ios/Sources/NativeMapPlugin/AppleMapMarker.swift b/ios/Sources/NativeMapPlugin/AppleMapMarker.swift new file mode 100644 index 0000000..b599854 --- /dev/null +++ b/ios/Sources/NativeMapPlugin/AppleMapMarker.swift @@ -0,0 +1,94 @@ +import Foundation +import MapKit +import Capacitor + +// MARK: - Annotation +// +// Split out of CapacitorNativeMap.swift to keep the core Map type within +// SwiftLint's length budget. The marker model plus the payload parsing that is +// specific to a marker (icon fields, anchor), so makeMarker/updateMarkers on the +// Map stay small. + +/// A map pin carrying a stable id echoed back to JS on tap. The id is generated +/// unless the caller supplied one in the marker payload. +class NativeMapMarker: MKPointAnnotation { + var markerId: String = UUID().uuidString + var iconUrl: String? + var iconSize: CGSize? + /// Where the icon image is pinned to the coordinate, in 0..1 fractions from + /// the image's top-left. `nil` keeps the bottom-centre default (a teardrop + /// pin's tip); `(0.5, 0.5)` centres the image, as a dot wants. + var iconAnchor: CGPoint? + /// When true the pin can be dragged (press-and-hold, then move), emitting the + /// `onMarkerDrag*` events. Dragging is driven by a long-press recognizer on the + /// map rather than `MKAnnotationView.isDraggable`, so intermediate coordinates + /// stream to JS instead of only the drop point. + var isDraggable = false + /// Marker opacity 0..1, applied to the annotation view's `alpha`. Defaults to 1. + var opacity: CGFloat = 1 + /// Tint for the default MapKit pin (`MKMarkerAnnotationView.markerTintColor`). + /// Ignored for image markers, which carry their own colors. nil = MapKit default. + var tintColor: UIColor? + /// Draw order relative to other markers (higher draws on top), mapped to + /// `MKAnnotationView.zPriority`. Defaults to 0. + var zIndex: Double = 0 + + /// The `MKAnnotationView.centerOffset` that lands this marker's anchor point on + /// its coordinate, for an icon rendered at `imageSize`. A view is centred on + /// its coordinate by default, so the offset moves the view until the anchor — + /// not the centre — sits on the point. The bottom-centre default `(0.5, 1)` + /// gives `(0, -height/2)`, the classic teardrop-tip anchoring. + func centerOffset(for imageSize: CGSize) -> CGPoint { + let anchor = iconAnchor ?? CGPoint(x: 0.5, y: 1.0) + return CGPoint(x: imageSize.width * (0.5 - anchor.x), + y: imageSize.height * (0.5 - anchor.y)) + } + + /// Applies whichever icon fields (`iconUrl`, `iconSize`, `iconAnchor`) are + /// present in an update payload, returning whether any changed — the caller + /// re-renders the annotation when so. A present `iconAnchor` of `null` resets + /// to the bottom-centre default. Mirrors the parsing in `Map.makeMarker`. + func applyIconUpdates(from obj: JSObject) -> Bool { + var changed = false + if obj.keys.contains("iconUrl") { + iconUrl = obj["iconUrl"] as? String + changed = true + } + if let size = NativeMapMarker.parseSize(obj["iconSize"]) { + iconSize = size + changed = true + } + if obj.keys.contains("iconAnchor") { + iconAnchor = NativeMapMarker.parseAnchor(obj["iconAnchor"]) + changed = true + } + return changed + } + + /// A `{ width, height }` payload as a `CGSize`, or nil when absent/malformed. + static func parseSize(_ value: Any?) -> CGSize? { + guard let obj = value as? JSObject, + let width = obj["width"] as? Double, + let height = obj["height"] as? Double else { return nil } + return CGSize(width: width, height: height) + } + + /// A `{ x, y }` anchor payload as a `CGPoint`, or nil when absent/malformed. + static func parseAnchor(_ value: Any?) -> CGPoint? { + guard let obj = value as? JSObject, + let x = obj["x"] as? Double, + let y = obj["y"] as? Double else { return nil } + return CGPoint(x: x, y: y) + } + + /// A `{ r, g, b, a }` payload (each channel 0..255, `a` optional) as a + /// `UIColor`, or nil when absent/malformed. + static func parseTintColor(_ value: Any?) -> UIColor? { + guard let obj = value as? JSObject, + let red = obj["r"] as? Double, + let green = obj["g"] as? Double, + let blue = obj["b"] as? Double else { return nil } + let alpha = obj["a"] as? Double ?? 255 + return UIColor(red: red / 255, green: green / 255, blue: blue / 255, alpha: alpha / 255) + } +} diff --git a/ios/Sources/NativeMapPlugin/Callout.swift b/ios/Sources/NativeMapPlugin/Callout.swift new file mode 100644 index 0000000..5e11418 --- /dev/null +++ b/ios/Sources/NativeMapPlugin/Callout.swift @@ -0,0 +1,133 @@ +import Foundation +import MapKit +import UIKit + +// MARK: - Custom info window (callout) +// +// MapKit's native callout bubble does not render when the MKMapView is composited +// inside the web view (the way @capacitor/google-maps mounts it). So instead of +// relying on `canShowCallout`, we draw our own bubble as a plain subview of the +// map and keep it glued to the pin with a display link. This renders reliably, +// exactly like the annotation pins do. + +/// A rounded info-window bubble showing a marker's title and optional snippet. +/// Interactive: a tap on it emits `onInfoWindowClick` (a tap elsewhere on the map +/// dismisses it). +final class CalloutBubble: UIView { + /// Widest the bubble grows before text wraps. + private static let maxWidth: CGFloat = 260 + + init(title: String, subtitle: String?) { + super.init(frame: .zero) + backgroundColor = .secondarySystemBackground + layer.cornerRadius = 10 + layer.shadowColor = UIColor.black.cgColor + layer.shadowOpacity = 0.18 + layer.shadowRadius = 5 + layer.shadowOffset = CGSize(width: 0, height: 2) + layer.masksToBounds = false + + let stack = UIStackView() + stack.axis = .vertical + stack.spacing = 2 + stack.isLayoutMarginsRelativeArrangement = true + stack.layoutMargins = UIEdgeInsets(top: 8, left: 12, bottom: 8, right: 12) + stack.translatesAutoresizingMaskIntoConstraints = false + addSubview(stack) + NSLayoutConstraint.activate([ + stack.topAnchor.constraint(equalTo: topAnchor), + stack.bottomAnchor.constraint(equalTo: bottomAnchor), + stack.leadingAnchor.constraint(equalTo: leadingAnchor), + stack.trailingAnchor.constraint(equalTo: trailingAnchor), + widthAnchor.constraint(lessThanOrEqualToConstant: CalloutBubble.maxWidth) + ]) + + let titleLabel = UILabel() + titleLabel.text = title + titleLabel.font = .systemFont(ofSize: 15, weight: .semibold) + titleLabel.textColor = .label + titleLabel.numberOfLines = 2 + stack.addArrangedSubview(titleLabel) + + if let subtitle = subtitle, !subtitle.isEmpty { + let subtitleLabel = UILabel() + subtitleLabel.text = subtitle + subtitleLabel.font = .systemFont(ofSize: 13) + subtitleLabel.textColor = .secondaryLabel + subtitleLabel.numberOfLines = 2 + stack.addArrangedSubview(subtitleLabel) + } + } + + required init?(coder: NSCoder) { fatalError("init(coder:) has not been implemented") } + + /// The natural size for the current content (respecting `maxWidth`). + func fittingSize() -> CGSize { + systemLayoutSizeFitting( + UIView.layoutFittingCompressedSize, + withHorizontalFittingPriority: .fittingSizeLevel, + verticalFittingPriority: .fittingSizeLevel + ) + } +} + +extension Map { + /// Approximate height of a default MKMarkerAnnotationView, so the bubble sits + /// just above the balloon rather than over it. + private static let markerPinHeight: CGFloat = 46 + + /// Show the info window for `marker` (replacing any current one) and start the + /// display link that keeps it glued to the pin. Must run on the main thread. + func showCallout(for marker: NativeMapMarker) { + dismissCallout() + guard let title = marker.title, !title.isEmpty else { return } + + let bubble = CalloutBubble(title: title, subtitle: marker.subtitle) + bubble.bounds = CGRect(origin: .zero, size: bubble.fittingSize()) + let tap = UITapGestureRecognizer(target: self, action: #selector(handleCalloutTap)) + bubble.addGestureRecognizer(tap) + calloutView = bubble + calloutMarker = marker + mapView.addSubview(bubble) + repositionCallout() + + let link = CADisplayLink(target: self, selector: #selector(handleCalloutTick)) + link.add(to: .main, forMode: .common) + calloutDisplayLink = link + } + + @objc private func handleCalloutTick() { + repositionCallout() + } + + /// Emit `onInfoWindowClick` for the marker whose bubble is showing. + @objc private func handleCalloutTap() { + guard let marker = calloutMarker else { return } + delegate?.notifyListeners("onInfoWindowClick", data: [ + "mapId": id, + "markerId": marker.markerId, + "latitude": marker.coordinate.latitude, + "longitude": marker.coordinate.longitude, + "title": marker.title ?? "" + ]) + } + + /// Place the bubble centered horizontally over the pin and just above it. + func repositionCallout() { + guard let bubble = calloutView, let marker = calloutMarker else { return } + let anchor = mapView.convert(marker.coordinate, toPointTo: mapView) + bubble.center = CGPoint( + x: anchor.x, + y: anchor.y - Map.markerPinHeight - 6 - bubble.bounds.height / 2 + ) + } + + /// Remove the info window and stop its display link. Must run on the main thread. + func dismissCallout() { + calloutDisplayLink?.invalidate() + calloutDisplayLink = nil + calloutView?.removeFromSuperview() + calloutView = nil + calloutMarker = nil + } +} diff --git a/ios/Sources/NativeMapPlugin/CameraEvents.swift b/ios/Sources/NativeMapPlugin/CameraEvents.swift new file mode 100644 index 0000000..d035f74 --- /dev/null +++ b/ios/Sources/NativeMapPlugin/CameraEvents.swift @@ -0,0 +1,70 @@ +import Foundation +import MapKit +import Capacitor + +// MARK: - Plugin: camera region-change events +// +// Split out of NativeMapPlugin.swift so the plugin type stays within +// SwiftLint's body-length budget. These are still MKMapViewDelegate callbacks +// on the same plugin type, relaying the map's region changes to JS +// (`onCameraMoveStarted` when a move begins, `onCameraIdle` when it settles) and +// enforcing the min/max-zoom bounce. + +extension NativeMapPlugin { + + public func mapView(_ mapView: MKMapView, regionWillChangeAnimated animated: Bool) { + guard let map = findMap(for: mapView) else { return } + // The self-triggered min/max-zoom bounce (see regionDidChange) is not a + // camera-move the caller started, so don't report it. + if map.isAdjustingRegion { return } + notifyListeners("onCameraMoveStarted", data: [ + "mapId": map.id, + "isGesture": Self.regionChangeIsGesture(mapView) + ]) + } + + /// Whether an in-flight region change originates from a user gesture rather + /// than a programmatic move. MapKit hangs its pan/pinch/rotate recognizers on + /// the map's first subview; if any is mid-recognition the move is a gesture. + static func regionChangeIsGesture(_ mapView: MKMapView) -> Bool { + guard let gestureHost = mapView.subviews.first, + let recognizers = gestureHost.gestureRecognizers else { return false } + return recognizers.contains { recognizer in + switch recognizer.state { + case .began, .changed, .ended: + return true + default: + return false + } + } + } + + public func mapView(_ mapView: MKMapView, regionDidChangeAnimated animated: Bool) { + guard let map = findMap(for: mapView) else { return } + + if map.isAdjustingRegion { + // This callback is the settle after our own clamp - clear the guard + // and report the corrected camera. + map.isAdjustingRegion = false + } else if let minZoom = map.config.minZoom, map.currentZoom() < minZoom - 0.01 { + // The user zoomed out past the floor; bounce back to it. + map.isAdjustingRegion = true + map.setCameraInternal(coordinate: mapView.centerCoordinate, zoom: minZoom, animate: true) + return + } else if let maxZoom = map.config.maxZoom, map.currentZoom() > maxZoom + 0.01 { + // The user zoomed in past the ceiling; bounce back to it. + map.isAdjustingRegion = true + map.setCameraInternal(coordinate: mapView.centerCoordinate, zoom: maxZoom, animate: true) + return + } + + let center = mapView.centerCoordinate + notifyListeners("onCameraIdle", data: [ + "mapId": map.id, + "latitude": center.latitude, + "longitude": center.longitude, + "zoom": map.currentZoom(), + "bounds": map.boundsPayload() + ]) + } +} diff --git a/ios/Sources/NativeMapPlugin/CapacitorAppleMaps.swift b/ios/Sources/NativeMapPlugin/CapacitorAppleMaps.swift new file mode 100644 index 0000000..c8cf562 --- /dev/null +++ b/ios/Sources/NativeMapPlugin/CapacitorAppleMaps.swift @@ -0,0 +1,487 @@ +import Foundation +import MapKit +import Capacitor +import WebKit +import UIKit + +// MARK: - Errors + +enum NativeMapsError: Error, LocalizedError { + case invalidArguments(String) + + var errorDescription: String? { + switch self { + case .invalidArguments(let message): + return message + } + } +} + +// MARK: - Zoom <-> region conversion +// +// MapKit has no notion of a Google-style integer zoom; it works in region +// spans. These helpers convert between the two using the web-mercator tile +// relationship: the whole world (360°) is `256 * 2^zoom` points wide, so a +// viewport `widthPoints` points wide spans `360 * widthPoints / (256 * 2^zoom)` +// degrees of longitude. The round trip is approximate - MapKit adjusts spans to +// the view's aspect ratio - which is fine for the host app's radius estimates. + +func zoomToLongitudeDelta(_ zoom: Double, widthPoints: Double) -> Double { + let width = widthPoints > 0 ? widthPoints : 256.0 + return 360.0 * width / (256.0 * pow(2.0, zoom)) +} + +func longitudeDeltaToZoom(_ delta: Double, widthPoints: Double) -> Double { + let width = widthPoints > 0 ? widthPoints : 256.0 + let safeDelta = delta > 0 ? delta : 0.0001 + return log2(360.0 * width / (256.0 * safeDelta)) +} + +/// Clamps a Google-style zoom to an optional `[minZoom, maxZoom]` range. A nil +/// bound means unbounded on that side; if `minZoom > maxZoom` the ceiling wins. +/// Pure so the clamp behavior can be unit-tested without an `MKMapView`. +func clampZoom(_ zoom: Double, minZoom: Double?, maxZoom: Double?) -> Double { + var result = max(zoom, minZoom ?? -Double.greatestFiniteMagnitude) + result = min(result, maxZoom ?? Double.greatestFiniteMagnitude) + return result +} + +/// The smallest `MKMapRect` containing both corners, regardless of their relative +/// orientation (latitude grows north but `MKMapPoint.y` grows south). Pure so the +/// `fitBounds` framing math can be unit-tested without an `MKMapView`. +func boundingMapRect(southwest: CLLocationCoordinate2D, northeast: CLLocationCoordinate2D) -> MKMapRect { + let swPoint = MKMapPoint(southwest) + let nePoint = MKMapPoint(northeast) + return MKMapRect( + x: min(swPoint.x, nePoint.x), + y: min(swPoint.y, nePoint.y), + width: abs(swPoint.x - nePoint.x), + height: abs(swPoint.y - nePoint.y) + ) +} + +/// The corner coordinates of a region, used to report the visible bounds to JS. +/// Pure function so it can be unit-tested without an `MKMapView`. +func regionCorners(center: CLLocationCoordinate2D, span: MKCoordinateSpan) +-> (southwest: CLLocationCoordinate2D, northeast: CLLocationCoordinate2D) { + let southwest = CLLocationCoordinate2D( + latitude: center.latitude - span.latitudeDelta / 2, + longitude: center.longitude - span.longitudeDelta / 2 + ) + let northeast = CLLocationCoordinate2D( + latitude: center.latitude + span.latitudeDelta / 2, + longitude: center.longitude + span.longitudeDelta / 2 + ) + return (southwest, northeast) +} + +// MARK: - Annotation +// +// The pin model, `NativeMapMarker`, lives in NativeMapMarker.swift (kept there so +// this file stays within SwiftLint's length budget). + +/// Stroke/fill styling for an overlay, resolved from the JS payload and looked +/// up by the map's `rendererFor` delegate when MapKit asks how to draw it. +struct OverlayStyle { + var strokeColor: UIColor + var lineWidth: CGFloat + var fillColor: UIColor? + /// Dash pattern (on/off point lengths) for the stroke, or nil for a solid line. + var lineDashPattern: [NSNumber]? +} + +// MARK: - Config + +struct NativeMapConfig { + let center: CLLocationCoordinate2D + let zoom: Double + let minZoom: Double? + let maxZoom: Double? + let x: Double + let y: Double + let width: Double + let height: Double + let clustering: Bool + let mapType: String + let showInfoWindows: Bool + let showsTraffic: Bool + let showsPointsOfInterest: Bool + let showsCompass: Bool + let showsScale: Bool + let showsBuildings: Bool + let colorScheme: String + let scrollEnabled: Bool + let zoomEnabled: Bool + let rotateEnabled: Bool + let pitchEnabled: Bool + let padding: UIEdgeInsets + + init(fromJSObject obj: JSObject) throws { + guard let centerObj = obj["center"] as? JSObject, + let lat = centerObj["lat"] as? Double, + let lng = centerObj["lng"] as? Double else { + throw NativeMapsError.invalidArguments("config.center is missing or malformed") + } + self.center = CLLocationCoordinate2D(latitude: lat, longitude: lng) + self.zoom = obj["zoom"] as? Double ?? 12 + self.minZoom = obj["minZoom"] as? Double + self.maxZoom = obj["maxZoom"] as? Double + self.width = obj["width"] as? Double ?? 0 + self.height = obj["height"] as? Double ?? 0 + self.x = obj["x"] as? Double ?? 0 + self.y = obj["y"] as? Double ?? 0 + self.clustering = obj["clustering"] as? Bool ?? false + self.mapType = obj["mapType"] as? String ?? "standard" + self.showInfoWindows = obj["showInfoWindows"] as? Bool ?? false + // Defaults mirror MapKit's own (traffic/scale off, POI/compass on). + self.showsTraffic = obj["showsTraffic"] as? Bool ?? false + self.showsPointsOfInterest = obj["showsPointsOfInterest"] as? Bool ?? true + self.showsCompass = obj["showsCompass"] as? Bool ?? true + self.showsScale = obj["showsScale"] as? Bool ?? false + self.showsBuildings = obj["showsBuildings"] as? Bool ?? true + self.colorScheme = obj["colorScheme"] as? String ?? "default" + let gestures = obj["gestures"] as? JSObject ?? [:] + self.scrollEnabled = gestures["scroll"] as? Bool ?? true + self.zoomEnabled = gestures["zoom"] as? Bool ?? true + self.rotateEnabled = gestures["rotate"] as? Bool ?? true + self.pitchEnabled = gestures["pitch"] as? Bool ?? true + self.padding = NativeMapConfig.parsePadding(obj["padding"]) + } +} + +// MARK: - Map + +/// Owns one native `MKMapView` and mounts it into the WKWebView's view tree at +/// the bound element's location, mirroring the compositing approach of +/// `@capacitor/google-maps`. +public class Map: NSObject, UIGestureRecognizerDelegate { + static let mapTag = 99999 + /// Name given to the marker-drag long-press recognizer, so the gesture + /// delegate can let it receive touches on a marker while the map-surface + /// recognizers decline them (letting MapKit select the pin / show its callout). + static let markerDragGestureName = "capacitorNativeMapMarkerDrag" + + let id: String + var config: NativeMapConfig + let mapView: MKMapView + + var markers: [String: NativeMapMarker] = [:] + /// Overlays keyed by the id handed back to JS, for removal. + var overlays: [String: MKOverlay] = [:] + /// Overlay styling keyed by the overlay instance, read back in `rendererFor`. + var overlayStyles: [ObjectIdentifier: OverlayStyle] = [:] + private(set) var clusteringEnabled = false + /// Best-effort lower bound on the total marker count before clustering applies. + /// MapKit has no per-cluster minimum, so this gates clustering on the number of + /// markers present when each annotation view is built. See enableClustering. + var clusterMinSize = 2 + /// Whether an annotation view should cluster right now, given the toggle and count. + var shouldCluster: Bool { clusteringEnabled && markers.count >= clusterMinSize } + + /// Guards against a feedback loop when we programmatically clamp the region + /// back to the minimum zoom inside `regionDidChange`. + var isAdjustingRegion = false + + /// The custom info-window bubble currently shown (a plain subview of the map, + /// since MapKit's own callout doesn't render when the map is composited inside + /// the web view), the marker it points at, and a display link that keeps it + /// glued to the pin as the map pans/zooms. See Callout.swift. + var calloutView: UIView? + var calloutMarker: NativeMapMarker? + var calloutDisplayLink: CADisplayLink? + + /// The marker currently being dragged (via the map's long-press recognizer), + /// or nil when no drag is in progress. + var draggingMarker: NativeMapMarker? + /// The map's `isScrollEnabled` value before a drag disabled it, restored when + /// the drag ends. + var scrollWasEnabledBeforeDrag = true + + /// Edge insets from `setPadding`, added to the `fitBounds` framing so it + /// respects the padding the caller asked for. + var contentInsets: UIEdgeInsets = .zero + + /// Retains the in-flight `MKMapSnapshotter` for the duration of `takeSnapshot`. + var pendingSnapshotter: MKMapSnapshotter? + + /// The user-tracking button (recenter/follow control) when shown, so it can be + /// removed again. See setUserTrackingButton in MapControls.swift. + var userTrackingButton: MKUserTrackingButton? + + weak var delegate: NativeMapPlugin? + var targetView: UIView? + /// Decoded marker icons keyed by their url/asset string. `NSCache` bounds the + /// footprint and evicts under memory pressure, unlike a plain dictionary that + /// would grow without limit as icons come and go. Read/written in MarkerIcons. + let iconCache: NSCache = { + let cache = NSCache() + cache.countLimit = 100 + return cache + }() + /// Remote icon urls with a download in flight, so a re-render (e.g. a + /// clustering toggle re-adding every annotation) doesn't start a duplicate. + var inFlightIconURLs: Set = [] + /// Remote icon urls that returned a response but no usable image - a permanent + /// miss we must not retry on every re-render (a transport error is left out so + /// a later render can retry it). + var failedIconURLs: Set = [] + + init(id: String, config: NativeMapConfig, delegate: NativeMapPlugin) { + self.id = id + self.config = config + self.mapView = MKMapView() + self.delegate = delegate + super.init() + // Start clustered when the caller asked for it, so markers added later + // cluster on their first render instead of flashing as individual pins. + self.clusteringEnabled = config.clustering + self.render() + } + + private func render() { + DispatchQueue.main.async { + self.mapView.delegate = self.delegate + self.mapView.showsUserLocation = false + self.mapView.mapType = Map.mapType(from: self.config.mapType) + self.applyAppearance(self.config) + self.mapView.isScrollEnabled = self.config.scrollEnabled + self.mapView.isZoomEnabled = self.config.zoomEnabled + self.mapView.isRotateEnabled = self.config.rotateEnabled + self.mapView.isPitchEnabled = self.config.pitchEnabled + self.mapView.layoutMargins = self.config.padding + self.contentInsets = self.config.padding + self.mapView.frame = CGRect(x: self.config.x, y: self.config.y, width: self.config.width, height: self.config.height) + self.setCameraInternal(coordinate: self.config.center, zoom: self.config.zoom, animate: false) + + // Emit onMapClick for taps that don't land on a marker. cancelsTouchesInView + // stays false and the delegate allows simultaneous recognition so this + // never swallows MapKit's own pan/zoom or marker-selection gestures. + let tap = UITapGestureRecognizer(target: self, action: #selector(self.handleMapTap(_:))) + tap.cancelsTouchesInView = false + tap.delegate = self + self.mapView.addGestureRecognizer(tap) + + // Emit onMapLongClick for a long-press that doesn't land on a marker. + let longPress = UILongPressGestureRecognizer(target: self, action: #selector(self.handleMapLongPress(_:))) + longPress.cancelsTouchesInView = false + longPress.delegate = self + self.mapView.addGestureRecognizer(longPress) + + // Drives marker dragging: a long-press that lands on a draggable pin + // picks it up; subsequent movement streams onMarkerDrag. Presses that + // miss a draggable pin are ignored here and handled by the long-press + // recognizer above. + let markerDrag = UILongPressGestureRecognizer(target: self, action: #selector(self.handleMarkerDrag(_:))) + markerDrag.cancelsTouchesInView = false + markerDrag.name = Map.markerDragGestureName + markerDrag.delegate = self + self.mapView.addGestureRecognizer(markerDrag) + + self.targetView = self.getTargetContainer(refWidth: self.config.width, refHeight: self.config.height) + if let target = self.targetView { + target.tag = Map.mapTag + target.removeAllSubview() + self.mapView.frame = target.bounds + self.mapView.autoresizingMask = [.flexibleWidth, .flexibleHeight] + target.addSubview(self.mapView) + } else { + // The mount depends on finding WebKit's private child scroll view + // for the map element (see getTargetContainer). If that ever fails + // again on a future iOS, the map is silently never added to the + // view tree — a blank, touch-dead map with no error. Leave a + // breadcrumb so that failure is diagnosable from the console + // instead of a mystery. onMapReady still fires below, as before. + CAPLog.print("[NativeMaps] getTargetContainer found no container to mount into " + + "(ref=\(self.config.width)x\(self.config.height)); map will not render. " + + "Likely a WebKit view-tree change — inspect the WKWebView's scroll views.") + } + + self.delegate?.notifyListeners("onMapReady", data: ["mapId": self.id]) + } + } + + func destroy() { + DispatchQueue.main.async { + self.dismissCallout() + self.mapView.removeFromSuperview() + self.mapView.delegate = nil + self.targetView?.tag = 0 + } + } + + // MARK: Camera + + /// Must be called on the main thread. `bearing` (heading, degrees clockwise + /// from north) and `pitch` (tilt, degrees from top-down) are applied on top of + /// the region/center change when supplied; nil leaves that axis unchanged. + func setCameraInternal( + coordinate: CLLocationCoordinate2D?, + zoom: Double?, + animate: Bool, + bearing: Double? = nil, + pitch: Double? = nil + ) { + let center = coordinate ?? mapView.centerCoordinate + + if let zoom = zoom { + // Enforce the zoom range: a smaller zoom means a wider span (minZoom is the + // zoom-out floor), a larger zoom a tighter one (maxZoom is the zoom-in ceiling). + let clampedZoom = clampZoom(zoom, minZoom: config.minZoom, maxZoom: config.maxZoom) + + let width = Double(mapView.bounds.width > 0 ? mapView.bounds.width : UIScreen.main.bounds.width) + let height = Double(mapView.bounds.height > 0 ? mapView.bounds.height : UIScreen.main.bounds.height) + let lonDelta = min(zoomToLongitudeDelta(clampedZoom, widthPoints: width), 360.0) + let latDelta = min(lonDelta * (height / max(width, 1)), 180.0) + let span = MKCoordinateSpan(latitudeDelta: latDelta, longitudeDelta: lonDelta) + let region = mapView.regionThatFits(MKCoordinateRegion(center: center, span: span)) + mapView.setRegion(region, animated: animate) + } else if coordinate != nil { + mapView.setCenter(center, animated: animate) + } + + // Rotation/tilt ride on top of the region change, preserving the resulting + // center and distance. Reading the camera after the region set gives the + // new center/zoom to build on. + if bearing != nil || pitch != nil, let camera = mapView.camera.copy() as? MKMapCamera { + if let bearing = bearing { camera.heading = bearing } + if let pitch = pitch { camera.pitch = CGFloat(max(0, pitch)) } + mapView.setCamera(camera, animated: animate) + } + } + + /// Frame `southwest`..`northeast` in the viewport, inset by `padding` points. + func fitBounds(southwest: CLLocationCoordinate2D, northeast: CLLocationCoordinate2D, padding: Double, animate: Bool) { + let rect = boundingMapRect(southwest: southwest, northeast: northeast) + runOnMainSync { + // Combine the per-call padding with any standing content insets (setPadding). + let inset = UIEdgeInsets( + top: padding + self.contentInsets.top, + left: padding + self.contentInsets.left, + bottom: padding + self.contentInsets.bottom, + right: padding + self.contentInsets.right + ) + self.mapView.setVisibleMapRect(rect, edgePadding: inset, animated: animate) + } + } + + // MARK: Markers + + func addMarkers(_ markerObjs: [JSObject]) -> [String] { + var ids: [String] = [] + runOnMainSync { + var toAdd: [NativeMapMarker] = [] + for obj in markerObjs { + guard let marker = Map.makeMarker(from: obj) else { continue } + self.markers[marker.markerId] = marker + toAdd.append(marker) + ids.append(marker.markerId) + } + self.mapView.addAnnotations(toAdd) + } + return ids + } + + /// Builds an annotation from a marker payload, or nil if the coordinate is + /// missing/malformed. Pure (no `MKMapView`), so it can be unit-tested. + static func makeMarker(from obj: JSObject) -> NativeMapMarker? { + guard let coordObj = obj["coordinate"] as? JSObject, + let lat = coordObj["lat"] as? Double, + let lng = coordObj["lng"] as? Double else { return nil } + let marker = NativeMapMarker() + if let customId = obj["markerId"] as? String, !customId.isEmpty { + marker.markerId = customId + } + marker.coordinate = CLLocationCoordinate2D(latitude: lat, longitude: lng) + marker.title = obj["title"] as? String + marker.subtitle = obj["snippet"] as? String + marker.iconUrl = obj["iconUrl"] as? String + marker.isDraggable = obj["draggable"] as? Bool ?? false + marker.iconSize = NativeMapMarker.parseSize(obj["iconSize"]) + marker.iconAnchor = NativeMapMarker.parseAnchor(obj["iconAnchor"]) + if let opacity = obj["opacity"] as? Double { marker.opacity = CGFloat(opacity) } + marker.tintColor = NativeMapMarker.parseTintColor(obj["tintColor"]) + if let zIndex = obj["zIndex"] as? Double { marker.zIndex = zIndex } + return marker + } + + func removeMarkers(_ ids: [String]) { + runOnMainSync { + var toRemove: [NativeMapMarker] = [] + for id in ids { + if let marker = self.markers[id] { + toRemove.append(marker) + self.markers.removeValue(forKey: id) + } + } + self.mapView.removeAnnotations(toRemove) + } + } + + /// Apply partial changes to existing markers. A moved marker animates to its + /// new coordinate; an icon change re-adds the annotation so `viewFor` reruns. + func updateMarkers(_ objs: [JSObject]) { + runOnMainSync { + var toRefresh: [NativeMapMarker] = [] + for obj in objs { + guard let markerId = obj["markerId"] as? String, + let marker = self.markers[markerId] else { continue } + + if let coordObj = obj["coordinate"] as? JSObject, + let lat = coordObj["lat"] as? Double, + let lng = coordObj["lng"] as? Double { + UIView.animate(withDuration: 0.25) { + marker.coordinate = CLLocationCoordinate2D(latitude: lat, longitude: lng) + } + } + if obj.keys.contains("title") { + marker.title = obj["title"] as? String + } + if obj.keys.contains("snippet") { + marker.subtitle = obj["snippet"] as? String + } + if obj.keys.contains("draggable") { + // The drag gate reads this flag live, so no view rebuild is + // needed to enable/disable dragging. + marker.isDraggable = obj["draggable"] as? Bool ?? false + } + // Opacity / tint / z-order are applied to the live annotation view + // in place (see applyLiveStyleUpdates), so they don't need a + // re-render (which would flash the pin). + self.applyLiveStyleUpdates(from: obj, to: marker) + // Icon fields (url / size / anchor) re-render the annotation so + // viewFor reapplies the image and centerOffset; the fields above + // mutate in place. See NativeMapMarker.applyIconUpdates. + if marker.applyIconUpdates(from: obj) { toRefresh.append(marker) } + } + if !toRefresh.isEmpty { + self.mapView.removeAnnotations(toRefresh) + self.mapView.addAnnotations(toRefresh) + } + } + } + + func enableClustering(minClusterSize: Int? = nil) { + runOnMainSync { + if let minSize = minClusterSize { self.clusterMinSize = max(1, minSize) } + self.clusteringEnabled = true + self.refreshAnnotations() + } + } + + func disableClustering() { + runOnMainSync { + guard self.clusteringEnabled else { return } + self.clusteringEnabled = false + self.refreshAnnotations() + } + } + + /// Re-add every annotation so `viewFor` reruns and the clustering identifier + /// is applied or cleared. Must be called on the main thread. + private func refreshAnnotations() { + let all = Array(self.markers.values) + self.mapView.removeAnnotations(all) + self.mapView.addAnnotations(all) + } + +} diff --git a/ios/Sources/NativeMapPlugin/CapacitorAppleMapsPlugin.swift b/ios/Sources/NativeMapPlugin/CapacitorAppleMapsPlugin.swift new file mode 100644 index 0000000..577ae52 --- /dev/null +++ b/ios/Sources/NativeMapPlugin/CapacitorAppleMapsPlugin.swift @@ -0,0 +1,293 @@ +// Portions Copyright Katama Labs contributors, licensed under the MIT License. +// Adapted for @capgo/capacitor-native-map (MPL-2.0). +import Foundation +import Capacitor +import MapKit +import UIKit + +/** + * Bridges the JS API to native MapKit and relays map events back to JS. + * See CapacitorNativeMap.swift for the per-map implementation. + */ +@objc(NativeMapPlugin) +public class NativeMapPlugin: CAPPlugin, CAPBridgedPlugin, MKMapViewDelegate { + public let identifier = "NativeMapPlugin" + public let jsName = "NativeMap" + public let pluginMethods: [CAPPluginMethod] = [ + CAPPluginMethod(name: "create", returnType: CAPPluginReturnPromise), + CAPPluginMethod(name: "destroy", returnType: CAPPluginReturnPromise), + CAPPluginMethod(name: "setCamera", returnType: CAPPluginReturnPromise), + CAPPluginMethod(name: "getMapBounds", returnType: CAPPluginReturnPromise), + CAPPluginMethod(name: "getCameraPosition", returnType: CAPPluginReturnPromise), + CAPPluginMethod(name: "fitBounds", returnType: CAPPluginReturnPromise), + CAPPluginMethod(name: "addMarkers", returnType: CAPPluginReturnPromise), + CAPPluginMethod(name: "addMarker", returnType: CAPPluginReturnPromise), + CAPPluginMethod(name: "updateMarkers", returnType: CAPPluginReturnPromise), + CAPPluginMethod(name: "removeMarkers", returnType: CAPPluginReturnPromise), + CAPPluginMethod(name: "removeMarker", returnType: CAPPluginReturnPromise), + CAPPluginMethod(name: "enableClustering", returnType: CAPPluginReturnPromise), + CAPPluginMethod(name: "disableClustering", returnType: CAPPluginReturnPromise), + CAPPluginMethod(name: "addPolylines", returnType: CAPPluginReturnPromise), + CAPPluginMethod(name: "addPolygons", returnType: CAPPluginReturnPromise), + CAPPluginMethod(name: "addCircles", returnType: CAPPluginReturnPromise), + CAPPluginMethod(name: "removeOverlays", returnType: CAPPluginReturnPromise), + CAPPluginMethod(name: "setMapType", returnType: CAPPluginReturnPromise), + CAPPluginMethod(name: "getMapType", returnType: CAPPluginReturnPromise), + CAPPluginMethod(name: "setUserTrackingMode", returnType: CAPPluginReturnPromise), + CAPPluginMethod(name: "setUserTrackingButtonVisible", returnType: CAPPluginReturnPromise), + CAPPluginMethod(name: "setBuildingsEnabled", returnType: CAPPluginReturnPromise), + CAPPluginMethod(name: "setCameraBoundary", returnType: CAPPluginReturnPromise), + CAPPluginMethod(name: "selectMarker", returnType: CAPPluginReturnPromise), + CAPPluginMethod(name: "deselectMarker", returnType: CAPPluginReturnPromise), + CAPPluginMethod(name: "enableCurrentLocation", returnType: CAPPluginReturnPromise), + CAPPluginMethod(name: "setTrafficEnabled", returnType: CAPPluginReturnPromise), + CAPPluginMethod(name: "setPointsOfInterestEnabled", returnType: CAPPluginReturnPromise), + CAPPluginMethod(name: "setCompassEnabled", returnType: CAPPluginReturnPromise), + CAPPluginMethod(name: "setScaleEnabled", returnType: CAPPluginReturnPromise), + CAPPluginMethod(name: "setColorScheme", returnType: CAPPluginReturnPromise), + CAPPluginMethod(name: "setGestures", returnType: CAPPluginReturnPromise), + CAPPluginMethod(name: "setPadding", returnType: CAPPluginReturnPromise), + CAPPluginMethod(name: "takeSnapshot", returnType: CAPPluginReturnPromise), + CAPPluginMethod(name: "searchAutocomplete", returnType: CAPPluginReturnPromise), + CAPPluginMethod(name: "searchPlaces", returnType: CAPPluginReturnPromise), + CAPPluginMethod(name: "searchResolve", returnType: CAPPluginReturnPromise), + CAPPluginMethod(name: "reverseGeocode", returnType: CAPPluginReturnPromise), + CAPPluginMethod(name: "geocode", returnType: CAPPluginReturnPromise), + CAPPluginMethod(name: "onResize", returnType: CAPPluginReturnPromise), + CAPPluginMethod(name: "onDisplay", returnType: CAPPluginReturnPromise), + CAPPluginMethod(name: "onScroll", returnType: CAPPluginReturnPromise), + CAPPluginMethod(name: "checkPermissions", returnType: CAPPluginReturnPromise), + CAPPluginMethod(name: "requestPermissions", returnType: CAPPluginReturnPromise), + CAPPluginMethod(name: "enableTouch", returnType: CAPPluginReturnPromise), + CAPPluginMethod(name: "disableTouch", returnType: CAPPluginReturnPromise), + CAPPluginMethod(name: "enableIndoorMaps", returnType: CAPPluginReturnPromise), + CAPPluginMethod(name: "enableTrafficLayer", returnType: CAPPluginReturnPromise), + CAPPluginMethod(name: "enableAccessibilityElements", returnType: CAPPluginReturnPromise), + CAPPluginMethod(name: "addTileOverlay", returnType: CAPPluginReturnPromise), + CAPPluginMethod(name: "removeTileOverlay", returnType: CAPPluginReturnPromise), + CAPPluginMethod(name: "removePolygons", returnType: CAPPluginReturnPromise), + CAPPluginMethod(name: "removeCircles", returnType: CAPPluginReturnPromise), + CAPPluginMethod(name: "removePolylines", returnType: CAPPluginReturnPromise), + CAPPluginMethod(name: "mapBoundsContains", returnType: CAPPluginReturnPromise), + CAPPluginMethod(name: "mapBoundsExtend", returnType: CAPPluginReturnPromise), + CAPPluginMethod(name: "dispatchMapEvent", returnType: CAPPluginReturnPromise) + ] + + var maps = [String: Map]() + private let searchService = SearchService() + private let geocodeService = GeocodeService() + + // MARK: - Location permission + // + // Backing state for the `location` permission alias. The check/request + // implementations and the CLLocationManagerDelegate callback live in + // Permissions.swift. The manager is created lazily on first use so a plugin + // that never touches location never instantiates one. + var locationManager: CLLocationManager? + /// Callback id of the in-flight `requestPermissions` call, held while the + /// system prompt is up so the delegate can resolve it once the user answers. + var permissionCallID: String? + + // MARK: - App lifecycle + + override public func load() { + NotificationCenter.default.addObserver( + self, + selector: #selector(handleDidBecomeActive), + name: UIApplication.didBecomeActiveNotification, + object: nil + ) + } + + /// After the app returns to the foreground WebKit can rebuild its scroll-view + /// hierarchy, orphaning the native map's touch handling (it still renders but + /// gestures stop working). Re-mount each map into its current container. + @objc private func handleDidBecomeActive() { + for (_, map) in maps { + map.remountIntoContainer() + } + } + + // MARK: - Lifecycle + + @objc func create(_ call: CAPPluginCall) { + guard let id = call.getString("id") else { + call.reject("id is required", PluginError.invalidArgument) + return + } + guard let configObj = call.getObject("config") else { + call.reject("config is required", PluginError.invalidArgument) + return + } + let forceCreate = call.getBool("forceCreate", false) + + do { + let config = try NativeMapConfig(fromJSObject: configObj) + + if maps[id] != nil { + if !forceCreate { + call.resolve() + return + } + maps.removeValue(forKey: id)?.destroy() + } + + runOnMainSync { + self.maps[id] = Map(id: id, config: config, delegate: self) + } + call.resolve() + } catch { + call.reject(error.localizedDescription, PluginError.operationFailed, error) + } + } + + @objc func destroy(_ call: CAPPluginCall) { + guard let id = call.getString("id"), let map = maps.removeValue(forKey: id) else { + call.reject("map not found", PluginError.mapNotFound) + return + } + map.destroy() + call.resolve() + } + + // MARK: - Camera + + @objc func setCamera(_ call: CAPPluginCall) { + guard let id = call.getString("id"), let map = maps[id] else { + call.reject("map not found", PluginError.mapNotFound) + return + } + runOnMainSync { + map.setCamera(from: call.getObject("config") ?? [:]) + } + call.resolve() + } + + @objc func getMapBounds(_ call: CAPPluginCall) { + guard let id = call.getString("id"), let map = maps[id] else { + call.reject("map not found", PluginError.mapNotFound) + return + } + runOnMainSync { + call.resolve(map.boundsPayload()) + } + } + + @objc func getCameraPosition(_ call: CAPPluginCall) { + guard let id = call.getString("id"), let map = maps[id] else { + call.reject("map not found", PluginError.mapNotFound) + return + } + runOnMainSync { + call.resolve(map.cameraPayload()) + } + } + + @objc func fitBounds(_ call: CAPPluginCall) { + guard let id = call.getString("id"), let map = maps[id] else { + call.reject("map not found", PluginError.mapNotFound) + return + } + guard let boundsObj = call.getObject("bounds"), + let swObj = boundsObj["southwest"] as? JSObject, + let swLat = swObj["lat"] as? Double, let swLng = swObj["lng"] as? Double, + let neObj = boundsObj["northeast"] as? JSObject, + let neLat = neObj["lat"] as? Double, let neLng = neObj["lng"] as? Double else { + call.reject("bounds with southwest and northeast is required", PluginError.invalidArgument) + return + } + let padding = call.getDouble("padding") ?? 0 + let animate = call.getBool("animate", true) + map.fitBounds( + southwest: CLLocationCoordinate2D(latitude: swLat, longitude: swLng), + northeast: CLLocationCoordinate2D(latitude: neLat, longitude: neLng), + padding: padding, animate: animate + ) + call.resolve() + } + + // MARK: - Markers + // + // The marker + clustering bridge methods live in MarkerBridge.swift to keep + // this type within SwiftLint's body-length budget. + + // MARK: - Search + + @objc func searchAutocomplete(_ call: CAPPluginCall) { + searchService.autocomplete(call) + } + + @objc func searchPlaces(_ call: CAPPluginCall) { + searchService.places(call) + } + + @objc func searchResolve(_ call: CAPPluginCall) { + searchService.resolve(call) + } + + // MARK: - Geocoding + + @objc func reverseGeocode(_ call: CAPPluginCall) { + geocodeService.reverse(call) + } + + @objc func geocode(_ call: CAPPluginCall) { + geocodeService.forward(call) + } + + // MARK: - MKMapViewDelegate + // + // The region-change delegate methods (onCameraMoveStarted / onCameraIdle and + // the min/max-zoom bounce) live in CameraEvents.swift to keep this type within + // SwiftLint's body-length budget. + + public func mapView(_ mapView: MKMapView, viewFor annotation: MKAnnotation) -> MKAnnotationView? { + findMap(for: mapView)?.annotationView(for: annotation, in: mapView) + } + + public func mapView(_ mapView: MKMapView, didSelect view: MKAnnotationView) { + guard let map = findMap(for: mapView) else { return } + + if let cluster = view.annotation as? MKClusterAnnotation { + notifyListeners("onClusterClick", data: [ + "mapId": map.id, + "latitude": cluster.coordinate.latitude, + "longitude": cluster.coordinate.longitude, + "count": cluster.memberAnnotations.count, + "markerIds": cluster.memberAnnotations.compactMap { ($0 as? NativeMapMarker)?.markerId } + ]) + map.expandCluster(cluster, in: mapView) + return + } + + if view.annotation is MKUserLocation { + let coordinate = view.annotation?.coordinate ?? mapView.userLocation.coordinate + notifyListeners("onMyLocationClick", data: [ + "mapId": map.id, + "latitude": coordinate.latitude, + "longitude": coordinate.longitude + ]) + mapView.deselectAnnotation(view.annotation, animated: false) + return + } + + guard let marker = view.annotation as? NativeMapMarker else { return } + notifyListeners("onMarkerClick", data: [ + "mapId": map.id, + "markerId": marker.markerId, + "latitude": marker.coordinate.latitude, + "longitude": marker.coordinate.longitude, + "title": marker.title ?? "" + ]) + map.handleMarkerSelection(marker) + } + + // MARK: - Helpers + + func findMap(for mapView: MKMapView) -> Map? { + for (_, map) in maps where map.mapView === mapView { + return map + } + return nil + } +} diff --git a/ios/Sources/NativeMapPlugin/ControlsBridge.swift b/ios/Sources/NativeMapPlugin/ControlsBridge.swift new file mode 100644 index 0000000..78c628f --- /dev/null +++ b/ios/Sources/NativeMapPlugin/ControlsBridge.swift @@ -0,0 +1,84 @@ +import Foundation +import MapKit +import Capacitor + +// MARK: - Plugin: user-tracking / buildings / camera-boundary / selection bridge +// +// Split out of NativeMapPlugin.swift so the plugin type stays within +// SwiftLint's body-length budget. The per-map work lives on `Map` (MapControls.swift). + +extension NativeMapPlugin { + + @objc func setUserTrackingMode(_ call: CAPPluginCall) { + guard let id = call.getString("id"), let map = maps[id] else { + call.reject("map not found", PluginError.mapNotFound) + return + } + map.setUserTrackingMode(call.getString("mode") ?? "none") + call.resolve() + } + + @objc func setUserTrackingButtonVisible(_ call: CAPPluginCall) { + guard let id = call.getString("id"), let map = maps[id] else { + call.reject("map not found", PluginError.mapNotFound) + return + } + map.setUserTrackingButton(call.getBool("visible", true)) + call.resolve() + } + + @objc func setBuildingsEnabled(_ call: CAPPluginCall) { + guard let id = call.getString("id"), let map = maps[id] else { + call.reject("map not found", PluginError.mapNotFound) + return + } + map.setBuildings(call.getBool("enabled", true)) + call.resolve() + } + + @objc func setCameraBoundary(_ call: CAPPluginCall) { + guard let id = call.getString("id"), let map = maps[id] else { + call.reject("map not found", PluginError.mapNotFound) + return + } + // A bounds object restricts panning; omitting it (or null) clears the limit. + if let boundsObj = call.getObject("bounds"), + let swObj = boundsObj["southwest"] as? JSObject, + let swLat = swObj["lat"] as? Double, let swLng = swObj["lng"] as? Double, + let neObj = boundsObj["northeast"] as? JSObject, + let neLat = neObj["lat"] as? Double, let neLng = neObj["lng"] as? Double { + map.setCameraBoundary( + southwest: CLLocationCoordinate2D(latitude: swLat, longitude: swLng), + northeast: CLLocationCoordinate2D(latitude: neLat, longitude: neLng) + ) + } else { + map.setCameraBoundary(southwest: nil, northeast: nil) + } + call.resolve() + } + + @objc func selectMarker(_ call: CAPPluginCall) { + guard let id = call.getString("id"), let map = maps[id] else { + call.reject("map not found", PluginError.mapNotFound) + return + } + guard let markerId = call.getString("markerId") else { + call.reject("markerId is required", PluginError.invalidArgument) + return + } + if map.selectMarker(markerId) { + call.resolve() + } else { + call.reject("marker not found", PluginError.markerNotFound) + } + } + + @objc func deselectMarker(_ call: CAPPluginCall) { + guard let id = call.getString("id"), let map = maps[id] else { + call.reject("map not found", PluginError.mapNotFound) + return + } + map.deselectMarker() + call.resolve() + } +} diff --git a/ios/Sources/NativeMapPlugin/Geocode.swift b/ios/Sources/NativeMapPlugin/Geocode.swift new file mode 100644 index 0000000..3650fd5 --- /dev/null +++ b/ios/Sources/NativeMapPlugin/Geocode.swift @@ -0,0 +1,112 @@ +import Foundation +import CoreLocation +import Contacts +import Capacitor + +/// Collapses a multi-line postal address (as `CNPostalAddressFormatter` writes +/// it) into one comma-separated line, dropping blank lines. Pure so it can be +/// unit-tested. +func singleLineAddress(_ multiline: String) -> String { + return multiline + .components(separatedBy: .newlines) + .map { $0.trimmingCharacters(in: .whitespaces) } + .filter { !$0.isEmpty } + .joined(separator: ", ") +} + +/// Joins whatever address parts exist, skipping nil/empty ones and immediate +/// repeats (a placemark's `name` is often just its locality). Nil when nothing +/// usable remains. Pure so it can be unit-tested. +func joinedAddressParts(_ parts: [String?]) -> String? { + var kept: [String] = [] + for part in parts { + guard let part = part?.trimmingCharacters(in: .whitespaces), !part.isEmpty, part != kept.last else { continue } + kept.append(part) + } + return kept.isEmpty ? nil : kept.joined(separator: ", ") +} + +/// One display line for a placemark. Prefers the locale-aware postal format +/// (which knows, e.g., that a German postal code precedes the city); falls back +/// to the loose parts for places with no postal address, like open water. +private func formattedAddress(for placemark: CLPlacemark) -> String? { + if let postal = placemark.postalAddress { + let line = singleLineAddress(CNPostalAddressFormatter.string(from: postal, style: .mailingAddress)) + if !line.isEmpty { return line } + } + return joinedAddressParts([placemark.name, placemark.locality, placemark.administrativeArea, placemark.country]) +} + +/// The bridge payload for a placemark. Absent fields are omitted, not null. +private func placePayload(for placemark: CLPlacemark) -> [String: Any] { + var payload: [String: Any] = [:] + if let coordinate = placemark.location?.coordinate { + payload["latitude"] = coordinate.latitude + payload["longitude"] = coordinate.longitude + } + let street = [placemark.subThoroughfare, placemark.thoroughfare].compactMap { $0 }.joined(separator: " ") + let fields: [String: String?] = [ + "address": formattedAddress(for: placemark), + "name": placemark.name, + "street": street, + "locality": placemark.locality, + "subLocality": placemark.subLocality, + "administrativeArea": placemark.administrativeArea, + "postalCode": placemark.postalCode, + "country": placemark.country, + "countryCode": placemark.isoCountryCode + ] + for (key, value) in fields { + if let value = value, !value.isEmpty { payload[key] = value } + } + return payload +} + +/// Native geocoding via `CLGeocoder`, in both directions. Needs no API key. +/// +/// Both fail soft, like search: no match, an offline device, or Apple's rate +/// limit resolve an empty object rather than rejecting, because callers show an +/// address as a nicety and must never be blocked by its absence. +class GeocodeService { + private func locale(_ call: CAPPluginCall) -> Locale? { + guard let language = call.getString("language"), !language.isEmpty else { return nil } + return Locale(identifier: language) + } + + func reverse(_ call: CAPPluginCall) { + guard let lat = call.getDouble("latitude"), let lng = call.getDouble("longitude"), + CLLocationCoordinate2DIsValid(CLLocationCoordinate2D(latitude: lat, longitude: lng)) else { + call.resolve([:]) + return + } + // A geocoder runs one request at a time, so each call gets its own; the + // completion handler keeps it alive until it answers. + let geocoder = CLGeocoder() + let location = CLLocation(latitude: lat, longitude: lng) + geocoder.reverseGeocodeLocation(location, preferredLocale: locale(call)) { placemarks, _ in + _ = geocoder + guard let placemark = placemarks?.first else { + call.resolve([:]) + return + } + call.resolve(placePayload(for: placemark)) + } + } + + func forward(_ call: CAPPluginCall) { + let address = (call.getString("address") ?? "").trimmingCharacters(in: .whitespacesAndNewlines) + if address.isEmpty { + call.resolve([:]) + return + } + let geocoder = CLGeocoder() + geocoder.geocodeAddressString(address, in: nil, preferredLocale: locale(call)) { placemarks, _ in + _ = geocoder + guard let placemark = placemarks?.first, placemark.location != nil else { + call.resolve([:]) + return + } + call.resolve(placePayload(for: placemark)) + } + } +} diff --git a/ios/Sources/NativeMapPlugin/GoogleMapsBridge.swift b/ios/Sources/NativeMapPlugin/GoogleMapsBridge.swift new file mode 100644 index 0000000..ebb1677 --- /dev/null +++ b/ios/Sources/NativeMapPlugin/GoogleMapsBridge.swift @@ -0,0 +1,91 @@ +// Portions adapted from @capacitor/google-maps (MIT) bridge method names for a unified JS API. +import Foundation +import Capacitor + +extension NativeMapPlugin { + + @objc func enableTouch(_ call: CAPPluginCall) { + call.resolve() + } + + @objc func disableTouch(_ call: CAPPluginCall) { + call.resolve() + } + + @objc func enableIndoorMaps(_ call: CAPPluginCall) { + call.resolve() + } + + @objc func enableAccessibilityElements(_ call: CAPPluginCall) { + call.resolve() + } + + @objc func enableTrafficLayer(_ call: CAPPluginCall) { + guard let id = call.getString("id"), let map = maps[id] else { + call.reject("map not found", PluginError.mapNotFound) + return + } + let enabled = call.getBool("enabled", false) + map.setTraffic(enabled) + call.resolve() + } + + @objc func addTileOverlay(_ call: CAPPluginCall) { + call.reject("tile overlays are not supported on iOS", PluginError.unavailable) + } + + @objc func removeTileOverlay(_ call: CAPPluginCall) { + call.reject("tile overlays are not supported on iOS", PluginError.unavailable) + } + + @objc func removePolygons(_ call: CAPPluginCall) { + removeOverlayIds(call, key: "polygonIds") + } + + @objc func removeCircles(_ call: CAPPluginCall) { + removeOverlayIds(call, key: "circleIds") + } + + @objc func removePolylines(_ call: CAPPluginCall) { + removeOverlayIds(call, key: "polylineIds") + } + + private func removeOverlayIds(_ call: CAPPluginCall, key: String) { + guard let id = call.getString("id"), let map = maps[id] else { + call.reject("map not found", PluginError.mapNotFound) + return + } + guard let ids = call.getArray(key) as? [String] else { + call.reject("\(key) is required", PluginError.invalidArgument) + return + } + map.removeOverlays(ids) + call.resolve() + } + + @objc func mapBoundsContains(_ call: CAPPluginCall) { + guard let boundsObj = call.getObject("bounds"), + let pointObj = call.getObject("point") else { + call.reject("bounds and point are required", PluginError.invalidArgument) + return + } + let sw = boundsObj["southwest"] as? JSObject ?? [:] + let ne = boundsObj["northeast"] as? JSObject ?? [:] + let lat = pointObj["lat"] as? Double ?? 0 + let lng = pointObj["lng"] as? Double ?? 0 + let south = sw["lat"] as? Double ?? -90 + let west = sw["lng"] as? Double ?? -180 + let north = ne["lat"] as? Double ?? 90 + let east = ne["lng"] as? Double ?? 180 + let contains = lat >= south && lat <= north && lng >= west && lng <= east + call.resolve(["contains": contains]) + } + + @objc func mapBoundsExtend(_ call: CAPPluginCall) { + call.reject("mapBoundsExtend is not implemented on iOS", PluginError.unavailable) + } + + @objc func dispatchMapEvent(_ call: CAPPluginCall) { + call.resolve() + } +} diff --git a/ios/Sources/NativeMapPlugin/MainThread.swift b/ios/Sources/NativeMapPlugin/MainThread.swift new file mode 100644 index 0000000..3fba1f5 --- /dev/null +++ b/ios/Sources/NativeMapPlugin/MainThread.swift @@ -0,0 +1,17 @@ +import Foundation + +/// Runs `block` synchronously on the main thread and returns its result. +/// +/// Unlike `DispatchQueue.main.sync`, this is safe to call from the main thread: +/// it runs the block inline instead of deadlocking. Capacitor dispatches plugin +/// calls off the main thread, so the bridge methods normally hop over via the +/// `DispatchQueue.main.sync` path; this guard keeps them correct if any path ever +/// reaches them already on the main thread (a lifecycle callback, a test, a +/// future caller). +@discardableResult +func runOnMainSync(_ block: () -> T) -> T { + if Thread.isMainThread { + return block() + } + return DispatchQueue.main.sync(execute: block) +} diff --git a/ios/Sources/NativeMapPlugin/MapAnnotations.swift b/ios/Sources/NativeMapPlugin/MapAnnotations.swift new file mode 100644 index 0000000..07d04f0 --- /dev/null +++ b/ios/Sources/NativeMapPlugin/MapAnnotations.swift @@ -0,0 +1,124 @@ +import Foundation +import MapKit +import Capacitor +import UIKit + +// MARK: - Map: camera + annotation views +// +// The per-map work behind the plugin's thin MKMapViewDelegate methods. Keeping it +// on `Map` (rather than in the bridge class) leaves NativeMapPlugin as a +// thin wrapper and keeps both types within SwiftLint's body-length budget. + +extension Map { + static let clusterReuseId = "appleMapCluster" + static let markerReuseId = "appleMapMarker" + // Markers with an icon and markers without one use different view classes + // (MKAnnotationView vs MKMarkerAnnotationView) and so must not share a reuse + // identifier — MapKit would hand back the wrong class from the reuse pool. + static let markerDefaultReuseId = "appleMapMarkerDefault" + + /// Parse a JS camera config (`coordinate` / `zoom` / `animate`) and apply it. + func setCamera(from configObj: JSObject) { + var coordinate: CLLocationCoordinate2D? + if let coordObj = configObj["coordinate"] as? JSObject, + let lat = coordObj["lat"] as? Double, + let lng = coordObj["lng"] as? Double { + coordinate = CLLocationCoordinate2D(latitude: lat, longitude: lng) + } + let zoom = configObj["zoom"] as? Double + let animate = configObj["animate"] as? Bool ?? false + let bearing = configObj["bearing"] as? Double + let angle = configObj["angle"] as? Double + setCameraInternal(coordinate: coordinate, zoom: zoom, animate: animate, bearing: bearing, pitch: angle) + } + + /// Build (or recycle) the annotation view for a marker, cluster, or the user + /// location dot. Returns nil for the user location so MapKit draws its default. + func annotationView(for annotation: MKAnnotation, in mapView: MKMapView) -> MKAnnotationView? { + if annotation is MKUserLocation { return nil } + + if let cluster = annotation as? MKClusterAnnotation { + let view = (mapView.dequeueReusableAnnotationView(withIdentifier: Map.clusterReuseId) as? MKMarkerAnnotationView) + ?? MKMarkerAnnotationView(annotation: cluster, reuseIdentifier: Map.clusterReuseId) + view.annotation = cluster + view.canShowCallout = false + view.glyphText = "\(cluster.memberAnnotations.count)" + view.markerTintColor = .systemGray + view.displayPriority = .required + return view + } + + guard let marker = annotation as? NativeMapMarker else { return nil } + + // No icon → MapKit's native pin (MKMarkerAnnotationView), mirroring how + // @capacitor/google-maps renders a default marker when the host supplies + // none; a bare image-less MKAnnotationView would be invisible. The two + // view classes can't share a reuse id. + let hasIcon = !(marker.iconUrl?.isEmpty ?? true) + let view: MKAnnotationView + if hasIcon { + view = mapView.dequeueReusableAnnotationView(withIdentifier: Map.markerReuseId) + ?? MKAnnotationView(annotation: marker, reuseIdentifier: Map.markerReuseId) + } else { + view = mapView.dequeueReusableAnnotationView(withIdentifier: Map.markerDefaultReuseId) as? MKMarkerAnnotationView + ?? MKMarkerAnnotationView(annotation: marker, reuseIdentifier: Map.markerDefaultReuseId) + } + view.annotation = marker + view.clusteringIdentifier = shouldCluster ? Map.clusterReuseId : nil + // `.required` opts an annotation out of decluttering — which includes + // clustering — so a required marker will never collapse into a bubble no + // matter its clusteringIdentifier. When clustering is on, drop to + // `.defaultHigh` so overlapping markers may cluster; when it's off keep + // `.required` so no pin is ever silently hidden by decluttering. + view.displayPriority = shouldCluster ? .defaultHigh : .required + view.alpha = marker.opacity + view.zPriority = MKAnnotationViewZPriority(rawValue: Float(marker.zIndex)) + // Info windows are drawn as our own bubble (see Callout.swift), so the + // native callout stays off. When info windows are on, hide the inline + // title/subtitle labels too, so the bubble is the sole info display. + if let markerView = view as? MKMarkerAnnotationView { + let visibility: MKFeatureVisibility = config.showInfoWindows ? .hidden : .adaptive + markerView.titleVisibility = visibility + markerView.subtitleVisibility = visibility + // Tint applies only to the default pin; image markers carry their own colors. + markerView.markerTintColor = marker.tintColor + } + + // Reset first: a recycled image view must not keep a previous marker's + // icon while an `https:` icon for this one is still downloading (the + // async completion in `annotationImage` sets it on the live view). + view.image = nil + view.centerOffset = .zero + if hasIcon, let image = annotationImage(for: marker, in: mapView) { + view.image = image + view.centerOffset = marker.centerOffset(for: image.size) + } + // The native callout stays off - we render our own bubble (Callout.swift), + // because MapKit's callout doesn't show through the web-view compositing. + view.canShowCallout = false + return view + } + + /// Clear MapKit's selection for a marker and show (or hide) our own info-window + /// bubble. The pin stays its normal size rather than enlarging on selection. + func handleMarkerSelection(_ marker: NativeMapMarker) { + mapView.deselectAnnotation(marker, animated: false) + if config.showInfoWindows && !(marker.title?.isEmpty ?? true) { + showCallout(for: marker) + } else { + dismissCallout() + } + } + + /// Deselect a tapped cluster and zoom to frame its members. + func expandCluster(_ cluster: MKClusterAnnotation, in mapView: MKMapView) { + mapView.deselectAnnotation(cluster, animated: false) + var rect = MKMapRect.null + for member in cluster.memberAnnotations { + let point = MKMapPoint(member.coordinate) + rect = rect.union(MKMapRect(x: point.x, y: point.y, width: 0.01, height: 0.01)) + } + let padding = UIEdgeInsets(top: 60, left: 60, bottom: 60, right: 60) + mapView.setVisibleMapRect(rect, edgePadding: padding, animated: true) + } +} diff --git a/ios/Sources/NativeMapPlugin/MapControls.swift b/ios/Sources/NativeMapPlugin/MapControls.swift new file mode 100644 index 0000000..5d27c04 --- /dev/null +++ b/ios/Sources/NativeMapPlugin/MapControls.swift @@ -0,0 +1,101 @@ +import Foundation +import MapKit +import UIKit +import Capacitor + +// MARK: - Map: user tracking, buildings, camera boundary, marker selection +// +// Per-map controls behind the plugin bridge (see ControlsBridge.swift). Split out +// to keep CapacitorNativeMap.swift within SwiftLint's length budget. + +extension Map { + + // MARK: User tracking + + /// Follow the user's location (and optionally heading). A non-`none` mode turns + /// the user-location dot on; the host app still needs location permission. + func setUserTrackingMode(_ mode: String) { + DispatchQueue.main.async { + let tracking = Map.userTrackingMode(from: mode) + if tracking != .none { + self.mapView.showsUserLocation = true + } + self.mapView.setUserTrackingMode(tracking, animated: true) + } + } + + /// Maps a JS tracking-mode string to `MKUserTrackingMode`. Pure, so it can be + /// unit-tested. + static func userTrackingMode(from string: String) -> MKUserTrackingMode { + switch string.lowercased() { + case "follow": return .follow + case "followwithheading": return .followWithHeading + default: return .none + } + } + + /// Show or hide an `MKUserTrackingButton` (a recenter/follow control) pinned to + /// the map's bottom-trailing corner. + func setUserTrackingButton(_ visible: Bool) { + DispatchQueue.main.async { + if visible { + guard self.userTrackingButton == nil else { return } + let button = MKUserTrackingButton(mapView: self.mapView) + button.translatesAutoresizingMaskIntoConstraints = false + button.backgroundColor = UIColor.systemBackground.withAlphaComponent(0.85) + button.layer.cornerRadius = 6 + button.layer.masksToBounds = true + self.mapView.addSubview(button) + NSLayoutConstraint.activate([ + button.trailingAnchor.constraint(equalTo: self.mapView.trailingAnchor, constant: -12), + button.bottomAnchor.constraint(equalTo: self.mapView.bottomAnchor, constant: -12) + ]) + self.userTrackingButton = button + } else { + self.userTrackingButton?.removeFromSuperview() + self.userTrackingButton = nil + } + } + } + + // MARK: Buildings + + func setBuildings(_ enabled: Bool) { + DispatchQueue.main.async { self.mapView.showsBuildings = enabled } + } + + // MARK: Camera boundary + + /// Restrict panning so the camera center stays within `southwest`..`northeast`. + /// Passing nil corners clears the restriction. + func setCameraBoundary(southwest: CLLocationCoordinate2D?, northeast: CLLocationCoordinate2D?) { + runOnMainSync { + guard let southwest = southwest, let northeast = northeast else { + self.mapView.setCameraBoundary(nil, animated: true) + return + } + let rect = boundingMapRect(southwest: southwest, northeast: northeast) + self.mapView.setCameraBoundary(MKMapView.CameraBoundary(mapRect: rect), animated: true) + } + } + + // MARK: Marker selection + + /// Open the info-window bubble for a marker programmatically. Returns false if + /// no marker has that id. A marker with no title selects without a bubble. + @discardableResult + func selectMarker(_ markerId: String) -> Bool { + runOnMainSync { + guard let marker = self.markers[markerId] else { return false } + if !(marker.title?.isEmpty ?? true) { + self.showCallout(for: marker) + } + return true + } + } + + /// Close any open info-window bubble. + func deselectMarker() { + runOnMainSync { self.dismissCallout() } + } +} diff --git a/ios/Sources/NativeMapPlugin/MapMounting.swift b/ios/Sources/NativeMapPlugin/MapMounting.swift new file mode 100644 index 0000000..b1f2b51 --- /dev/null +++ b/ios/Sources/NativeMapPlugin/MapMounting.swift @@ -0,0 +1,150 @@ +import Foundation +import MapKit +import Capacitor +import WebKit + +// MARK: - Native-view mounting and frame syncing +// +// Split out of CapacitorNativeMap.swift / NativeMapPlugin.swift to keep +// those types within SwiftLint's length budget. This is the compositing glue +// that keeps the native MKMapView aligned with its bound web element, ported +// from `@capacitor/google-maps`. + +extension Map { + + func updateRender(mapBounds: CGRect) { + runOnMainSync { + let newWidth = round(Double(mapBounds.width)) + let newHeight = round(Double(mapBounds.height)) + let widthEqual = round(Double(self.mapView.bounds.width)) == newWidth + let heightEqual = round(Double(self.mapView.bounds.height)) == newHeight + if !widthEqual || !heightEqual { + CATransaction.begin() + CATransaction.setDisableActions(true) + self.mapView.frame.size.width = mapBounds.width + self.mapView.frame.size.height = mapBounds.height + CATransaction.commit() + } + } + } + + func rebindTargetContainer(mapBounds: CGRect) { + runOnMainSync { + let refWidth = round(Double(mapBounds.width)) + let refHeight = round(Double(mapBounds.height)) + guard let target = self.getTargetContainer(refWidth: refWidth, refHeight: refHeight) else { return } + self.targetView = target + target.tag = Map.mapTag + target.removeAllSubview() + CATransaction.begin() + CATransaction.setDisableActions(true) + self.mapView.frame.size.width = mapBounds.width + self.mapView.frame.size.height = mapBounds.height + CATransaction.commit() + target.addSubview(self.mapView) + } + } + + /// Re-mount the map into its current webview container using the map's own + /// size. Called when the app returns to the foreground, after WebKit may + /// have rebuilt the scroll-view hierarchy and detached the native map's + /// touch handling. Keeps the existing mount if a container can't be found. + func remountIntoContainer() { + DispatchQueue.main.async { + let width = round(Double(self.mapView.bounds.width)) + let height = round(Double(self.mapView.bounds.height)) + guard width > 0, height > 0 else { return } + + // Clear the previous tag so getTargetContainer rediscovers from a + // clean slate (its default reference tag is Map.mapTag). + let previous = self.targetView + previous?.tag = 0 + self.targetView = nil + + guard let target = self.getTargetContainer(refWidth: width, refHeight: height) else { + // Couldn't rediscover a container; restore the previous mount. + previous?.tag = Map.mapTag + self.targetView = previous + return + } + + self.targetView = target + target.tag = Map.mapTag + target.removeAllSubview() + self.mapView.frame = target.bounds + target.addSubview(self.mapView) + } + } + + /// Finds the WKWebView child scroll view whose content size matches the bound + /// element, so the native map can be mounted into it. Ported from + /// `@capacitor/google-maps`. Must be called on the main thread. + func getTargetContainer(refWidth: Double, refHeight: Double) -> UIView? { + guard let webView = self.delegate?.bridge?.webView else { return nil } + for item in webView.getAllSubViews() { + guard let scrollView = item as? UIScrollView else { continue } + let childScrollClass = NSClassFromString("WKChildScrollView") + let scrollClass = NSClassFromString("WKScrollView") + let isChildScroll = (childScrollClass.map { item.isKind(of: $0) } ?? false) + || (scrollClass.map { item.isKind(of: $0) } ?? false) + let isBridgeScroll = item.isEqual(webView.scrollView) + if isChildScroll && !isBridgeScroll { + scrollView.isScrollEnabled = true + let height = Double(scrollView.contentSize.height) + let width = Double(scrollView.contentSize.width) + // The element carries an inner 200%-tall spacer, so the child + // scroll view's contentSize is ~2x the element's size. Match with + // a 1pt tolerance rather than an exact / floor-ceil-to-integer + // check: on devices whose layout lands the element on a + // half-point (e.g. iPhone 17 Pro at 558.5pt) contentSize.height/2 + // equals the element height exactly (1117/2 == 558.5), but the + // old integer floor(558.5)=558 / ceil=559 comparison missed it, + // leaving the map unmounted. Older devices happened to land on + // whole points, which is why the exact check worked there. + let widthEqual = abs(width - refWidth) <= 1.0 + let heightEqual = abs(height / 2.0 - refHeight) <= 1.0 + if widthEqual && heightEqual && item.tag < (self.targetView?.tag ?? Map.mapTag) { + return item + } + } + } + return nil + } +} + +// MARK: - Plugin frame-sync bridge + +extension NativeMapPlugin { + + @objc func onResize(_ call: CAPPluginCall) { + guard let id = call.getString("id"), let map = maps[id] else { + call.reject("map not found", PluginError.mapNotFound) + return + } + guard let boundsObj = call.getObject("mapBounds") else { + call.reject("mapBounds is required", PluginError.invalidArgument) + return + } + map.updateRender(mapBounds: CGRect.fromJSObject(boundsObj)) + call.resolve() + } + + @objc func onDisplay(_ call: CAPPluginCall) { + guard let id = call.getString("id"), let map = maps[id] else { + call.reject("map not found", PluginError.mapNotFound) + return + } + guard let boundsObj = call.getObject("mapBounds") else { + call.reject("mapBounds is required", PluginError.invalidArgument) + return + } + map.rebindTargetContainer(mapBounds: CGRect.fromJSObject(boundsObj)) + call.resolve() + } + + @objc func onScroll(_ call: CAPPluginCall) { + // The native map is a subview inside the webview's own scroll view on + // iOS, so it tracks page scrolling automatically. Nothing to do. + call.resolve() + } +} diff --git a/ios/Sources/NativeMapPlugin/MapReadback.swift b/ios/Sources/NativeMapPlugin/MapReadback.swift new file mode 100644 index 0000000..9668d87 --- /dev/null +++ b/ios/Sources/NativeMapPlugin/MapReadback.swift @@ -0,0 +1,66 @@ +import Foundation +import MapKit +import UIKit +import Capacitor + +// MARK: - Map: camera/bounds read-back + live marker styling +// +// Split out of CapacitorNativeMap.swift to keep the core Map type within +// SwiftLint's length budget. These are still part of the same Map type: the +// payload readers behind getCameraPosition / getMapBounds, and the in-place +// style updates behind updateMarkers. + +extension Map { + + /// Must be called on the main thread. + func currentZoom() -> Double { + let width = Double(mapView.bounds.width > 0 ? mapView.bounds.width : UIScreen.main.bounds.width) + return longitudeDeltaToZoom(mapView.region.span.longitudeDelta, widthPoints: width) + } + + /// Must be called on the main thread. Shape matches `LatLngBounds` in JS. + func boundsPayload() -> PluginCallResultData { + let region = mapView.region + let corners = regionCorners(center: region.center, span: region.span) + return [ + "center": ["lat": region.center.latitude, "lng": region.center.longitude], + "southwest": ["lat": corners.southwest.latitude, "lng": corners.southwest.longitude], + "northeast": ["lat": corners.northeast.latitude, "lng": corners.northeast.longitude] + ] + } + + /// Must be called on the main thread. Shape matches `CameraPosition` in JS. + func cameraPayload() -> PluginCallResultData { + let center = mapView.centerCoordinate + let camera = mapView.camera + return [ + "latitude": center.latitude, + "longitude": center.longitude, + "zoom": currentZoom(), + "bearing": camera.heading, + "angle": Double(camera.pitch), + "bounds": boundsPayload() + ] + } + + /// Apply opacity / tint / z-order from an update payload to a marker and its + /// live annotation view, so the change shows without re-adding the annotation + /// (which would flash the pin). Only keys present in `obj` are touched. Must be + /// called on the main thread. + func applyLiveStyleUpdates(from obj: JSObject, to marker: NativeMapMarker) { + if obj.keys.contains("opacity") { + marker.opacity = CGFloat(obj["opacity"] as? Double ?? 1) + mapView.view(for: marker)?.alpha = marker.opacity + } + if obj.keys.contains("zIndex") { + marker.zIndex = obj["zIndex"] as? Double ?? 0 + mapView.view(for: marker)?.zPriority = MKAnnotationViewZPriority(rawValue: Float(marker.zIndex)) + } + if obj.keys.contains("tintColor") { + marker.tintColor = NativeMapMarker.parseTintColor(obj["tintColor"]) + if let markerView = mapView.view(for: marker) as? MKMarkerAnnotationView { + markerView.markerTintColor = marker.tintColor + } + } + } +} diff --git a/ios/Sources/NativeMapPlugin/MarkerBridge.swift b/ios/Sources/NativeMapPlugin/MarkerBridge.swift new file mode 100644 index 0000000..10a6547 --- /dev/null +++ b/ios/Sources/NativeMapPlugin/MarkerBridge.swift @@ -0,0 +1,98 @@ +import Foundation +import MapKit +import Capacitor + +// MARK: - Plugin: marker + clustering bridge +// +// Split out of NativeMapPlugin.swift so the plugin type stays within +// SwiftLint's body-length budget. These are still bridge methods on the same +// plugin type; the per-map work lives on `Map` (CapacitorNativeMap.swift). + +extension NativeMapPlugin { + + @objc func addMarkers(_ call: CAPPluginCall) { + guard let id = call.getString("id"), let map = maps[id] else { + call.reject("map not found", PluginError.mapNotFound) + return + } + guard let markerObjs = call.getArray("markers") as? [JSObject] else { + call.reject("markers array is required", PluginError.invalidArgument) + return + } + let ids = map.addMarkers(markerObjs) + call.resolve(["ids": ids]) + } + + @objc func addMarker(_ call: CAPPluginCall) { + guard let id = call.getString("id"), let map = maps[id] else { + call.reject("map not found", PluginError.mapNotFound) + return + } + guard let markerObj = call.getObject("marker") else { + call.reject("marker is required", PluginError.invalidArgument) + return + } + guard let markerId = map.addMarkers([markerObj]).first else { + call.reject("marker is missing or malformed", PluginError.invalidArgument) + return + } + call.resolve(["id": markerId]) + } + + @objc func updateMarkers(_ call: CAPPluginCall) { + guard let id = call.getString("id"), let map = maps[id] else { + call.reject("map not found", PluginError.mapNotFound) + return + } + guard let markerObjs = call.getArray("markers") as? [JSObject] else { + call.reject("markers array is required", PluginError.invalidArgument) + return + } + map.updateMarkers(markerObjs) + call.resolve() + } + + @objc func removeMarkers(_ call: CAPPluginCall) { + guard let id = call.getString("id"), let map = maps[id] else { + call.reject("map not found", PluginError.mapNotFound) + return + } + guard let ids = call.getArray("markerIds") as? [String] else { + call.reject("markerIds array is required", PluginError.invalidArgument) + return + } + map.removeMarkers(ids) + call.resolve() + } + + @objc func removeMarker(_ call: CAPPluginCall) { + guard let id = call.getString("id"), let map = maps[id] else { + call.reject("map not found", PluginError.mapNotFound) + return + } + guard let markerId = call.getString("markerId") else { + call.reject("markerId is required", PluginError.invalidArgument) + return + } + map.removeMarkers([markerId]) + call.resolve() + } + + @objc func enableClustering(_ call: CAPPluginCall) { + guard let id = call.getString("id"), let map = maps[id] else { + call.reject("map not found", PluginError.mapNotFound) + return + } + map.enableClustering(minClusterSize: call.getInt("minClusterSize")) + call.resolve() + } + + @objc func disableClustering(_ call: CAPPluginCall) { + guard let id = call.getString("id"), let map = maps[id] else { + call.reject("map not found", PluginError.mapNotFound) + return + } + map.disableClustering() + call.resolve() + } +} diff --git a/ios/Sources/NativeMapPlugin/MarkerIcons.swift b/ios/Sources/NativeMapPlugin/MarkerIcons.swift new file mode 100644 index 0000000..0161e8e --- /dev/null +++ b/ios/Sources/NativeMapPlugin/MarkerIcons.swift @@ -0,0 +1,92 @@ +import Foundation +import MapKit +import UIKit +import Capacitor + +// MARK: - Marker icon resolution +// +// Split out of CapacitorNativeMap.swift to keep the core Map type within +// SwiftLint's length budget. Resolves a marker's `iconUrl` (bundled asset, +// `data:` URI, or `http(s):` download) to a sized image, caching results in the +// Map's `NSCache` and de-duping in-flight downloads. + +extension Map { + + /// Resolves a marker icon. Returns nil synchronously for `http(s):` URLs and + /// sets the image on the live annotation view once the download finishes. + /// Must be called on the main thread. + func annotationImage(for marker: NativeMapMarker, in mapView: MKMapView) -> UIImage? { + guard let iconUrl = marker.iconUrl else { return nil } + + if let cached = iconCache.object(forKey: iconUrl as NSString) { + return resize(cached, marker.iconSize) + } + + if iconUrl.hasPrefix("data:") { + if let commaIndex = iconUrl.firstIndex(of: ","), + let data = Data(base64Encoded: String(iconUrl[iconUrl.index(after: commaIndex)...])), + let image = UIImage(data: data) { + iconCache.setObject(image, forKey: iconUrl as NSString) + return resize(image, marker.iconSize) + } + return nil + } + + if iconUrl.hasPrefix("http") { + downloadRemoteIcon(iconUrl, for: marker, in: mapView) + return nil + } + + // Bundled web asset - Capacitor copies the web `static/` dir into the app + // bundle under `public/`. + if let image = UIImage(named: "public/\(iconUrl)") { + iconCache.setObject(image, forKey: iconUrl as NSString) + return resize(image, marker.iconSize) + } + return nil + } + + /// Fetches a remote icon once and applies it to the live annotation view. + /// De-dupes concurrent requests for the same url and remembers permanent + /// misses so a re-render doesn't re-download. Must be called on the main + /// thread; the completion hops back to it. + private func downloadRemoteIcon(_ iconUrl: String, for marker: NativeMapMarker, in mapView: MKMapView) { + guard !failedIconURLs.contains(iconUrl), !inFlightIconURLs.contains(iconUrl) else { return } + guard let url = URL(string: iconUrl) else { + failedIconURLs.insert(iconUrl) + return + } + inFlightIconURLs.insert(iconUrl) + URLSession.shared.dataTask(with: url) { [weak self, weak mapView] data, _, error in + DispatchQueue.main.async { + guard let self = self else { return } + self.inFlightIconURLs.remove(iconUrl) + + guard let data = data, let image = UIImage(data: data) else { + // A response with no usable image (404 body, wrong content, + // decode failure) is a permanent miss; a transport error + // (offline, timeout) is left out so a later render can retry. + if error == nil { self.failedIconURLs.insert(iconUrl) } + return + } + + self.iconCache.setObject(image, forKey: iconUrl as NSString) + if let view = mapView?.view(for: marker) { + let sized = self.resize(image, marker.iconSize) + view.image = sized + if let sized = sized { + view.centerOffset = marker.centerOffset(for: sized.size) + } + } + } + }.resume() + } + + private func resize(_ image: UIImage, _ size: CGSize?) -> UIImage? { + guard let size = size else { return image } + let renderer = UIGraphicsImageRenderer(size: size) + return renderer.image { _ in + image.draw(in: CGRect(origin: .zero, size: size)) + } + } +} diff --git a/ios/Sources/NativeMapPlugin/Overlays.swift b/ios/Sources/NativeMapPlugin/Overlays.swift new file mode 100644 index 0000000..effe2c9 --- /dev/null +++ b/ios/Sources/NativeMapPlugin/Overlays.swift @@ -0,0 +1,427 @@ +import Foundation +import MapKit +import UIKit +import Capacitor + +// MARK: - Map: overlays, appearance, tap, helpers +// +// Split out of CapacitorNativeMap.swift so the core Map type stays within +// SwiftLint's body-length budget. These are still part of the same Map type. + +extension Map { + + // MARK: Overlays + + func addPolylines(_ objs: [JSObject]) -> [String] { + var ids: [String] = [] + runOnMainSync { + for obj in objs { + let coords = Map.parseCoords(obj["path"]) + guard coords.count >= 2 else { continue } + // A geodesic line follows the great-circle (shortest) path between + // points rather than a straight screen line. MKGeodesicPolyline is a + // MKPolyline subclass, so it renders and hit-tests through the same paths. + let polyline: MKPolyline = (obj["geodesic"] as? Bool ?? false) + ? MKGeodesicPolyline(coordinates: coords, count: coords.count) + : MKPolyline(coordinates: coords, count: coords.count) + let style = Map.overlayStyle(from: obj, defaultLineWidth: 3, filled: false) + ids.append(self.register(polyline, style: style)) + } + } + return ids + } + + func addPolygons(_ objs: [JSObject]) -> [String] { + var ids: [String] = [] + runOnMainSync { + for obj in objs { + let rings = Map.parseRings(obj["paths"]) + guard let exterior = rings.first, exterior.count >= 3 else { continue } + let holes = rings.dropFirst().map { MKPolygon(coordinates: $0, count: $0.count) } + let polygon = MKPolygon( + coordinates: exterior, count: exterior.count, + interiorPolygons: holes.isEmpty ? nil : Array(holes) + ) + let style = Map.overlayStyle(from: obj, defaultLineWidth: 2, filled: true) + ids.append(self.register(polygon, style: style)) + } + } + return ids + } + + func addCircles(_ objs: [JSObject]) -> [String] { + var ids: [String] = [] + runOnMainSync { + for obj in objs { + guard let centerObj = obj["center"] as? JSObject, + let lat = centerObj["lat"] as? Double, + let lng = centerObj["lng"] as? Double, + let radius = obj["radius"] as? Double else { continue } + let circle = MKCircle( + center: CLLocationCoordinate2D(latitude: lat, longitude: lng), + radius: radius + ) + let style = Map.overlayStyle(from: obj, defaultLineWidth: 2, filled: true) + ids.append(self.register(circle, style: style)) + } + } + return ids + } + + func removeOverlays(_ ids: [String]) { + runOnMainSync { + for id in ids { + if let overlay = self.overlays.removeValue(forKey: id) { + self.mapView.removeOverlay(overlay) + self.overlayStyles.removeValue(forKey: ObjectIdentifier(overlay)) + } + } + } + } + + /// Store an overlay + its style under a fresh id and add it to the map. Must + /// be called on the main thread. + private func register(_ overlay: MKOverlay, style: OverlayStyle) -> String { + let id = UUID().uuidString + overlays[id] = overlay + overlayStyles[ObjectIdentifier(overlay)] = style + mapView.addOverlay(overlay) + return id + } + + // Appearance / location / gestures / padding live in Appearance.swift. + + // MARK: Map tap + + /// Emits `onMapClick` for taps on the map surface. Taps that land on a marker + /// never reach here (the gesture delegate declines them) so MapKit alone + /// selects the pin and shows its callout / info window; `onMarkerClick` fires + /// from `didSelect`. + @objc func handleMapTap(_ gesture: UITapGestureRecognizer) { + guard gesture.state == .ended else { return } + // A tap on the bare map closes any open info window. + dismissCallout() + let point = gesture.location(in: mapView) + // An overlay tap reports the overlay hit (polygon/polyline/circle) instead + // of onMapClick; a tap on the bare map surface falls through to onMapClick. + if let hit = overlayHit(at: point) { + let coordinate = mapView.convert(point, toCoordinateFrom: mapView) + delegate?.notifyListeners(hit.event, data: [ + "mapId": id, + hit.idKey: hit.id, + "latitude": coordinate.latitude, + "longitude": coordinate.longitude + ]) + return + } + emitMapGesture("onMapClick", at: point) + } + + /// A tapped overlay: the JS event name, the id key for that overlay kind, and + /// the overlay's id. + struct OverlayHit { + let event: String + let idKey: String + let id: String + } + + /// The topmost overlay under `point`, if the tap landed on one. Polygons and + /// circles hit on their filled interior; polylines hit within a finger-width + /// tolerance of the stroke. + private func overlayHit(at point: CGPoint) -> OverlayHit? { + let mapPoint = MKMapPoint(mapView.convert(point, toCoordinateFrom: mapView)) + for (id, overlay) in overlays { + guard let renderer = mapView.renderer(for: overlay) as? MKOverlayPathRenderer, + let path = renderer.path else { continue } + let rendererPoint = renderer.point(for: mapPoint) + + let event: String + let idKey: String + var hitPath = path + if overlay is MKPolyline { + event = "onPolylineClick" + idKey = "polylineId" + // A line has no interior, so widen the stroke to a tappable band. + let width = max(renderer.lineWidth, 22) + hitPath = path.copy(strokingWithWidth: width, lineCap: .round, lineJoin: .round, miterLimit: 1) + } else if overlay is MKCircle { + event = "onCircleClick" + idKey = "circleId" + } else if overlay is MKPolygon { + event = "onPolygonClick" + idKey = "polygonId" + } else { + continue + } + + if hitPath.contains(rendererPoint) { + return OverlayHit(event: event, idKey: idKey, id: id) + } + } + return nil + } + + /// The marker under `point`, if the point landed on one (any marker, draggable + /// or not); nil for the map surface or a cluster bubble. + private func markerAnnotation(at point: CGPoint) -> NativeMapMarker? { + var view = mapView.hitTest(point, with: nil) + while let current = view { + if let annotationView = current as? MKAnnotationView, + let marker = annotationView.annotation as? NativeMapMarker { + return marker + } + view = current.superview + } + return nil + } + + /// Emits `onMapLongClick` for a long-press on the map surface. A long-press + /// recognizer reports `.began` once when the press threshold is reached. + @objc func handleMapLongPress(_ gesture: UILongPressGestureRecognizer) { + guard gesture.state == .began else { return } + emitMapGesture("onMapLongClick", at: gesture.location(in: mapView)) + } + + /// Converts a view point to a coordinate and notifies `event`, unless the + /// point landed on an annotation (marker selection reports those separately). + private func emitMapGesture(_ event: String, at point: CGPoint) { + var view = mapView.hitTest(point, with: nil) + while let current = view { + if current is MKAnnotationView { return } + view = current.superview + } + let coordinate = mapView.convert(point, toCoordinateFrom: mapView) + delegate?.notifyListeners(event, data: [ + "mapId": id, + "latitude": coordinate.latitude, + "longitude": coordinate.longitude + ]) + } + + public func gestureRecognizer( + _ gestureRecognizer: UIGestureRecognizer, + shouldRecognizeSimultaneouslyWith otherGestureRecognizer: UIGestureRecognizer + ) -> Bool { + return true + } + + /// Decide which of our recognizers may claim a given touch. The marker-drag + /// recognizer wants touches only on a *draggable* pin. The tap and + /// map-long-press recognizers decline touches on *any* marker, so MapKit's own + /// selection runs and presents the pin's callout (info window) - relaying it + /// through our own tap recognizer raced with MapKit's and cancelled the + /// selection, so the callout never showed. Both still fire for the bare map + /// surface. + public func gestureRecognizer( + _ gestureRecognizer: UIGestureRecognizer, + shouldReceive touch: UITouch + ) -> Bool { + let marker = markerAnnotation(at: touch.location(in: mapView)) + if gestureRecognizer.name == Map.markerDragGestureName { + return marker?.isDraggable ?? false + } + // A tap on the info-window bubble must not reach the map tap handler (which + // dismisses it); the bubble's own recognizer emits onInfoWindowClick. + if let callout = calloutView, touch.view?.isDescendant(of: callout) ?? false { + return false + } + return marker == nil + } + + // MARK: Marker drag + + /// Drives dragging of `draggable` markers. On `.began` a press that lands on a + /// draggable pin picks it up and freezes the map; each `.changed` moves the + /// pin and streams `onMarkerDrag`; the end states drop it and restore the map. + @objc func handleMarkerDrag(_ gesture: UILongPressGestureRecognizer) { + let point = gesture.location(in: mapView) + switch gesture.state { + case .began: + guard let marker = draggableMarker(at: point) else { return } + draggingMarker = marker + scrollWasEnabledBeforeDrag = mapView.isScrollEnabled + mapView.isScrollEnabled = false + emitMarkerDrag("onMarkerDragStart", for: marker) + case .changed: + guard let marker = draggingMarker else { return } + marker.coordinate = mapView.convert(point, toCoordinateFrom: mapView) + emitMarkerDrag("onMarkerDrag", for: marker) + case .ended, .cancelled, .failed: + guard let marker = draggingMarker else { return } + emitMarkerDrag("onMarkerDragEnd", for: marker) + mapView.isScrollEnabled = scrollWasEnabledBeforeDrag + draggingMarker = nil + default: + break + } + } + + /// The draggable marker under `point`, if any; nil for the map surface, a + /// cluster bubble, or a non-draggable pin. + private func draggableMarker(at point: CGPoint) -> NativeMapMarker? { + guard let marker = markerAnnotation(at: point), marker.isDraggable else { return nil } + return marker + } + + private func emitMarkerDrag(_ event: String, for marker: NativeMapMarker) { + delegate?.notifyListeners(event, data: [ + "mapId": id, + "markerId": marker.markerId, + "latitude": marker.coordinate.latitude, + "longitude": marker.coordinate.longitude + ]) + } + + // MARK: Static helpers + + /// Resolves an overlay's stroke/fill styling from its payload, applying the + /// per-shape default line width and dropping the fill for unfilled shapes + /// (polylines). Pure, so overlay styling can be unit-tested. + static func overlayStyle(from obj: JSObject, defaultLineWidth: Double, filled: Bool) -> OverlayStyle { + OverlayStyle( + strokeColor: color(obj["strokeColor"], opacity: obj["strokeOpacity"]) ?? .systemBlue, + lineWidth: CGFloat(obj["strokeWeight"] as? Double ?? defaultLineWidth), + fillColor: filled ? color(obj["fillColor"], opacity: obj["fillOpacity"]) : nil, + lineDashPattern: parseDashPattern(obj["lineDashPattern"]) + ) + } + + /// A `[on, off, ...]` array of point lengths as `[NSNumber]` for a dashed + /// stroke, or nil for a solid line (absent, empty, or malformed). + static func parseDashPattern(_ value: Any?) -> [NSNumber]? { + guard let arr = value as? [Any] else { return nil } + let lengths = arr.compactMap { ($0 as? Double).map { NSNumber(value: $0) } } + return lengths.isEmpty ? nil : lengths + } + + /// Parses a flat array of `{lat,lng}` objects into coordinates. + static func parseCoords(_ value: Any?) -> [CLLocationCoordinate2D] { + guard let arr = value as? [Any] else { return [] } + return arr.compactMap { item in + guard let obj = item as? JSObject, + let lat = obj["lat"] as? Double, + let lng = obj["lng"] as? Double else { return nil } + return CLLocationCoordinate2D(latitude: lat, longitude: lng) + } + } + + /// Parses a polygon `paths` value: either a single ring of coordinates or an + /// array of rings (exterior first, then holes). + static func parseRings(_ value: Any?) -> [[CLLocationCoordinate2D]] { + guard let arr = value as? [Any] else { return [] } + if let first = arr.first, first is [Any] { + return arr.compactMap { ($0 as? [Any]).map { parseCoords($0) } } + } + return [parseCoords(arr)] + } + + /// Parses a `#RGB`/`#RRGGBB`/`#RRGGBBAA` hex string, overriding the alpha with + /// `opacity` (0..1) when supplied. Returns nil for a missing/malformed value. + static func color(_ value: Any?, opacity: Any?) -> UIColor? { + guard let hex = value as? String else { return nil } + var str = hex.trimmingCharacters(in: .whitespacesAndNewlines) + if str.hasPrefix("#") { str.removeFirst() } + guard let intVal = UInt64(str, radix: 16) else { return nil } + + let red, green, blue: Double + var alpha: Double = 1 + switch str.count { + case 8: + red = Double((intVal & 0xFF00_0000) >> 24) / 255 + green = Double((intVal & 0x00FF_0000) >> 16) / 255 + blue = Double((intVal & 0x0000_FF00) >> 8) / 255 + alpha = Double(intVal & 0x0000_00FF) / 255 + case 6: + red = Double((intVal & 0xFF0000) >> 16) / 255 + green = Double((intVal & 0x00FF00) >> 8) / 255 + blue = Double(intVal & 0x0000FF) / 255 + default: + return nil + } + if let alphaOverride = opacity as? Double { alpha = alphaOverride } + return UIColor(red: red, green: green, blue: blue, alpha: alpha) + } +} + +// MARK: - Plugin: overlay + appearance bridge and the overlay renderer + +extension NativeMapPlugin { + + @objc func addPolylines(_ call: CAPPluginCall) { + guard let id = call.getString("id"), let map = maps[id] else { + call.reject("map not found", PluginError.mapNotFound) + return + } + guard let objs = call.getArray("polylines") as? [JSObject] else { + call.reject("polylines array is required", PluginError.invalidArgument) + return + } + call.resolve(["ids": map.addPolylines(objs)]) + } + + @objc func addPolygons(_ call: CAPPluginCall) { + guard let id = call.getString("id"), let map = maps[id] else { + call.reject("map not found", PluginError.mapNotFound) + return + } + guard let objs = call.getArray("polygons") as? [JSObject] else { + call.reject("polygons array is required", PluginError.invalidArgument) + return + } + call.resolve(["ids": map.addPolygons(objs)]) + } + + @objc func addCircles(_ call: CAPPluginCall) { + guard let id = call.getString("id"), let map = maps[id] else { + call.reject("map not found", PluginError.mapNotFound) + return + } + guard let objs = call.getArray("circles") as? [JSObject] else { + call.reject("circles array is required", PluginError.invalidArgument) + return + } + call.resolve(["ids": map.addCircles(objs)]) + } + + @objc func removeOverlays(_ call: CAPPluginCall) { + guard let id = call.getString("id"), let map = maps[id] else { + call.reject("map not found", PluginError.mapNotFound) + return + } + guard let ids = call.getArray("ids") as? [String] else { + call.reject("ids array is required", PluginError.invalidArgument) + return + } + map.removeOverlays(ids) + call.resolve() + } + + public func mapView(_ mapView: MKMapView, rendererFor overlay: MKOverlay) -> MKOverlayRenderer { + let style = findMap(for: mapView)?.overlayStyles[ObjectIdentifier(overlay)] + + if let polyline = overlay as? MKPolyline { + let renderer = MKPolylineRenderer(polyline: polyline) + renderer.strokeColor = style?.strokeColor ?? .systemBlue + renderer.lineWidth = style?.lineWidth ?? 3 + renderer.lineDashPattern = style?.lineDashPattern + return renderer + } + if let polygon = overlay as? MKPolygon { + let renderer = MKPolygonRenderer(polygon: polygon) + renderer.strokeColor = style?.strokeColor ?? .systemBlue + renderer.lineWidth = style?.lineWidth ?? 2 + renderer.fillColor = style?.fillColor + renderer.lineDashPattern = style?.lineDashPattern + return renderer + } + if let circle = overlay as? MKCircle { + let renderer = MKCircleRenderer(circle: circle) + renderer.strokeColor = style?.strokeColor ?? .systemBlue + renderer.lineWidth = style?.lineWidth ?? 2 + renderer.fillColor = style?.fillColor + renderer.lineDashPattern = style?.lineDashPattern + return renderer + } + return MKOverlayRenderer(overlay: overlay) + } +} diff --git a/ios/Sources/NativeMapPlugin/Permissions.swift b/ios/Sources/NativeMapPlugin/Permissions.swift new file mode 100644 index 0000000..aa931cb --- /dev/null +++ b/ios/Sources/NativeMapPlugin/Permissions.swift @@ -0,0 +1,66 @@ +import Foundation +import Capacitor +import CoreLocation + +// MARK: - Location permission +// +// Implements the Capacitor permission pattern for the `location` alias, used by +// `enableCurrentLocation` (the blue user-location dot). The host app must still +// declare `NSLocationWhenInUseUsageDescription` in its Info.plist; without it the +// system prompt never appears and iOS treats access as denied. + +extension NativeMapPlugin: CLLocationManagerDelegate { + + /// The CLLocationManager, created on first use. Owning it (rather than a + /// throwaway) is what lets the authorization-change delegate fire back into us. + func ensureLocationManager() -> CLLocationManager { + if let manager = locationManager { + return manager + } + let manager = CLLocationManager() + manager.delegate = self + locationManager = manager + return manager + } + + /// Current authorization mapped to a Capacitor `PermissionState` string. + private func locationPermissionState() -> String { + switch ensureLocationManager().authorizationStatus { + case .notDetermined: + return "prompt" + case .restricted, .denied: + return "denied" + case .authorizedAlways, .authorizedWhenInUse: + return "granted" + @unknown default: + return "prompt" + } + } + + @objc override public func checkPermissions(_ call: CAPPluginCall) { + call.resolve(["location": locationPermissionState()]) + } + + @objc override public func requestPermissions(_ call: CAPPluginCall) { + let manager = ensureLocationManager() + if manager.authorizationStatus == .notDetermined { + // The prompt is answered asynchronously; hold the call and resolve it + // from the delegate once the user responds. + bridge?.saveCall(call) + permissionCallID = call.callbackId + manager.requestWhenInUseAuthorization() + } else { + // Already decided (granted, denied or restricted) - nothing to prompt. + checkPermissions(call) + } + } + + public func locationManagerDidChangeAuthorization(_ manager: CLLocationManager) { + guard let callID = permissionCallID, let call = bridge?.getSavedCall(callID) else { + return + } + checkPermissions(call) + bridge?.releaseCall(call) + permissionCallID = nil + } +} diff --git a/ios/Sources/NativeMapPlugin/PluginError.swift b/ios/Sources/NativeMapPlugin/PluginError.swift new file mode 100644 index 0000000..28ee058 --- /dev/null +++ b/ios/Sources/NativeMapPlugin/PluginError.swift @@ -0,0 +1,21 @@ +import Foundation + +// MARK: - Rejection codes +// +// Stable, machine-readable codes passed as the second argument to +// `call.reject(_:_:)`. They reach JS as the `code` property of the rejected +// error, so host apps can branch on them instead of matching message strings +// (which are for humans and may change). Keep these values stable. + +enum PluginError { + /// No map is registered for the `id` the call supplied. + static let mapNotFound = "MAP_NOT_FOUND" + /// No marker is registered for the `markerId` the call supplied. + static let markerNotFound = "MARKER_NOT_FOUND" + /// A required argument was missing or the wrong type. + static let invalidArgument = "INVALID_ARGUMENT" + /// A native operation failed at runtime (its `Error` is forwarded too). + static let operationFailed = "OPERATION_FAILED" + /// The capability is not available on this platform. + static let unavailable = "UNAVAILABLE" +} diff --git a/ios/Sources/NativeMapPlugin/Search.swift b/ios/Sources/NativeMapPlugin/Search.swift new file mode 100644 index 0000000..c8f3dd6 --- /dev/null +++ b/ios/Sources/NativeMapPlugin/Search.swift @@ -0,0 +1,246 @@ +import Foundation +import MapKit +import Capacitor + +/// True when `coordinate` is within `maxKm` of `center`. A nil/zero limit or a +/// nil center means "no filter" (always true). Pure so it can be unit-tested. +func withinDistance(maxKm: Double?, from center: CLLocation?, to coordinate: CLLocationCoordinate2D) -> Bool { + guard let maxKm = maxKm, maxKm > 0, let center = center else { return true } + let here = CLLocation(latitude: coordinate.latitude, longitude: coordinate.longitude) + return center.distance(from: here) / 1000.0 <= maxKm +} + +/// Reads an optional `region` object into an `MKCoordinateRegion` and its center. +private func parseRegion(_ region: JSObject?) -> (region: MKCoordinateRegion, center: CLLocation)? { + guard let region = region, + let lat = region["latitude"] as? Double, + let lng = region["longitude"] as? Double else { return nil } + let latDelta = region["latitudeDelta"] as? Double ?? 1.0 + let lngDelta = region["longitudeDelta"] as? Double ?? 1.0 + let center = CLLocationCoordinate2D(latitude: lat, longitude: lng) + return ( + MKCoordinateRegion(center: center, span: MKCoordinateSpan(latitudeDelta: latDelta, longitudeDelta: lngDelta)), + CLLocation(latitude: lat, longitude: lng) + ) +} + +/// What `searchAutocomplete` returns when the caller does not say. +let defaultCompleterResultTypes: MKLocalSearchCompleter.ResultType = [.address, .pointOfInterest] + +/// Reads the optional `resultTypes` string list into completer result types. +/// Unknown names are ignored, and a list that names nothing usable falls back +/// to the default: an empty option set would make the completer return no +/// suggestions at all, which reads as a broken search rather than a filter. +func parseCompleterResultTypes(_ names: [String]?) -> MKLocalSearchCompleter.ResultType { + guard let names = names else { return defaultCompleterResultTypes } + var types: MKLocalSearchCompleter.ResultType = [] + for name in names { + switch name { + case "address": types.insert(.address) + case "pointOfInterest": types.insert(.pointOfInterest) + case "query": types.insert(.query) + default: break + } + } + return types.isEmpty ? defaultCompleterResultTypes : types +} + +/// A "City, State" style secondary line, skipping the locality when it just +/// repeats the primary name. +private func placeSubtitle(for placemark: MKPlacemark, name: String?) -> String { + var parts: [String] = [] + if let locality = placemark.locality, locality != name { + parts.append(locality) + } + if let admin = placemark.administrativeArea { + parts.append(admin) + } + if parts.isEmpty, let country = placemark.country { + parts.append(country) + } + return parts.joined(separator: ", ") +} + +/// Native place search. Offers two independent APIs: +/// +/// - `autocomplete` / `resolve`: idiomatic type-ahead via `MKLocalSearchCompleter`, +/// returning lightweight `{id, title, subtitle}` completions that `resolve` +/// turns into coordinates on demand. +/// - `places`: a one-shot `MKLocalSearch` returning coordinate-bearing results, +/// optionally scoped to a region and filtered by distance. +/// +/// Both kinds of id resolve through `resolve`. +class SearchService: NSObject, MKLocalSearchCompleterDelegate { + // Autocomplete (MKLocalSearchCompleter) + private var completer: MKLocalSearchCompleter? + private var pendingCall: CAPPluginCall? + private var completions: [String: MKLocalSearchCompletion] = [:] + + // One-shot search (MKLocalSearch) + private var items: [String: MKMapItem] = [:] + private var currentSearch: MKLocalSearch? + + // MARK: - Autocomplete (type-ahead) + + private func ensureCompleter() { + if completer == nil { + let newCompleter = MKLocalSearchCompleter() + newCompleter.resultTypes = defaultCompleterResultTypes + newCompleter.delegate = self + completer = newCompleter + } + } + + func autocomplete(_ call: CAPPluginCall) { + let query = call.getString("query") ?? "" + let regionObj = call.getObject("region") + let resultTypes = parseCompleterResultTypes(call.getArray("resultTypes") as? [String]) + DispatchQueue.main.async { + self.pendingCall?.resolve(["results": []]) + + if query.isEmpty { + self.pendingCall = nil + call.resolve(["results": []]) + return + } + + self.ensureCompleter() + guard let completer = self.completer else { + call.resolve(["results": []]) + return + } + + if let parsed = parseRegion(regionObj) { + completer.region = parsed.region + } + // Set on every call, not only when given: the completer is shared, so + // a call without the option must get the default back rather than + // inherit the previous caller's filter. + completer.resultTypes = resultTypes + + self.pendingCall = call + completer.queryFragment = query + } + } + + func completerDidUpdateResults(_ completer: MKLocalSearchCompleter) { + guard let call = pendingCall else { return } + pendingCall = nil + + if completions.count > 300 { + completions.removeAll() + } + + var results: [[String: Any]] = [] + for completion in completer.results { + let id = UUID().uuidString + completions[id] = completion + results.append([ + "id": id, + "title": completion.title, + "subtitle": completion.subtitle + ]) + } + call.resolve(["results": results]) + } + + func completer(_ completer: MKLocalSearchCompleter, didFailWithError error: Error) { + pendingCall?.resolve(["results": []]) + pendingCall = nil + } + + // MARK: - One-shot search (coordinate-bearing, filterable) + + func places(_ call: CAPPluginCall) { + let query = call.getString("query") ?? "" + if query.isEmpty { + call.resolve(["results": []]) + return + } + + let regionObj = call.getObject("region") + let maxDistanceKm = call.getDouble("maxDistanceKm") + let limit = call.getInt("limit") + + DispatchQueue.main.async { + self.currentSearch?.cancel() + + let request = MKLocalSearch.Request() + request.naturalLanguageQuery = query + + var center: CLLocation? + if let parsed = parseRegion(regionObj) { + request.region = parsed.region + center = parsed.center + } + + let search = MKLocalSearch(request: request) + self.currentSearch = search + search.start { response, _ in + if self.items.count > 300 { + self.items.removeAll() + } + + var results: [[String: Any]] = [] + for item in response?.mapItems ?? [] { + let coordinate = item.placemark.coordinate + guard withinDistance(maxKm: maxDistanceKm, from: center, to: coordinate) else { continue } + + let id = UUID().uuidString + self.items[id] = item + results.append([ + "id": id, + "title": item.name ?? item.placemark.locality ?? "", + "subtitle": placeSubtitle(for: item.placemark, name: item.name), + "latitude": coordinate.latitude, + "longitude": coordinate.longitude + ]) + + if let limit = limit, limit > 0, results.count >= limit { break } + } + call.resolve(["results": results]) + } + } + } + + // MARK: - Resolve (either kind of id) + + func resolve(_ call: CAPPluginCall) { + guard let id = call.getString("id") else { + call.resolve([:]) + return + } + + // A `places` result already carries its coordinate. + if let item = items[id] { + let coordinate = item.placemark.coordinate + call.resolve([ + "lat": coordinate.latitude, + "lng": coordinate.longitude, + "title": item.name ?? "" + ]) + return + } + + // An `autocomplete` completion needs a search to get its coordinate. + guard let completion = completions[id] else { + call.resolve([:]) + return + } + DispatchQueue.main.async { + let search = MKLocalSearch(request: MKLocalSearch.Request(completion: completion)) + search.start { response, _ in + guard let item = response?.mapItems.first else { + call.resolve([:]) + return + } + let coordinate = item.placemark.coordinate + call.resolve([ + "lat": coordinate.latitude, + "lng": coordinate.longitude, + "title": item.name ?? completion.title + ]) + } + } + } +} diff --git a/ios/Sources/NativeMapPlugin/Snapshot.swift b/ios/Sources/NativeMapPlugin/Snapshot.swift new file mode 100644 index 0000000..88fdbfb --- /dev/null +++ b/ios/Sources/NativeMapPlugin/Snapshot.swift @@ -0,0 +1,153 @@ +import Foundation +import MapKit +import UIKit +import Capacitor + +// MARK: - Map snapshot (#10) +// +// Renders the current map region to a PNG via MKMapSnapshotter, then composites +// the live annotation pins and overlays on top (MKMapSnapshotter itself renders +// only the base-map tiles, not the map view's subviews/overlays). + +enum SnapshotError: Error, LocalizedError { + case failed(String) + var errorDescription: String? { + switch self { + case .failed(let message): return message + } + } +} + +extension Map { + /// Snapshot the visible region (with pins + overlays drawn in) and hand back a + /// `data:image/png;base64,...` URL. `completion` is called on the main thread. + func takeSnapshot(completion: @escaping (Result) -> Void) { + DispatchQueue.main.async { + let options = MKMapSnapshotter.Options() + options.region = self.mapView.region + options.mapType = self.mapView.mapType + options.size = self.mapView.bounds.size + options.showsBuildings = true + + let snapshotter = MKMapSnapshotter(options: options) + self.pendingSnapshotter = snapshotter + // Composite on the main thread - it reads live annotation views. + snapshotter.start(with: .main) { snapshot, error in + self.pendingSnapshotter = nil + if let error = error { + completion(.failure(error)) + return + } + guard let snapshot = snapshot else { + completion(.failure(SnapshotError.failed("snapshot produced no image"))) + return + } + let composed = self.composite(snapshot) + guard let data = composed.pngData() else { + completion(.failure(SnapshotError.failed("could not encode snapshot"))) + return + } + completion(.success("data:image/png;base64," + data.base64EncodedString())) + } + } + } + + /// Draw the base-map snapshot, then overlays, then pins on top. + private func composite(_ snapshot: MKMapSnapshotter.Snapshot) -> UIImage { + let renderer = UIGraphicsImageRenderer(size: snapshot.image.size) + return renderer.image { context in + snapshot.image.draw(at: .zero) + drawOverlays(into: context.cgContext, snapshot: snapshot) + drawMarkers(into: context.cgContext, snapshot: snapshot) + } + } + + private func drawMarkers(into ctx: CGContext, snapshot: MKMapSnapshotter.Snapshot) { + for marker in markers.values { + // Render the live annotation view so the pin looks exactly as on the + // map (default balloon or custom icon). MapKit positions a view so its + // center sits at the coordinate offset by `centerOffset`. + guard let view = mapView.view(for: marker) else { continue } + let anchor = snapshot.point(for: marker.coordinate) + let center = CGPoint(x: anchor.x + view.centerOffset.x, y: anchor.y + view.centerOffset.y) + ctx.saveGState() + ctx.translateBy(x: center.x - view.bounds.width / 2, y: center.y - view.bounds.height / 2) + view.layer.render(in: ctx) + ctx.restoreGState() + } + } + + private func drawOverlays(into ctx: CGContext, snapshot: MKMapSnapshotter.Snapshot) { + for overlay in overlays.values { + let style = overlayStyles[ObjectIdentifier(overlay)] + let stroke = (style?.strokeColor ?? .systemBlue).cgColor + let lineWidth = style?.lineWidth ?? 3 + if let polyline = overlay as? MKPolyline { + strokePath(multiPointPath(polyline, snapshot: snapshot, closed: false), + into: ctx, stroke: stroke, fill: nil, lineWidth: lineWidth) + } else if let polygon = overlay as? MKPolygon { + strokePath(multiPointPath(polygon, snapshot: snapshot, closed: true), + into: ctx, stroke: stroke, fill: style?.fillColor?.cgColor, lineWidth: lineWidth) + } else if let circle = overlay as? MKCircle { + strokePath(circlePath(circle, snapshot: snapshot), + into: ctx, stroke: stroke, fill: style?.fillColor?.cgColor, lineWidth: lineWidth) + } + } + } + + private func strokePath(_ path: CGPath, into ctx: CGContext, stroke: CGColor, fill: CGColor?, lineWidth: CGFloat) { + if let fill = fill { + ctx.addPath(path) + ctx.setFillColor(fill) + ctx.fillPath() + } + ctx.addPath(path) + ctx.setStrokeColor(stroke) + ctx.setLineWidth(lineWidth) + ctx.setLineJoin(.round) + ctx.strokePath() + } + + private func multiPointPath(_ shape: MKMultiPoint, snapshot: MKMapSnapshotter.Snapshot, closed: Bool) -> CGPath { + let path = CGMutablePath() + let points = shape.points() + for index in 0.. CGPath { + let center = snapshot.point(for: circle.coordinate) + // Convert the radius (meters) to points via a coordinate one radius north. + let north = CLLocationCoordinate2D( + latitude: circle.coordinate.latitude + circle.radius / 111_320.0, + longitude: circle.coordinate.longitude + ) + let edge = snapshot.point(for: north) + let radius = hypot(edge.x - center.x, edge.y - center.y) + return CGPath( + ellipseIn: CGRect(x: center.x - radius, y: center.y - radius, width: radius * 2, height: radius * 2), + transform: nil + ) + } +} + +extension NativeMapPlugin { + @objc func takeSnapshot(_ call: CAPPluginCall) { + guard let id = call.getString("id"), let map = maps[id] else { + call.reject("map not found", PluginError.mapNotFound) + return + } + map.takeSnapshot { result in + switch result { + case .success(let image): + call.resolve(["image": image]) + case .failure(let error): + call.reject(error.localizedDescription, PluginError.operationFailed, error) + } + } + } +} diff --git a/ios/Sources/NativeMapPlugin/ViewHelpers.swift b/ios/Sources/NativeMapPlugin/ViewHelpers.swift new file mode 100644 index 0000000..c09d3a7 --- /dev/null +++ b/ios/Sources/NativeMapPlugin/ViewHelpers.swift @@ -0,0 +1,68 @@ +import Foundation +import UIKit +import WebKit +import Capacitor + +// MARK: - View-tree + touch-routing helpers (ported from @capacitor/google-maps) +// +// Split out of CapacitorNativeMap.swift so that file stays within SwiftLint's +// file-length budget. These compositing helpers mount the native map into the +// WKWebView's view tree and route touches down to it. + +// MARK: - WKWebView touch routing +// +// Routes touches that land on a WKChildScrollView down to the native map view +// mounted inside it. +extension WKWebView { + override open func hitTest(_ point: CGPoint, with event: UIEvent?) -> UIView? { + var hitView = super.hitTest(point, with: event) + if let childScrollClass = NSClassFromString("WKChildScrollView"), + let candidate = hitView, candidate.isKind(of: childScrollClass) { + for item in candidate.subviews.reversed() { + let converted = item.convert(point, from: self) + if let inner = item.hitTest(converted, with: event) { + hitView = inner + break + } + } + } + return hitView + } +} + +// MARK: - View tree helpers + +extension UIView { + private static var allSubviews: [UIView] = [] + + private func viewArray(root: UIView) -> [UIView] { + var index = root.tag + for view in root.subviews { + if view.tag == Map.mapTag { continue } + view.tag = index + UIView.allSubviews.append(view) + _ = viewArray(root: view) + index += 1 + } + return UIView.allSubviews + } + + func getAllSubViews() -> [UIView] { + UIView.allSubviews = [] + return viewArray(root: self).reversed() + } + + func removeAllSubview() { + subviews.forEach { $0.removeFromSuperview() } + } +} + +extension CGRect { + static func fromJSObject(_ obj: JSObject) -> CGRect { + let x = obj["x"] as? Double ?? 0 + let y = obj["y"] as? Double ?? 0 + let width = obj["width"] as? Double ?? 0 + let height = obj["height"] as? Double ?? 0 + return CGRect(x: x, y: y, width: width, height: height) + } +} diff --git a/ios/Tests/NativeMapPluginTests/CapacitorAppleMapsTests.swift b/ios/Tests/NativeMapPluginTests/CapacitorAppleMapsTests.swift new file mode 100644 index 0000000..788a1d7 --- /dev/null +++ b/ios/Tests/NativeMapPluginTests/CapacitorAppleMapsTests.swift @@ -0,0 +1,490 @@ +import XCTest +import MapKit +import Capacitor +@testable import NativeMapPlugin + +class CapacitorNativeMapTests: XCTestCase { + + // MARK: - Zoom <-> region conversion + + /// The zoom <-> longitude-delta conversion should round-trip for a fixed + /// viewport width across the useful zoom range. + func testZoomRoundTrip() { + let width = 390.0 // typical iPhone point width + for zoom in stride(from: 3.0, through: 18.0, by: 1.0) { + let delta = zoomToLongitudeDelta(zoom, widthPoints: width) + let recovered = longitudeDeltaToZoom(delta, widthPoints: width) + XCTAssertEqual(zoom, recovered, accuracy: 0.0001, "zoom \(zoom) did not round-trip") + } + } + + /// A larger zoom must produce a narrower longitude span. + func testHigherZoomIsNarrower() { + let width = 390.0 + XCTAssertGreaterThan( + zoomToLongitudeDelta(5, widthPoints: width), + zoomToLongitudeDelta(12, widthPoints: width) + ) + } + + /// A zero/invalid viewport width must fall back rather than divide by zero. + func testZoomToDeltaHandlesZeroWidth() { + let delta = zoomToLongitudeDelta(10, widthPoints: 0) + XCTAssertTrue(delta.isFinite) + XCTAssertGreaterThan(delta, 0) + } + + /// A zero span must not produce a non-finite zoom. + func testLongitudeDeltaToZoomHandlesZeroDelta() { + let zoom = longitudeDeltaToZoom(0, widthPoints: 390) + XCTAssertTrue(zoom.isFinite) + } + + // MARK: - Zoom clamping (minZoom floor / maxZoom ceiling) + + func testClampZoomUnboundedIsIdentity() { + XCTAssertEqual(clampZoom(11.0, minZoom: nil, maxZoom: nil), 11.0) + } + + func testClampZoomAppliesFloorAndCeiling() { + XCTAssertEqual(clampZoom(3.0, minZoom: 7.0, maxZoom: nil), 7.0) // below floor + XCTAssertEqual(clampZoom(20.0, minZoom: nil, maxZoom: 18.0), 18.0) // above ceiling + XCTAssertEqual(clampZoom(12.0, minZoom: 7.0, maxZoom: 18.0), 12.0) // in range + } + + /// An inverted range should not trap the value between crossed bounds; the + /// ceiling wins (min is applied first, then max). + func testClampZoomInvertedRangeCeilingWins() { + XCTAssertEqual(clampZoom(12.0, minZoom: 18.0, maxZoom: 7.0), 7.0) + } + + // MARK: - fitBounds framing rect + + func testBoundingMapRectContainsBothCorners() { + let southWest = CLLocationCoordinate2D(latitude: 41.0, longitude: -73.0) + let northEast = CLLocationCoordinate2D(latitude: 43.0, longitude: -69.0) + let rect = boundingMapRect(southwest: southWest, northeast: northEast) + XCTAssertTrue(rect.contains(MKMapPoint(southWest))) + XCTAssertTrue(rect.contains(MKMapPoint(northEast))) + XCTAssertGreaterThan(rect.size.width, 0) + XCTAssertGreaterThan(rect.size.height, 0) + } + + /// The rect is orientation-independent: swapping the corners yields the same + /// rect (latitude grows north but MKMapPoint.y grows south). + func testBoundingMapRectIsOrientationIndependent() { + let southWest = CLLocationCoordinate2D(latitude: 41.0, longitude: -73.0) + let northEast = CLLocationCoordinate2D(latitude: 43.0, longitude: -69.0) + let rect = boundingMapRect(southwest: southWest, northeast: northEast) + let swapped = boundingMapRect(southwest: northEast, northeast: southWest) + XCTAssertEqual(rect.origin.x, swapped.origin.x, accuracy: 1e-6) + XCTAssertEqual(rect.origin.y, swapped.origin.y, accuracy: 1e-6) + XCTAssertEqual(rect.size.width, swapped.size.width, accuracy: 1e-6) + XCTAssertEqual(rect.size.height, swapped.size.height, accuracy: 1e-6) + } + + // MARK: - Marker payload parsing + + func testMakeMarkerReadsAllFields() { + let obj: JSObject = [ + "coordinate": ["lat": 42.36, "lng": -71.06] as JSObject, + "title": "Boston", + "snippet": "MA", + "iconUrl": "pin.png", + "iconSize": ["width": 30.0, "height": 36.0] as JSObject + ] + let marker = Map.makeMarker(from: obj) + XCTAssertNotNil(marker) + XCTAssertEqual(marker?.coordinate.latitude ?? 0, 42.36, accuracy: 1e-9) + XCTAssertEqual(marker?.title, "Boston") + XCTAssertEqual(marker?.subtitle, "MA") + XCTAssertEqual(marker?.iconUrl, "pin.png") + XCTAssertEqual(marker?.iconSize, CGSize(width: 30, height: 36)) + } + + func testMakeMarkerUsesCustomIdButIgnoresEmpty() { + let coordinate = ["lat": 0.0, "lng": 0.0] as JSObject + let custom = Map.makeMarker(from: ["coordinate": coordinate, "markerId": "abc"]) + XCTAssertEqual(custom?.markerId, "abc") + + let empty = Map.makeMarker(from: ["coordinate": coordinate, "markerId": ""]) + XCTAssertFalse(empty?.markerId.isEmpty ?? true) // fell back to a generated id + XCTAssertNotEqual(empty?.markerId, "") + } + + func testMakeMarkerParsesDraggable() { + let coordinate = ["lat": 1.0, "lng": 2.0] as JSObject + XCTAssertTrue(Map.makeMarker(from: ["coordinate": coordinate, "draggable": true])?.isDraggable ?? false) + // Defaults off when omitted, preserving the non-draggable behavior. + XCTAssertFalse(Map.makeMarker(from: ["coordinate": coordinate])?.isDraggable ?? true) + } + + func testMakeMarkerReturnsNilWithoutCoordinate() { + XCTAssertNil(Map.makeMarker(from: ["title": "no coord"])) + XCTAssertNil(Map.makeMarker(from: ["coordinate": ["lat": 1.0] as JSObject])) + } + + // MARK: - Overlay style parsing + + func testOverlayStyleUnfilledUsesDefaults() { + let style = Map.overlayStyle(from: [:], defaultLineWidth: 3, filled: false) + XCTAssertEqual(style.lineWidth, 3) + XCTAssertNil(style.fillColor) // polylines never fill + XCTAssertNotNil(style.strokeColor) // defaults to system blue + } + + func testOverlayStyleFilledParsesColorsAndWidth() { + let obj: JSObject = [ + "strokeColor": "#FF0000", + "strokeWeight": 5.0, + "fillColor": "#00FF00", + "fillOpacity": 0.5 + ] + let style = Map.overlayStyle(from: obj, defaultLineWidth: 2, filled: true) + XCTAssertEqual(style.lineWidth, 5) + + var red: CGFloat = 0, green: CGFloat = 0, blue: CGFloat = 0, alpha: CGFloat = 0 + style.strokeColor.getRed(&red, green: &green, blue: &blue, alpha: &alpha) + XCTAssertEqual(red, 1.0, accuracy: 1e-6) + + XCTAssertNotNil(style.fillColor) + style.fillColor?.getRed(&red, green: &green, blue: &blue, alpha: &alpha) + XCTAssertEqual(green, 1.0, accuracy: 1e-6) + XCTAssertEqual(alpha, 0.5, accuracy: 1e-6) + } + + // MARK: - CAPPluginCall string-array reading (diagnostic) + + /// Reproduces exactly how the bridge builds a call's options, to determine + /// whether `getArray` can read a JS string array (as removeMarkers / + /// removeOverlays need). + func testGetArrayReadsStringArrayFromCoercedOptions() { + let options = JSTypes.coerceDictionaryToJSObject(["id": "map", "ids": ["a", "b", "c"]]) ?? [:] + guard let call = CAPPluginCall( + callbackId: "t", methodName: "removeOverlays", + options: options, success: { _, _ in }, error: { _ in } + ) else { + XCTFail("could not construct CAPPluginCall") + return + } + let raw = call.getArray("ids") + XCTAssertNotNil(raw, "getArray returned nil for a string array") + XCTAssertEqual(raw?.compactMap { $0 as? String }, ["a", "b", "c"]) + XCTAssertNotNil(call.getArray("ids") as? [String], "whole-array cast returned nil") + } + + // MARK: - Region corners (visible bounds math) + + func testRegionCorners() { + let center = CLLocationCoordinate2D(latitude: 42.0, longitude: -71.0) + let span = MKCoordinateSpan(latitudeDelta: 2.0, longitudeDelta: 4.0) + let corners = regionCorners(center: center, span: span) + + XCTAssertEqual(corners.southwest.latitude, 41.0, accuracy: 1e-9) + XCTAssertEqual(corners.southwest.longitude, -73.0, accuracy: 1e-9) + XCTAssertEqual(corners.northeast.latitude, 43.0, accuracy: 1e-9) + XCTAssertEqual(corners.northeast.longitude, -69.0, accuracy: 1e-9) + } + + // MARK: - Config parsing + + func testConfigParsesCenterAndZoom() throws { + let obj: JSObject = [ + "center": ["lat": 42.36, "lng": -71.06] as JSObject, + "zoom": 11.0, + "minZoom": 7.0 + ] + let config = try NativeMapConfig(fromJSObject: obj) + XCTAssertEqual(config.center.latitude, 42.36, accuracy: 1e-9) + XCTAssertEqual(config.center.longitude, -71.06, accuracy: 1e-9) + XCTAssertEqual(config.zoom, 11.0) + XCTAssertEqual(config.minZoom, 7.0) + } + + func testConfigDefaultsZoomWhenMissing() throws { + let obj: JSObject = ["center": ["lat": 0.0, "lng": 0.0] as JSObject] + let config = try NativeMapConfig(fromJSObject: obj) + XCTAssertEqual(config.zoom, 12.0) + XCTAssertNil(config.minZoom) + } + + func testConfigThrowsWithoutCenter() { + let obj: JSObject = ["zoom": 11.0] + XCTAssertThrowsError(try NativeMapConfig(fromJSObject: obj)) + } + + func testConfigParsesMaxZoomAndMapType() throws { + let obj: JSObject = [ + "center": ["lat": 0.0, "lng": 0.0] as JSObject, + "maxZoom": 18.0, + "mapType": "hybrid" + ] + let config = try NativeMapConfig(fromJSObject: obj) + XCTAssertEqual(config.maxZoom, 18.0) + XCTAssertEqual(config.mapType, "hybrid") + } + + func testConfigDefaultsMapTypeToStandard() throws { + let obj: JSObject = ["center": ["lat": 0.0, "lng": 0.0] as JSObject] + let config = try NativeMapConfig(fromJSObject: obj) + XCTAssertNil(config.maxZoom) + XCTAssertEqual(config.mapType, "standard") + } + + func testConfigParsesShowInfoWindows() throws { + let center = ["lat": 0.0, "lng": 0.0] as JSObject + let enabled = try NativeMapConfig(fromJSObject: ["center": center, "showInfoWindows": true]) + XCTAssertTrue(enabled.showInfoWindows) + // Defaults off, preserving the original tap-only behavior. + let disabled = try NativeMapConfig(fromJSObject: ["center": center]) + XCTAssertFalse(disabled.showInfoWindows) + } + + /// Parse the config through the SAME coercion the bridge applies to a JS + /// object (not a Swift literal), to catch a boolean that survives a literal + /// but not the real `create` path. + func testConfigParsesShowInfoWindowsThroughBridgeCoercion() throws { + let coerced = JSTypes.coerceDictionaryToJSObject([ + "center": ["lat": 1.0, "lng": 2.0], + "showInfoWindows": true + ]) ?? [:] + let config = try NativeMapConfig(fromJSObject: coerced) + XCTAssertTrue(config.showInfoWindows) + } + + // MARK: - Map type mapping + + func testMapTypeMappingIsCaseInsensitive() { + XCTAssertEqual(Map.mapType(from: "satellite"), .satellite) + XCTAssertEqual(Map.mapType(from: "Hybrid"), .hybrid) + XCTAssertEqual(Map.mapType(from: "satelliteFlyover"), .satelliteFlyover) + XCTAssertEqual(Map.mapType(from: "hybridflyover"), .hybridFlyover) + XCTAssertEqual(Map.mapType(from: "mutedStandard"), .mutedStandard) + } + + func testMapTypeUnknownFallsBackToStandard() { + XCTAssertEqual(Map.mapType(from: "standard"), .standard) + XCTAssertEqual(Map.mapType(from: "nonsense"), .standard) + } + + // MARK: - Overlay coordinate parsing + + func testParseCoordsReadsLatLngObjects() { + let arr: [JSObject] = [["lat": 1.0, "lng": 2.0], ["lat": 3.0, "lng": 4.0]] + let coords = Map.parseCoords(arr) + XCTAssertEqual(coords.count, 2) + XCTAssertEqual(coords[0].latitude, 1.0, accuracy: 1e-9) + XCTAssertEqual(coords[1].longitude, 4.0, accuracy: 1e-9) + } + + func testParseCoordsIgnoresMalformedEntriesAndNonArrays() { + let mixed: [JSObject] = [["lat": 1.0, "lng": 2.0], ["lat": 3.0]] + XCTAssertEqual(Map.parseCoords(mixed).count, 1) + XCTAssertEqual(Map.parseCoords(nil).count, 0) + XCTAssertEqual(Map.parseCoords("not an array").count, 0) + } + + /// A flat ring of coordinates yields a single exterior ring. + func testParseRingsSingleRing() { + let ring: [JSObject] = [ + ["lat": 0.0, "lng": 0.0], ["lat": 0.0, "lng": 1.0], ["lat": 1.0, "lng": 1.0] + ] + let rings = Map.parseRings(ring) + XCTAssertEqual(rings.count, 1) + XCTAssertEqual(rings[0].count, 3) + } + + /// An array of rings yields exterior + holes in order. + func testParseRingsMultipleRings() { + let exterior: [JSObject] = [ + ["lat": 0.0, "lng": 0.0], ["lat": 0.0, "lng": 4.0], ["lat": 4.0, "lng": 4.0] + ] + let hole: [JSObject] = [ + ["lat": 1.0, "lng": 1.0], ["lat": 1.0, "lng": 2.0], ["lat": 2.0, "lng": 2.0] + ] + let rings = Map.parseRings([exterior, hole]) + XCTAssertEqual(rings.count, 2) + XCTAssertEqual(rings[0].count, 3) + XCTAssertEqual(rings[1].count, 3) + } + + // MARK: - Hex color parsing + + func testColorParsesSixDigitHex() { + let color = Map.color("#FF0000", opacity: nil) + var red: CGFloat = 0, green: CGFloat = 0, blue: CGFloat = 0, alpha: CGFloat = 0 + XCTAssertNotNil(color) + color?.getRed(&red, green: &green, blue: &blue, alpha: &alpha) + XCTAssertEqual(red, 1.0, accuracy: 1e-6) + XCTAssertEqual(green, 0.0, accuracy: 1e-6) + XCTAssertEqual(blue, 0.0, accuracy: 1e-6) + XCTAssertEqual(alpha, 1.0, accuracy: 1e-6) + } + + func testColorParsesEightDigitHexAlpha() { + let color = Map.color("#0000FF80", opacity: nil) + var red: CGFloat = 0, green: CGFloat = 0, blue: CGFloat = 0, alpha: CGFloat = 0 + color?.getRed(&red, green: &green, blue: &blue, alpha: &alpha) + XCTAssertEqual(blue, 1.0, accuracy: 1e-6) + XCTAssertEqual(alpha, 128.0 / 255.0, accuracy: 1e-6) + } + + /// An explicit opacity overrides any alpha baked into the hex string. + func testColorOpacityOverridesHexAlpha() { + let color = Map.color("#0000FF80", opacity: 0.5) + var red: CGFloat = 0, green: CGFloat = 0, blue: CGFloat = 0, alpha: CGFloat = 0 + color?.getRed(&red, green: &green, blue: &blue, alpha: &alpha) + XCTAssertEqual(alpha, 0.5, accuracy: 1e-6) + } + + func testColorReturnsNilForMalformedInput() { + XCTAssertNil(Map.color(nil, opacity: nil)) + XCTAssertNil(Map.color("not-a-color", opacity: nil)) + XCTAssertNil(Map.color("#FFFF", opacity: nil)) // unsupported length + } + + // MARK: - CGRect parsing + + func testCGRectFromJSObject() { + let obj: JSObject = ["x": 1.0, "y": 2.0, "width": 3.0, "height": 4.0] + let rect = CGRect.fromJSObject(obj) + XCTAssertEqual(rect.origin.x, 1.0) + XCTAssertEqual(rect.origin.y, 2.0) + XCTAssertEqual(rect.size.width, 3.0) + XCTAssertEqual(rect.size.height, 4.0) + } + + func testCGRectFromJSObjectDefaultsToZero() { + let rect = CGRect.fromJSObject([:]) + XCTAssertEqual(rect, .zero) + } + + // MARK: - Search distance filter + + func testWithinDistanceNoFilterWhenLimitMissing() { + let boston = CLLocation(latitude: 42.36, longitude: -71.06) + let saoPaulo = CLLocationCoordinate2D(latitude: -23.55, longitude: -46.63) + // No/zero limit means "keep everything". + XCTAssertTrue(withinDistance(maxKm: nil, from: boston, to: saoPaulo)) + XCTAssertTrue(withinDistance(maxKm: 0, from: boston, to: saoPaulo)) + // No center means "keep everything". + XCTAssertTrue(withinDistance(maxKm: 800, from: nil, to: saoPaulo)) + } + + func testWithinDistanceKeepsNearbyDropsFar() { + let boston = CLLocation(latitude: 42.36, longitude: -71.06) + let portland = CLLocationCoordinate2D(latitude: 43.66, longitude: -70.26) // ~150 km + let saoPaulo = CLLocationCoordinate2D(latitude: -23.55, longitude: -46.63) // ~7000 km + XCTAssertTrue(withinDistance(maxKm: 800, from: boston, to: portland)) + XCTAssertFalse(withinDistance(maxKm: 800, from: boston, to: saoPaulo)) + } +} + +// MARK: - Appearance toggles (#8) +// +// In an extension so the primary test-class body stays within SwiftLint's +// type_body_length budget. +extension CapacitorNativeMapTests { + + // MARK: Color scheme mapping (dark-mode override) + + func testUserInterfaceStyleMapping() { + XCTAssertEqual(Map.userInterfaceStyle(from: "light"), .light) + XCTAssertEqual(Map.userInterfaceStyle(from: "Dark"), .dark) + } + + func testUserInterfaceStyleDefaultsToUnspecified() { + XCTAssertEqual(Map.userInterfaceStyle(from: "default"), .unspecified) + XCTAssertEqual(Map.userInterfaceStyle(from: "nonsense"), .unspecified) + } + + // MARK: Appearance config parsing + + func testConfigParsesAppearanceToggles() throws { + let obj: JSObject = [ + "center": ["lat": 0.0, "lng": 0.0] as JSObject, + "showsTraffic": true, + "showsPointsOfInterest": false, + "showsCompass": false, + "showsScale": true, + "colorScheme": "dark" + ] + let config = try NativeMapConfig(fromJSObject: obj) + XCTAssertTrue(config.showsTraffic) + XCTAssertFalse(config.showsPointsOfInterest) + XCTAssertFalse(config.showsCompass) + XCTAssertTrue(config.showsScale) + XCTAssertEqual(config.colorScheme, "dark") + } + + /// The defaults mirror MapKit's own: traffic/scale off, POI/compass on, + /// system color scheme. + func testConfigAppearanceDefaults() throws { + let config = try NativeMapConfig(fromJSObject: ["center": ["lat": 0.0, "lng": 0.0] as JSObject]) + XCTAssertFalse(config.showsTraffic) + XCTAssertTrue(config.showsPointsOfInterest) + XCTAssertTrue(config.showsCompass) + XCTAssertFalse(config.showsScale) + XCTAssertEqual(config.colorScheme, "default") + } + + // MARK: Gestures + padding (#10) + + func testConfigParsesGestures() throws { + let obj: JSObject = [ + "center": ["lat": 0.0, "lng": 0.0] as JSObject, + "gestures": ["scroll": false, "zoom": false, "rotate": true, "pitch": false] as JSObject + ] + let config = try NativeMapConfig(fromJSObject: obj) + XCTAssertFalse(config.scrollEnabled) + XCTAssertFalse(config.zoomEnabled) + XCTAssertTrue(config.rotateEnabled) + XCTAssertFalse(config.pitchEnabled) + } + + /// Gestures all default on; an omitted gesture key keeps that gesture enabled. + func testConfigGestureDefaults() throws { + let config = try NativeMapConfig(fromJSObject: ["center": ["lat": 0.0, "lng": 0.0] as JSObject]) + XCTAssertTrue(config.scrollEnabled) + XCTAssertTrue(config.zoomEnabled) + XCTAssertTrue(config.rotateEnabled) + XCTAssertTrue(config.pitchEnabled) + } + + func testParsePaddingReadsSidesAndDefaultsToZero() { + let insets = NativeMapConfig.parsePadding(["top": 10.0, "left": 20.0, "bottom": 30.0] as JSObject) + XCTAssertEqual(insets.top, 10, accuracy: 1e-6) + XCTAssertEqual(insets.left, 20, accuracy: 1e-6) + XCTAssertEqual(insets.bottom, 30, accuracy: 1e-6) + XCTAssertEqual(insets.right, 0, accuracy: 1e-6) // omitted side defaults to 0 + XCTAssertEqual(NativeMapConfig.parsePadding(nil), .zero) + XCTAssertEqual(NativeMapConfig.parsePadding("not an object"), .zero) + } + + // MARK: - Autocomplete result types + + /// No option at all keeps the behaviour every existing caller relies on. + func testResultTypesDefaultWhenOmitted() { + XCTAssertEqual(parseCompleterResultTypes(nil), [.address, .pointOfInterest]) + } + + /// A "where" field asks for addresses alone and must not get landmarks back. + func testResultTypesAddressOnly() { + XCTAssertEqual(parseCompleterResultTypes(["address"]), [.address]) + } + + func testResultTypesCombine() { + XCTAssertEqual(parseCompleterResultTypes(["pointOfInterest", "query"]), [.pointOfInterest, .query]) + } + + /// An empty option set makes the completer return nothing, which looks like + /// a broken search - so nothing usable means the default, not silence. + func testResultTypesFallBackWhenNothingUsable() { + XCTAssertEqual(parseCompleterResultTypes([]), defaultCompleterResultTypes) + XCTAssertEqual(parseCompleterResultTypes(["landmark"]), defaultCompleterResultTypes) + } + + func testResultTypesIgnoreUnknownNames() { + XCTAssertEqual(parseCompleterResultTypes(["address", "landmark"]), [.address]) + } +} diff --git a/ios/Tests/NativeMapPluginTests/GeocodeTests.swift b/ios/Tests/NativeMapPluginTests/GeocodeTests.swift new file mode 100644 index 0000000..8f5cb97 --- /dev/null +++ b/ios/Tests/NativeMapPluginTests/GeocodeTests.swift @@ -0,0 +1,32 @@ +import XCTest +@testable import NativeMapPlugin + +// MARK: - Geocoding address formatting +final class GeocodeTests: XCTestCase { + + /// The postal formatter writes one line per address row; a heading wants one line. + func testSingleLineAddressJoinsRows() { + XCTAssertEqual( + singleLineAddress("1 Main St\nBoston MA 02110\nUnited States"), + "1 Main St, Boston MA 02110, United States" + ) + } + + func testSingleLineAddressDropsBlankRows() { + XCTAssertEqual(singleLineAddress("\n Boston MA \n\nUnited States\n"), "Boston MA, United States") + XCTAssertEqual(singleLineAddress(""), "") + } + + func testJoinedAddressPartsSkipsMissingAndEmpty() { + XCTAssertEqual(joinedAddressParts([nil, "Boston", "", "MA", " "]), "Boston, MA") + } + + /// A town's placemark is named after the town, which must not print twice. + func testJoinedAddressPartsSkipsImmediateRepeats() { + XCTAssertEqual(joinedAddressParts(["Boston", "Boston", "MA"]), "Boston, MA") + } + + func testJoinedAddressPartsNilWhenNothingUsable() { + XCTAssertNil(joinedAddressParts([nil, "", " "])) + } +} diff --git a/ios/Tests/NativeMapPluginTests/MapStateTests.swift b/ios/Tests/NativeMapPluginTests/MapStateTests.swift new file mode 100644 index 0000000..2e5b5f5 --- /dev/null +++ b/ios/Tests/NativeMapPluginTests/MapStateTests.swift @@ -0,0 +1,210 @@ +import XCTest +import MapKit +import Capacitor +@testable import NativeMapPlugin + +/// Headless `Map` bookkeeping: the marker/overlay/clustering state a live map +/// tracks, verified without rendering. `MKMapView` works fine off-screen in a unit +/// test, so these assert the data structures and flags Map maintains (not pixels). +/// Tests run on the main thread (XCTest's default), where `runOnMainSync` executes +/// inline; the few `DispatchQueue.main.async` setters are flushed explicitly. +final class MapStateTests: XCTestCase { + + /// The Map holds its delegate weakly, so the plugin must outlive it. A `lazy` + /// stored property does that and is created fresh for each test instance. + private lazy var plugin = NativeMapPlugin() + + private func makeMap(clustering: Bool = false) throws -> Map { + let config = try NativeMapConfig(fromJSObject: [ + "center": ["lat": 42.0, "lng": -71.0] as JSObject, + "zoom": 10.0, + "clustering": clustering + ]) + return Map(id: "test", config: config, delegate: plugin) + } + + /// Let queued `DispatchQueue.main.async` work (e.g. render(), setMapType) run. + /// Enqueued after those blocks on the serial main queue, so it drains them. + private func flushMainQueue() { + let drained = expectation(description: "main queue drained") + DispatchQueue.main.async { drained.fulfill() } + wait(for: [drained], timeout: 1) + } + + // MARK: - Markers + + func testAddAndRemoveMarkersTrackIds() throws { + let map = try makeMap() + let ids = map.addMarkers([ + ["coordinate": ["lat": 1.0, "lng": 2.0] as JSObject], + ["coordinate": ["lat": 3.0, "lng": 4.0] as JSObject, "markerId": "custom"] + ]) + XCTAssertEqual(ids.count, 2) + XCTAssertEqual(map.markers.count, 2) + XCTAssertTrue(ids.contains("custom")) + XCTAssertNotNil(map.markers["custom"]) + + map.removeMarkers(["custom"]) + XCTAssertNil(map.markers["custom"]) + XCTAssertEqual(map.markers.count, 1) + } + + func testMalformedMarkerIsSkipped() throws { + let map = try makeMap() + let ids = map.addMarkers([ + ["coordinate": ["lat": 1.0, "lng": 2.0] as JSObject], + ["title": "no coordinate"] // dropped: no coordinate + ]) + XCTAssertEqual(ids.count, 1) + XCTAssertEqual(map.markers.count, 1) + } + + func testUpdateMarkersAppliesFields() throws { + let map = try makeMap() + let id = try XCTUnwrap(map.addMarkers([["coordinate": ["lat": 1.0, "lng": 2.0] as JSObject]]).first) + map.updateMarkers([[ + "markerId": id, + "title": "Updated", + "opacity": 0.4, + "zIndex": 5.0 + ]]) + let marker = map.markers[id] + XCTAssertEqual(marker?.title, "Updated") + XCTAssertEqual(marker?.opacity, 0.4) + XCTAssertEqual(marker?.zIndex, 5.0) + } + + // MARK: - Overlays + + func testOverlayRegisterAndRemove() throws { + let map = try makeMap() + let polylineIds = map.addPolylines([[ + "path": [["lat": 0.0, "lng": 0.0] as JSObject, ["lat": 1.0, "lng": 1.0] as JSObject] + ]]) + let circleIds = map.addCircles([[ + "center": ["lat": 0.0, "lng": 0.0] as JSObject, "radius": 100.0 + ]]) + XCTAssertEqual(polylineIds.count, 1) + XCTAssertEqual(circleIds.count, 1) + XCTAssertEqual(map.overlays.count, 2) + XCTAssertEqual(map.overlayStyles.count, 2) + + map.removeOverlays(polylineIds + circleIds) + XCTAssertTrue(map.overlays.isEmpty) + XCTAssertTrue(map.overlayStyles.isEmpty) + } + + func testMalformedOverlayIsSkipped() throws { + let map = try makeMap() + // A polyline needs at least two points; one point is dropped. + let ids = map.addPolylines([["path": [["lat": 0.0, "lng": 0.0] as JSObject]]]) + XCTAssertTrue(ids.isEmpty) + XCTAssertTrue(map.overlays.isEmpty) + } + + // MARK: - Clustering + + func testClusteringToggleAndThreshold() throws { + let map = try makeMap() + XCTAssertFalse(map.clusteringEnabled) + XCTAssertFalse(map.shouldCluster) + + map.enableClustering(minClusterSize: 3) + XCTAssertTrue(map.clusteringEnabled) + XCTAssertEqual(map.clusterMinSize, 3) + XCTAssertFalse(map.shouldCluster) // no markers yet + + _ = map.addMarkers([ + ["coordinate": ["lat": 1.0, "lng": 1.0] as JSObject], + ["coordinate": ["lat": 2.0, "lng": 2.0] as JSObject] + ]) + XCTAssertFalse(map.shouldCluster) // 2 < 3 + _ = map.addMarkers([["coordinate": ["lat": 3.0, "lng": 3.0] as JSObject]]) + XCTAssertTrue(map.shouldCluster) // 3 >= 3 + + map.disableClustering() + XCTAssertFalse(map.clusteringEnabled) + XCTAssertFalse(map.shouldCluster) + } + + func testConfigClusteringStartsEnabledWithDefaultMinSize() throws { + let map = try makeMap(clustering: true) + XCTAssertTrue(map.clusteringEnabled) + XCTAssertEqual(map.clusterMinSize, 2) + } + + func testClusteringDrivesAnnotationViewPriority() throws { + let map = try makeMap() + _ = map.addMarkers([ + ["coordinate": ["lat": 1.0, "lng": 1.0] as JSObject], + ["coordinate": ["lat": 1.0, "lng": 1.0] as JSObject] + ]) + let marker = try XCTUnwrap(map.markers.values.first) + + // Clustering off: no clustering id, and `.required` so the pin is never + // hidden by decluttering. + let unclustered = try XCTUnwrap(map.annotationView(for: marker, in: map.mapView)) + XCTAssertNil(unclustered.clusteringIdentifier) + XCTAssertEqual(unclustered.displayPriority, .required) + + // Clustering on: a clustering id, and a below-required priority so MapKit is + // actually allowed to collapse overlapping markers into a bubble. + map.enableClustering() + let clustered = try XCTUnwrap(map.annotationView(for: marker, in: map.mapView)) + XCTAssertEqual(clustered.clusteringIdentifier, Map.clusterReuseId) + XCTAssertEqual(clustered.displayPriority, .defaultHigh) + } + + func testGeodesicPolylineUsesGeodesicClass() throws { + let map = try makeMap() + let ids = map.addPolylines([[ + "path": [["lat": 0.0, "lng": 0.0] as JSObject, ["lat": 10.0, "lng": 80.0] as JSObject], + "geodesic": true + ]]) + let overlay = try XCTUnwrap(map.overlays[try XCTUnwrap(ids.first)]) + XCTAssertTrue(overlay is MKGeodesicPolyline) + + // A plain polyline is not geodesic. + let plainId = try XCTUnwrap(map.addPolylines([[ + "path": [["lat": 0.0, "lng": 0.0] as JSObject, ["lat": 1.0, "lng": 1.0] as JSObject] + ]]).first) + XCTAssertFalse(try XCTUnwrap(map.overlays[plainId]) is MKGeodesicPolyline) + } + + // MARK: - Selection + + func testSelectMarkerReportsFoundState() throws { + let map = try makeMap() + let id = try XCTUnwrap(map.addMarkers([["coordinate": ["lat": 1.0, "lng": 2.0] as JSObject]]).first) + XCTAssertTrue(map.selectMarker(id)) + XCTAssertFalse(map.selectMarker("does-not-exist")) + map.deselectMarker() // no-op with nothing open; must not crash + } + + // MARK: - Camera boundary + + func testCameraBoundarySetAndClear() throws { + let map = try makeMap() + map.setCameraBoundary( + southwest: CLLocationCoordinate2D(latitude: 40, longitude: -75), + northeast: CLLocationCoordinate2D(latitude: 43, longitude: -70) + ) + XCTAssertNotNil(map.mapView.cameraBoundary) + + map.setCameraBoundary(southwest: nil, northeast: nil) + XCTAssertNil(map.mapView.cameraBoundary) + } + + // MARK: - Map type + + func testSetMapTypeRoundTripsThroughMap() throws { + let map = try makeMap() + map.setMapType("hybrid") + flushMainQueue() + XCTAssertEqual(map.currentMapType(), "hybrid") + + map.setMapType("satellite") + flushMainQueue() + XCTAssertEqual(map.currentMapType(), "satellite") + } +} diff --git a/ios/Tests/NativeMapPluginTests/MarkerAnchorTests.swift b/ios/Tests/NativeMapPluginTests/MarkerAnchorTests.swift new file mode 100644 index 0000000..5b5d79c --- /dev/null +++ b/ios/Tests/NativeMapPluginTests/MarkerAnchorTests.swift @@ -0,0 +1,76 @@ +import XCTest +import MapKit +import Capacitor +@testable import NativeMapPlugin + +/// Icon anchoring: how a marker payload's `iconAnchor` is parsed and turned into +/// the `MKAnnotationView.centerOffset` that lands the anchor point on the +/// coordinate. Split from CapacitorNativeMapTests to keep that file's body within +/// SwiftLint's length budget. +class MarkerAnchorTests: XCTestCase { + + func testMakeMarkerParsesIconAnchor() { + let coordinate = ["lat": 1.0, "lng": 2.0] as JSObject + let anchored = Map.makeMarker(from: [ + "coordinate": coordinate, + "iconAnchor": ["x": 0.5, "y": 0.5] as JSObject + ]) + XCTAssertEqual(anchored?.iconAnchor, CGPoint(x: 0.5, y: 0.5)) + // Omitted stays nil, so centerOffset keeps the bottom-centre default. + XCTAssertNil(Map.makeMarker(from: ["coordinate": coordinate])?.iconAnchor) + // A malformed anchor is ignored rather than half-applied. + XCTAssertNil(Map.makeMarker(from: ["coordinate": coordinate, "iconAnchor": ["x": 0.5] as JSObject])?.iconAnchor) + } + + func testCenterOffsetHonoursAnchor() { + let size = CGSize(width: 40, height: 60) + let marker = NativeMapMarker() + + // Default (nil) anchors the bottom-centre — the classic teardrop tip. + XCTAssertEqual(marker.centerOffset(for: size), CGPoint(x: 0, y: -30)) + + marker.iconAnchor = CGPoint(x: 0.5, y: 0.5) // centred, as a dot wants + XCTAssertEqual(marker.centerOffset(for: size), .zero) + + marker.iconAnchor = CGPoint(x: 0, y: 0) // top-left corner on the coordinate + XCTAssertEqual(marker.centerOffset(for: size), CGPoint(x: 20, y: 30)) + } + + func testApplyIconUpdatesReportsAndResets() { + let marker = NativeMapMarker() + marker.iconAnchor = CGPoint(x: 0.5, y: 0.5) + + // A present iconAnchor of null resets to the bottom-centre default. + XCTAssertTrue(marker.applyIconUpdates(from: ["iconAnchor": NSNull()] as JSObject)) + XCTAssertNil(marker.iconAnchor) + + // No icon fields present → nothing changed, so no re-render is requested. + XCTAssertFalse(marker.applyIconUpdates(from: ["title": "unrelated"] as JSObject)) + } + + func testApplyIconUpdatesUrlAndSize() { + let marker = NativeMapMarker() + + // A url change is applied and reported (so the caller re-renders). + XCTAssertTrue(marker.applyIconUpdates(from: ["iconUrl": "pin.png"] as JSObject)) + XCTAssertEqual(marker.iconUrl, "pin.png") + + // A present iconUrl of null clears it (and still reports a change). + XCTAssertTrue(marker.applyIconUpdates(from: ["iconUrl": NSNull()] as JSObject)) + XCTAssertNil(marker.iconUrl) + + // A size change is applied and reported. + XCTAssertTrue(marker.applyIconUpdates(from: ["iconSize": ["width": 30.0, "height": 40.0] as JSObject])) + XCTAssertEqual(marker.iconSize, CGSize(width: 30, height: 40)) + } + + func testParseSizeValidAndMalformed() { + XCTAssertEqual( + NativeMapMarker.parseSize(["width": 12.0, "height": 24.0] as JSObject), + CGSize(width: 12, height: 24) + ) + // Missing a dimension, wrong type, or absent → nil (never half-applied). + XCTAssertNil(NativeMapMarker.parseSize(["width": 12.0] as JSObject)) + XCTAssertNil(NativeMapMarker.parseSize(nil)) + } +} diff --git a/ios/Tests/NativeMapPluginTests/MarkerStyleTests.swift b/ios/Tests/NativeMapPluginTests/MarkerStyleTests.swift new file mode 100644 index 0000000..36230cd --- /dev/null +++ b/ios/Tests/NativeMapPluginTests/MarkerStyleTests.swift @@ -0,0 +1,80 @@ +import XCTest +import MapKit +import Capacitor +@testable import NativeMapPlugin + +/// Parity additions: marker opacity/tint/z-order parsing and the `MKMapType` +/// string round-trip behind get/setMapType. Split from CapacitorNativeMapTests to +/// keep that file's body within SwiftLint's length budget. +class MarkerStyleTests: XCTestCase { + + func testMakeMarkerParsesStyleFields() { + let coordinate = ["lat": 1.0, "lng": 2.0] as JSObject + let marker = Map.makeMarker(from: [ + "coordinate": coordinate, + "opacity": 0.5, + "zIndex": 7.0, + "tintColor": ["r": 255.0, "g": 0.0, "b": 0.0, "a": 255.0] as JSObject + ]) + XCTAssertEqual(marker?.opacity, 0.5) + XCTAssertEqual(marker?.zIndex, 7.0) + XCTAssertNotNil(marker?.tintColor) + + // Defaults when omitted: fully opaque, z 0, no tint. + let plain = Map.makeMarker(from: ["coordinate": coordinate]) + XCTAssertEqual(plain?.opacity, 1) + XCTAssertEqual(plain?.zIndex, 0) + XCTAssertNil(plain?.tintColor) + } + + func testParseTintColor() { + // r/g/b are 0..255; alpha defaults to fully opaque when absent. + let opaqueRed = NativeMapMarker.parseTintColor(["r": 255.0, "g": 0.0, "b": 0.0] as JSObject) + var red: CGFloat = 0, green: CGFloat = 0, blue: CGFloat = 0, alpha: CGFloat = 0 + opaqueRed?.getRed(&red, green: &green, blue: &blue, alpha: &alpha) + XCTAssertEqual(red, 1, accuracy: 0.01) + XCTAssertEqual(green, 0, accuracy: 0.01) + XCTAssertEqual(blue, 0, accuracy: 0.01) + XCTAssertEqual(alpha, 1, accuracy: 0.01) + + // A half-alpha value is honoured. + let half = NativeMapMarker.parseTintColor(["r": 0.0, "g": 0.0, "b": 0.0, "a": 128.0] as JSObject) + half?.getRed(&red, green: &green, blue: &blue, alpha: &alpha) + XCTAssertEqual(alpha, 128.0 / 255.0, accuracy: 0.01) + + // Malformed (missing a channel) is ignored rather than half-applied. + XCTAssertNil(NativeMapMarker.parseTintColor(["r": 255.0, "g": 0.0] as JSObject)) + } + + func testMapTypeStringRoundTrip() { + let names = ["standard", "satellite", "hybrid", "satelliteFlyover", "hybridFlyover", "mutedStandard"] + for name in names { + XCTAssertEqual(Map.mapTypeString(from: Map.mapType(from: name)), name) + } + // An unknown type string falls back to standard. + XCTAssertEqual(Map.mapType(from: "bogus"), .standard) + } + + func testUserTrackingModeMapping() { + XCTAssertEqual(Map.userTrackingMode(from: "follow"), .follow) + XCTAssertEqual(Map.userTrackingMode(from: "followWithHeading"), .followWithHeading) + XCTAssertEqual(Map.userTrackingMode(from: "none"), MKUserTrackingMode.none) + // Unknown/absent falls back to no tracking. + XCTAssertEqual(Map.userTrackingMode(from: "bogus"), MKUserTrackingMode.none) + } + + func testParseDashPattern() { + XCTAssertEqual(Map.parseDashPattern([8.0, 4.0]), [NSNumber(value: 8.0), NSNumber(value: 4.0)]) + // Empty, non-array, and absent all mean "solid line". + XCTAssertNil(Map.parseDashPattern([])) + XCTAssertNil(Map.parseDashPattern("dashed")) + XCTAssertNil(Map.parseDashPattern(nil)) + } + + func testConfigParsesShowsBuildings() throws { + let center = ["lat": 0.0, "lng": 0.0] as JSObject + // Defaults to true (MapKit's default), and honours an explicit false. + XCTAssertTrue(try NativeMapConfig(fromJSObject: ["center": center]).showsBuildings) + XCTAssertFalse(try NativeMapConfig(fromJSObject: ["center": center, "showsBuildings": false]).showsBuildings) + } +} diff --git a/legal/MIT-capacitor-google-maps.txt b/legal/MIT-capacitor-google-maps.txt new file mode 100644 index 0000000..dea6c60 --- /dev/null +++ b/legal/MIT-capacitor-google-maps.txt @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) 2020-present Ionic + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/legal/MIT-capacitor-plugin-apple-maps.txt b/legal/MIT-capacitor-plugin-apple-maps.txt new file mode 100644 index 0000000..1ea6046 --- /dev/null +++ b/legal/MIT-capacitor-plugin-apple-maps.txt @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) 2026 Katama Labs + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/package.json b/package.json new file mode 100644 index 0000000..cdcbb4b --- /dev/null +++ b/package.json @@ -0,0 +1,103 @@ +{ + "name": "@capgo/capacitor-native-map", + "version": "0.0.1", + "description": "Native maps for Capacitor: Google Maps on Android, Apple MapKit on iOS, Google Maps JS on web", + "license": "MPL-2.0", + "main": "dist/plugin.cjs.js", + "module": "dist/esm/index.js", + "types": "dist/esm/index.d.ts", + "unpkg": "dist/plugin.js", + "files": [ + "android/src/main/", + "android/build.gradle", + "dist/", + "ios/Sources", + "ios/Tests", + "Package.swift", + "CapgoCapacitorNativeMap.podspec", + "NOTICE", + "THIRD_PARTY_LICENSES", + "legal/" + ], + "author": "Martin Donadieu", + "repository": { + "type": "git", + "url": "git+https://github.com/Cap-go/capacitor-native-map.git" + }, + "bugs": { + "url": "https://github.com/Cap-go/capacitor-native-map/issues" + }, + "homepage": "https://capgo.app/docs/plugins/native-map/", + "keywords": [ + "capacitor", + "plugin", + "maps", + "google-maps", + "mapkit", + "capgo", + "native" + ], + "scripts": { + "verify": "bun run verify:ios && bun run verify:android && bun run verify:web", + "verify:ios": "xcodebuild -scheme CapgoCapacitorNativeMap -destination generic/platform=iOS", + "verify:android": "cd android && ./gradlew clean build test && cd ..", + "verify:web": "bun run build", + "lint": "bun run eslint && bun run prettier -- --check && bun run swiftlint -- lint", + "fmt": "bun run eslint -- --fix && bun run prettier -- --write && bun run swiftlint -- --fix --format", + "eslint": "eslint . --ext .ts", + "prettier": "prettier-pretty-check \"**/*.{css,html,ts,js,java}\" --plugin=prettier-plugin-java", + "swiftlint": "node-swiftlint", + "docgen": "docgen --api NativeMapPlugin --output-readme README.md --output-json dist/docs.json", + "build": "bun run clean && bun run docgen && tsc && rollup -c rollup.config.mjs", + "clean": "rimraf ./dist", + "watch": "tsc --watch", + "example:install": "cd example-app && bun install", + "example:build": "cd example-app && bun run build", + "prepublishOnly": "bun run build", + "check:wiring": "node scripts/check-capacitor-plugin-wiring.mjs", + "check:cap9-deprecated": "node scripts/check-cap9-deprecated.mjs", + "changelog:ai": "node scripts/generate-ai-changelog.mjs" + }, + "dependencies": { + "@googlemaps/js-api-loader": "^2.0.2", + "@googlemaps/markerclusterer": "^2.6.2", + "@types/google.maps": "^3.58.1" + }, + "devDependencies": { + "@capacitor/android": "^8.0.0", + "@capacitor/cli": "^8.0.0", + "@capacitor/core": "^8.0.0", + "@capacitor/docgen": "^0.3.1", + "@capacitor/ios": "^8.0.0", + "@ionic/eslint-config": "^0.4.0", + "@ionic/prettier-config": "^4.0.0", + "@ionic/swiftlint-config": "^2.0.0", + "@types/node": "^24.10.1", + "@types/resize-observer-browser": "^0.1.11", + "eslint": "^8.57.1", + "eslint-plugin-import": "^2.31.0", + "prettier": "^3.6.2", + "prettier-plugin-java": "^2.7.7", + "prettier-pretty-check": "^0.2.0", + "rimraf": "^6.1.0", + "rollup": "^4.53.2", + "swiftlint": "^2.0.0", + "typescript": "^5.9.3" + }, + "peerDependencies": { + "@capacitor/core": ">=8.0.0" + }, + "prettier": "@ionic/prettier-config", + "swiftlint": "@ionic/swiftlint-config", + "eslintConfig": { + "extends": "@ionic/eslint-config/recommended" + }, + "capacitor": { + "ios": { + "src": "ios" + }, + "android": { + "src": "android" + } + } +} diff --git a/renovate.json b/renovate.json new file mode 100644 index 0000000..2cc02e4 --- /dev/null +++ b/renovate.json @@ -0,0 +1,93 @@ +{ + "$schema": "https://docs.renovatebot.com/renovate-schema.json", + "extends": [ + "config:base", + "schedule:earlyMondays" + ], + "dependencyDashboard": false, + "lockFileMaintenance": { + "enabled": true, + "automerge": true, + "automergeType": "branch", + "platformAutomerge": true + }, + "packageRules": [ + { + "matchUpdateTypes": [ + "minor", + "patch" + ], + "matchCurrentVersion": "!/^0/", + "automerge": true + }, + { + "matchPackageNames": [ + "eslint" + ], + "matchManagers": [ + "npm" + ], + "enabled": false + }, + { + "matchPackagePatterns": [ + "^com\\.google\\..*" + ], + "matchCurrentVersion": "/^.*-android$/", + "allowedVersions": "/^.*-android$/" + }, + { + "matchPackagePatterns": [ + "^com\\.android\\.tools\\.build\\:gradle$" + ], + "matchManagers": [ + "gradle" + ], + "enabled": false + }, + { + "matchManagers": [ + "swift" + ], + "matchPackagePatterns": [ + "^https://github.com/ionic-team/capacitor-swift-pm\\.git$", + "^ionic-team/capacitor-swift-pm$", + "^capacitor-swift-pm$" + ], + "allowedVersions": "8.0.0", + "enabled": false + }, + { + "matchDepTypes": [ + "peerDependencies" + ], + "matchPackageNames": [ + "@capacitor/core" + ], + "matchUpdateTypes": [ + "minor", + "patch" + ], + "enabled": false + }, + { + "matchDepTypes": [ + "peerDependencies" + ], + "matchPackageNames": [ + "@capacitor/core" + ], + "rangeStrategy": "replace", + "allowedVersions": "/^>=\\d+\\.0\\.0$/" + }, + { + "matchPackageNames": [ + "androidx.core:core" + ], + "matchManagers": [ + "gradle" + ], + "enabled": false + } + ] +} \ No newline at end of file diff --git a/rollup.config.mjs b/rollup.config.mjs new file mode 100644 index 0000000..f37393c --- /dev/null +++ b/rollup.config.mjs @@ -0,0 +1,22 @@ +export default { + input: 'dist/esm/index.js', + output: [ + { + file: 'dist/plugin.js', + format: 'iife', + name: 'capacitorNativeMap', + globals: { + '@capacitor/core': 'capacitorExports', + }, + sourcemap: true, + inlineDynamicImports: true, + }, + { + file: 'dist/plugin.cjs.js', + format: 'cjs', + sourcemap: true, + inlineDynamicImports: true, + }, + ], + external: ['@capacitor/core'], +}; diff --git a/scripts/check-cap9-deprecated.mjs b/scripts/check-cap9-deprecated.mjs new file mode 100644 index 0000000..8502fb0 --- /dev/null +++ b/scripts/check-cap9-deprecated.mjs @@ -0,0 +1,304 @@ +#!/usr/bin/env node +/** + * Capacitor 9 deprecated native API guard. + * + * Fails when plugin native sources still use APIs removed in Capacitor 9. + * Does not flag Cordova SwiftPM product dependencies (still required on Cap 8). + * + * Usage: + * node scripts/check-cap9-deprecated.mjs + * node scripts/check-cap9-deprecated.mjs --workspace + * node scripts/check-cap9-deprecated.mjs --dir path + */ + +import fs from "node:fs"; +import path from "node:path"; +import { fileURLToPath } from "node:url"; + +const SKIP_DIRS = new Set([ + "node_modules", + "dist", + "build", + ".build", + ".gradle", + "Pods", + "DerivedData", + ".swiftpm", + ".git", + "example-app", +]); + +/** @type {{ id: string, pattern: RegExp, exts: string[], ignoreLine?: RegExp }[]} */ +const RULES = [ + { + id: "hasOption", + pattern: /\bhasOption\s*\(/, + exts: [".java", ".kt", ".swift"], + }, + { + id: "getConfigValue", + pattern: /\bgetConfigValue\s*\(/, + exts: [".java", ".kt", ".swift"], + }, + { + id: "@NativePlugin", + pattern: /@NativePlugin\b/, + exts: [".java", ".kt"], + }, + { + id: "saveCall", + pattern: /\bsaveCall\s*\(/, + exts: [".java", ".kt", ".swift"], + }, + { + id: "getSavedCall", + pattern: /\bgetSavedCall\s*\(/, + exts: [".java", ".kt", ".swift"], + }, + { + id: "freeSavedCall", + pattern: /\bfreeSavedCall\s*\(/, + exts: [".java", ".kt", ".swift"], + }, + { + id: "releaseCall", + pattern: /\breleaseCall\s*\(/, + exts: [".java", ".kt", ".swift"], + ignoreLine: /\.releaseCall\s*\(\s*withID:/, + }, + { + id: "pluginRequestPermission", + pattern: /\bpluginRequestPermissions?\s*\(/, + exts: [".java", ".kt"], + }, + { + id: "pluginRequestAllPermissions", + pattern: /\bpluginRequestAllPermissions\s*\(/, + exts: [".java", ".kt"], + }, + { + id: "hasDefinedPermissions", + pattern: /\bhasDefinedPermissions\s*\(/, + exts: [".java", ".kt"], + }, + { + id: "CAPBridge", + pattern: /\bCAPBridge\./, + exts: [".swift"], + ignoreLine: /CAPBridgedPlugin/, + }, + { + id: "CAPNotifications", + pattern: /\bCAPNotifications\b/, + exts: [".swift"], + }, +]; + +const CORDova_SPM_LINE = + /\.product\s*\(\s*name\s*:\s*"Cordova"\s*,\s*package\s*:\s*"capacitor-swift-pm"\s*\)/; + +function readText(p) { + try { + return fs.readFileSync(p, "utf8"); + } catch { + return ""; + } +} + +function exists(p) { + try { + fs.accessSync(p); + return true; + } catch { + return false; + } +} + +function parseArgs(argv) { + const out = { dir: process.cwd(), workspace: false }; + for (let i = 2; i < argv.length; i++) { + const a = argv[i]; + if (a === "--workspace") { + out.workspace = true; + continue; + } + if (a === "--dir" || a === "--pluginDir") { + out.dir = path.resolve(argv[++i] || "."); + continue; + } + } + return out; +} + +function walkFiles(rootDir, exts) { + const out = []; + const stack = [rootDir]; + while (stack.length) { + const dir = stack.pop(); + let entries; + try { + entries = fs.readdirSync(dir, { withFileTypes: true }); + } catch { + continue; + } + for (const e of entries) { + if (e.isDirectory()) { + if (SKIP_DIRS.has(e.name)) continue; + stack.push(path.join(dir, e.name)); + continue; + } + if (!e.isFile()) continue; + for (const ext of exts) { + if (e.name.endsWith(ext)) { + out.push(path.join(dir, e.name)); + break; + } + } + } + } + out.sort(); + return out; +} + +function collectScanRoots(pluginDir, cap) { + const roots = []; + if (cap.android) { + const androidMain = path.join(pluginDir, "android", "src", "main"); + if (exists(androidMain)) roots.push(androidMain); + } + if (cap.ios) { + const iosSources = path.join(pluginDir, "ios", "Sources"); + if (exists(iosSources)) roots.push(iosSources); + else { + const iosDir = path.join(pluginDir, "ios"); + if (exists(iosDir)) roots.push(iosDir); + } + } + const packageSwift = path.join(pluginDir, "Package.swift"); + if (exists(packageSwift)) roots.push(packageSwift); + return roots; +} + +function scanFile(filePath, rule) { + const ext = path.extname(filePath); + if (!rule.exts.includes(ext)) return []; + + const txt = readText(filePath); + const lines = txt.split(/\r?\n/); + const hits = []; + for (let i = 0; i < lines.length; i++) { + const line = lines[i]; + if (filePath.endsWith("Package.swift") && CORDova_SPM_LINE.test(line)) { + continue; + } + if (rule.ignoreLine?.test(line)) continue; + if (rule.pattern.test(line)) { + hits.push({ line: i + 1, text: line.trim() }); + } + } + return hits; +} + +function listWorkspacePluginDirs(repoRoot) { + const packagesRoot = path.join(repoRoot, "packages"); + if (!exists(packagesRoot)) return []; + return fs + .readdirSync(packagesRoot, { withFileTypes: true }) + .filter((e) => e.isDirectory()) + .map((e) => path.join(packagesRoot, e.name)) + .filter((dir) => { + const pkgPath = path.join(dir, "package.json"); + if (!exists(pkgPath)) return false; + try { + const pkg = JSON.parse(readText(pkgPath)); + const cap = typeof pkg.capacitor === "object" && pkg.capacitor ? pkg.capacitor : {}; + return Boolean(cap.android || cap.ios); + } catch { + return false; + } + }) + .sort(); +} + +/** + * @returns {boolean} true when the plugin passes + */ +function checkPluginDir(pluginDir) { + const pkgPath = path.join(pluginDir, "package.json"); + + if (!exists(pkgPath)) { + console.error(`[cap9-deprecated] ERROR: missing package.json in ${pluginDir}`); + return false; + } + + let pkg; + try { + pkg = JSON.parse(readText(pkgPath)); + } catch (e) { + console.error(`[cap9-deprecated] ERROR: invalid package.json (${pkgPath}): ${e?.message || e}`); + return false; + } + + const cap = typeof pkg.capacitor === "object" && pkg.capacitor ? pkg.capacitor : {}; + if (!cap.android && !cap.ios) { + return true; + } + + const scanRoots = collectScanRoots(pluginDir, cap); + const allExts = [...new Set(RULES.flatMap((r) => r.exts))]; + const files = []; + for (const root of scanRoots) { + if (root.endsWith("Package.swift")) { + files.push(root); + continue; + } + files.push(...walkFiles(root, allExts)); + } + + const violations = []; + for (const file of files) { + for (const rule of RULES) { + const hits = scanFile(file, rule); + for (const hit of hits) { + violations.push({ + rule: rule.id, + file: path.relative(pluginDir, file), + line: hit.line, + text: hit.text, + }); + } + } + } + + if (violations.length) { + const relDir = path.relative(process.cwd(), pluginDir) || "."; + console.error(`[cap9-deprecated] FAIL in ${relDir}`); + for (const v of violations) { + console.error(`- ${v.rule}: ${v.file}:${v.line}: ${v.text}`); + } + return false; + } + + return true; +} + +const repoRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), ".."); +const args = parseArgs(process.argv); + +if (args.workspace) { + const pluginDirs = listWorkspacePluginDirs(repoRoot); + if (!pluginDirs.length) { + console.error("[cap9-deprecated] ERROR: no Capacitor plugin packages found under packages/*"); + process.exit(2); + } + let failed = false; + for (const dir of pluginDirs) { + if (!checkPluginDir(dir)) failed = true; + } + if (failed) process.exit(1); + console.log(`[cap9-deprecated] OK (${pluginDirs.length} plugin package(s) scanned)`); + process.exit(0); +} + +const ok = checkPluginDir(args.dir); +process.exit(ok ? 0 : 1); diff --git a/scripts/check-capacitor-plugin-wiring.mjs b/scripts/check-capacitor-plugin-wiring.mjs new file mode 100644 index 0000000..538d9b5 --- /dev/null +++ b/scripts/check-capacitor-plugin-wiring.mjs @@ -0,0 +1,254 @@ +#!/usr/bin/env node +/** + * Capacitor plugin wiring/name checker. + * + * Enforces that runtime plugin name matches across: + * - JS: registerPlugin('Name') + * - Android: @CapacitorPlugin(name = "Name") + * - iOS: CAPBridgedPlugin jsName = "Name" + * + * And (when iOS is declared in package.json capacitor config): + * - CocoaPods podspec s.name matches SwiftPM Package(name: ...) and .library(name: ...) + * + * Usage: + * node scripts/check-capacitor-plugin-wiring.mjs # checks current working dir + * node scripts/check-capacitor-plugin-wiring.mjs --dir path # checks given plugin dir + */ + +import fs from "node:fs"; +import path from "node:path"; + +const SKIP_DIRS = new Set([ + "node_modules", + "dist", + "build", + ".build", + ".gradle", + "Pods", + "DerivedData", + ".swiftpm", + ".git", +]); + +function readText(p) { + try { + return fs.readFileSync(p, "utf8"); + } catch { + return ""; + } +} + +function exists(p) { + try { + fs.accessSync(p); + return true; + } catch { + return false; + } +} + +function walkFiles(rootDir, exts) { + const out = []; + const stack = [rootDir]; + while (stack.length) { + const dir = stack.pop(); + let entries; + try { + entries = fs.readdirSync(dir, { withFileTypes: true }); + } catch { + continue; + } + for (const e of entries) { + if (e.isDirectory()) { + if (SKIP_DIRS.has(e.name)) continue; + stack.push(path.join(dir, e.name)); + continue; + } + if (!e.isFile()) continue; + for (const ext of exts) { + if (e.name.endsWith(ext)) { + out.push(path.join(dir, e.name)); + break; + } + } + } + } + out.sort(); + return out; +} + +function uniq(arr) { + const out = []; + for (const x of arr) { + if (!x) continue; + if (!out.includes(x)) out.push(x); + } + return out; +} + +function parseArgs(argv) { + const out = { dir: process.cwd() }; + for (let i = 2; i < argv.length; i++) { + const a = argv[i]; + if (a === "--dir" || a === "--pluginDir") { + out.dir = path.resolve(argv[++i] || "."); + continue; + } + } + return out; +} + +const args = parseArgs(process.argv); +const pluginDir = args.dir; +const pkgPath = path.join(pluginDir, "package.json"); + +if (!exists(pkgPath)) { + console.error(`[wiring] ERROR: missing package.json in ${pluginDir}`); + process.exit(2); +} + +let pkg; +try { + pkg = JSON.parse(readText(pkgPath)); +} catch (e) { + console.error(`[wiring] ERROR: invalid package.json (${pkgPath}): ${e?.message || e}`); + process.exit(2); +} + +const cap = typeof pkg.capacitor === "object" && pkg.capacitor ? pkg.capacitor : {}; +const supportsAndroid = typeof cap.android === "object" && cap.android; +const supportsIos = typeof cap.ios === "object" && cap.ios; + +// Not a Capacitor plugin package (e.g. meta/workspace package). +// We only enforce wiring rules for actual plugin packages declaring a `capacitor` config. +if (!supportsAndroid && !supportsIos) { + process.exit(0); +} + +// ---------------- JS (registerPlugin) ---------------- +const jsSrcDir = path.join(pluginDir, "src"); +let jsName = ""; +if (exists(jsSrcDir)) { + const jsFiles = walkFiles(jsSrcDir, [".ts", ".js"]); + const reRegister = /registerPlugin(?:<[^>]*>)?\(\s*['"]([^'"]+)['"]/; + for (const f of jsFiles) { + const m = reRegister.exec(readText(f)); + if (m) { + jsName = m[1]; + break; + } + } +} + +// ---------------- Android (@CapacitorPlugin) ---------------- +let androidNames = []; +if (supportsAndroid) { + const androidMain = path.join(pluginDir, "android", "src", "main"); + const files = walkFiles(androidMain, [".java", ".kt"]); + const foundAnnotations = []; + for (const f of files) { + const txt = readText(f); + if (!txt.includes("@CapacitorPlugin")) continue; + foundAnnotations.push(f); + const m = + /@CapacitorPlugin\(\s*name\s*=\s*"([^"]+)"/.exec(txt) || + /@CapacitorPlugin\(\s*name\s*=\s*([A-Za-z0-9_]+)\b/.exec(txt); + if (m) androidNames.push(m[1]); + } + androidNames = uniq(androidNames); + + // Enforce explicit name attribute to prevent silent class-name drift. + if (foundAnnotations.length && !androidNames.length) { + console.error( + `[wiring] ERROR: Android has @CapacitorPlugin but none specify name = \"...\". Add an explicit name to the plugin class.` + ); + process.exit(1); + } +} + +// ---------------- iOS (jsName) ---------------- +let iosJsNames = []; +if (supportsIos) { + const iosDir = path.join(pluginDir, "ios"); + const scanRoot = exists(path.join(iosDir, "Sources")) ? path.join(iosDir, "Sources") : iosDir; + const swiftFiles = walkFiles(scanRoot, [".swift"]); + const reJsName = /\bjsName\s*=\s*"([^"]+)"/g; + for (const f of swiftFiles) { + const txt = readText(f); + if (!txt.includes("jsName")) continue; + let m; + while ((m = reJsName.exec(txt))) iosJsNames.push(m[1]); + } + iosJsNames = uniq(iosJsNames); +} + +// ---------------- Podspec/SPM ---------------- +function parsePodspecName(podspecPath) { + const txt = readText(podspecPath); + const m = /\bs\.name\s*=\s*'([^']+)'/.exec(txt); + return m ? m[1] : ""; +} + +function parseSpmNames(packageSwiftPath) { + const txt = readText(packageSwiftPath); + const pkg = /Package\(\s*name\s*:\s*"([^"]+)"/.exec(txt)?.[1] || ""; + const libs = []; + const reLib = /\.library\(\s*name\s*:\s*"([^"]+)"/g; + let m; + while ((m = reLib.exec(txt))) libs.push(m[1]); + return { pkgName: pkg, libNames: uniq(libs) }; +} + +// ---------------- Validate ---------------- +const errors = []; + +if (!jsName) { + errors.push("JS: no registerPlugin('...') found under src/"); +} + +if (supportsAndroid) { + if (!androidNames.length) errors.push("Android: missing @CapacitorPlugin(name = \"...\")"); + if (jsName && androidNames.length && androidNames.some((n) => n !== jsName)) { + errors.push(`Android: @CapacitorPlugin(name)=${JSON.stringify(androidNames)} != JS registerPlugin=${jsName}`); + } +} + +if (supportsIos) { + if (!iosJsNames.length) errors.push('iOS: missing jsName = "..." in Swift sources'); + if (jsName && iosJsNames.length && iosJsNames.some((n) => n !== jsName)) { + errors.push(`iOS: jsName=${JSON.stringify(iosJsNames)} != JS registerPlugin=${jsName}`); + } + + const podspecs = fs + .readdirSync(pluginDir, { withFileTypes: true }) + .filter((e) => e.isFile() && e.name.endsWith(".podspec")) + .map((e) => path.join(pluginDir, e.name)) + .sort(); + if (!podspecs.length) errors.push("iOS: missing *.podspec at plugin root"); + if (podspecs.length > 1) errors.push(`iOS: multiple podspecs at plugin root: ${podspecs.map((p) => path.basename(p))}`); + + const pkgSwift = path.join(pluginDir, "Package.swift"); + if (!exists(pkgSwift)) { + errors.push("iOS: missing Package.swift at plugin root"); + } else if (podspecs.length) { + const podName = parsePodspecName(podspecs[0]); + const { pkgName, libNames } = parseSpmNames(pkgSwift); + if (!podName) errors.push("Podspec: missing s.name = '...'"); + if (!pkgName) errors.push('SPM: missing Package(name: "...")'); + if (podName && pkgName && podName !== pkgName) { + errors.push(`Podspec: s.name=${podName} != Package(name)=${pkgName}`); + } + if (pkgName && libNames.length && !libNames.includes(pkgName)) { + errors.push(`SPM: Package(name)=${pkgName} not present in .library(name) list ${JSON.stringify(libNames)}`); + } + } +} + +if (errors.length) { + const relDir = path.relative(process.cwd(), pluginDir) || "."; + console.error(`[wiring] FAIL in ${relDir}`); + for (const e of errors) console.error(`- ${e}`); + process.exit(1); +} + +process.exit(0); diff --git a/scripts/generate-ai-changelog.mjs b/scripts/generate-ai-changelog.mjs new file mode 100755 index 0000000..fad185e --- /dev/null +++ b/scripts/generate-ai-changelog.mjs @@ -0,0 +1,135 @@ +#!/usr/bin/env node +/** + * Generate a release changelog with Cloudflare Workers AI in CI. + * Invoked from build.yml on tag releases via `bun run changelog:ai`. + */ + +import { execFileSync } from 'node:child_process'; +import { appendFileSync } from 'node:fs'; + +const DEFAULT_MODEL = '@cf/moonshotai/kimi-k2.7-code'; + +function parseArgs(argv) { + const args = { fromTag: process.env.FROM_TAG, toTag: process.env.TO_TAG }; + for (let i = 0; i < argv.length; i++) { + if (argv[i] === '--from-tag') args.fromTag = argv[++i]; + if (argv[i] === '--to-tag') args.toTag = argv[++i]; + if (argv[i] === '--model') args.model = argv[++i]; + } + return args; +} + +function git(args) { + return execFileSync('/usr/bin/git', args, { encoding: 'utf8' }).trim(); +} + +function resolveTags({ fromTag, toTag }) { + const currentTag = + toTag ?? + (process.env.GITHUB_REF?.startsWith('refs/tags/') ? process.env.GITHUB_REF.replace('refs/tags/', '') : null); + + if (!currentTag) { + throw new Error('Missing target tag. Set GITHUB_REF to refs/tags/ or pass --to-tag.'); + } + + const previousTag = fromTag ?? git(['describe', '--tags', '--abbrev=0', `${currentTag}^`]); + return { previousTag, currentTag }; +} + +function buildPrompt(previousTag, currentTag) { + const commits = git(['log', `${previousTag}..${currentTag}`, '--pretty=format:%s']); + const diffLines = git(['diff', '--stat', `${previousTag}..${currentTag}`]).split('\n'); + const diffStat = diffLines.at(-1)?.trim() ?? ''; + + return `You are a technical writer creating a changelog for a software project. + +There are changes in the git repository between two points: +- From tag: ${previousTag} +- To tag: ${currentTag} +- Commits: +${commits || '(none)'} +- Diff summary: ${diffStat || '(no file changes)'} + +## Instructions: +1. **Categorize changes** using standard changelog categories: + - **Added**: New features + - **Changed**: Changes in existing functionality + - **Deprecated**: Soon-to-be removed features + - **Removed**: Removed features + - **Fixed**: Bug fixes + - **Security**: Security improvements + +2. **Write clear, user-focused descriptions** that explain: + - What changed from a user's perspective + - Why it matters + - Any breaking changes or migration notes + +3. **Use consistent formatting**: + - Each item should be a concise bullet point + - Start with an action verb when possible + - Group related changes together + +4. **Focus on semantic meaning** rather than technical implementation details + +Output ONLY the changelog content in markdown format. Do NOT include any explanatory text, metadata, introductory phrases like "Based on the git analysis" or "Here's the changelog", or concluding remarks. Start IMMEDIATELY with the changelog categories and items (e.g., "## Added"). Do not include version numbers or dates. Do not preface your response with any text whatsoever.`; +} + +async function generateChangelog(prompt, model) { + const accountId = process.env.CLOUDFLARE_ACCOUNT_ID; + const apiToken = process.env.CLOUDFLARE_API_TOKEN; + + if (!accountId || !apiToken) { + throw new Error('CLOUDFLARE_ACCOUNT_ID and CLOUDFLARE_API_TOKEN are required.'); + } + + const url = `https://api.cloudflare.com/client/v4/accounts/${accountId}/ai/run/${model}`; + const response = await fetch(url, { + method: 'POST', + headers: { + Authorization: `Bearer ${apiToken}`, + 'Content-Type': 'application/json', + }, + body: JSON.stringify({ + messages: [{ role: 'user', content: prompt }], + }), + }); + + const payload = await response.json(); + if (!response.ok || !payload.success) { + throw new Error(`Cloudflare AI request failed with status ${response.status}`); + } + + const content = payload.result?.choices?.[0]?.message?.content ?? payload.result?.response; + if (!content || typeof content !== 'string') { + throw new Error('Cloudflare AI returned an empty changelog response'); + } + + return content.trim(); +} + +function writeGithubOutput({ result, fromTag, toTag }) { + const outputFile = process.env.GITHUB_OUTPUT; + if (!outputFile) return; + + const delimiter = `changelog_${Date.now()}`; + appendFileSync(outputFile, `result<<${delimiter}\n${result}\n${delimiter}\n`); + appendFileSync(outputFile, `from_tag=${fromTag}\n`); + appendFileSync(outputFile, `to_tag=${toTag}\n`); +} + +const args = parseArgs(process.argv.slice(2)); +const model = args.model ?? process.env.CLOUDFLARE_AI_MODEL ?? DEFAULT_MODEL; +const { previousTag, currentTag } = resolveTags(args); +const prompt = buildPrompt(previousTag, currentTag); + +console.error(`Generating changelog with ${model}`); +console.error(`Range: ${previousTag}..${currentTag}`); + +try { + const result = await generateChangelog(prompt, model); + writeGithubOutput({ result, fromTag: previousTag, toTag: currentTag }); +} catch (error) { + const message = error instanceof Error ? error.message : 'Unknown error'; + console.error(`Changelog generation failed: ${message}`); + process.exit(1); +} diff --git a/scripts/tsconfig.json b/scripts/tsconfig.json new file mode 100644 index 0000000..a622fa5 --- /dev/null +++ b/scripts/tsconfig.json @@ -0,0 +1,19 @@ +{ + "compilerOptions": { + "target": "ES2020", + "module": "commonjs", + "lib": ["ES2020"], + "outDir": ".", + "rootDir": ".", + "strict": true, + "esModuleInterop": true, + "skipLibCheck": true, + "forceConsistentCasingInFileNames": true, + "resolveJsonModule": true, + "moduleResolution": "node", + "declaration": false, + "sourceMap": false + }, + "include": ["configure-dependencies.ts"], + "exclude": ["node_modules"] +} diff --git a/src/definitions.ts b/src/definitions.ts new file mode 100644 index 0000000..ff26582 --- /dev/null +++ b/src/definitions.ts @@ -0,0 +1,534 @@ +import { CapacitorNativeMap } from './implementation'; + +/** + * An interface representing the viewports latitude and longitude bounds. + */ +export interface LatLngBoundsInterface { + southwest: LatLng; + center: LatLng; + northeast: LatLng; +} + +export class LatLngBounds { + southwest: LatLng; + center: LatLng; + northeast: LatLng; + + constructor(bounds: LatLngBoundsInterface) { + this.southwest = bounds.southwest; + this.center = bounds.center; + this.northeast = bounds.northeast; + } + + async contains(point: LatLng): Promise { + const result = await CapacitorNativeMap.mapBoundsContains({ + bounds: this, + point, + }); + return result['contains']; + } + + async extend(point: LatLng): Promise { + const result = await CapacitorNativeMap.mapBoundsExtend({ + bounds: this, + point, + }); + this.southwest = result['bounds']['southwest']; + this.center = result['bounds']['center']; + this.northeast = result['bounds']['northeast']; + return this; + } +} + +/** + * An interface representing a pair of latitude and longitude coordinates. + */ +export interface LatLng { + /** + * Coordinate latitude, in degrees. This value is in the range [-90, 90]. + */ + lat: number; + + /** + * Coordinate longitude, in degrees. This value is in the range [-180, 180]. + */ + lng: number; +} + +export interface Size { + width: number; + height: number; +} + +export interface Point { + x: number; + y: number; +} + +/** + * For web, all the javascript Polygon options are available as + * Polygon extends google.maps.PolygonOptions. + * For iOS and Android only the config options declared on Polygon are available. + */ +export interface Polygon extends google.maps.PolygonOptions { + paths?: google.maps.MVCArray | any[]; + strokeColor?: string; + strokeOpacity?: number; + strokeWeight?: number; + fillColor?: string; + fillOpacity?: number; + geodesic?: boolean; + clickable?: boolean; + /** + * Title, a short description of the overlay. Some overlays, such as markers, will display the title on the map. The title is also the default accessibility text. + * + * Only available on iOS. + */ + title?: string; + tag?: string; +} + +/** + * For web, all the javascript Circle options are available as + * Circle extends google.maps.CircleOptions. + * For iOS and Android only the config options declared on Circle are available. + */ +export interface Circle extends google.maps.CircleOptions { + fillColor?: string; + fillOpacity?: number; + strokeColor?: string; + strokeWeight?: number; + geodesic?: boolean; + clickable?: boolean; + /** + * Title, a short description of the overlay. Some overlays, such as markers, will display the title on the map. The title is also the default accessibility text. + * + * Only available on iOS. + */ + title?: string; + tag?: string; +} + +/** + * For web, all the javascript Polyline options are available as + * Polyline extends google.maps.PolylineOptions. + * For iOS and Android only the config options declared on Polyline are available. + */ +export interface Polyline extends google.maps.PolylineOptions { + strokeColor?: string; + strokeOpacity?: number; + strokeWeight?: number; + geodesic?: boolean; + clickable?: boolean; + tag?: string; + /** + * Used to specify the color of one or more segments of a polyline. The styleSpans property is an array of StyleSpan objects. + * Setting the spans property is the preferred way to change the color of a polyline. + * + * Only on iOS and Android. + */ + styleSpans?: StyleSpan[]; +} + +/** + * Describes the style for some region of a polyline. + */ +export interface StyleSpan { + /** + * The stroke color. All CSS3 colors are supported except for extended named colors. + */ + color: string; + /** + * The length of this span in number of segments. + */ + segments?: number; +} + +/** + * For web, all the javascript Google Maps options are available as + * NativeMapConfig extends google.maps.MapOptions. + * For iOS and Android only the config options declared on NativeMapConfig are available. + */ +export interface NativeMapConfig extends google.maps.MapOptions { + /** + * Override width for native map. + */ + width?: number; + /** + * Override height for native map. + */ + height?: number; + /** + * Override absolute x coordinate position for native map. + */ + x?: number; + /** + * Override absolute y coordinate position for native map. + */ + y?: number; + /** + * Default location on the Earth towards which the camera points. + */ + center: LatLng; + /** + * Sets the zoom of the map. + */ + zoom: number; + /** + * Enables image-based lite mode on Android. + * + * @default false + */ + androidLiteMode?: boolean; + /** + * Override pixel ratio for native map. + */ + devicePixelRatio?: number; + /** + * Styles to apply to each of the default map types. Note that for + * satellite, hybrid and terrain modes, + * these styles will only apply to labels and geometry. + * + * @since 4.3.0 + */ + styles?: google.maps.MapTypeStyle[] | null; + /** + * A map id associated with a specific map style or feature. + * + * [Use Map IDs](https://developers.google.com/maps/documentation/get-map-id) + * + * Only for Web. + * + * @since 5.4.0 + */ + mapId?: string; + /** + * A map id associated with a specific map style or feature. + * + * [Use Map IDs](https://developers.google.com/maps/documentation/get-map-id) + * + * Only for Android. + * + * @since 5.4.0 + */ + androidMapId?: string; + /** + * A map id associated with a specific map style or feature. + * + * [Use Map IDs](https://developers.google.com/maps/documentation/get-map-id) + * + * Only for iOS. + * + * @since 5.4.0 + */ + iOSMapId?: string; + /** + * The maximum zoom level which will be displayed on the map. If omitted, or + * set to null, the maximum zoom from the current map type is + * used instead. Valid zoom values are numbers from zero up to the supported + *         maximum + * zoom level. + */ + maxZoom?: number | null; + /** + * The minimum zoom level which will be displayed on the map. If omitted, or + * set to null, the minimum zoom from the current map type is + * used instead. Valid zoom values are numbers from zero up to the supported + * maximum + * zoom level. + */ + minZoom?: number | null; + /** + * The initial Map mapTypeId. Defaults to ROADMAP. + */ + mapTypeId?: string | null; + /** + * The heading for aerial imagery in degrees measured clockwise from + * cardinal direction North. Headings are snapped to the nearest available + * angle for which imagery is available. + */ + heading?: number | null; + /** + * Defines a boundary that restricts the area of the map accessible to + * users. When set, a user can only pan and zoom while the camera view stays + * inside the limits of the boundary. + */ + restriction?: google.maps.MapRestriction | null; +} + +/** + * Configuration properties for a Google Map Camera + */ +export interface CameraConfig { + /** + * Location on the Earth towards which the camera points. + */ + coordinate?: LatLng; + /** + * Sets the zoom of the map. + */ + zoom?: number; + /** + * Bearing of the camera, in degrees clockwise from true north. + * + * @default 0 + */ + bearing?: number; + /** + * The angle, in degrees, of the camera from the nadir (directly facing the Earth). + * + * The only allowed values are 0 and 45. + * + * @default 0 + */ + angle?: number; + /** + * Animate the transition to the new Camera properties. + * + * @default false + */ + animate?: boolean; + + /** + * This configuration option is not being used. + */ + animationDuration?: number; +} + +export enum MapType { + /** + * Basic map. + */ + Normal = 'Normal', + /** + * Satellite imagery with roads and labels. + */ + Hybrid = 'Hybrid', + /** + * Satellite imagery with no labels. + */ + Satellite = 'Satellite', + /** + * Topographic data. + */ + Terrain = 'Terrain', + /** + * No base map tiles. + */ + None = 'None', +} + +/** + * Controls for setting padding on the 'visible' region of the view. + */ +export interface MapPadding { + top: number; + left: number; + right: number; + bottom: number; +} + +/** + * A tile overlay is an image placed on top of your map at a specific zoom level. Available on iOS, Android and Web + */ +export interface TileOverlay { + /** + * A string representing the tile url. Should contain `{x}`, `{y}` and `{z}` so they can be replaced with actual values for x, y and zoom. Available on iOS, Android and Web + * + * @type {string} + */ + url: string; + + /** + * The opacity of the tile overlay, between 0 (completely transparent) and 1 inclusive. Available on iOS, Android and Web + * + * @type {number | undefined} + * @default undefined + */ + opacity?: number; + + /** + * Controls whether this tile overlay should be visible. Available only on Android + * + * @type {boolean | undefined} + * @default undefined + */ + visible?: boolean; + + /** + * The zIndex of the tile overlay. Available on iOS and Android + * + * @type {number | undefined} + * @default undefined + */ + zIndex?: number; +} + +/** + * A marker is an icon placed at a particular point on the map's surface. + */ +export interface Marker { + /** + * Marker position + */ + coordinate: LatLng; + /** + * Sets the opacity of the marker, between 0 (completely transparent) and 1 inclusive. + * + * @default 1 + */ + opacity?: number; + /** + * Title, a short description of the overlay. + */ + title?: string; + /** + * Snippet text, shown beneath the title in the info window when selected. + */ + snippet?: string; + /** + * Controls whether this marker should be flat against the Earth's surface or a billboard facing the camera. + * + * @default false + */ + isFlat?: boolean; + /** + * Path to a marker icon to render. It can be relative to the web app public directory, + * or a https url of a remote marker icon. + * + * **SVGs are not supported on native platforms.** + * + * @usage + * ```typescript + * { + * ... + * iconUrl: 'assets/icon/pin.png', + * ... + * } + * ``` + * + * @since 4.2.0 + */ + iconUrl?: string; + /** + * Controls the scaled size of the marker image set in `iconUrl`. + * + * @since 4.2.0 + */ + iconSize?: Size; + + /** + * The position of the image within a sprite, if any. By default, the origin is located at the top left corner of the image . + * + * @since 4.2.0 + */ + iconOrigin?: Point; + + /** + * The position at which to anchor an image in correspondence to the location of the marker on the map. By default, the anchor is located along the center point of the bottom of the image. + * + * @since 4.2.0 + */ + iconAnchor?: Point; + /** + * Customizes the color of the default marker image. Each value must be between 0 and 255. + * + * Only for iOS and Android. + * + * @since 4.2.0 + */ + tintColor?: { + r: number; + g: number; + b: number; + a: number; + }; + + /** + * Controls whether this marker can be dragged interactively + * + * @default false + */ + draggable?: boolean; + + /** + * Specifies the stack order of this marker, relative to other markers on the map. + * A marker with a high z-index is drawn on top of markers with lower z-indexes + * + * @default 0 + */ + zIndex?: number; +} + +/** + * The callback function to be called when map events are emitted. + */ +export type MapListenerCallback = (data: T) => void; + +export interface MapReadyCallbackData { + mapId: string; +} + +export interface MarkerCallbackData { + markerId: string; + latitude: number; + longitude: number; + title: string; + snippet: string; +} + +export interface PolylineCallbackData { + polylineId: string; + tag?: string; +} + +export interface CameraIdleCallbackData { + mapId: string; + bounds: LatLngBounds; + bearing: number; + latitude: number; + longitude: number; + tilt: number; + zoom: number; +} + +export interface CameraMoveStartedCallbackData { + mapId: string; + isGesture: boolean; +} + +export interface ClusterClickCallbackData { + mapId: string; + latitude: number; + longitude: number; + size: number; + items: MarkerCallbackData[]; +} + +export interface MapClickCallbackData { + mapId: string; + latitude: number; + longitude: number; +} + +export interface MarkerClickCallbackData extends MarkerCallbackData { + mapId: string; +} + +export interface PolygonClickCallbackData { + mapId: string; + polygonId: string; + tag?: string; +} + +export interface CircleClickCallbackData { + mapId: string; + circleId: string; + tag?: string; +} + +export interface MyLocationButtonClickCallbackData { + mapId: string; +} diff --git a/src/implementation.ts b/src/implementation.ts new file mode 100644 index 0000000..041bdcb --- /dev/null +++ b/src/implementation.ts @@ -0,0 +1,238 @@ +import type { Plugin } from '@capacitor/core'; +import { registerPlugin } from '@capacitor/core'; + +import type { + CameraConfig, + Circle, + NativeMapConfig, + LatLng, + LatLngBounds, + MapPadding, + MapType, + Marker, + Polygon, + Polyline, + TileOverlay, +} from './definitions'; + +/** + * An interface containing the options used when creating a map. + */ +export interface CreateMapArgs { + /** + * A unique identifier for the map instance. + */ + id: string; + /** + * The Google Maps SDK API Key. + */ + /** + * Google Maps API key. Required on Android and web. Not used on iOS (MapKit). + */ + apiKey?: string; + /** + * The initial configuration settings for the map. + */ + config: NativeMapConfig; + /** + * The DOM element that the Google Map View will be mounted on which determines size and positioning. + */ + element: HTMLElement; + /** + * Destroy and re-create the map instance if a map with the supplied id already exists + * @default false + */ + forceCreate?: boolean; + /** + * The region parameter alters your application to serve different map tiles or bias the application (such as biasing geocoding results towards the region). + * + * Only available for web. + */ + region?: string; + + /** + * The language parameter affects the names of controls, copyright notices, driving directions, and control labels, as well as the responses to service requests. + * + * Only available for web. + */ + language?: string; +} + +export interface DestroyMapArgs { + id: string; +} + +export interface RemoveMarkerArgs { + id: string; + markerId: string; +} + +export interface RemoveMarkersArgs { + id: string; + markerIds: string[]; +} + +export interface AddMarkerArgs { + id: string; + marker: Marker; +} + +export interface AddPolygonsArgs { + id: string; + polygons: Polygon[]; +} + +export interface RemovePolygonsArgs { + id: string; + polygonIds: string[]; +} + +export interface AddCirclesArgs { + id: string; + circles: Circle[]; +} + +export interface RemoveCirclesArgs { + id: string; + circleIds: string[]; +} +export interface AddPolylinesArgs { + id: string; + polylines: Polyline[]; +} + +export interface RemovePolylinesArgs { + id: string; + polylineIds: string[]; +} + +export interface CameraArgs { + id: string; + config: CameraConfig; +} + +export interface MapTypeArgs { + id: string; + mapType: MapType; +} + +export interface IndoorMapArgs { + id: string; + enabled: boolean; +} + +export interface RemoveTileOverlayArgs { + id: string; + tileOverlayId: string; +} + +export interface AddTileOverlayArgs { + id: string; + tileOverlay: TileOverlay; +} + +export interface TrafficLayerArgs { + id: string; + enabled: boolean; +} + +export interface AccElementsArgs { + id: string; + enabled: boolean; +} + +export interface PaddingArgs { + id: string; + padding: MapPadding; +} + +export interface CurrentLocArgs { + id: string; + enabled: boolean; +} +export interface AddMarkersArgs { + id: string; + markers: Marker[]; +} + +export interface MapBoundsArgs { + id: string; + mapBounds: { + x: number; + y: number; + width: number; + height: number; + }; +} + +export interface MapBoundsContainsArgs { + bounds: LatLngBounds; + point: LatLng; +} + +export type MapBoundsExtendArgs = MapBoundsContainsArgs; + +export interface EnableClusteringArgs { + id: string; + minClusterSize?: number; +} + +export interface FitBoundsArgs { + id: string; + bounds: LatLngBounds; + padding?: number; +} + +export interface NativeMapPlugin extends Plugin { + create(options: CreateMapArgs): Promise; + enableTouch(args: { id: string }): Promise; + disableTouch(args: { id: string }): Promise; + addTileOverlay(args: AddTileOverlayArgs): Promise<{ id: string }>; + removeTileOverlay(args: RemoveTileOverlayArgs): Promise; + addMarker(args: AddMarkerArgs): Promise<{ id: string }>; + addMarkers(args: AddMarkersArgs): Promise<{ ids: string[] }>; + removeMarker(args: RemoveMarkerArgs): Promise; + removeMarkers(args: RemoveMarkersArgs): Promise; + addPolygons(args: AddPolygonsArgs): Promise<{ ids: string[] }>; + removePolygons(args: RemovePolygonsArgs): Promise; + addCircles(args: AddCirclesArgs): Promise<{ ids: string[] }>; + removeCircles(args: RemoveCirclesArgs): Promise; + addPolylines(args: AddPolylinesArgs): Promise<{ ids: string[] }>; + removePolylines(args: RemovePolylinesArgs): Promise; + enableClustering(args: EnableClusteringArgs): Promise; + disableClustering(args: { id: string }): Promise; + destroy(args: DestroyMapArgs): Promise; + setCamera(args: CameraArgs): Promise; + getMapType(args: { id: string }): Promise<{ type: string }>; + setMapType(args: MapTypeArgs): Promise; + enableIndoorMaps(args: IndoorMapArgs): Promise; + enableTrafficLayer(args: TrafficLayerArgs): Promise; + enableAccessibilityElements(args: AccElementsArgs): Promise; + enableCurrentLocation(args: CurrentLocArgs): Promise; + setPadding(args: PaddingArgs): Promise; + onScroll(args: MapBoundsArgs): Promise; + onResize(args: MapBoundsArgs): Promise; + onDisplay(args: MapBoundsArgs): Promise; + dispatchMapEvent(args: { id: string; focus: boolean }): Promise; + getMapBounds(args: { id: string }): Promise; + fitBounds(args: FitBoundsArgs): Promise; + mapBoundsContains(args: MapBoundsContainsArgs): Promise<{ contains: boolean }>; + mapBoundsExtend(args: MapBoundsExtendArgs): Promise<{ bounds: LatLngBounds }>; +} + +const CapacitorNativeMap = registerPlugin('NativeMap', { + web: () => import('./web').then((m) => new m.CapacitorNativeMapWeb()), +}); + +CapacitorNativeMap.addListener('isMapInFocus', (data) => { + const x = data.x; + const y = data.y; + + const elem = document.elementFromPoint(x, y) as HTMLElement | null; + const internalId = elem?.dataset?.internalId; + const mapInFocus = internalId === data.mapId; + + CapacitorNativeMap.dispatchMapEvent({ id: data.mapId, focus: mapInFocus }); +}); + +export { CapacitorNativeMap }; diff --git a/src/index.ts b/src/index.ts new file mode 100644 index 0000000..4b669db --- /dev/null +++ b/src/index.ts @@ -0,0 +1,13 @@ +/* eslint-disable @typescript-eslint/no-namespace */ +import { LatLngBounds, MapType, Marker, Polygon, Circle, Polyline, StyleSpan } from './definitions'; +import { NativeMap } from './map'; + +export { NativeMap, LatLngBounds, MapType, Marker, Polygon, Circle, Polyline, StyleSpan }; + +declare global { + export namespace JSX { + export interface IntrinsicElements { + 'capacitor-native-map': any; + } + } +} diff --git a/src/map.ts b/src/map.ts new file mode 100644 index 0000000..0054172 --- /dev/null +++ b/src/map.ts @@ -0,0 +1,1113 @@ +import { Capacitor } from '@capacitor/core'; +import type { PluginListenerHandle } from '@capacitor/core'; + +import type { + CameraConfig, + Marker, + MapPadding, + MapListenerCallback, + MapReadyCallbackData, + CameraIdleCallbackData, + CameraMoveStartedCallbackData, + ClusterClickCallbackData, + MapClickCallbackData, + MarkerClickCallbackData, + MyLocationButtonClickCallbackData, + Polygon, + PolygonClickCallbackData, + Circle, + CircleClickCallbackData, + Polyline, + PolylineCallbackData, + TileOverlay, +} from './definitions'; +import { LatLngBounds, MapType } from './definitions'; +import type { CreateMapArgs } from './implementation'; +import { CapacitorNativeMap } from './implementation'; + +export interface NativeMapInterface { + create(options: CreateMapArgs, callback?: MapListenerCallback): Promise; + enableTouch(): Promise; + disableTouch(): Promise; + enableClustering( + /** + * The minimum number of markers that can be clustered together. The default is 4 markers. + */ + minClusterSize?: number, + ): Promise; + disableClustering(): Promise; + addTileOverlay(tileOverlay: TileOverlay): Promise<{ id: string }>; + removeTileOverlay(id: string): Promise; + addMarker(marker: Marker): Promise; + addMarkers(markers: Marker[]): Promise; + removeMarker(id: string): Promise; + removeMarkers(ids: string[]): Promise; + addPolygons(polygons: Polygon[]): Promise; + removePolygons(ids: string[]): Promise; + addCircles(circles: Circle[]): Promise; + removeCircles(ids: string[]): Promise; + addPolylines(polylines: Polyline[]): Promise; + removePolylines(ids: string[]): Promise; + destroy(): Promise; + setCamera(config: CameraConfig): Promise; + /** + * Get current map type + */ + getMapType(): Promise; + setMapType(mapType: MapType): Promise; + enableIndoorMaps(enabled: boolean): Promise; + enableTrafficLayer(enabled: boolean): Promise; + enableAccessibilityElements(enabled: boolean): Promise; + enableCurrentLocation(enabled: boolean): Promise; + setPadding(padding: MapPadding): Promise; + /** + * Get the map's current viewport latitude and longitude bounds. + * + * @returns {LatLngBounds} + */ + getMapBounds(): Promise; + /** + * Sets the map viewport to contain the given bounds. + * @param bounds The bounds to fit in the viewport. + * @param padding Optional padding to apply in pixels. The bounds will be fit in the part of the map that remains after padding is removed. + */ + fitBounds(bounds: LatLngBounds, padding?: number): Promise; + setOnBoundsChangedListener(callback?: MapListenerCallback): Promise; + setOnCameraIdleListener(callback?: MapListenerCallback): Promise; + setOnCameraMoveStartedListener(callback?: MapListenerCallback): Promise; + setOnClusterClickListener(callback?: MapListenerCallback): Promise; + setOnClusterInfoWindowClickListener(callback?: MapListenerCallback): Promise; + setOnInfoWindowClickListener(callback?: MapListenerCallback): Promise; + setOnMapClickListener(callback?: MapListenerCallback): Promise; + setOnMarkerClickListener(callback?: MapListenerCallback): Promise; + setOnPolygonClickListener(callback?: MapListenerCallback): Promise; + setOnCircleClickListener(callback?: MapListenerCallback): Promise; + setOnPolylineClickListener(callback?: MapListenerCallback): Promise; + setOnMarkerDragStartListener(callback?: MapListenerCallback): Promise; + setOnMarkerDragListener(callback?: MapListenerCallback): Promise; + setOnMarkerDragEndListener(callback?: MapListenerCallback): Promise; + setOnMyLocationButtonClickListener(callback?: MapListenerCallback): Promise; + setOnMyLocationClickListener(callback?: MapListenerCallback): Promise; +} + +class MapCustomElement extends HTMLElement { + constructor() { + super(); + } + + connectedCallback() { + this.innerHTML = ''; + + if (Capacitor.getPlatform() == 'ios') { + this.style.overflow = 'scroll'; + (this.style as any)['-webkit-overflow-scrolling'] = 'touch'; + + const overflowDiv = document.createElement('div'); + overflowDiv.style.height = '200%'; + + this.appendChild(overflowDiv); + } + } +} + +customElements.define('capacitor-native-map', MapCustomElement); + +export class NativeMap { + private id: string; + private element: HTMLElement | null = null; + private resizeObserver: ResizeObserver | null = null; + + private onBoundsChangedListener?: PluginListenerHandle; + private onCameraIdleListener?: PluginListenerHandle; + private onCameraMoveStartedListener?: PluginListenerHandle; + private onClusterClickListener?: PluginListenerHandle; + private onClusterInfoWindowClickListener?: PluginListenerHandle; + private onInfoWindowClickListener?: PluginListenerHandle; + private onMapClickListener?: PluginListenerHandle; + private onPolylineClickListener?: PluginListenerHandle; + private onMarkerClickListener?: PluginListenerHandle; + private onPolygonClickListener?: PluginListenerHandle; + private onCircleClickListener?: PluginListenerHandle; + private onMarkerDragStartListener?: PluginListenerHandle; + private onMarkerDragListener?: PluginListenerHandle; + private onMarkerDragEndListener?: PluginListenerHandle; + private onMyLocationButtonClickListener?: PluginListenerHandle; + private onMyLocationClickListener?: PluginListenerHandle; + + private constructor(id: string) { + this.id = id; + } + + /** + * Creates a new instance of a Google Map + * @param options + * @param callback + * @returns NativeMap + */ + public static async create( + options: CreateMapArgs, + callback?: MapListenerCallback, + ): Promise { + const newMap = new NativeMap(options.id); + + if (!options.element) { + throw new Error('container element is required'); + } + + if (options.config.androidLiteMode === undefined) { + options.config.androidLiteMode = false; + } + + newMap.element = options.element; + newMap.element.dataset.internalId = options.id; + + const elementBounds = await NativeMap.getElementBounds(options.element); + options.config.width = elementBounds.width; + options.config.height = elementBounds.height; + options.config.x = elementBounds.x; + options.config.y = elementBounds.y; + options.config.devicePixelRatio = window.devicePixelRatio; + + if (Capacitor.getPlatform() == 'android') { + newMap.initScrolling(); + } + + if (Capacitor.isNativePlatform()) { + (options.element as any) = {}; + + const getMapBounds = () => { + const mapRect = newMap.element?.getBoundingClientRect() ?? ({} as DOMRect); + return { + x: mapRect.x, + y: mapRect.y, + width: mapRect.width, + height: mapRect.height, + }; + }; + + const onDisplay = () => { + CapacitorNativeMap.onDisplay({ + id: newMap.id, + mapBounds: getMapBounds(), + }); + }; + + const onResize = () => { + CapacitorNativeMap.onResize({ + id: newMap.id, + mapBounds: getMapBounds(), + }); + }; + + const ionicPage = newMap.element.closest('.ion-page'); + if (Capacitor.getPlatform() === 'ios' && ionicPage) { + ionicPage.addEventListener('ionViewWillEnter', () => { + setTimeout(() => { + onDisplay(); + }, 100); + }); + ionicPage.addEventListener('ionViewDidEnter', () => { + setTimeout(() => { + onDisplay(); + }, 100); + }); + } + + const lastState = { + width: elementBounds.width, + height: elementBounds.height, + isHidden: false, + }; + newMap.resizeObserver = new ResizeObserver(() => { + if (newMap.element != null) { + const mapRect = newMap.element.getBoundingClientRect(); + + const isHidden = mapRect.width === 0 && mapRect.height === 0; + if (!isHidden) { + if (lastState.isHidden) { + if (Capacitor.getPlatform() === 'ios' && !ionicPage) { + onDisplay(); + } + } else if (lastState.width !== mapRect.width || lastState.height !== mapRect.height) { + onResize(); + } + } + + lastState.width = mapRect.width; + lastState.height = mapRect.height; + lastState.isHidden = isHidden; + } + }); + newMap.resizeObserver.observe(newMap.element); + } + + // small delay to allow for iOS WKWebView to setup corresponding element sub-scroll views ??? + await new Promise((resolve, reject) => { + setTimeout(async () => { + try { + await CapacitorNativeMap.create(options); + resolve(undefined); + } catch (err) { + reject(err); + } + }, 200); + }); + + if (callback) { + const onMapReadyListener = await CapacitorNativeMap.addListener('onMapReady', (data: MapReadyCallbackData) => { + if (data.mapId == newMap.id) { + callback(data); + onMapReadyListener.remove(); + } + }); + } + + return newMap; + } + + private static async getElementBounds(element: HTMLElement): Promise { + return new Promise((resolve) => { + let elementBounds = element.getBoundingClientRect(); + if (elementBounds.width == 0) { + let retries = 0; + const boundsInterval = setInterval(function () { + if (elementBounds.width == 0 && retries < 30) { + elementBounds = element.getBoundingClientRect(); + retries++; + } else { + if (retries == 30) { + console.warn('Map size could not be determined'); + } + clearInterval(boundsInterval); + resolve(elementBounds); + } + }, 100); + } else { + resolve(elementBounds); + } + }); + } + + /** + * Enable touch events on native map + * + * @returns void + */ + async enableTouch(): Promise { + return CapacitorNativeMap.enableTouch({ + id: this.id, + }); + } + + /** + * Disable touch events on native map + * + * @returns void + */ + async disableTouch(): Promise { + return CapacitorNativeMap.disableTouch({ + id: this.id, + }); + } + + /** + * Enable marker clustering + * + * @param minClusterSize - The minimum number of markers that can be clustered together. + * @defaultValue 4 + * + * @returns void + */ + async enableClustering(minClusterSize?: number): Promise { + return CapacitorNativeMap.enableClustering({ + id: this.id, + minClusterSize, + }); + } + + /** + * Disable marker clustering + * + * @returns void + */ + async disableClustering(): Promise { + return CapacitorNativeMap.disableClustering({ + id: this.id, + }); + } + + /** + * Adds a tile overlay to the map + * + * @param tileOverlay + * @returns created tile overlay id + */ + async addTileOverlay(tileOverlay: TileOverlay): Promise { + const res = await CapacitorNativeMap.addTileOverlay({ + id: this.id, + tileOverlay, + }); + + return res.id; + } + + /** + * Removes a tile overlay from the map + * + * @param id of the tile overlay to remove from the map + * @returns void + */ + async removeTileOverlay(id: string): Promise { + return CapacitorNativeMap.removeTileOverlay({ + id: this.id, + tileOverlayId: id, + }); + } + + /** + * Adds a marker to the map + * + * @param marker + * @returns created marker id + */ + async addMarker(marker: Marker): Promise { + const res = await CapacitorNativeMap.addMarker({ + id: this.id, + marker, + }); + + return res.id; + } + + /** + * Adds multiple markers to the map + * + * @param markers + * @returns array of created marker IDs + */ + async addMarkers(markers: Marker[]): Promise { + const res = await CapacitorNativeMap.addMarkers({ + id: this.id, + markers, + }); + + return res.ids; + } + + /** + * Remove marker from the map + * + * @param id id of the marker to remove from the map + * @returns + */ + async removeMarker(id: string): Promise { + return CapacitorNativeMap.removeMarker({ + id: this.id, + markerId: id, + }); + } + + /** + * Remove markers from the map + * + * @param ids array of ids to remove from the map + * @returns + */ + async removeMarkers(ids: string[]): Promise { + return CapacitorNativeMap.removeMarkers({ + id: this.id, + markerIds: ids, + }); + } + + async addPolygons(polygons: Polygon[]): Promise { + const res = await CapacitorNativeMap.addPolygons({ + id: this.id, + polygons, + }); + + return res.ids; + } + + async addPolylines(polylines: Polyline[]): Promise { + const res = await CapacitorNativeMap.addPolylines({ + id: this.id, + polylines, + }); + + return res.ids; + } + + async removePolygons(ids: string[]): Promise { + return CapacitorNativeMap.removePolygons({ + id: this.id, + polygonIds: ids, + }); + } + + async addCircles(circles: Circle[]): Promise { + const res = await CapacitorNativeMap.addCircles({ + id: this.id, + circles, + }); + + return res.ids; + } + + async removeCircles(ids: string[]): Promise { + return CapacitorNativeMap.removeCircles({ + id: this.id, + circleIds: ids, + }); + } + + async removePolylines(ids: string[]): Promise { + return CapacitorNativeMap.removePolylines({ + id: this.id, + polylineIds: ids, + }); + } + + /** + * Destroy the current instance of the map + */ + async destroy(): Promise { + if (Capacitor.getPlatform() == 'android') { + this.disableScrolling(); + } + + if (Capacitor.isNativePlatform()) { + this.resizeObserver?.disconnect(); + } + + this.removeAllMapListeners(); + + return CapacitorNativeMap.destroy({ + id: this.id, + }); + } + + /** + * Update the map camera configuration + * + * @param config + * @returns + */ + async setCamera(config: CameraConfig): Promise { + return CapacitorNativeMap.setCamera({ + id: this.id, + config, + }); + } + + async getMapType(): Promise { + const res = await CapacitorNativeMap.getMapType({ id: this.id }); + const raw = (res as { type?: string; mapType?: string }).type ?? (res as { mapType?: string }).mapType ?? 'Normal'; + if (raw in MapType) { + return MapType[raw as keyof typeof MapType]; + } + const capitalized = `${raw.charAt(0).toUpperCase()}${raw.slice(1)}`; + if (capitalized in MapType) { + return MapType[capitalized as keyof typeof MapType]; + } + if (raw === 'standard' || raw === 'roadmap') { + return MapType.Normal; + } + return MapType.Normal; + } + + /** + * Sets the type of map tiles that should be displayed. + * + * @param mapType + * @returns + */ + async setMapType(mapType: MapType): Promise { + return CapacitorNativeMap.setMapType({ + id: this.id, + mapType, + }); + } + + /** + * Sets whether indoor maps are shown, where available. + * + * @param enabled + * @returns + */ + async enableIndoorMaps(enabled: boolean): Promise { + return CapacitorNativeMap.enableIndoorMaps({ + id: this.id, + enabled, + }); + } + + /** + * Controls whether the map is drawing traffic data, if available. + * + * @param enabled + * @returns + */ + async enableTrafficLayer(enabled: boolean): Promise { + return CapacitorNativeMap.enableTrafficLayer({ + id: this.id, + enabled, + }); + } + + /** + * Show accessibility elements for overlay objects, such as Marker and Polyline. + * + * Only available on iOS. + * + * @param enabled + * @returns + */ + async enableAccessibilityElements(enabled: boolean): Promise { + return CapacitorNativeMap.enableAccessibilityElements({ + id: this.id, + enabled, + }); + } + + /** + * Set whether the My Location dot and accuracy circle is enabled. + * + * @param enabled + * @returns + */ + async enableCurrentLocation(enabled: boolean): Promise { + return CapacitorNativeMap.enableCurrentLocation({ + id: this.id, + enabled, + }); + } + + /** + * Set padding on the 'visible' region of the view. + * + * @param padding + * @returns + */ + async setPadding(padding: MapPadding): Promise { + return CapacitorNativeMap.setPadding({ + id: this.id, + padding, + }); + } + + /** + * Get the map's current viewport latitude and longitude bounds. + * + * @returns {LatLngBounds} + */ + async getMapBounds(): Promise { + return new LatLngBounds( + await CapacitorNativeMap.getMapBounds({ + id: this.id, + }), + ); + } + + async fitBounds(bounds: LatLngBounds, padding?: number): Promise { + return CapacitorNativeMap.fitBounds({ + id: this.id, + bounds, + padding, + }); + } + + initScrolling(): void { + const ionContents = document.getElementsByTagName('ion-content'); + + Array.from(ionContents).forEach((ionContent) => { + (ionContent as any).scrollEvents = true; + }); + + window.addEventListener('ionScroll', this.handleScrollEvent); + window.addEventListener('scroll', this.handleScrollEvent); + window.addEventListener('resize', this.handleScrollEvent); + if (screen.orientation) { + screen.orientation.addEventListener('change', () => { + setTimeout(this.updateMapBounds, 500); + }); + } else { + window.addEventListener('orientationchange', () => { + setTimeout(this.updateMapBounds, 500); + }); + } + } + + disableScrolling(): void { + window.removeEventListener('ionScroll', this.handleScrollEvent); + window.removeEventListener('scroll', this.handleScrollEvent); + window.removeEventListener('resize', this.handleScrollEvent); + if (screen.orientation) { + screen.orientation.removeEventListener('change', () => { + setTimeout(this.updateMapBounds, 1000); + }); + } else { + window.removeEventListener('orientationchange', () => { + setTimeout(this.updateMapBounds, 1000); + }); + } + } + + handleScrollEvent = (): void => this.updateMapBounds(); + + private updateMapBounds(): void { + if (this.element) { + const mapRect = this.element.getBoundingClientRect(); + + CapacitorNativeMap.onScroll({ + id: this.id, + mapBounds: { + x: mapRect.x, + y: mapRect.y, + width: mapRect.width, + height: mapRect.height, + }, + }); + } + } + + /* + private findContainerElement(): HTMLElement | null { + if (!this.element) { + return null; + } + + let parentElement = this.element.parentElement; + while (parentElement !== null) { + if (window.getComputedStyle(parentElement).overflowY !== 'hidden') { + return parentElement; + } + + parentElement = parentElement.parentElement; + } + + return null; + } + */ + + /** + * Set the event listener on the map for 'onCameraIdle' events. + * + * @param callback + * @returns + */ + async setOnCameraIdleListener(callback?: MapListenerCallback): Promise { + if (this.onCameraIdleListener) { + this.onCameraIdleListener.remove(); + } + + if (callback) { + this.onCameraIdleListener = await CapacitorNativeMap.addListener('onCameraIdle', this.generateCallback(callback)); + } else { + this.onCameraIdleListener = undefined; + } + } + + /** + * Set the event listener on the map for 'onBoundsChanged' events. + * + * @param callback + * @returns + */ + async setOnBoundsChangedListener(callback?: MapListenerCallback): Promise { + if (this.onBoundsChangedListener) { + this.onBoundsChangedListener.remove(); + } + + if (callback) { + this.onBoundsChangedListener = await CapacitorNativeMap.addListener( + 'onBoundsChanged', + this.generateCallback(callback), + ); + } else { + this.onBoundsChangedListener = undefined; + } + } + + /** + * Set the event listener on the map for 'onCameraMoveStarted' events. + * + * @param callback + * @returns + */ + async setOnCameraMoveStartedListener(callback?: MapListenerCallback): Promise { + if (this.onCameraMoveStartedListener) { + this.onCameraMoveStartedListener.remove(); + } + + if (callback) { + this.onCameraMoveStartedListener = await CapacitorNativeMap.addListener( + 'onCameraMoveStarted', + this.generateCallback(callback), + ); + } else { + this.onCameraMoveStartedListener = undefined; + } + } + + /** + * Set the event listener on the map for 'onClusterClick' events. + * + * @param callback + * @returns + */ + async setOnClusterClickListener(callback?: MapListenerCallback): Promise { + if (this.onClusterClickListener) { + this.onClusterClickListener.remove(); + } + + if (callback) { + this.onClusterClickListener = await CapacitorNativeMap.addListener( + 'onClusterClick', + this.generateCallback(callback), + ); + } else { + this.onClusterClickListener = undefined; + } + } + + /** + * Set the event listener on the map for 'onClusterInfoWindowClick' events. + * + * @param callback + * @returns + */ + async setOnClusterInfoWindowClickListener(callback?: MapListenerCallback): Promise { + if (this.onClusterInfoWindowClickListener) { + this.onClusterInfoWindowClickListener.remove(); + } + + if (callback) { + this.onClusterInfoWindowClickListener = await CapacitorNativeMap.addListener( + 'onClusterInfoWindowClick', + this.generateCallback(callback), + ); + } else { + this.onClusterInfoWindowClickListener = undefined; + } + } + + /** + * Set the event listener on the map for 'onInfoWindowClick' events. + * + * @param callback + * @returns + */ + async setOnInfoWindowClickListener(callback?: MapListenerCallback): Promise { + if (this.onInfoWindowClickListener) { + this.onInfoWindowClickListener.remove(); + } + + if (callback) { + this.onInfoWindowClickListener = await CapacitorNativeMap.addListener( + 'onInfoWindowClick', + this.generateCallback(callback), + ); + } else { + this.onInfoWindowClickListener = undefined; + } + } + + /** + * Set the event listener on the map for 'onMapClick' events. + * + * @param callback + * @returns + */ + async setOnMapClickListener(callback?: MapListenerCallback): Promise { + if (this.onMapClickListener) { + this.onMapClickListener.remove(); + } + + if (callback) { + this.onMapClickListener = await CapacitorNativeMap.addListener('onMapClick', this.generateCallback(callback)); + } else { + this.onMapClickListener = undefined; + } + } + + /** + * Set the event listener on the map for 'onPolygonClick' events. + * + * @param callback + * @returns + */ + async setOnPolygonClickListener(callback?: MapListenerCallback): Promise { + if (this.onPolygonClickListener) { + this.onPolygonClickListener.remove(); + } + + if (callback) { + this.onPolygonClickListener = await CapacitorNativeMap.addListener( + 'onPolygonClick', + this.generateCallback(callback), + ); + } else { + this.onPolygonClickListener = undefined; + } + } + + /** + * Set the event listener on the map for 'onCircleClick' events. + * + * @param callback + * @returns + */ + async setOnCircleClickListener(callback?: MapListenerCallback): Promise { + if (this.onCircleClickListener) [this.onCircleClickListener.remove()]; + + if (callback) { + this.onCircleClickListener = await CapacitorNativeMap.addListener( + 'onCircleClick', + this.generateCallback(callback), + ); + } else { + this.onCircleClickListener = undefined; + } + } + + /** + * Set the event listener on the map for 'onMarkerClick' events. + * + * @param callback + * @returns + */ + async setOnMarkerClickListener(callback?: MapListenerCallback): Promise { + if (this.onMarkerClickListener) { + this.onMarkerClickListener.remove(); + } + + if (callback) { + this.onMarkerClickListener = await CapacitorNativeMap.addListener( + 'onMarkerClick', + this.generateCallback(callback), + ); + } else { + this.onMarkerClickListener = undefined; + } + } + /** + * Set the event listener on the map for 'onPolylineClick' events. + * + * @param callback + * @returns + */ + async setOnPolylineClickListener(callback?: MapListenerCallback): Promise { + if (this.onPolylineClickListener) { + this.onPolylineClickListener.remove(); + } + + if (callback) { + this.onPolylineClickListener = await CapacitorNativeMap.addListener( + 'onPolylineClick', + this.generateCallback(callback), + ); + } else { + this.onPolylineClickListener = undefined; + } + } + + /** + * Set the event listener on the map for 'onMarkerDragStart' events. + * + * @param callback + * @returns + */ + async setOnMarkerDragStartListener(callback?: MapListenerCallback): Promise { + if (this.onMarkerDragStartListener) { + this.onMarkerDragStartListener.remove(); + } + + if (callback) { + this.onMarkerDragStartListener = await CapacitorNativeMap.addListener( + 'onMarkerDragStart', + this.generateCallback(callback), + ); + } else { + this.onMarkerDragStartListener = undefined; + } + } + + /** + * Set the event listener on the map for 'onMarkerDrag' events. + * + * @param callback + * @returns + */ + async setOnMarkerDragListener(callback?: MapListenerCallback): Promise { + if (this.onMarkerDragListener) { + this.onMarkerDragListener.remove(); + } + + if (callback) { + this.onMarkerDragListener = await CapacitorNativeMap.addListener('onMarkerDrag', this.generateCallback(callback)); + } else { + this.onMarkerDragListener = undefined; + } + } + + /** + * Set the event listener on the map for 'onMarkerDragEnd' events. + * + * @param callback + * @returns + */ + async setOnMarkerDragEndListener(callback?: MapListenerCallback): Promise { + if (this.onMarkerDragEndListener) { + this.onMarkerDragEndListener.remove(); + } + + if (callback) { + this.onMarkerDragEndListener = await CapacitorNativeMap.addListener( + 'onMarkerDragEnd', + this.generateCallback(callback), + ); + } else { + this.onMarkerDragEndListener = undefined; + } + } + + /** + * Set the event listener on the map for 'onMyLocationButtonClick' events. + * + * @param callback + * @returns + */ + async setOnMyLocationButtonClickListener( + callback?: MapListenerCallback, + ): Promise { + if (this.onMyLocationButtonClickListener) { + this.onMyLocationButtonClickListener.remove(); + } + + if (callback) { + this.onMyLocationButtonClickListener = await CapacitorNativeMap.addListener( + 'onMyLocationButtonClick', + this.generateCallback(callback), + ); + } else { + this.onMyLocationButtonClickListener = undefined; + } + } + + /** + * Set the event listener on the map for 'onMyLocationClick' events. + * + * @param callback + * @returns + */ + async setOnMyLocationClickListener(callback?: MapListenerCallback): Promise { + if (this.onMyLocationClickListener) { + this.onMyLocationClickListener.remove(); + } + + if (callback) { + this.onMyLocationClickListener = await CapacitorNativeMap.addListener( + 'onMyLocationClick', + this.generateCallback(callback), + ); + } else { + this.onMyLocationClickListener = undefined; + } + } + + /** + * Remove all event listeners on the map. + * + * @param callback + * @returns + */ + async removeAllMapListeners(): Promise { + if (this.onBoundsChangedListener) { + this.onBoundsChangedListener.remove(); + this.onBoundsChangedListener = undefined; + } + if (this.onCameraIdleListener) { + this.onCameraIdleListener.remove(); + this.onCameraIdleListener = undefined; + } + if (this.onCameraMoveStartedListener) { + this.onCameraMoveStartedListener.remove(); + this.onCameraMoveStartedListener = undefined; + } + + if (this.onClusterClickListener) { + this.onClusterClickListener.remove(); + this.onClusterClickListener = undefined; + } + + if (this.onClusterInfoWindowClickListener) { + this.onClusterInfoWindowClickListener.remove(); + this.onClusterInfoWindowClickListener = undefined; + } + + if (this.onInfoWindowClickListener) { + this.onInfoWindowClickListener.remove(); + this.onInfoWindowClickListener = undefined; + } + + if (this.onMapClickListener) { + this.onMapClickListener.remove(); + this.onMapClickListener = undefined; + } + + if (this.onPolylineClickListener) { + this.onPolylineClickListener.remove(); + this.onPolylineClickListener = undefined; + } + + if (this.onMarkerClickListener) { + this.onMarkerClickListener.remove(); + this.onMarkerClickListener = undefined; + } + + if (this.onPolygonClickListener) { + this.onPolygonClickListener.remove(); + this.onPolygonClickListener = undefined; + } + + if (this.onCircleClickListener) { + this.onCircleClickListener.remove(); + this.onCircleClickListener = undefined; + } + + if (this.onMarkerDragStartListener) { + this.onMarkerDragStartListener.remove(); + this.onMarkerDragStartListener = undefined; + } + + if (this.onMarkerDragListener) { + this.onMarkerDragListener.remove(); + this.onMarkerDragListener = undefined; + } + + if (this.onMarkerDragEndListener) { + this.onMarkerDragEndListener.remove(); + this.onMarkerDragEndListener = undefined; + } + + if (this.onMyLocationButtonClickListener) { + this.onMyLocationButtonClickListener.remove(); + this.onMyLocationButtonClickListener = undefined; + } + + if (this.onMyLocationClickListener) { + this.onMyLocationClickListener.remove(); + this.onMyLocationClickListener = undefined; + } + } + + private generateCallback(callback: MapListenerCallback): MapListenerCallback { + const mapId = this.id; + return (data: any) => { + if (data.mapId == mapId) { + callback(data); + } + }; + } +} diff --git a/src/web.ts b/src/web.ts new file mode 100644 index 0000000..02411bd --- /dev/null +++ b/src/web.ts @@ -0,0 +1,726 @@ +import { WebPlugin } from '@capacitor/core'; +import type { Cluster, onClusterClickHandler } from '@googlemaps/markerclusterer'; +import { MarkerClusterer, SuperClusterAlgorithm } from '@googlemaps/markerclusterer'; + +import type { Marker, TileOverlay } from './definitions'; +import { MapType, LatLngBounds } from './definitions'; +import type { + AddTileOverlayArgs, + AddMarkerArgs, + CameraArgs, + AddMarkersArgs, + NativeMapPlugin, + CreateMapArgs, + CurrentLocArgs, + DestroyMapArgs, + MapTypeArgs, + PaddingArgs, + RemoveMarkerArgs, + TrafficLayerArgs, + RemoveMarkersArgs, + MapBoundsContainsArgs, + EnableClusteringArgs, + FitBoundsArgs, + MapBoundsExtendArgs, + AddPolygonsArgs, + RemovePolygonsArgs, + AddCirclesArgs, + RemoveCirclesArgs, + AddPolylinesArgs, + RemovePolylinesArgs, + RemoveTileOverlayArgs, +} from './implementation'; + +export class CapacitorNativeMapWeb extends WebPlugin implements NativeMapPlugin { + private gMapsRef: google.maps.MapsLibrary | undefined = undefined; + private AdvancedMarkerElement: typeof google.maps.marker.AdvancedMarkerElement | undefined = undefined; + private PinElement: typeof google.maps.marker.PinElement | undefined = undefined; + private maps: { + [id: string]: { + element: HTMLElement; + map: google.maps.Map; + markers: { + [id: string]: google.maps.marker.AdvancedMarkerElement; + }; + tileOverlays: { + [id: string]: google.maps.ImageMapType; + }; + polygons: { + [id: string]: google.maps.Polygon; + }; + circles: { + [id: string]: google.maps.Circle; + }; + polylines: { + [id: string]: google.maps.Polyline; + }; + markerClusterer?: MarkerClusterer; + trafficLayer?: google.maps.TrafficLayer; + }; + } = {}; + private currMarkerId = 0; + private currTileOverlayId = 0; + private currPolygonId = 0; + private currCircleId = 0; + private currPolylineId = 0; + private currMapId = 0; + + private onClusterClickHandler: onClusterClickHandler = ( + _: google.maps.MapMouseEvent, + cluster: Cluster, + map: google.maps.Map, + ): void => { + const mapId = this.getIdFromMap(map); + const items: any[] = []; + + if (cluster.markers != undefined && this.AdvancedMarkerElement) { + for (const marker of cluster.markers) { + if (marker instanceof this.AdvancedMarkerElement) { + const markerId = this.getIdFromMarker(mapId, marker); + const position = marker.position as google.maps.LatLngLiteral; + + items.push({ + markerId: markerId, + latitude: position.lat, + longitude: position.lng, + title: marker.title ?? '', + snippet: '', + }); + } + } + } + + this.notifyListeners('onClusterClick', { + mapId: mapId, + latitude: cluster.position.lat, + longitude: cluster.position.lng, + size: cluster.count, + items: items, + }); + }; + + private getIdFromMap(map: google.maps.Map): string { + for (const id in this.maps) { + if (this.maps[id].map == map) { + return id; + } + } + + return ''; + } + + private getIdFromMarker(mapId: string, marker: google.maps.marker.AdvancedMarkerElement): string { + for (const id in this.maps[mapId].markers) { + if (this.maps[mapId].markers[id] == marker) { + return id; + } + } + + return ''; + } + + private async importGoogleLib(apiKey: string, region?: string, language?: string) { + if (this.gMapsRef === undefined) { + const lib = await import('@googlemaps/js-api-loader'); + lib.setOptions({ + key: apiKey ?? '', + language, + region, + }); + + this.gMapsRef = await lib.importLibrary('maps'); + + // Import marker library once + const { AdvancedMarkerElement, PinElement } = (await google.maps.importLibrary( + 'marker', + )) as google.maps.MarkerLibrary; + this.AdvancedMarkerElement = AdvancedMarkerElement; + this.PinElement = PinElement; + + console.log('Loaded google maps API'); + } + } + + async enableTouch(_args: { id: string }): Promise { + this.maps[_args.id].map.setOptions({ gestureHandling: 'auto' }); + } + + async disableTouch(_args: { id: string }): Promise { + this.maps[_args.id].map.setOptions({ gestureHandling: 'none' }); + } + + async setCamera(_args: CameraArgs): Promise { + // Animation not supported yet... + this.maps[_args.id].map.moveCamera({ + center: _args.config.coordinate, + heading: _args.config.bearing, + tilt: _args.config.angle, + zoom: _args.config.zoom, + }); + } + + async getMapType(_args: { id: string }): Promise<{ type: string }> { + let type = this.maps[_args.id].map.getMapTypeId(); + if (type !== undefined) { + if (type === 'roadmap') { + type = MapType.Normal; + } + return { type: `${type.charAt(0).toUpperCase()}${type.slice(1)}` }; + } + throw new Error('Map type is undefined'); + } + + async setMapType(_args: MapTypeArgs): Promise { + let mapType = _args.mapType.toLowerCase(); + if (_args.mapType === MapType.Normal) { + mapType = 'roadmap'; + } + this.maps[_args.id].map.setMapTypeId(mapType); + } + + async enableIndoorMaps(): Promise { + throw new Error('Method not supported on web.'); + } + + async enableTrafficLayer(_args: TrafficLayerArgs): Promise { + const trafficLayer = this.maps[_args.id].trafficLayer ?? new google.maps.TrafficLayer(); + + if (_args.enabled) { + trafficLayer.setMap(this.maps[_args.id].map); + this.maps[_args.id].trafficLayer = trafficLayer; + } else if (this.maps[_args.id].trafficLayer) { + trafficLayer.setMap(null); + this.maps[_args.id].trafficLayer = undefined; + } + } + + async enableAccessibilityElements(): Promise { + throw new Error('Method not supported on web.'); + } + + dispatchMapEvent(): Promise { + throw new Error('Method not supported on web.'); + } + + async enableCurrentLocation(_args: CurrentLocArgs): Promise { + if (_args.enabled) { + if (navigator.geolocation) { + navigator.geolocation.getCurrentPosition( + (position: GeolocationPosition) => { + const pos = { + lat: position.coords.latitude, + lng: position.coords.longitude, + }; + + this.maps[_args.id].map.setCenter(pos); + + this.notifyListeners('onMyLocationButtonClick', {}); + + this.notifyListeners('onMyLocationClick', {}); + }, + () => { + throw new Error('Geolocation not supported on web browser.'); + }, + ); + } else { + throw new Error('Geolocation not supported on web browser.'); + } + } + } + async setPadding(_args: PaddingArgs): Promise { + const bounds = this.maps[_args.id].map.getBounds(); + + if (bounds !== undefined) { + this.maps[_args.id].map.fitBounds(bounds, _args.padding); + } + } + + async getMapBounds(_args: { id: string }): Promise { + const bounds = this.maps[_args.id].map.getBounds(); + + if (!bounds) { + throw new Error('Google Map Bounds could not be found.'); + } + + return new LatLngBounds({ + southwest: { + lat: bounds.getSouthWest().lat(), + lng: bounds.getSouthWest().lng(), + }, + center: { + lat: bounds.getCenter().lat(), + lng: bounds.getCenter().lng(), + }, + northeast: { + lat: bounds.getNorthEast().lat(), + lng: bounds.getNorthEast().lng(), + }, + }); + } + + async fitBounds(_args: FitBoundsArgs): Promise { + const map = this.maps[_args.id].map; + const bounds = this.getLatLngBounds(_args.bounds); + map.fitBounds(bounds, _args.padding); + } + + async addTileOverlay(_args: AddTileOverlayArgs): Promise<{ id: string }> { + const tileOverlay = _args.tileOverlay as TileOverlay; + + const map = this.maps[_args.id].map; + + const id = '' + this.currTileOverlayId; + + const customMapOverlay = new google.maps.ImageMapType({ + getTileUrl: function (coord, zoom) { + return tileOverlay.url.replace('{x}', `${coord.x}`).replace('{y}', `${coord.y}`).replace('{z}', `${zoom}`); + }, + tileSize: new google.maps.Size(256, 256), + opacity: tileOverlay.opacity, + }); + + this.maps[_args.id].tileOverlays[id] = customMapOverlay; + + map.overlayMapTypes.push(customMapOverlay); + + this.currTileOverlayId++; + + return { id: id }; + } + + async removeTileOverlay(_args: RemoveTileOverlayArgs): Promise { + const map = this.maps[_args.id].map; + if (!map) { + return; + } + + for (let i = 0; i < map.overlayMapTypes.getLength(); i++) { + if (map.overlayMapTypes.getAt(i) === this.maps[_args.id].tileOverlays[_args.tileOverlayId]) { + map.overlayMapTypes.removeAt(i); + delete this.maps[_args.id].tileOverlays[_args.tileOverlayId]; + break; + } + } + } + + async addMarkers(_args: AddMarkersArgs): Promise<{ ids: string[] }> { + const markerIds: string[] = []; + const map = this.maps[_args.id]; + + for (const markerArgs of _args.markers) { + const advancedMarker = this.buildMarkerOpts(markerArgs, map.map); + + const id = '' + this.currMarkerId; + + map.markers[id] = advancedMarker; + await this.setMarkerListeners(_args.id, id, advancedMarker); + + markerIds.push(id); + this.currMarkerId++; + } + + return { ids: markerIds }; + } + + async addMarker(_args: AddMarkerArgs): Promise<{ id: string }> { + const advancedMarker = this.buildMarkerOpts(_args.marker, this.maps[_args.id].map); + + const id = '' + this.currMarkerId; + + this.maps[_args.id].markers[id] = advancedMarker; + await this.setMarkerListeners(_args.id, id, advancedMarker); + + this.currMarkerId++; + + return { id: id }; + } + + async removeMarkers(_args: RemoveMarkersArgs): Promise { + const map = this.maps[_args.id]; + + for (const id of _args.markerIds) { + if (map.markers[id]) { + map.markers[id].map = null; + delete map.markers[id]; + } + } + } + + async removeMarker(_args: RemoveMarkerArgs): Promise { + if (this.maps[_args.id].markers[_args.markerId]) { + this.maps[_args.id].markers[_args.markerId].map = null; + delete this.maps[_args.id].markers[_args.markerId]; + } + } + + async addPolygons(args: AddPolygonsArgs): Promise<{ ids: string[] }> { + const polygonIds: string[] = []; + const map = this.maps[args.id]; + + for (const polygonArgs of args.polygons) { + const polygon = new google.maps.Polygon(polygonArgs); + polygon.setMap(map.map); + + const id = '' + this.currPolygonId; + this.maps[args.id].polygons[id] = polygon; + this.setPolygonListeners(args.id, id, polygon); + + polygonIds.push(id); + this.currPolygonId++; + } + + return { ids: polygonIds }; + } + + async removePolygons(args: RemovePolygonsArgs): Promise { + const map = this.maps[args.id]; + + for (const id of args.polygonIds) { + map.polygons[id].setMap(null); + delete map.polygons[id]; + } + } + + async addCircles(args: AddCirclesArgs): Promise<{ ids: string[] }> { + const circleIds: string[] = []; + const map = this.maps[args.id]; + + for (const circleArgs of args.circles) { + const circle = new google.maps.Circle(circleArgs); + circle.setMap(map.map); + + const id = '' + this.currCircleId; + this.maps[args.id].circles[id] = circle; + this.setCircleListeners(args.id, id, circle); + + circleIds.push(id); + this.currCircleId++; + } + + return { ids: circleIds }; + } + + async removeCircles(args: RemoveCirclesArgs): Promise { + const map = this.maps[args.id]; + + for (const id of args.circleIds) { + map.circles[id].setMap(null); + delete map.circles[id]; + } + } + + async addPolylines(args: AddPolylinesArgs): Promise<{ ids: string[] }> { + const lineIds: string[] = []; + const map = this.maps[args.id]; + + for (const polylineArgs of args.polylines) { + const polyline = new google.maps.Polyline(polylineArgs); + polyline.set('tag', polylineArgs.tag); + polyline.setMap(map.map); + + const id = '' + this.currPolylineId; + this.maps[args.id].polylines[id] = polyline; + this.setPolylineListeners(args.id, id, polyline); + + lineIds.push(id); + this.currPolylineId++; + } + + return { + ids: lineIds, + }; + } + + async removePolylines(args: RemovePolylinesArgs): Promise { + const map = this.maps[args.id]; + + for (const id of args.polylineIds) { + map.polylines[id].setMap(null); + delete map.polylines[id]; + } + } + + async enableClustering(_args: EnableClusteringArgs): Promise { + const markers: google.maps.marker.AdvancedMarkerElement[] = []; + + for (const id in this.maps[_args.id].markers) { + markers.push(this.maps[_args.id].markers[id]); + } + + this.maps[_args.id].markerClusterer = new MarkerClusterer({ + map: this.maps[_args.id].map, + markers: markers, + algorithm: new SuperClusterAlgorithm({ + minPoints: _args.minClusterSize ?? 4, + }), + onClusterClick: this.onClusterClickHandler, + }); + } + + async disableClustering(_args: { id: string }): Promise { + const mapInstance = this.maps[_args.id]; + if (mapInstance.markerClusterer) { + const markers = Object.values(mapInstance.markers); + + mapInstance.markerClusterer.setMap(null); + mapInstance.markerClusterer = undefined; + + for (const marker of markers) { + marker.map = mapInstance.map; + } + } + } + + async onScroll(): Promise { + throw new Error('Method not supported on web.'); + } + + async onResize(): Promise { + throw new Error('Method not supported on web.'); + } + + async onDisplay(): Promise { + throw new Error('Method not supported on web.'); + } + + async create(_args: CreateMapArgs): Promise { + console.log(`Create map: ${_args.id}`); + if (!_args.apiKey) { + throw new Error('apiKey is required when using NativeMap on web'); + } + await this.importGoogleLib(_args.apiKey, _args.region, _args.language); + + // Ensure we have a Map ID for Advanced Markers + const config = { ..._args.config }; + if (!config.mapId) { + config.mapId = `capacitor_map_${this.currMapId++}`; + } + + this.maps[_args.id] = { + map: new window.google.maps.Map(_args.element, config), + element: _args.element, + markers: {}, + tileOverlays: {}, + polygons: {}, + circles: {}, + polylines: {}, + }; + this.setMapListeners(_args.id); + } + + async destroy(_args: DestroyMapArgs): Promise { + console.log(`Destroy map: ${_args.id}`); + const mapItem = this.maps[_args.id]; + mapItem.element.innerHTML = ''; + mapItem.map.unbindAll(); + delete this.maps[_args.id]; + } + + async mapBoundsContains(_args: MapBoundsContainsArgs): Promise<{ contains: boolean }> { + const bounds = this.getLatLngBounds(_args.bounds); + const point = new google.maps.LatLng(_args.point.lat, _args.point.lng); + return { contains: bounds.contains(point) }; + } + + async mapBoundsExtend(_args: MapBoundsExtendArgs): Promise<{ bounds: LatLngBounds }> { + const bounds = this.getLatLngBounds(_args.bounds); + const point = new google.maps.LatLng(_args.point.lat, _args.point.lng); + bounds.extend(point); + const result = new LatLngBounds({ + southwest: { + lat: bounds.getSouthWest().lat(), + lng: bounds.getSouthWest().lng(), + }, + center: { + lat: bounds.getCenter().lat(), + lng: bounds.getCenter().lng(), + }, + northeast: { + lat: bounds.getNorthEast().lat(), + lng: bounds.getNorthEast().lng(), + }, + }); + return { bounds: result }; + } + + private getLatLngBounds(_args: LatLngBounds): google.maps.LatLngBounds { + return new google.maps.LatLngBounds( + new google.maps.LatLng(_args.southwest.lat, _args.southwest.lng), + new google.maps.LatLng(_args.northeast.lat, _args.northeast.lng), + ); + } + + async setCircleListeners(mapId: string, circleId: string, circle: google.maps.Circle): Promise { + circle.addListener('click', () => { + this.notifyListeners('onCircleClick', { + mapId: mapId, + circleId: circleId, + tag: circle.get('tag'), + }); + }); + } + + async setPolygonListeners(mapId: string, polygonId: string, polygon: google.maps.Polygon): Promise { + polygon.addListener('click', () => { + this.notifyListeners('onPolygonClick', { + mapId: mapId, + polygonId: polygonId, + tag: polygon.get('tag'), + }); + }); + } + + async setPolylineListeners(mapId: string, polylineId: string, polyline: google.maps.Polyline): Promise { + polyline.addListener('click', () => { + this.notifyListeners('onPolylineClick', { + mapId: mapId, + polylineId: polylineId, + tag: polyline.get('tag'), + }); + }); + } + + async setMarkerListeners( + mapId: string, + markerId: string, + marker: google.maps.marker.AdvancedMarkerElement, + ): Promise { + marker.addListener('click', () => { + const position = marker.position as google.maps.LatLngLiteral; + this.notifyListeners('onMarkerClick', { + mapId: mapId, + markerId: markerId, + latitude: position.lat, + longitude: position.lng, + title: marker.title ?? '', + snippet: '', + }); + }); + + if (marker.gmpDraggable) { + marker.addListener('dragstart', () => { + const position = marker.position as google.maps.LatLngLiteral; + this.notifyListeners('onMarkerDragStart', { + mapId: mapId, + markerId: markerId, + latitude: position.lat, + longitude: position.lng, + title: marker.title ?? '', + snippet: '', + }); + }); + + marker.addListener('drag', () => { + const position = marker.position as google.maps.LatLngLiteral; + this.notifyListeners('onMarkerDrag', { + mapId: mapId, + markerId: markerId, + latitude: position.lat, + longitude: position.lng, + title: marker.title ?? '', + snippet: '', + }); + }); + + marker.addListener('dragend', () => { + const position = marker.position as google.maps.LatLngLiteral; + this.notifyListeners('onMarkerDragEnd', { + mapId: mapId, + markerId: markerId, + latitude: position.lat, + longitude: position.lng, + title: marker.title ?? '', + snippet: '', + }); + }); + } + } + + async setMapListeners(mapId: string): Promise { + const map = this.maps[mapId].map; + + map.addListener('idle', async () => { + const bounds = await this.getMapBounds({ id: mapId }); + this.notifyListeners('onCameraIdle', { + mapId: mapId, + bearing: map.getHeading(), + bounds: bounds, + latitude: map.getCenter()?.lat(), + longitude: map.getCenter()?.lng(), + tilt: map.getTilt(), + zoom: map.getZoom(), + }); + }); + + map.addListener('center_changed', () => { + this.notifyListeners('onCameraMoveStarted', { + mapId: mapId, + isGesture: true, + }); + }); + + map.addListener('bounds_changed', async () => { + const bounds = await this.getMapBounds({ id: mapId }); + this.notifyListeners('onBoundsChanged', { + mapId: mapId, + bearing: map.getHeading(), + bounds: bounds, + latitude: map.getCenter()?.lat(), + longitude: map.getCenter()?.lng(), + tilt: map.getTilt(), + zoom: map.getZoom(), + }); + }); + + map.addListener('click', (e: google.maps.MapMouseEvent | google.maps.IconMouseEvent) => { + this.notifyListeners('onMapClick', { + mapId: mapId, + latitude: e.latLng?.lat(), + longitude: e.latLng?.lng(), + }); + }); + + this.notifyListeners('onMapReady', { + mapId: mapId, + }); + } + + private buildMarkerOpts(marker: Marker, map: google.maps.Map): google.maps.marker.AdvancedMarkerElement { + if (!this.AdvancedMarkerElement || !this.PinElement) { + throw new Error('Marker library not loaded'); + } + + let content: HTMLElement | undefined = undefined; + + if (marker.iconUrl) { + const img = document.createElement('img'); + img.src = marker.iconUrl; + if (marker.iconSize) { + img.style.width = `${marker.iconSize.width}px`; + img.style.height = `${marker.iconSize.height}px`; + } + content = img; + } else { + const pinOptions: google.maps.marker.PinElementOptions = { + scale: marker.opacity ?? 1, + glyph: marker.title, + background: marker.tintColor + ? `rgb(${marker.tintColor.r}, ${marker.tintColor.g}, ${marker.tintColor.b})` + : undefined, + }; + + const pin = new this.PinElement(pinOptions); + content = pin.element; + } + + const advancedMarker = new this.AdvancedMarkerElement({ + position: marker.coordinate, + map: map, + content: content, + title: marker.title, + gmpDraggable: marker.draggable, + }); + + return advancedMarker; + } +} diff --git a/swiftlint.config.js b/swiftlint.config.js new file mode 100644 index 0000000..f2db685 --- /dev/null +++ b/swiftlint.config.js @@ -0,0 +1,25 @@ +const base = require('@ionic/swiftlint-config'); + +// Extends the Ionic base config. This is a single small MapKit plugin: the +// delegate-heavy plugin class and the map-implementation file run a little past +// SwiftLint's conservative length defaults, and `x` / `y` are the honest names +// for the geometry the plugin exchanges with JS. Everything else stays on base. +module.exports = { + ...base, + // `unused_import` only runs under `swiftlint analyze`; the base lists it in + // `opt_in_rules`, which makes `swiftlint lint` print a placement note. Move it + // to `analyzer_rules` so a plain lint run is silent. + opt_in_rules: base.opt_in_rules.filter((rule) => rule !== 'unused_import'), + analyzer_rules: ['unused_import'], + identifier_name: { + excluded: ['id', 'x', 'y'], + }, + type_body_length: { + warning: 300, + error: 400, + }, + file_length: { + warning: 500, + error: 600, + }, +}; diff --git a/tsconfig.json b/tsconfig.json new file mode 100644 index 0000000..b2cbfd6 --- /dev/null +++ b/tsconfig.json @@ -0,0 +1,21 @@ +{ + "compilerOptions": { + "allowUnreachableCode": false, + "declaration": true, + "declarationDir": "dist/typings", + "esModuleInterop": true, + "inlineSources": true, + "lib": ["dom", "es2017"], + "module": "esnext", + "moduleResolution": "node", + "noFallthroughCasesInSwitch": true, + "noUnusedLocals": true, + "noUnusedParameters": true, + "outDir": "dist/esm", + "pretty": true, + "sourceMap": true, + "strict": true, + "target": "es2017" + }, + "files": ["src/index.ts"] +} From 8832da54e054fac34bc370b04e049e2a98013e8b Mon Sep 17 00:00:00 2001 From: Cursor Agent Date: Thu, 1 Oct 2026 00:09:34 +0000 Subject: [PATCH 02/42] fix(ios): use keepAlive for location permission request Co-authored-by: Martin DONADIEU --- .../NativeMapPlugin/CapacitorAppleMapsPlugin.swift | 5 ++--- ios/Sources/NativeMapPlugin/Permissions.swift | 13 +++++-------- 2 files changed, 7 insertions(+), 11 deletions(-) diff --git a/ios/Sources/NativeMapPlugin/CapacitorAppleMapsPlugin.swift b/ios/Sources/NativeMapPlugin/CapacitorAppleMapsPlugin.swift index 577ae52..1bbee43 100644 --- a/ios/Sources/NativeMapPlugin/CapacitorAppleMapsPlugin.swift +++ b/ios/Sources/NativeMapPlugin/CapacitorAppleMapsPlugin.swift @@ -84,9 +84,8 @@ public class NativeMapPlugin: CAPPlugin, CAPBridgedPlugin, MKMapViewDelegate { // Permissions.swift. The manager is created lazily on first use so a plugin // that never touches location never instantiates one. var locationManager: CLLocationManager? - /// Callback id of the in-flight `requestPermissions` call, held while the - /// system prompt is up so the delegate can resolve it once the user answers. - var permissionCallID: String? + /// In-flight `requestPermissions` call, held while the system prompt is up. + var pendingPermissionCall: CAPPluginCall? // MARK: - App lifecycle diff --git a/ios/Sources/NativeMapPlugin/Permissions.swift b/ios/Sources/NativeMapPlugin/Permissions.swift index aa931cb..0081b88 100644 --- a/ios/Sources/NativeMapPlugin/Permissions.swift +++ b/ios/Sources/NativeMapPlugin/Permissions.swift @@ -44,23 +44,20 @@ extension NativeMapPlugin: CLLocationManagerDelegate { @objc override public func requestPermissions(_ call: CAPPluginCall) { let manager = ensureLocationManager() if manager.authorizationStatus == .notDetermined { - // The prompt is answered asynchronously; hold the call and resolve it - // from the delegate once the user responds. - bridge?.saveCall(call) - permissionCallID = call.callbackId + pendingPermissionCall = call + call.keepAlive = true manager.requestWhenInUseAuthorization() } else { - // Already decided (granted, denied or restricted) - nothing to prompt. checkPermissions(call) } } public func locationManagerDidChangeAuthorization(_ manager: CLLocationManager) { - guard let callID = permissionCallID, let call = bridge?.getSavedCall(callID) else { + guard let call = pendingPermissionCall else { return } checkPermissions(call) - bridge?.releaseCall(call) - permissionCallID = nil + bridge?.releaseCall(withID: call.callbackId) + pendingPermissionCall = nil } } From bd87c9cca531986d23ade686bf2a9415e2c267a2 Mon Sep 17 00:00:00 2001 From: Cursor Agent Date: Thu, 1 Oct 2026 00:14:04 +0000 Subject: [PATCH 03/42] fix: correct TypeScript types path and Android GoogleMap references Co-authored-by: Martin DONADIEU --- .../nativemap/CapacitorClusterManagerRenderer.kt | 2 +- .../capgo/plugins/nativemap/CapacitorGoogleMap.kt | 12 ++++++------ package.json | 2 +- 3 files changed, 8 insertions(+), 8 deletions(-) diff --git a/android/src/main/java/com/capgo/plugins/nativemap/CapacitorClusterManagerRenderer.kt b/android/src/main/java/com/capgo/plugins/nativemap/CapacitorClusterManagerRenderer.kt index 903056d..2dfa426 100644 --- a/android/src/main/java/com/capgo/plugins/nativemap/CapacitorClusterManagerRenderer.kt +++ b/android/src/main/java/com/capgo/plugins/nativemap/CapacitorClusterManagerRenderer.kt @@ -8,7 +8,7 @@ import com.google.maps.android.clustering.view.DefaultClusterRenderer class CapacitorClusterManagerRenderer( context: Context, - map: NativeMap?, + map: GoogleMap??, clusterManager: ClusterManager?, minClusterSize: Int? ) : DefaultClusterRenderer(context, map, clusterManager) { diff --git a/android/src/main/java/com/capgo/plugins/nativemap/CapacitorGoogleMap.kt b/android/src/main/java/com/capgo/plugins/nativemap/CapacitorGoogleMap.kt index a13b60a..403e068 100644 --- a/android/src/main/java/com/capgo/plugins/nativemap/CapacitorGoogleMap.kt +++ b/android/src/main/java/com/capgo/plugins/nativemap/CapacitorGoogleMap.kt @@ -40,7 +40,7 @@ class CapacitorNativeMapView( OnPolylineClickListener, OnPolygonClickListener { private var mapView: MapView - private var googleMap: NativeMap? = null + private var googleMap: GoogleMap? = null private val markers = HashMap() private val tileOverlays = HashMap() private val polygons = HashMap() @@ -116,10 +116,10 @@ class CapacitorNativeMapView( if (config.mapTypeId != null) { when (config.mapTypeId!!) { - "hybrid" -> googleMap?.mapType = NativeMap.MAP_TYPE_HYBRID - "roadmap" -> googleMap?.mapType = NativeMap.MAP_TYPE_NORMAL - "satellite" -> googleMap?.mapType = NativeMap.MAP_TYPE_SATELLITE - "terrain" -> googleMap?.mapType = NativeMap.MAP_TYPE_TERRAIN + "hybrid" -> googleMap?.mapType = GoogleMap.MAP_TYPE_HYBRID + "roadmap" -> googleMap?.mapType = GoogleMap.MAP_TYPE_NORMAL + "satellite" -> googleMap?.mapType = GoogleMap.MAP_TYPE_SATELLITE + "terrain" -> googleMap?.mapType = GoogleMap.MAP_TYPE_TERRAIN } } @@ -943,7 +943,7 @@ class CapacitorNativeMapView( mapView.onDestroy() } - override fun onMapReady(map: NativeMap) { + override fun onMapReady(map: GoogleMap) { runBlocking { googleMap = map diff --git a/package.json b/package.json index cdcbb4b..bbebe16 100644 --- a/package.json +++ b/package.json @@ -5,7 +5,7 @@ "license": "MPL-2.0", "main": "dist/plugin.cjs.js", "module": "dist/esm/index.js", - "types": "dist/esm/index.d.ts", + "types": "dist/typings/index.d.ts", "unpkg": "dist/plugin.js", "files": [ "android/src/main/", From ec4b48e6f6098a448887e7cec226dad8f871ab15 Mon Sep 17 00:00:00 2001 From: Cursor Agent Date: Thu, 1 Oct 2026 00:20:47 +0000 Subject: [PATCH 04/42] chore: replace em dashes in iOS source comments Co-authored-by: Martin DONADIEU --- ios/Sources/NativeMapPlugin/AppleMapMarker.swift | 6 +++--- ios/Sources/NativeMapPlugin/CapacitorAppleMaps.swift | 4 ++-- ios/Sources/NativeMapPlugin/MapAnnotations.swift | 6 +++--- ios/Tests/NativeMapPluginTests/MarkerAnchorTests.swift | 2 +- 4 files changed, 9 insertions(+), 9 deletions(-) diff --git a/ios/Sources/NativeMapPlugin/AppleMapMarker.swift b/ios/Sources/NativeMapPlugin/AppleMapMarker.swift index b599854..4a37286 100644 --- a/ios/Sources/NativeMapPlugin/AppleMapMarker.swift +++ b/ios/Sources/NativeMapPlugin/AppleMapMarker.swift @@ -35,8 +35,8 @@ class NativeMapMarker: MKPointAnnotation { /// The `MKAnnotationView.centerOffset` that lands this marker's anchor point on /// its coordinate, for an icon rendered at `imageSize`. A view is centred on - /// its coordinate by default, so the offset moves the view until the anchor — - /// not the centre — sits on the point. The bottom-centre default `(0.5, 1)` + /// its coordinate by default, so the offset moves the view until the anchor - + /// not the centre - sits on the point. The bottom-centre default `(0.5, 1)` /// gives `(0, -height/2)`, the classic teardrop-tip anchoring. func centerOffset(for imageSize: CGSize) -> CGPoint { let anchor = iconAnchor ?? CGPoint(x: 0.5, y: 1.0) @@ -45,7 +45,7 @@ class NativeMapMarker: MKPointAnnotation { } /// Applies whichever icon fields (`iconUrl`, `iconSize`, `iconAnchor`) are - /// present in an update payload, returning whether any changed — the caller + /// present in an update payload, returning whether any changed - the caller /// re-renders the annotation when so. A present `iconAnchor` of `null` resets /// to the bottom-centre default. Mirrors the parsing in `Map.makeMarker`. func applyIconUpdates(from obj: JSObject) -> Bool { diff --git a/ios/Sources/NativeMapPlugin/CapacitorAppleMaps.swift b/ios/Sources/NativeMapPlugin/CapacitorAppleMaps.swift index c8cf562..13e4a6a 100644 --- a/ios/Sources/NativeMapPlugin/CapacitorAppleMaps.swift +++ b/ios/Sources/NativeMapPlugin/CapacitorAppleMaps.swift @@ -288,12 +288,12 @@ public class Map: NSObject, UIGestureRecognizerDelegate { // The mount depends on finding WebKit's private child scroll view // for the map element (see getTargetContainer). If that ever fails // again on a future iOS, the map is silently never added to the - // view tree — a blank, touch-dead map with no error. Leave a + // view tree - a blank, touch-dead map with no error. Leave a // breadcrumb so that failure is diagnosable from the console // instead of a mystery. onMapReady still fires below, as before. CAPLog.print("[NativeMaps] getTargetContainer found no container to mount into " + "(ref=\(self.config.width)x\(self.config.height)); map will not render. " - + "Likely a WebKit view-tree change — inspect the WKWebView's scroll views.") + + "Likely a WebKit view-tree change - inspect the WKWebView's scroll views.") } self.delegate?.notifyListeners("onMapReady", data: ["mapId": self.id]) diff --git a/ios/Sources/NativeMapPlugin/MapAnnotations.swift b/ios/Sources/NativeMapPlugin/MapAnnotations.swift index 07d04f0..260001f 100644 --- a/ios/Sources/NativeMapPlugin/MapAnnotations.swift +++ b/ios/Sources/NativeMapPlugin/MapAnnotations.swift @@ -14,7 +14,7 @@ extension Map { static let markerReuseId = "appleMapMarker" // Markers with an icon and markers without one use different view classes // (MKAnnotationView vs MKMarkerAnnotationView) and so must not share a reuse - // identifier — MapKit would hand back the wrong class from the reuse pool. + // identifier - MapKit would hand back the wrong class from the reuse pool. static let markerDefaultReuseId = "appleMapMarkerDefault" /// Parse a JS camera config (`coordinate` / `zoom` / `animate`) and apply it. @@ -65,8 +65,8 @@ extension Map { } view.annotation = marker view.clusteringIdentifier = shouldCluster ? Map.clusterReuseId : nil - // `.required` opts an annotation out of decluttering — which includes - // clustering — so a required marker will never collapse into a bubble no + // `.required` opts an annotation out of decluttering - which includes + // clustering - so a required marker will never collapse into a bubble no // matter its clusteringIdentifier. When clustering is on, drop to // `.defaultHigh` so overlapping markers may cluster; when it's off keep // `.required` so no pin is ever silently hidden by decluttering. diff --git a/ios/Tests/NativeMapPluginTests/MarkerAnchorTests.swift b/ios/Tests/NativeMapPluginTests/MarkerAnchorTests.swift index 5b5d79c..ffe3dfc 100644 --- a/ios/Tests/NativeMapPluginTests/MarkerAnchorTests.swift +++ b/ios/Tests/NativeMapPluginTests/MarkerAnchorTests.swift @@ -26,7 +26,7 @@ class MarkerAnchorTests: XCTestCase { let size = CGSize(width: 40, height: 60) let marker = NativeMapMarker() - // Default (nil) anchors the bottom-centre — the classic teardrop tip. + // Default (nil) anchors the bottom-centre - the classic teardrop tip. XCTAssertEqual(marker.centerOffset(for: size), CGPoint(x: 0, y: -30)) marker.iconAnchor = CGPoint(x: 0.5, y: 0.5) // centred, as a dot wants From 3d409693bb3cc734b00b39f79e46082f4a7c49eb Mon Sep 17 00:00:00 2001 From: Cursor Agent Date: Thu, 1 Oct 2026 00:29:28 +0000 Subject: [PATCH 05/42] chore(ci): pin GitHub Actions to latest major tags Co-authored-by: Martin DONADIEU --- .github/workflows/build.yml | 4 ++-- .github/workflows/bump_version.yml | 4 ++-- .github/workflows/github-releases-to-discord.yml | 4 ++-- .github/workflows/pr_beta_prompt.yml | 4 ++-- .github/workflows/pr_beta_publish.yml | 14 +++++++------- .github/workflows/test.yml | 14 +++++++------- 6 files changed, 22 insertions(+), 22 deletions(-) diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml index 0a377cb..6284c6d 100644 --- a/.github/workflows/build.yml +++ b/.github/workflows/build.yml @@ -21,7 +21,7 @@ jobs: id-token: write steps: - name: Check out - uses: actions/checkout@v6 + uses: actions/checkout@v7 with: fetch-depth: 0 filter: blob:none @@ -42,7 +42,7 @@ jobs: CLOUDFLARE_ACCOUNT_ID: ${{ secrets.CLOUDFLARE_ACCOUNT_ID }} run: bun run changelog:ai - name: Setup Node.js for npm publish - uses: actions/setup-node@v6 + uses: actions/setup-node@v7 with: node-version: 24.x registry-url: 'https://registry.npmjs.org' diff --git a/.github/workflows/bump_version.yml b/.github/workflows/bump_version.yml index c9fcb95..61e045f 100644 --- a/.github/workflows/bump_version.yml +++ b/.github/workflows/bump_version.yml @@ -26,11 +26,11 @@ jobs: name: "Bump version and create tag" steps: - name: Setup Node.js - uses: actions/setup-node@v6 + uses: actions/setup-node@v7 with: node-version: 24.x - name: Check out - uses: actions/checkout@v6 + uses: actions/checkout@v7 with: fetch-depth: 0 filter: blob:none diff --git a/.github/workflows/github-releases-to-discord.yml b/.github/workflows/github-releases-to-discord.yml index cae7011..22c7cdc 100644 --- a/.github/workflows/github-releases-to-discord.yml +++ b/.github/workflows/github-releases-to-discord.yml @@ -11,11 +11,11 @@ jobs: timeout-minutes: 10 steps: - name: Setup Node.js - uses: actions/setup-node@v6 + uses: actions/setup-node@v7 with: node-version: 24.x - name: Checkout - uses: actions/checkout@v6 + uses: actions/checkout@v7 - name: GitHub Releases to Discord uses: SethCohen/github-releases-to-discord@v1 with: diff --git a/.github/workflows/pr_beta_prompt.yml b/.github/workflows/pr_beta_prompt.yml index b918fed..961d0d9 100644 --- a/.github/workflows/pr_beta_prompt.yml +++ b/.github/workflows/pr_beta_prompt.yml @@ -19,11 +19,11 @@ jobs: timeout-minutes: 10 steps: - name: Setup Node.js - uses: actions/setup-node@v6.5.0 + uses: actions/setup-node@v7 with: node-version: 24.x - name: Upsert beta publish comment - uses: actions/github-script@v9.0.0 + uses: actions/github-script@v9 env: IS_SAME_REPO: ${{ github.event.pull_request.head.repo.full_name == github.repository && 'true' || 'false' }} with: diff --git a/.github/workflows/pr_beta_publish.yml b/.github/workflows/pr_beta_publish.yml index 7756366..bf714e5 100644 --- a/.github/workflows/pr_beta_publish.yml +++ b/.github/workflows/pr_beta_publish.yml @@ -30,7 +30,7 @@ jobs: steps: - name: Resolve PR and access checks id: pr - uses: actions/github-script@v9.0.0 + uses: actions/github-script@v9 with: script: | const prNumber = context.eventName === 'workflow_dispatch' @@ -108,7 +108,7 @@ jobs: core.setOutput('head_sha', pr.head.sha); - name: Mark publish as running - uses: actions/github-script@v9.0.0 + uses: actions/github-script@v9 with: script: | const marker = ''; @@ -155,14 +155,14 @@ jobs: }); - name: Check out PR head - uses: actions/checkout@v6.1.0 + uses: actions/checkout@v7 with: ref: ${{ steps.pr.outputs.head_sha }} fetch-depth: 0 filter: blob:none persist-credentials: false - - uses: oven-sh/setup-bun@v2.2.0 + - uses: oven-sh/setup-bun@v2 - name: Install dependencies run: bun i @@ -196,7 +196,7 @@ jobs: run: bun run build - name: Setup Node.js for npm publish - uses: actions/setup-node@v6.5.0 + uses: actions/setup-node@v7 with: node-version: 24.x registry-url: 'https://registry.npmjs.org' @@ -224,7 +224,7 @@ jobs: -f "client_payload[package]=${{ steps.version.outputs.package_name }}" - name: Publish success comment if: ${{ success() }} - uses: actions/github-script@v9.0.0 + uses: actions/github-script@v9 with: script: | const marker = ''; @@ -281,7 +281,7 @@ jobs: - name: Publish failure comment if: ${{ failure() && steps.pr.outputs.pr_number != '' }} - uses: actions/github-script@v9.0.0 + uses: actions/github-script@v9 with: script: | const marker = ''; diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml index 3a96939..815e78a 100644 --- a/.github/workflows/test.yml +++ b/.github/workflows/test.yml @@ -15,7 +15,7 @@ jobs: timeout-minutes: 10 steps: - name: Check out - uses: actions/checkout@v6 + uses: actions/checkout@v7 - name: Enforce capacitor-swift-pm version run: | set -euo pipefail @@ -29,10 +29,10 @@ jobs: timeout-minutes: 10 steps: - name: Check out - uses: actions/checkout@v6 + uses: actions/checkout@v7 - uses: oven-sh/setup-bun@v2 - name: Setup Node.js - uses: actions/setup-node@v6 + uses: actions/setup-node@v7 with: node-version: 24.x - name: Install dependencies @@ -43,7 +43,7 @@ jobs: - name: Check Cap 9 deprecated APIs run: bun run check:cap9-deprecated - name: Setup java - uses: actions/setup-java@v5 + uses: actions/setup-java@v6 with: distribution: 'zulu' java-version: '21' @@ -59,10 +59,10 @@ jobs: timeout-minutes: 10 steps: - name: Check out - uses: actions/checkout@v6 + uses: actions/checkout@v7 - uses: oven-sh/setup-bun@v2 - name: Setup Node.js - uses: actions/setup-node@v6 + uses: actions/setup-node@v7 with: node-version: 24.x - name: Install dependencies @@ -85,7 +85,7 @@ jobs: name: 'Build code and test' steps: - name: Check out - uses: actions/checkout@v6 + uses: actions/checkout@v7 - uses: oven-sh/setup-bun@v2 - name: Install dependencies id: install_code From 848e9989591e6e3de4e8f587c3dda0d7a1b1e8dc Mon Sep 17 00:00:00 2001 From: Cursor Agent Date: Thu, 1 Oct 2026 00:40:33 +0000 Subject: [PATCH 06/42] fix: address Cubic review findings and polish example app Co-authored-by: Martin DONADIEU --- .github/workflows/pr_beta_publish.yml | 2 +- .maestro/android/basic-features.yaml | 3 +- .maestro/flows/basic-local-music.yaml | 47 ------------------- .maestro/flows/native-map-smoke.yaml | 4 ++ .maestro/ios/basic-features.yaml | 3 +- CapgoCapacitorNativeMap.podspec | 2 +- README.md | 16 +++---- android/src/main/AndroidManifest.xml | 1 + .../CapacitorClusterManagerRenderer.kt | 2 + .../plugins/nativemap/CapacitorGoogleMap.kt | 36 ++++++-------- .../nativemap/CapacitorGoogleMapMarker.kt | 11 ++--- .../nativemap/CapacitorGoogleMapPolyline.kt | 2 +- .../CapacitorGoogleMapTileOverlay.kt | 2 +- .../nativemap/CapacitorGoogleMapsCircle.kt | 10 ++-- .../nativemap/CapacitorGoogleMapsPlugin.kt | 16 +++++-- .../nativemap/CapacitorGoogleMapsPolygon.kt | 8 +++- .../plugins/nativemap/GoogleMapConfig.kt | 4 +- .../plugins/nativemap/GoogleMapErrors.kt | 40 ++++++++-------- example-app/README.md | 42 +++++------------ example-app/android/app/build.gradle | 4 +- .../android/app/src/main/AndroidManifest.xml | 5 ++ .../MainActivity.java | 2 +- .../app/src/main/res/values/colors.xml | 6 +++ .../app/src/main/res/values/strings.xml | 4 +- example-app/bun.lock | 26 ++++++++-- .../ios/App/App.xcodeproj/project.pbxproj | 4 +- example-app/ios/App/CapApp-SPM/Package.swift | 6 +-- .../NativeMapPlugin/CameraEvents.swift | 8 +++- .../NativeMapPlugin/CapacitorAppleMaps.swift | 1 + .../CapacitorAppleMapsPlugin.swift | 14 +++++- .../NativeMapPlugin/GoogleMapsBridge.swift | 30 +++++++++++- ios/Sources/NativeMapPlugin/MarkerIcons.swift | 15 ++++-- scripts/check-capacitor-plugin-wiring.mjs | 3 ++ src/definitions.ts | 6 +-- src/implementation.ts | 9 ++-- src/map.ts | 38 +++++++-------- src/web.ts | 4 +- 37 files changed, 227 insertions(+), 209 deletions(-) delete mode 100644 .maestro/flows/basic-local-music.yaml create mode 100644 .maestro/flows/native-map-smoke.yaml rename example-app/android/app/src/main/java/app/capgo/{nativeaudio => nativemap}/MainActivity.java (75%) create mode 100644 example-app/android/app/src/main/res/values/colors.xml diff --git a/.github/workflows/pr_beta_publish.yml b/.github/workflows/pr_beta_publish.yml index bf714e5..f82e70f 100644 --- a/.github/workflows/pr_beta_publish.yml +++ b/.github/workflows/pr_beta_publish.yml @@ -34,7 +34,7 @@ jobs: with: script: | const prNumber = context.eventName === 'workflow_dispatch' - ? Number(core.getInput('pr_number')) + ? Number(context.payload.inputs?.pr_number ?? 0) : context.payload.issue.number; const { owner, repo } = context.repo; diff --git a/.maestro/android/basic-features.yaml b/.maestro/android/basic-features.yaml index 2de34b9..32f3170 100644 --- a/.maestro/android/basic-features.yaml +++ b/.maestro/android/basic-features.yaml @@ -1,5 +1,4 @@ -appId: app.capgo.nativeaudio --- - launchApp: clearState: true -- runFlow: ../flows/basic-local-music.yaml +- runFlow: ../flows/native-map-smoke.yaml diff --git a/.maestro/flows/basic-local-music.yaml b/.maestro/flows/basic-local-music.yaml deleted file mode 100644 index 603e3d6..0000000 --- a/.maestro/flows/basic-local-music.yaml +++ /dev/null @@ -1,47 +0,0 @@ -appId: app.capgo.nativeaudio -name: Basic local music smoke ---- -- assertVisible: "@capgo/native-audio" -- tapOn: - text: "Local Music" - retryTapIfNoChange: true -- extendedWaitUntil: - visible: "Longer local MP3 for testing seek, fades, and delayed playback\\." - timeout: 15000 -- scrollUntilVisible: - element: "Preload" - direction: DOWN - centerElement: true - timeout: 15000 -- tapOn: "Preload" -- extendedWaitUntil: - visible: "Re-preload" - timeout: 15000 -- tapOn: - text: "Play" - enabled: true -- extendedWaitUntil: - visible: - text: "Pause" - enabled: true - timeout: 15000 -- tapOn: - text: "Pause" - enabled: true -- extendedWaitUntil: - visible: ".*Paused Local Music\\." - timeout: 15000 -- tapOn: - text: "Resume" - enabled: true -- tapOn: - text: "Stop" - enabled: true -- extendedWaitUntil: - visible: ".*Stopped Local Music\\." - timeout: 15000 -- tapOn: "Unload" -- extendedWaitUntil: - visible: ".*Local Music unloaded\\." - timeout: 15000 -- assertVisible: "Preload" diff --git a/.maestro/flows/native-map-smoke.yaml b/.maestro/flows/native-map-smoke.yaml new file mode 100644 index 0000000..abf6185 --- /dev/null +++ b/.maestro/flows/native-map-smoke.yaml @@ -0,0 +1,4 @@ +appId: app.capgo.nativemap +name: Native map smoke +--- +- assertVisible: "@capgo/capacitor-native-map" diff --git a/.maestro/ios/basic-features.yaml b/.maestro/ios/basic-features.yaml index 2de34b9..32f3170 100644 --- a/.maestro/ios/basic-features.yaml +++ b/.maestro/ios/basic-features.yaml @@ -1,5 +1,4 @@ -appId: app.capgo.nativeaudio --- - launchApp: clearState: true -- runFlow: ../flows/basic-local-music.yaml +- runFlow: ../flows/native-map-smoke.yaml diff --git a/CapgoCapacitorNativeMap.podspec b/CapgoCapacitorNativeMap.podspec index d82a5e5..e9a3036 100644 --- a/CapgoCapacitorNativeMap.podspec +++ b/CapgoCapacitorNativeMap.podspec @@ -9,7 +9,7 @@ Pod::Spec.new do |s| s.license = package['license'] s.homepage = package['repository']['url'] s.author = package['author'] - s.source = { :git => package['repository']['url'], :tag => s.version.to_s } + s.source = { :git => package['repository']['url'].sub(/\Agit\+/, ''), :tag => s.version.to_s } s.source_files = 'ios/Sources/**/*.{swift,h,m,c,cc,mm,cpp}' s.ios.deployment_target = '15.0' s.dependency 'Capacitor' diff --git a/README.md b/README.md index 3027f9a..8ea4c7a 100644 --- a/README.md +++ b/README.md @@ -502,7 +502,7 @@ An interface containing the options used when creating a map. | Prop | Type | Description | Default | | ----------------- | ----------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------ | | **`id`** | string | A unique identifier for the map instance. | | -| **`apiKey`** | string | Google Maps API key. Required on Android and web. Not used on iOS (MapKit). | | +| **`apiKey`** | string | Google Maps API key. Required on web. On Android, also set `com.google.android.geo.API_KEY` in the app manifest. Not used on iOS (MapKit). | | | **`config`** | NativeMapConfig | The initial configuration settings for the map. | | | **`element`** | HTMLElement | The DOM element that the Google Map View will be mounted on which determines size and positioning. | | | **`forceCreate`** | boolean | Destroy and re-create the map instance if a map with the supplied id already exists | false | @@ -557,14 +557,14 @@ An interface representing a pair of latitude and longitude coordinates. #### TileOverlay -A tile overlay is an image placed on top of your map at a specific zoom level. Available on iOS, Android and Web +A tile overlay is an image placed on top of your map at a specific zoom level. Supported on Android and web only. -| Prop | Type | Description | Default | -| ------------- | -------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------- | -| **`url`** | string | A string representing the tile url. Should contain `{x}`, `{y}` and `{z}` so they can be replaced with actual values for x, y and zoom. Available on iOS, Android and Web | | -| **`opacity`** | number | The opacity of the tile overlay, between 0 (completely transparent) and 1 inclusive. Available on iOS, Android and Web | undefined | -| **`visible`** | boolean | Controls whether this tile overlay should be visible. Available only on Android | undefined | -| **`zIndex`** | number | The zIndex of the tile overlay. Available on iOS and Android | undefined | +| Prop | Type | Description | Default | +| ------------- | -------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------- | +| **`url`** | string | A string representing the tile url. Should contain `{x}`, `{y}` and `{z}` so they can be replaced with actual values for x, y and zoom. Android and web only. | | +| **`opacity`** | number | The opacity of the tile overlay, between 0 (completely transparent) and 1 inclusive. Available on iOS, Android and Web | undefined | +| **`visible`** | boolean | Controls whether this tile overlay should be visible. Available only on Android | undefined | +| **`zIndex`** | number | The zIndex of the tile overlay. Available on iOS and Android | undefined | #### RemoveTileOverlayArgs diff --git a/android/src/main/AndroidManifest.xml b/android/src/main/AndroidManifest.xml index a2f47b6..a2e33cc 100644 --- a/android/src/main/AndroidManifest.xml +++ b/android/src/main/AndroidManifest.xml @@ -1,2 +1,3 @@ + diff --git a/android/src/main/java/com/capgo/plugins/nativemap/CapacitorClusterManagerRenderer.kt b/android/src/main/java/com/capgo/plugins/nativemap/CapacitorClusterManagerRenderer.kt index 2dfa426..87e825d 100644 --- a/android/src/main/java/com/capgo/plugins/nativemap/CapacitorClusterManagerRenderer.kt +++ b/android/src/main/java/com/capgo/plugins/nativemap/CapacitorClusterManagerRenderer.kt @@ -29,6 +29,8 @@ class CapacitorClusterManagerRenderer( markerOptions.alpha(it.alpha) markerOptions.flat(it.isFlat) markerOptions.draggable(it.isDraggable) + markerOptions.zIndex(it.zIndex) + markerOptions.anchor(it.anchorU, it.anchorV) if(null != it.icon) { markerOptions.icon(it.icon) } diff --git a/android/src/main/java/com/capgo/plugins/nativemap/CapacitorGoogleMap.kt b/android/src/main/java/com/capgo/plugins/nativemap/CapacitorGoogleMap.kt index 403e068..effdba3 100644 --- a/android/src/main/java/com/capgo/plugins/nativemap/CapacitorGoogleMap.kt +++ b/android/src/main/java/com/capgo/plugins/nativemap/CapacitorGoogleMap.kt @@ -61,25 +61,18 @@ class CapacitorNativeMapView( } private fun initMap() { - runBlocking { - val job = - CoroutineScope(Dispatchers.Main).launch { - mapView.onCreate(null) - mapView.onStart() - mapView.getMapAsync(this@CapacitorNativeMapView) - mapView.setWillNotDraw(false) - isReadyChannel.receive() - - render() - } - - job.join() + CoroutineScope(Dispatchers.Main).launch { + mapView.onCreate(null) + mapView.onStart() + mapView.getMapAsync(this@CapacitorNativeMapView) + mapView.setWillNotDraw(false) + isReadyChannel.receive() + render() } } private fun render() { - runBlocking { - CoroutineScope(Dispatchers.Main).launch { + CoroutineScope(Dispatchers.Main).launch { val bridge = delegate.bridge val mapViewParent = FrameLayout(bridge.context) mapViewParent.minimumHeight = bridge.webView.height @@ -138,7 +131,6 @@ class CapacitorNativeMapView( ) } } - } } } @@ -231,7 +223,7 @@ class CapacitorNativeMapView( tileOverlayOptions.visible(tileOverlay.visible!!) } if (tileOverlay.opacity != null) { - tileOverlayOptions.transparency(tileOverlay.opacity!!) + tileOverlayOptions.transparency(1f - tileOverlay.opacity!!) } val googleMapTileOverlay = googleMap?.addTileOverlay(tileOverlayOptions) @@ -944,13 +936,13 @@ class CapacitorNativeMapView( } override fun onMapReady(map: GoogleMap) { - runBlocking { - googleMap = map + googleMap = map - val data = JSObject() - data.put("mapId", this@CapacitorNativeMapView.id) - delegate.notify("onMapReady", data) + val data = JSObject() + data.put("mapId", this@CapacitorNativeMapView.id) + delegate.notify("onMapReady", data) + CoroutineScope(Dispatchers.Main).launch { isReadyChannel.send(true) isReadyChannel.close() } diff --git a/android/src/main/java/com/capgo/plugins/nativemap/CapacitorGoogleMapMarker.kt b/android/src/main/java/com/capgo/plugins/nativemap/CapacitorGoogleMapMarker.kt index e5eb016..e7750b7 100644 --- a/android/src/main/java/com/capgo/plugins/nativemap/CapacitorGoogleMapMarker.kt +++ b/android/src/main/java/com/capgo/plugins/nativemap/CapacitorGoogleMapMarker.kt @@ -63,7 +63,7 @@ class CapacitorNativeMapViewMarker(fromJSONObject: JSONObject): ClusterItem { } draggable = fromJSONObject.optBoolean("draggable", false) - zIndex = fromJSONObject.optLong("zIndex").toFloat() + zIndex = fromJSONObject.optDouble("zIndex", 0.0).toFloat() } override fun getPosition(): LatLng { @@ -82,12 +82,7 @@ class CapacitorNativeMapViewMarker(fromJSONObject: JSONObject): ClusterItem { return zIndex } - private fun buildIconAnchorPoint(iconAnchor: CapacitorNativeMapPoint): CapacitorNativeMapPoint? { - iconSize ?: return null - - val u: Float = iconAnchor.x / iconSize!!.width - val v: Float = iconAnchor.y / iconSize!!.height - - return CapacitorNativeMapPoint(u, v) + private fun buildIconAnchorPoint(iconAnchor: CapacitorNativeMapPoint): CapacitorNativeMapPoint { + return CapacitorNativeMapPoint(iconAnchor.x, iconAnchor.y) } } \ No newline at end of file diff --git a/android/src/main/java/com/capgo/plugins/nativemap/CapacitorGoogleMapPolyline.kt b/android/src/main/java/com/capgo/plugins/nativemap/CapacitorGoogleMapPolyline.kt index ad3cfdc..eb42f41 100644 --- a/android/src/main/java/com/capgo/plugins/nativemap/CapacitorGoogleMapPolyline.kt +++ b/android/src/main/java/com/capgo/plugins/nativemap/CapacitorGoogleMapPolyline.kt @@ -56,7 +56,7 @@ class CapacitorNativeMapViewPolyline(fromJSONObject: JSONObject) { val strokeOpacity = fromJSONObject.optDouble("strokeOpacity", 1.0) - strokeColor = this.processColor(fromJSONObject.getString("strokeColor"), strokeOpacity) + strokeColor = this.processColor(fromJSONObject.optString("strokeColor", "#0000FF"), strokeOpacity) strokeWidth = fromJSONObject.optDouble("strokeWeight", 1.0).toFloat() clickable = fromJSONObject.optBoolean("clickable", false) geodesic = fromJSONObject.optBoolean("geodesic", false) diff --git a/android/src/main/java/com/capgo/plugins/nativemap/CapacitorGoogleMapTileOverlay.kt b/android/src/main/java/com/capgo/plugins/nativemap/CapacitorGoogleMapTileOverlay.kt index 0f39405..f7a0bb3 100644 --- a/android/src/main/java/com/capgo/plugins/nativemap/CapacitorGoogleMapTileOverlay.kt +++ b/android/src/main/java/com/capgo/plugins/nativemap/CapacitorGoogleMapTileOverlay.kt @@ -22,7 +22,7 @@ class CapacitorNativeMapViewTileOverlay(fromJSONObject: JSONObject) { visible = fromJSONObject.optBoolean("visible") } if (fromJSONObject.has("zIndex")) { - zIndex = fromJSONObject.optLong("zIndex").toFloat() + zIndex = fromJSONObject.optDouble("zIndex").toFloat() } } } \ No newline at end of file diff --git a/android/src/main/java/com/capgo/plugins/nativemap/CapacitorGoogleMapsCircle.kt b/android/src/main/java/com/capgo/plugins/nativemap/CapacitorGoogleMapsCircle.kt index 6a5344a..6298094 100644 --- a/android/src/main/java/com/capgo/plugins/nativemap/CapacitorGoogleMapsCircle.kt +++ b/android/src/main/java/com/capgo/plugins/nativemap/CapacitorGoogleMapsCircle.kt @@ -38,13 +38,17 @@ class CapacitorNativeMapCircle(fromJSONObject: JSONObject) { radius = fromJSONObject.getDouble("radius").toFloat() val strokeOpacity = fromJSONObject.optDouble("strokeOpacity", 1.0) - strokeColor = this.processColor(fromJSONObject.getString("strokeColor"), strokeOpacity) + if (fromJSONObject.has("strokeColor")) { + strokeColor = this.processColor(fromJSONObject.getString("strokeColor"), strokeOpacity) + } val fillOpacity = fromJSONObject.optDouble("fillOpacity", 1.0) - fillColor = this.processColor(fromJSONObject.getString("fillColor"), fillOpacity) + if (fromJSONObject.has("fillColor")) { + fillColor = this.processColor(fromJSONObject.getString("fillColor"), fillOpacity) + } strokeWidth = fromJSONObject.optDouble("strokeWeight", 1.0).toFloat() - clickable = fromJSONObject.optBoolean("clickable", false) + clickable = fromJSONObject.optBoolean("clickable", true) zIndex = fromJSONObject.optDouble("zIndex", 1.0).toFloat() tag = fromJSONObject.optString("tag", "") } diff --git a/android/src/main/java/com/capgo/plugins/nativemap/CapacitorGoogleMapsPlugin.kt b/android/src/main/java/com/capgo/plugins/nativemap/CapacitorGoogleMapsPlugin.kt index a8d91ac..69e6f83 100644 --- a/android/src/main/java/com/capgo/plugins/nativemap/CapacitorGoogleMapsPlugin.kt +++ b/android/src/main/java/com/capgo/plugins/nativemap/CapacitorGoogleMapsPlugin.kt @@ -967,9 +967,15 @@ class CapacitorNativeMapPlugin : Plugin(), OnMapsSdkInitializedCallback { map ?: throw MapNotFoundError() CoroutineScope(Dispatchers.Main).launch { - val bounds = map.getLatLngBounds() - val data = getLatLngBoundsJSObject(bounds) - call.resolve(data) + try { + val bounds = map.getLatLngBounds() + val data = getLatLngBoundsJSObject(bounds) + call.resolve(data) + } catch (e: NativeMapsError) { + handleError(call, e) + } catch (e: Exception) { + handleError(call, e) + } } } catch (e: NativeMapsError) { handleError(call, e) @@ -1015,7 +1021,9 @@ class CapacitorNativeMapPlugin : Plugin(), OnMapsSdkInitializedCallback { CoroutineScope(Dispatchers.Main).launch { val bounds = createLatLngBounds(boundsObject) - map.fitBounds(bounds, padding) + val density = bridge.context.resources.displayMetrics.density + val scaledPadding = (padding * density).toInt() + map.fitBounds(bounds, scaledPadding) call.resolve() } } catch (e: NativeMapsError) { diff --git a/android/src/main/java/com/capgo/plugins/nativemap/CapacitorGoogleMapsPolygon.kt b/android/src/main/java/com/capgo/plugins/nativemap/CapacitorGoogleMapsPolygon.kt index 413cb50..a693b59 100644 --- a/android/src/main/java/com/capgo/plugins/nativemap/CapacitorGoogleMapsPolygon.kt +++ b/android/src/main/java/com/capgo/plugins/nativemap/CapacitorGoogleMapsPolygon.kt @@ -37,10 +37,14 @@ class CapacitorNativeMapPolygon(fromJSONObject: JSONObject) { } val strokeOpacity = fromJSONObject.optDouble("strokeOpacity", 1.0) - strokeColor = this.processColor(fromJSONObject.getString("strokeColor"), strokeOpacity) + if (fromJSONObject.has("strokeColor")) { + strokeColor = this.processColor(fromJSONObject.getString("strokeColor"), strokeOpacity) + } val fillOpacity = fromJSONObject.optDouble("fillOpacity", 1.0) - fillColor = this.processColor(fromJSONObject.getString("fillColor"), fillOpacity) + if (fromJSONObject.has("fillColor")) { + fillColor = this.processColor(fromJSONObject.getString("fillColor"), fillOpacity) + } strokeWidth = fromJSONObject.optDouble("strokeWeight", 1.0).toFloat() clickable = fromJSONObject.optBoolean("clickable", false) diff --git a/android/src/main/java/com/capgo/plugins/nativemap/GoogleMapConfig.kt b/android/src/main/java/com/capgo/plugins/nativemap/GoogleMapConfig.kt index e6a9e71..4eb56ae 100644 --- a/android/src/main/java/com/capgo/plugins/nativemap/GoogleMapConfig.kt +++ b/android/src/main/java/com/capgo/plugins/nativemap/GoogleMapConfig.kt @@ -106,9 +106,9 @@ class NativeMapConfig(fromJSONObject: JSONObject) { val cameraPosition = CameraPosition(center, zoom.toFloat(), 0.0F, 0.0F) - styles = fromJSONObject.getString("styles") + styles = fromJSONObject.optString("styles").takeIf { fromJSONObject.has("styles") } - mapId = fromJSONObject.getString("androidMapId") + mapId = fromJSONObject.optString("androidMapId").takeIf { fromJSONObject.has("androidMapId") } restriction = fromJSONObject.optJSONObject("restriction")?.let { NativeMapConfigRestriction(it) } diff --git a/android/src/main/java/com/capgo/plugins/nativemap/GoogleMapErrors.kt b/android/src/main/java/com/capgo/plugins/nativemap/GoogleMapErrors.kt index 4ee6c33..e08121a 100644 --- a/android/src/main/java/com/capgo/plugins/nativemap/GoogleMapErrors.kt +++ b/android/src/main/java/com/capgo/plugins/nativemap/GoogleMapErrors.kt @@ -7,7 +7,7 @@ enum class NativeMapErrors { UNHANDLED_ERROR, INVALID_MAP_ID, MAP_NOT_FOUND, MARKER_NOT_FOUND, INVALID_ARGUMENTS, PERMISSIONS_DENIED_LOCATION, GOOGLE_MAP_NOT_AVAILABLE, BOUNDS_NOT_FOUND, TILE_OVERLAY_NOT_FOUND } -class NativeMapErrorObject(val code: Int, val message: String, val extra: HashMap = HashMap()) { +class NativeMapErrorObject(val code: String, val message: String, val extra: HashMap = HashMap()) { private fun asJSONObject(): JSONObject { val returnJSONObject = JSONObject() @@ -56,59 +56,59 @@ fun getErrorObject(err: NativeMapsError): NativeMapErrorObject { } fun getErrorObject(err: Exception): NativeMapErrorObject { - return NativeMapErrorObject(0, "Unhandled Error: ${err.message}.") + return NativeMapErrorObject(NativeMapErrors.UNHANDLED_ERROR.name, "Unhandled Error: ${err.message}.") } open class NativeMapsError(message: String? = ""): Throwable(message) { - open fun getErrorCode(): Int { - return NativeMapErrors.UNHANDLED_ERROR.ordinal + open fun getErrorCode(): String { + return NativeMapErrors.UNHANDLED_ERROR.name } } class InvalidMapIdError(message: String? = ""): NativeMapsError(message) { - override fun getErrorCode(): Int { - return NativeMapErrors.INVALID_MAP_ID.ordinal + override fun getErrorCode(): String { + return NativeMapErrors.INVALID_MAP_ID.name } } class MapNotFoundError(message: String? = ""): NativeMapsError(message) { - override fun getErrorCode(): Int { - return NativeMapErrors.MAP_NOT_FOUND.ordinal + override fun getErrorCode(): String { + return NativeMapErrors.MAP_NOT_FOUND.name } } class MarkerNotFoundError(message: String? = ""): NativeMapsError(message) { - override fun getErrorCode(): Int { - return NativeMapErrors.MARKER_NOT_FOUND.ordinal + override fun getErrorCode(): String { + return NativeMapErrors.MARKER_NOT_FOUND.name } } class TileOverlayNotFoundError(message: String? = ""): NativeMapsError(message) { - override fun getErrorCode(): Int { - return NativeMapErrors.TILE_OVERLAY_NOT_FOUND.ordinal + override fun getErrorCode(): String { + return NativeMapErrors.TILE_OVERLAY_NOT_FOUND.name } } class InvalidArgumentsError(message: String? = ""): NativeMapsError(message) { - override fun getErrorCode(): Int { - return NativeMapErrors.INVALID_ARGUMENTS.ordinal + override fun getErrorCode(): String { + return NativeMapErrors.INVALID_ARGUMENTS.name } } class PermissionDeniedLocation(message: String? = ""): NativeMapsError(message) { - override fun getErrorCode(): Int { - return NativeMapErrors.PERMISSIONS_DENIED_LOCATION.ordinal + override fun getErrorCode(): String { + return NativeMapErrors.PERMISSIONS_DENIED_LOCATION.name } } class NativeMapNotAvailable(message: String? = ""): NativeMapsError(message) { - override fun getErrorCode(): Int { - return NativeMapErrors.GOOGLE_MAP_NOT_AVAILABLE.ordinal + override fun getErrorCode(): String { + return NativeMapErrors.GOOGLE_MAP_NOT_AVAILABLE.name } } class BoundsNotFoundError(message: String? = ""): NativeMapsError(message) { - override fun getErrorCode(): Int { - return NativeMapErrors.BOUNDS_NOT_FOUND.ordinal + override fun getErrorCode(): String { + return NativeMapErrors.BOUNDS_NOT_FOUND.name } } diff --git a/example-app/README.md b/example-app/README.md index cc63839..41680a9 100644 --- a/example-app/README.md +++ b/example-app/README.md @@ -1,34 +1,18 @@ -# Native Audio Example +# Native Map Example -This Vite + React application demonstrates how to use `@capgo/capacitor-native-audio` with local bundled assets and remote streaming audio. +This Vite + React app demonstrates `@capgo/capacitor-native-map`: create a map, add a marker, and move the camera. -## Getting started +## API keys -1. Install dependencies: - ```bash - bun install - ``` -2. Run the web demo: - ```bash - bun run dev - ``` -3. Sync native projects (optional): - ```bash - bun run sync - ``` -4. Launch a native shell application: - ```bash - bun run ios - # or - bun run android - ``` +- **Web / Android (Google Maps):** set a valid Google Maps API key when calling `NativeMap.create({ apiKey, ... })`. +- **Android:** also add your key to `AndroidManifest.xml` as `com.google.android.geo.API_KEY` (see the example manifest). +- **iOS:** uses Apple MapKit; no Google API key is required. -## Features +## Run locally -- Preload bundled and remote audio assets -- Playback controls (play, pause, resume, stop, loop) -- Volume adjustments with live updates -- Display of current playback time and duration -- Remote cache clearing for streaming assets - -The example references the local plugin source via `"@capgo/capacitor-native-audio": ".."`, so any local changes to the plugin code are picked up after reinstalling dependencies. +```bash +bun install +bun run build +bunx cap sync +bunx cap open android # or ios +``` diff --git a/example-app/android/app/build.gradle b/example-app/android/app/build.gradle index e0ccd82..8aef0c8 100644 --- a/example-app/android/app/build.gradle +++ b/example-app/android/app/build.gradle @@ -1,10 +1,10 @@ apply plugin: 'com.android.application' android { - namespace = "app.capgo.nativeaudio" + namespace = "app.capgo.nativemap" compileSdk = rootProject.ext.compileSdkVersion defaultConfig { - applicationId = "app.capgo.nativeaudio" + applicationId = "app.capgo.nativemap" minSdkVersion = rootProject.ext.minSdkVersion targetSdkVersion = rootProject.ext.targetSdkVersion versionCode = 1 diff --git a/example-app/android/app/src/main/AndroidManifest.xml b/example-app/android/app/src/main/AndroidManifest.xml index b7297ee..7315cbf 100644 --- a/example-app/android/app/src/main/AndroidManifest.xml +++ b/example-app/android/app/src/main/AndroidManifest.xml @@ -9,6 +9,10 @@ android:supportsRtl="true" android:theme="@style/AppTheme"> + + + diff --git a/example-app/android/app/src/main/java/app/capgo/nativeaudio/MainActivity.java b/example-app/android/app/src/main/java/app/capgo/nativemap/MainActivity.java similarity index 75% rename from example-app/android/app/src/main/java/app/capgo/nativeaudio/MainActivity.java rename to example-app/android/app/src/main/java/app/capgo/nativemap/MainActivity.java index 00fde36..0f1905f 100644 --- a/example-app/android/app/src/main/java/app/capgo/nativeaudio/MainActivity.java +++ b/example-app/android/app/src/main/java/app/capgo/nativemap/MainActivity.java @@ -1,4 +1,4 @@ -package app.capgo.nativeaudio; +package app.capgo.nativemap; import com.getcapacitor.BridgeActivity; diff --git a/example-app/android/app/src/main/res/values/colors.xml b/example-app/android/app/src/main/res/values/colors.xml new file mode 100644 index 0000000..8d53adf --- /dev/null +++ b/example-app/android/app/src/main/res/values/colors.xml @@ -0,0 +1,6 @@ + + + #3880FF + #3171E0 + #5260FF + diff --git a/example-app/android/app/src/main/res/values/strings.xml b/example-app/android/app/src/main/res/values/strings.xml index 05d8765..fd5e7fd 100644 --- a/example-app/android/app/src/main/res/values/strings.xml +++ b/example-app/android/app/src/main/res/values/strings.xml @@ -2,6 +2,6 @@ Native Audio Example Native Audio Example - app.capgo.nativeaudio - app.capgo.nativeaudio + app.capgo.nativemap + app.capgo.nativemap diff --git a/example-app/bun.lock b/example-app/bun.lock index 9a6e4f5..21e9c7b 100644 --- a/example-app/bun.lock +++ b/example-app/bun.lock @@ -6,7 +6,7 @@ "name": "native-audio-example", "dependencies": { "@capacitor/core": "^8.5.2", - "@capgo/capacitor-native-audio": "..", + "@capgo/capacitor-native-map": "..", "react": "^18.3.1", "react-dom": "^18.3.1", }, @@ -37,7 +37,7 @@ "@capacitor/ios": ["@capacitor/ios@8.5.2", "", { "peerDependencies": { "@capacitor/core": "^8.5.0" } }, "sha512-eOT2S67AfTFG7KN0T3oxwAajrJz4rSye+ODfvChiwrk0F/+kWufFM1qU6cDjGJUOfwdAoeuEpZyWHSwZlu4GFg=="], - "@capgo/capacitor-native-audio": ["@capgo/capacitor-native-audio@file:..", { "devDependencies": { "@capacitor/android": "^8.0.0", "@capacitor/cli": "^8.0.0", "@capacitor/core": "^8.0.0", "@capacitor/docgen": "^0.3.1", "@capacitor/ios": "^8.0.0", "@ionic/eslint-config": "^0.4.0", "@ionic/prettier-config": "^4.0.0", "@ionic/swiftlint-config": "^2.0.0", "@types/node": "^24.10.1", "eslint": "^8.57.1", "eslint-plugin-import": "^2.31.0", "husky": "^9.1.7", "prettier": "^3.6.2", "prettier-plugin-java": "^2.7.7", "prettier-pretty-check": "^0.2.0", "rimraf": "^6.1.0", "rollup": "^4.53.2", "swiftlint": "^2.0.0", "typescript": "^5.9.3" }, "peerDependencies": { "@capacitor/core": ">=8.0.0" } }], + "@capgo/capacitor-native-map": ["@capgo/capacitor-native-map@file:..", { "dependencies": { "@googlemaps/js-api-loader": "^2.0.2", "@googlemaps/markerclusterer": "^2.6.2", "@types/google.maps": "^3.58.1" }, "devDependencies": { "@capacitor/android": "^8.0.0", "@capacitor/cli": "^8.0.0", "@capacitor/core": "^8.0.0", "@capacitor/docgen": "^0.3.1", "@capacitor/ios": "^8.0.0", "@ionic/eslint-config": "^0.4.0", "@ionic/prettier-config": "^4.0.0", "@ionic/swiftlint-config": "^2.0.0", "@types/node": "^24.10.1", "@types/resize-observer-browser": "^0.1.11", "eslint": "^8.57.1", "eslint-plugin-import": "^2.31.0", "prettier": "^3.6.2", "prettier-plugin-java": "^2.7.7", "prettier-pretty-check": "^0.2.0", "rimraf": "^6.1.0", "rollup": "^4.53.2", "swiftlint": "^2.0.0", "typescript": "^5.9.3" }, "peerDependencies": { "@capacitor/core": ">=8.0.0" } }], "@chevrotain/cst-dts-gen": ["@chevrotain/cst-dts-gen@11.0.3", "", { "dependencies": { "@chevrotain/gast": "11.0.3", "@chevrotain/types": "11.0.3", "lodash-es": "4.17.21" } }, "sha512-BvIKpRLeS/8UbfxXxgC33xOumsacaeCKAjAeLyOn7Pcp95HiRbrpl14S+9vaZLolnbssPIUuiUd8IvgkRyt6NQ=="], @@ -57,6 +57,10 @@ "@eslint/js": ["@eslint/js@8.57.1", "", {}, "sha512-d9zaMRSTIKDLhctzH12MtXvJKSSUhaHcjV+2Z+GK+EEY7XKpP5yR4x+N3TAcHTcu963nIr+TMcCb4DBCYX1z6Q=="], + "@googlemaps/js-api-loader": ["@googlemaps/js-api-loader@2.1.3", "", { "dependencies": { "@types/google.maps": "^3.65.3" } }, "sha512-1t6umwRufEGzIPjHPjPeuuY1dCal0zU2bZeomkf4OA0MprFdlKCnXY3zeFkzDaCvKjwbFubeapm61P5+EbrAoA=="], + + "@googlemaps/markerclusterer": ["@googlemaps/markerclusterer@2.6.2", "", { "dependencies": { "@types/supercluster": "^7.1.3", "fast-equals": "^5.2.2", "supercluster": "^8.0.1" } }, "sha512-U6uVhq8iWhiIckA89sgRu8OK35mjd6/3CuoZKWakKEf0QmRRWpatlsPb3kqXkoWSmbcZkopRiI4dnW6DQSd7bQ=="], + "@humanwhocodes/config-array": ["@humanwhocodes/config-array@0.13.0", "", { "dependencies": { "@humanwhocodes/object-schema": "^2.0.3", "debug": "^4.3.1", "minimatch": "^3.0.5" } }, "sha512-DZLEEqFWQFiyK6h5YIeynKx7JlvCYWL0cImfSRXZ9l4Sg2efkFGTuFf6vzXjK1cq6IYkU+Eg/JizXw+TD2vRNw=="], "@humanwhocodes/module-importer": ["@humanwhocodes/module-importer@1.0.1", "", {}, "sha512-bxveV4V8v5Yb4ncFTT3rPSgZBOpCkjfK0y4oVVVJwIuDVBRMDXrPyXRL988i5ap9m9bnyEEjWfm5WkBmtffLfA=="], @@ -183,6 +187,10 @@ "@types/fs-extra": ["@types/fs-extra@8.1.5", "", { "dependencies": { "@types/node": "*" } }, "sha512-0dzKcwO+S8s2kuF5Z9oUWatQJj5Uq/iqphEtE3GQJVRRYm/tD1LglU2UnXi2A8jLq5umkGouOXOR9y0n613ZwQ=="], + "@types/geojson": ["@types/geojson@7946.0.16", "", {}, "sha512-6C8nqWur3j98U6+lXDfTUWIfgvZU+EumvpHKcYjujKH7woYyLj2sUmff0tRhrqM7BohUw7Pz3ZB1jj2gW9Fvmg=="], + + "@types/google.maps": ["@types/google.maps@3.66.4", "", {}, "sha512-t01LM0VeIsUOZWno7ABUv4XL82RalnhRGaTzWykPUtQ+hHT39vsIekeU+roqEaibwebpYIjS7dslx51HwG95nw=="], + "@types/json-schema": ["@types/json-schema@7.0.15", "", {}, "sha512-5+fP8P8MFNC+AyZCDxrB2pkZFPGzqQWUzpSeuuVLvm8VMcorNYavBqoFcxK8bQz4Qsbn4oUEEem4wDLfcysGHA=="], "@types/json5": ["@types/json5@0.0.29", "", {}, "sha512-dRLjCWHYg4oaA77cxO64oO+7JwCwnIzkZPdrrC71jQmQtlhM556pwKo5bUzqvZndkVbeFLIIi+9TC40JNF5hNQ=="], @@ -195,10 +203,14 @@ "@types/react-dom": ["@types/react-dom@18.3.7", "", { "peerDependencies": { "@types/react": "^18.0.0" } }, "sha512-MEe3UeoENYVFXzoXEWsvcpg6ZvlrFNlOQ7EOsvhI3CfAXwzPfO8Qwuxd40nepsYKqyyVQnTdEfv68q91yLcKrQ=="], + "@types/resize-observer-browser": ["@types/resize-observer-browser@0.1.11", "", {}, "sha512-cNw5iH8JkMkb3QkCoe7DaZiawbDQEUX8t7iuQaRTyLOyQCR2h+ibBD4GJt7p5yhUHrlOeL7ZtbxNHeipqNsBzQ=="], + "@types/semver": ["@types/semver@7.7.1", "", {}, "sha512-FmgJfu+MOcQ370SD0ev7EI8TlCAfKYU+B4m5T3yXc1CiRN94g/SZPtsCkk506aUDtlMnFZvasDwHHUcZUEaYuA=="], "@types/slice-ansi": ["@types/slice-ansi@4.0.0", "", {}, "sha512-+OpjSaq85gvlZAYINyzKpLeiFkSC4EsC6IIiT6v6TLSU5k5U83fHGj9Lel8oKEXM0HqgrMVCjXPDPVICtxF7EQ=="], + "@types/supercluster": ["@types/supercluster@7.1.3", "", { "dependencies": { "@types/geojson": "*" } }, "sha512-Z0pOY34GDFl3Q6hUFYf3HkTwKEE02e7QgtJppBt+beEAxnyOpJua+voGFvxINBHa06GwLFFym7gRPY2SiKIfIA=="], + "@typescript-eslint/eslint-plugin": ["@typescript-eslint/eslint-plugin@5.62.0", "", { "dependencies": { "@eslint-community/regexpp": "^4.4.0", "@typescript-eslint/scope-manager": "5.62.0", "@typescript-eslint/type-utils": "5.62.0", "@typescript-eslint/utils": "5.62.0", "debug": "^4.3.4", "graphemer": "^1.4.0", "ignore": "^5.2.0", "natural-compare-lite": "^1.4.0", "semver": "^7.3.7", "tsutils": "^3.21.0" }, "peerDependencies": { "@typescript-eslint/parser": "^5.0.0", "eslint": "^6.0.0 || ^7.0.0 || ^8.0.0" } }, "sha512-TiZzBSJja/LbhNPvk6yc0JrX9XqhQ0hdh6M2svYfsHGejaKFIAGd9MQ+ERIMzLGlN/kZoYIgdxFV0PuljTKXag=="], "@typescript-eslint/parser": ["@typescript-eslint/parser@5.62.0", "", { "dependencies": { "@typescript-eslint/scope-manager": "5.62.0", "@typescript-eslint/types": "5.62.0", "@typescript-eslint/typescript-estree": "5.62.0", "debug": "^4.3.4" }, "peerDependencies": { "eslint": "^6.0.0 || ^7.0.0 || ^8.0.0" } }, "sha512-VlJEV0fOQ7BExOsHYAGrgbEiZoi8D+Bl2+f6V2RrXerRSylnp+ZBHmPvaIa8cz0Ajx7WO7Z5RqfgYg7ED1nRhA=="], @@ -379,6 +391,8 @@ "fast-deep-equal": ["fast-deep-equal@3.1.3", "", {}, "sha512-f3qQ9oQy9j2AhBe/H9VC91wLmKBCCU/gDOnKNAYG5hswO7BLKj09Hc5HYNz9cGI++xlpDCIgDaitVs03ATR84Q=="], + "fast-equals": ["fast-equals@5.4.3", "", {}, "sha512-8unmvA0qrfpFWBYUate9BTGtQdKHWBYt+KdAIkag7Vvxe7wz8Q2nJg7fLMC0bJqe0bjP31kca7Ckaawrs4Istg=="], + "fast-glob": ["fast-glob@3.3.3", "", { "dependencies": { "@nodelib/fs.stat": "^2.0.2", "@nodelib/fs.walk": "^1.2.3", "glob-parent": "^5.1.2", "merge2": "^1.3.0", "micromatch": "^4.0.8" } }, "sha512-7MptL8U0cqcFdzIzwOTHoilX9x5BrNqye7Z/LuC7kCMRio1EMSyqRK3BEAUD7sXRq4iT4AzTVuZdhgQ2TCvYLg=="], "fast-json-stable-stringify": ["fast-json-stable-stringify@2.1.0", "", {}, "sha512-lhd/wF+Lk98HZoTCtlVraHtfh5XYijIjalXck7saUtuanSDyLMxnHhSXEDJqHxD7msR8D0uCmqlkwjCV8xvwHw=="], @@ -455,8 +469,6 @@ "hasown": ["hasown@2.0.2", "", { "dependencies": { "function-bind": "^1.1.2" } }, "sha512-0hJU9SCPvmMzIBdZFqNPXWa6dqh7WdH0cII9y+CyS8rG3nL48Bclra9HmKhVVUHyPWNH5Y7xDwAB7bfgSjkUMQ=="], - "husky": ["husky@9.1.7", "", { "bin": { "husky": "bin.js" } }, "sha512-5gs5ytaNjBrh5Ow3zrvdUUY+0VxIuWVL4i9irt6friV+BqdCfmV11CQTWMiBYWHbXhco+J1kHfTOUkePhCDvMA=="], - "ignore": ["ignore@5.3.2", "", {}, "sha512-hsBTNUqQTDwkWtcdYI2i06Y/nUBEsNEDJKjWdigLvegy8kDuJAS8uRlpkkcQpyEXL0Z/pjDy5HBmMjRCJ2gq+g=="], "import-fresh": ["import-fresh@3.3.1", "", { "dependencies": { "parent-module": "^1.0.0", "resolve-from": "^4.0.0" } }, "sha512-TR3KfrTZTYLPB6jUjfx6MF9WcWrHL9su5TObK4ZkYgBdWKPOFoSoQIdEuTuR82pmtxH2spWG9h6etwfr1pLBqQ=="], @@ -553,6 +565,8 @@ "jsonfile": ["jsonfile@6.2.0", "", { "dependencies": { "universalify": "^2.0.0" }, "optionalDependencies": { "graceful-fs": "^4.1.6" } }, "sha512-FGuPw30AdOIUTRMC2OMRtQV+jkVj2cfPqSeWXv1NEAJ1qZ5zb1X6z1mFhbfOB/iy3ssJCD+3KuZ8r8C3uVFlAg=="], + "kdbush": ["kdbush@4.1.0", "", {}, "sha512-e9vurzrXJQrFX6ckpHP3bvj5l+9CnYzkxDNnNQ1h2QTqdWsUAJgXiKdGNcOa1EY85dU8KbQ+z/FdQdB7P+9yfQ=="], + "keyv": ["keyv@4.5.4", "", { "dependencies": { "json-buffer": "3.0.1" } }, "sha512-oxVHkHR/EJf2CNXnWxRLW6mg7JyCCUcG0DtEGmL2ctUo1PNTin1PUil+r/+4r5MpVgC/fn1kjsx7mjSujKqIpw=="], "kleur": ["kleur@4.1.5", "", {}, "sha512-o+NO+8WrRiQEE4/7nwRJhN1HWpVmJm511pBHUxPLtp0BUISzlBplORYSmTclCnJvQq2tKu/sgl3xVpkc7ZWuQQ=="], @@ -779,6 +793,8 @@ "strip-json-comments": ["strip-json-comments@3.1.1", "", {}, "sha512-6fPc+R4ihwqP6N/aIv2f1gMH8lOVtWQHoqC4yK6oSDVVocumAsfCqjkXnqiYMhmMwS/mEHLp7Vehlt3ql6lEig=="], + "supercluster": ["supercluster@8.0.1", "", { "dependencies": { "kdbush": "^4.0.2" } }, "sha512-IiOea5kJ9iqzD2t7QJq/cREyLHTtSmUT6gQsweojg9WH2sYJqZK9SswTu6jrscO6D1G5v5vYZ9ru/eq85lXeZQ=="], + "supports-color": ["supports-color@7.2.0", "", { "dependencies": { "has-flag": "^4.0.0" } }, "sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw=="], "supports-preserve-symlinks-flag": ["supports-preserve-symlinks-flag@1.0.0", "", {}, "sha512-ot0WnXS9fgdkgIcePe6RHNk1WA8+muPa6cSjeR3V8K27q9BB1rTE3R1p7Hv0z1ZyAc8s6Vvv8DIyWf681MAt0w=="], @@ -863,7 +879,7 @@ "@capacitor/docgen/typescript": ["typescript@4.2.4", "", { "bin": { "tsc": "bin/tsc", "tsserver": "bin/tsserver" } }, "sha512-V+evlYHZnQkaz8TRBuxTA92yZBPotr5H+WhQ7bD3hZUndx5tGOa1fuCgeSjxAzM1RiN5IzvadIXTVefuuwZCRg=="], - "@capgo/capacitor-native-audio/typescript": ["typescript@5.9.3", "", { "bin": { "tsc": "bin/tsc", "tsserver": "bin/tsserver" } }, "sha512-jl1vZzPDinLr9eUt3J/t7V6FgNEw9QjvBPdysz9KfQDD41fQrC2Y4vKQdiaUpFT4bXlb1RHhLpp8wtm6M5TgSw=="], + "@capgo/capacitor-native-map/typescript": ["typescript@5.9.3", "", { "bin": { "tsc": "bin/tsc", "tsserver": "bin/tsserver" } }, "sha512-jl1vZzPDinLr9eUt3J/t7V6FgNEw9QjvBPdysz9KfQDD41fQrC2Y4vKQdiaUpFT4bXlb1RHhLpp8wtm6M5TgSw=="], "@ionic/utils-fs/fs-extra": ["fs-extra@9.1.0", "", { "dependencies": { "at-least-node": "^1.0.0", "graceful-fs": "^4.2.0", "jsonfile": "^6.0.1", "universalify": "^2.0.0" } }, "sha512-hcg3ZmepS30/7BSFqRvoo3DOMQu7IjqxO5nCDt+zM9XWjb33Wg7ziNT+Qvqbuc3+gWpzO02JubVyk2G4Zvo1OQ=="], diff --git a/example-app/ios/App/App.xcodeproj/project.pbxproj b/example-app/ios/App/App.xcodeproj/project.pbxproj index 7b5992e..61a4179 100644 --- a/example-app/ios/App/App.xcodeproj/project.pbxproj +++ b/example-app/ios/App/App.xcodeproj/project.pbxproj @@ -309,7 +309,7 @@ ); MARKETING_VERSION = 1.0; OTHER_SWIFT_FLAGS = "$(inherited) \"-D\" \"COCOAPODS\" \"-DDEBUG\""; - PRODUCT_BUNDLE_IDENTIFIER = app.capgo.nativeaudio; + PRODUCT_BUNDLE_IDENTIFIER = app.capgo.nativemap; PRODUCT_NAME = "$(TARGET_NAME)"; SWIFT_ACTIVE_COMPILATION_CONDITIONS = DEBUG; SWIFT_VERSION = 5.0; @@ -330,7 +330,7 @@ "@executable_path/Frameworks", ); MARKETING_VERSION = 1.0; - PRODUCT_BUNDLE_IDENTIFIER = app.capgo.nativeaudio; + PRODUCT_BUNDLE_IDENTIFIER = app.capgo.nativemap; PRODUCT_NAME = "$(TARGET_NAME)"; SWIFT_ACTIVE_COMPILATION_CONDITIONS = ""; SWIFT_VERSION = 5.0; diff --git a/example-app/ios/App/CapApp-SPM/Package.swift b/example-app/ios/App/CapApp-SPM/Package.swift index 6b92024..492ce35 100644 --- a/example-app/ios/App/CapApp-SPM/Package.swift +++ b/example-app/ios/App/CapApp-SPM/Package.swift @@ -11,8 +11,8 @@ let package = Package( targets: ["CapApp-SPM"]) ], dependencies: [ - .package(url: "https://github.com/ionic-team/capacitor-swift-pm.git", from: "8.0.0"), - .package(name: "CapgoCapacitorNativeAudio", path: "../../../node_modules/.bun/@capgo+capacitor-native-audio@file+../node_modules/@capgo/capacitor-native-audio") + .package(url: "https://github.com/ionic-team/capacitor-swift-pm.git", exact: "8.5.2"), + .package(name: "CapgoCapacitorNativeMap", path: "../../../node_modules/.bun/@capgo+capacitor-native-map@file+../node_modules/@capgo/capacitor-native-map") ], targets: [ .target( @@ -20,7 +20,7 @@ let package = Package( dependencies: [ .product(name: "Capacitor", package: "capacitor-swift-pm"), .product(name: "Cordova", package: "capacitor-swift-pm"), - .product(name: "CapgoCapacitorNativeAudio", package: "CapgoCapacitorNativeAudio") + .product(name: "CapgoCapacitorNativeMap", package: "CapgoCapacitorNativeMap") ] ) ] diff --git a/ios/Sources/NativeMapPlugin/CameraEvents.swift b/ios/Sources/NativeMapPlugin/CameraEvents.swift index d035f74..370f121 100644 --- a/ios/Sources/NativeMapPlugin/CameraEvents.swift +++ b/ios/Sources/NativeMapPlugin/CameraEvents.swift @@ -59,12 +59,16 @@ extension NativeMapPlugin { } let center = mapView.centerCoordinate - notifyListeners("onCameraIdle", data: [ + let payload: JSObject = [ "mapId": map.id, "latitude": center.latitude, "longitude": center.longitude, "zoom": map.currentZoom(), + "bearing": mapView.camera.heading, + "tilt": Double(mapView.camera.pitch), "bounds": map.boundsPayload() - ]) + ] + notifyListeners("onBoundsChanged", data: payload) + notifyListeners("onCameraIdle", data: payload) } } diff --git a/ios/Sources/NativeMapPlugin/CapacitorAppleMaps.swift b/ios/Sources/NativeMapPlugin/CapacitorAppleMaps.swift index 13e4a6a..edf9daf 100644 --- a/ios/Sources/NativeMapPlugin/CapacitorAppleMaps.swift +++ b/ios/Sources/NativeMapPlugin/CapacitorAppleMaps.swift @@ -221,6 +221,7 @@ public class Map: NSObject, UIGestureRecognizerDelegate { /// Remote icon urls with a download in flight, so a re-render (e.g. a /// clustering toggle re-adding every annotation) doesn't start a duplicate. var inFlightIconURLs: Set = [] + var pendingIconMarkers: [String: [NativeMapMarker]] = [:] /// Remote icon urls that returned a response but no usable image - a permanent /// miss we must not retry on every re-render (a transport error is left out so /// a later render can retry it). diff --git a/ios/Sources/NativeMapPlugin/CapacitorAppleMapsPlugin.swift b/ios/Sources/NativeMapPlugin/CapacitorAppleMapsPlugin.swift index 1bbee43..ad76d97 100644 --- a/ios/Sources/NativeMapPlugin/CapacitorAppleMapsPlugin.swift +++ b/ios/Sources/NativeMapPlugin/CapacitorAppleMapsPlugin.swift @@ -248,12 +248,22 @@ public class NativeMapPlugin: CAPPlugin, CAPBridgedPlugin, MKMapViewDelegate { guard let map = findMap(for: mapView) else { return } if let cluster = view.annotation as? MKClusterAnnotation { + let items: [JSObject] = cluster.memberAnnotations.compactMap { annotation in + guard let marker = annotation as? NativeMapMarker else { return nil } + return [ + "markerId": marker.markerId, + "latitude": marker.coordinate.latitude, + "longitude": marker.coordinate.longitude, + "title": marker.title ?? "", + "snippet": marker.subtitle ?? "" + ] + } notifyListeners("onClusterClick", data: [ "mapId": map.id, "latitude": cluster.coordinate.latitude, "longitude": cluster.coordinate.longitude, - "count": cluster.memberAnnotations.count, - "markerIds": cluster.memberAnnotations.compactMap { ($0 as? NativeMapMarker)?.markerId } + "size": cluster.memberAnnotations.count, + "items": items ]) map.expandCluster(cluster, in: mapView) return diff --git a/ios/Sources/NativeMapPlugin/GoogleMapsBridge.swift b/ios/Sources/NativeMapPlugin/GoogleMapsBridge.swift index ebb1677..115fc22 100644 --- a/ios/Sources/NativeMapPlugin/GoogleMapsBridge.swift +++ b/ios/Sources/NativeMapPlugin/GoogleMapsBridge.swift @@ -5,10 +5,20 @@ import Capacitor extension NativeMapPlugin { @objc func enableTouch(_ call: CAPPluginCall) { + guard let id = call.getString("id"), let map = maps[id] else { + call.reject("map not found", PluginError.mapNotFound) + return + } + map.setGestures(scroll: true, zoom: true, rotate: true, pitch: true) call.resolve() } @objc func disableTouch(_ call: CAPPluginCall) { + guard let id = call.getString("id"), let map = maps[id] else { + call.reject("map not found", PluginError.mapNotFound) + return + } + map.setGestures(scroll: false, zoom: false, rotate: false, pitch: false) call.resolve() } @@ -82,7 +92,25 @@ extension NativeMapPlugin { } @objc func mapBoundsExtend(_ call: CAPPluginCall) { - call.reject("mapBoundsExtend is not implemented on iOS", PluginError.unavailable) + guard let boundsObj = call.getObject("bounds"), + let pointObj = call.getObject("point") else { + call.reject("bounds and point are required", PluginError.invalidArgument) + return + } + let sw = boundsObj["southwest"] as? JSObject ?? [:] + let ne = boundsObj["northeast"] as? JSObject ?? [:] + let lat = pointObj["lat"] as? Double ?? 0 + let lng = pointObj["lng"] as? Double ?? 0 + let south = min(sw["lat"] as? Double ?? lat, lat) + let west = min(sw["lng"] as? Double ?? lng, lng) + let north = max(ne["lat"] as? Double ?? lat, lat) + let east = max(ne["lng"] as? Double ?? lng, lng) + call.resolve([ + "bounds": [ + "southwest": ["lat": south, "lng": west], + "northeast": ["lat": north, "lng": east] + ] + ]) } @objc func dispatchMapEvent(_ call: CAPPluginCall) { diff --git a/ios/Sources/NativeMapPlugin/MarkerIcons.swift b/ios/Sources/NativeMapPlugin/MarkerIcons.swift index 0161e8e..e286ab7 100644 --- a/ios/Sources/NativeMapPlugin/MarkerIcons.swift +++ b/ios/Sources/NativeMapPlugin/MarkerIcons.swift @@ -51,16 +51,22 @@ extension Map { /// misses so a re-render doesn't re-download. Must be called on the main /// thread; the completion hops back to it. private func downloadRemoteIcon(_ iconUrl: String, for marker: NativeMapMarker, in mapView: MKMapView) { - guard !failedIconURLs.contains(iconUrl), !inFlightIconURLs.contains(iconUrl) else { return } + guard !failedIconURLs.contains(iconUrl) else { return } + if inFlightIconURLs.contains(iconUrl) { + pendingIconMarkers[iconUrl, default: []].append(marker) + return + } guard let url = URL(string: iconUrl) else { failedIconURLs.insert(iconUrl) return } inFlightIconURLs.insert(iconUrl) + pendingIconMarkers[iconUrl] = [marker] URLSession.shared.dataTask(with: url) { [weak self, weak mapView] data, _, error in DispatchQueue.main.async { guard let self = self else { return } self.inFlightIconURLs.remove(iconUrl) + let markers = self.pendingIconMarkers.removeValue(forKey: iconUrl) ?? [] guard let data = data, let image = UIImage(data: data) else { // A response with no usable image (404 body, wrong content, @@ -71,11 +77,12 @@ extension Map { } self.iconCache.setObject(image, forKey: iconUrl as NSString) - if let view = mapView?.view(for: marker) { - let sized = self.resize(image, marker.iconSize) + for waitingMarker in markers where waitingMarker.iconUrl == iconUrl { + guard let view = mapView?.view(for: waitingMarker) else { continue } + let sized = self.resize(image, waitingMarker.iconSize) view.image = sized if let sized = sized { - view.centerOffset = marker.centerOffset(for: sized.size) + view.centerOffset = waitingMarker.centerOffset(for: sized.size) } } } diff --git a/scripts/check-capacitor-plugin-wiring.mjs b/scripts/check-capacitor-plugin-wiring.mjs index 538d9b5..582eac1 100644 --- a/scripts/check-capacitor-plugin-wiring.mjs +++ b/scripts/check-capacitor-plugin-wiring.mjs @@ -238,6 +238,9 @@ if (supportsIos) { if (podName && pkgName && podName !== pkgName) { errors.push(`Podspec: s.name=${podName} != Package(name)=${pkgName}`); } + if (pkgName && !libNames.length) { + errors.push('SPM: Package.swift must declare at least one .library product'); + } if (pkgName && libNames.length && !libNames.includes(pkgName)) { errors.push(`SPM: Package(name)=${pkgName} not present in .library(name) list ${JSON.stringify(libNames)}`); } diff --git a/src/definitions.ts b/src/definitions.ts index ff26582..817ad7d 100644 --- a/src/definitions.ts +++ b/src/definitions.ts @@ -331,11 +331,11 @@ export interface MapPadding { } /** - * A tile overlay is an image placed on top of your map at a specific zoom level. Available on iOS, Android and Web + * A tile overlay is an image placed on top of your map at a specific zoom level. Supported on Android and web only. */ export interface TileOverlay { /** - * A string representing the tile url. Should contain `{x}`, `{y}` and `{z}` so they can be replaced with actual values for x, y and zoom. Available on iOS, Android and Web + * A string representing the tile url. Should contain `{x}`, `{y}` and `{z}` so they can be replaced with actual values for x, y and zoom. Android and web only. * * @type {string} */ @@ -486,7 +486,7 @@ export interface PolylineCallbackData { export interface CameraIdleCallbackData { mapId: string; - bounds: LatLngBounds; + bounds: LatLngBoundsInterface; bearing: number; latitude: number; longitude: number; diff --git a/src/implementation.ts b/src/implementation.ts index 041bdcb..a83657c 100644 --- a/src/implementation.ts +++ b/src/implementation.ts @@ -24,10 +24,8 @@ export interface CreateMapArgs { */ id: string; /** - * The Google Maps SDK API Key. - */ - /** - * Google Maps API key. Required on Android and web. Not used on iOS (MapKit). + * Google Maps API key. Required on web. On Android, also set + * `com.google.android.geo.API_KEY` in the app manifest. Not used on iOS (MapKit). */ apiKey?: string; /** @@ -229,7 +227,8 @@ CapacitorNativeMap.addListener('isMapInFocus', (data) => { const y = data.y; const elem = document.elementFromPoint(x, y) as HTMLElement | null; - const internalId = elem?.dataset?.internalId; + const mapElement = elem?.closest('[data-internal-id]') as HTMLElement | null; + const internalId = mapElement?.dataset?.internalId; const mapInFocus = internalId === data.mapId; CapacitorNativeMap.dispatchMapEvent({ id: data.mapId, focus: mapInFocus }); diff --git a/src/map.ts b/src/map.ts index 0054172..5895b0c 100644 --- a/src/map.ts +++ b/src/map.ts @@ -116,6 +116,9 @@ export class NativeMap { private id: string; private element: HTMLElement | null = null; private resizeObserver: ResizeObserver | null = null; + private orientationChangeHandler = (): void => { + setTimeout(() => this.updateMapBounds(), 500); + }; private onBoundsChangedListener?: PluginListenerHandle; private onCameraIdleListener?: PluginListenerHandle; @@ -241,6 +244,16 @@ export class NativeMap { newMap.resizeObserver.observe(newMap.element); } + let onMapReadyListener: PluginListenerHandle | undefined; + if (callback) { + onMapReadyListener = await CapacitorNativeMap.addListener('onMapReady', (data: MapReadyCallbackData) => { + if (data.mapId == newMap.id) { + callback(data); + onMapReadyListener?.remove(); + } + }); + } + // small delay to allow for iOS WKWebView to setup corresponding element sub-scroll views ??? await new Promise((resolve, reject) => { setTimeout(async () => { @@ -253,15 +266,6 @@ export class NativeMap { }, 200); }); - if (callback) { - const onMapReadyListener = await CapacitorNativeMap.addListener('onMapReady', (data: MapReadyCallbackData) => { - if (data.mapId == newMap.id) { - callback(data); - onMapReadyListener.remove(); - } - }); - } - return newMap; } @@ -628,13 +632,9 @@ export class NativeMap { window.addEventListener('scroll', this.handleScrollEvent); window.addEventListener('resize', this.handleScrollEvent); if (screen.orientation) { - screen.orientation.addEventListener('change', () => { - setTimeout(this.updateMapBounds, 500); - }); + screen.orientation.addEventListener('change', this.orientationChangeHandler); } else { - window.addEventListener('orientationchange', () => { - setTimeout(this.updateMapBounds, 500); - }); + window.addEventListener('orientationchange', this.orientationChangeHandler); } } @@ -643,13 +643,9 @@ export class NativeMap { window.removeEventListener('scroll', this.handleScrollEvent); window.removeEventListener('resize', this.handleScrollEvent); if (screen.orientation) { - screen.orientation.removeEventListener('change', () => { - setTimeout(this.updateMapBounds, 1000); - }); + screen.orientation.removeEventListener('change', this.orientationChangeHandler); } else { - window.removeEventListener('orientationchange', () => { - setTimeout(this.updateMapBounds, 1000); - }); + window.removeEventListener('orientationchange', this.orientationChangeHandler); } } diff --git a/src/web.ts b/src/web.ts index 02411bd..cc65817 100644 --- a/src/web.ts +++ b/src/web.ts @@ -63,7 +63,6 @@ export class CapacitorNativeMapWeb extends WebPlugin implements NativeMapPlugin private currPolygonId = 0; private currCircleId = 0; private currPolylineId = 0; - private currMapId = 0; private onClusterClickHandler: onClusterClickHandler = ( _: google.maps.MapMouseEvent, @@ -490,10 +489,9 @@ export class CapacitorNativeMapWeb extends WebPlugin implements NativeMapPlugin } await this.importGoogleLib(_args.apiKey, _args.region, _args.language); - // Ensure we have a Map ID for Advanced Markers const config = { ..._args.config }; if (!config.mapId) { - config.mapId = `capacitor_map_${this.currMapId++}`; + throw new Error('config.mapId is required on web (create a Map ID in Google Cloud Console for Advanced Markers)'); } this.maps[_args.id] = { From 97c3281418ad02b2fd8c068b4cffbeb7e19ff119 Mon Sep 17 00:00:00 2001 From: Cursor Agent Date: Thu, 1 Oct 2026 00:48:41 +0000 Subject: [PATCH 07/42] fix(ci): Android manifest placeholder and iOS camera payload typing Co-authored-by: Martin DONADIEU --- example-app/android/app/build.gradle | 3 +++ ios/Sources/NativeMapPlugin/CameraEvents.swift | 2 +- 2 files changed, 4 insertions(+), 1 deletion(-) diff --git a/example-app/android/app/build.gradle b/example-app/android/app/build.gradle index 8aef0c8..33fa869 100644 --- a/example-app/android/app/build.gradle +++ b/example-app/android/app/build.gradle @@ -9,6 +9,9 @@ android { targetSdkVersion = rootProject.ext.targetSdkVersion versionCode = 1 versionName = "1.0" + manifestPlaceholders = [ + GOOGLE_MAPS_API_KEY: System.getenv("GOOGLE_MAPS_API_KEY") ?: "REPLACE_WITH_YOUR_GOOGLE_MAPS_API_KEY" + ] testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner" aaptOptions { // Files and dirs to omit from the packaged assets dir, modified to accommodate modern web apps. diff --git a/ios/Sources/NativeMapPlugin/CameraEvents.swift b/ios/Sources/NativeMapPlugin/CameraEvents.swift index 370f121..51eb0a0 100644 --- a/ios/Sources/NativeMapPlugin/CameraEvents.swift +++ b/ios/Sources/NativeMapPlugin/CameraEvents.swift @@ -66,7 +66,7 @@ extension NativeMapPlugin { "zoom": map.currentZoom(), "bearing": mapView.camera.heading, "tilt": Double(mapView.camera.pitch), - "bounds": map.boundsPayload() + "bounds": map.boundsPayload() as JSObject ] notifyListeners("onBoundsChanged", data: payload) notifyListeners("onCameraIdle", data: payload) From ab508769e84df519999f863bf4cfa5b997968847 Mon Sep 17 00:00:00 2001 From: Cursor Agent Date: Thu, 1 Oct 2026 00:55:13 +0000 Subject: [PATCH 08/42] fix(ci): iOS camera event payload and Android location permissions Co-authored-by: Martin DONADIEU --- example-app/android/app/src/main/AndroidManifest.xml | 1 + ios/Sources/NativeMapPlugin/CameraEvents.swift | 4 ++-- 2 files changed, 3 insertions(+), 2 deletions(-) diff --git a/example-app/android/app/src/main/AndroidManifest.xml b/example-app/android/app/src/main/AndroidManifest.xml index 7315cbf..a2047de 100644 --- a/example-app/android/app/src/main/AndroidManifest.xml +++ b/example-app/android/app/src/main/AndroidManifest.xml @@ -42,6 +42,7 @@ + diff --git a/ios/Sources/NativeMapPlugin/CameraEvents.swift b/ios/Sources/NativeMapPlugin/CameraEvents.swift index 51eb0a0..1e8e329 100644 --- a/ios/Sources/NativeMapPlugin/CameraEvents.swift +++ b/ios/Sources/NativeMapPlugin/CameraEvents.swift @@ -59,14 +59,14 @@ extension NativeMapPlugin { } let center = mapView.centerCoordinate - let payload: JSObject = [ + let payload: PluginCallResultData = [ "mapId": map.id, "latitude": center.latitude, "longitude": center.longitude, "zoom": map.currentZoom(), "bearing": mapView.camera.heading, "tilt": Double(mapView.camera.pitch), - "bounds": map.boundsPayload() as JSObject + "bounds": map.boundsPayload() ] notifyListeners("onBoundsChanged", data: payload) notifyListeners("onCameraIdle", data: payload) From ec38a9fc864963488466b28a0c257ec12ae0fdb5 Mon Sep 17 00:00:00 2001 From: Cursor Agent Date: Thu, 1 Oct 2026 01:05:43 +0000 Subject: [PATCH 09/42] chore: scope CodeRabbit reviews to plugin source paths Co-authored-by: Martin DONADIEU --- .coderabbit.yaml | 13 +++++++++++++ example-app/public/audio/beep.wav | Bin 52964 -> 0 bytes example-app/public/audio/music.mp3 | Bin 296934 -> 0 bytes example-app/supabase/.branches/_current_branch | 1 - example-app/supabase/.temp/cli-latest | 1 - 5 files changed, 13 insertions(+), 2 deletions(-) create mode 100644 .coderabbit.yaml delete mode 100644 example-app/public/audio/beep.wav delete mode 100644 example-app/public/audio/music.mp3 delete mode 100644 example-app/supabase/.branches/_current_branch delete mode 100644 example-app/supabase/.temp/cli-latest diff --git a/.coderabbit.yaml b/.coderabbit.yaml new file mode 100644 index 0000000..a526602 --- /dev/null +++ b/.coderabbit.yaml @@ -0,0 +1,13 @@ +# Keep CodeRabbit within the OSS per-review file cap: focus on plugin source. +reviews: + path_filters: + - "!example-app/**" + - "!.github/**" + - "!.maestro/**" + - "!assets/**" + - "!legal/**" + - "!README.md" + - "!CHANGELOG.md" + - "!AGENTS.md" + - "!NOTICE" + - "!THIRD_PARTY_LICENSES" diff --git a/example-app/public/audio/beep.wav b/example-app/public/audio/beep.wav deleted file mode 100644 index 9c382b1a98e9ce5a606a427c8baedd713d55a386..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 52964 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

        i`V#?l3 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

          *8jry8i&^4$0Bz8zz1{%p`10uS5|`1<$dlbD9x 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 qi$@c8;11Vu`6dXC0&{}! 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 Date: Thu, 1 Oct 2026 01:57:05 +0000 Subject: [PATCH 10/42] fix: address CodeRabbit review findings on native map v1 - Android: register map listeners in onMapReady; fix removeCircles cleanup - Android: parse bounds/points before coroutines for mapBounds* APIs - iOS: maps dictionary locking, permission callback, search resolve on main - iOS: snapshot concurrency, buildings flag, zoom clamp guard, view helpers - Web: geolocation promise errors, clustering attach/detach, marker opacity - TS: avoid mutating caller create options; bundle web deps in rollup IIFE Co-authored-by: Martin DONADIEU --- .../plugins/nativemap/CapacitorGoogleMap.kt | 4 +- .../nativemap/CapacitorGoogleMapsPlugin.kt | 52 +++++++---- bun.lock | 21 ++++- .../NativeMapPlugin/CameraEvents.swift | 16 ++++ .../NativeMapPlugin/CapacitorAppleMaps.swift | 1 + .../CapacitorAppleMapsPlugin.swift | 51 ++++++---- ios/Sources/NativeMapPlugin/Permissions.swift | 3 + ios/Sources/NativeMapPlugin/Search.swift | 12 ++- ios/Sources/NativeMapPlugin/Snapshot.swift | 5 +- ios/Sources/NativeMapPlugin/ViewHelpers.swift | 20 ++-- package.json | 1 + rollup.config.mjs | 3 + src/map.ts | 5 +- src/web.ts | 93 ++++++++++++------- 14 files changed, 197 insertions(+), 90 deletions(-) diff --git a/android/src/main/java/com/capgo/plugins/nativemap/CapacitorGoogleMap.kt b/android/src/main/java/com/capgo/plugins/nativemap/CapacitorGoogleMap.kt index effdba3..0c21b22 100644 --- a/android/src/main/java/com/capgo/plugins/nativemap/CapacitorGoogleMap.kt +++ b/android/src/main/java/com/capgo/plugins/nativemap/CapacitorGoogleMap.kt @@ -57,7 +57,6 @@ class CapacitorNativeMapView( mapView = MapView(bridge.context, config.googleMapOptions) initMap() - setListeners() } private fun initMap() { @@ -563,7 +562,7 @@ class CapacitorNativeMapView( val circle = circles[it] if (circle != null) { circle.googleMapsCircle?.remove() - markers.remove(it) + circles.remove(it) } } @@ -937,6 +936,7 @@ class CapacitorNativeMapView( override fun onMapReady(map: GoogleMap) { googleMap = map + setListeners() val data = JSObject() data.put("mapId", this@CapacitorNativeMapView.id) diff --git a/android/src/main/java/com/capgo/plugins/nativemap/CapacitorGoogleMapsPlugin.kt b/android/src/main/java/com/capgo/plugins/nativemap/CapacitorGoogleMapsPlugin.kt index 69e6f83..11b6d2c 100644 --- a/android/src/main/java/com/capgo/plugins/nativemap/CapacitorGoogleMapsPlugin.kt +++ b/android/src/main/java/com/capgo/plugins/nativemap/CapacitorGoogleMapsPlugin.kt @@ -989,14 +989,20 @@ class CapacitorNativeMapPlugin : Plugin(), OnMapsSdkInitializedCallback { try { val boundsObject = call.getObject("bounds") val pointObject = call.getObject("point") + val bounds = createLatLngBounds(boundsObject) + val point = createLatLng(pointObject) CoroutineScope(Dispatchers.Main).launch { - val bounds = createLatLngBounds(boundsObject) - val point = createLatLng(pointObject) - val contains = bounds.contains(point) - val data = JSObject() - data.put("contains", contains) - call.resolve(data) + try { + val contains = bounds.contains(point) + val data = JSObject() + data.put("contains", contains) + call.resolve(data) + } catch (e: NativeMapsError) { + handleError(call, e) + } catch (e: Exception) { + handleError(call, e) + } } } catch (e: NativeMapsError) { handleError(call, e) @@ -1018,13 +1024,19 @@ class CapacitorNativeMapPlugin : Plugin(), OnMapsSdkInitializedCallback { call.getObject("bounds") ?: throw InvalidArgumentsError("bounds is missing") val padding = call.getInt("padding", 0)!! + val bounds = createLatLngBounds(boundsObject) CoroutineScope(Dispatchers.Main).launch { - val bounds = createLatLngBounds(boundsObject) - val density = bridge.context.resources.displayMetrics.density - val scaledPadding = (padding * density).toInt() - map.fitBounds(bounds, scaledPadding) - call.resolve() + try { + val density = bridge.context.resources.displayMetrics.density + val scaledPadding = (padding * density).toInt() + map.fitBounds(bounds, scaledPadding) + call.resolve() + } catch (e: NativeMapsError) { + handleError(call, e) + } catch (e: Exception) { + handleError(call, e) + } } } catch (e: NativeMapsError) { handleError(call, e) @@ -1038,14 +1050,20 @@ class CapacitorNativeMapPlugin : Plugin(), OnMapsSdkInitializedCallback { try { val boundsObject = call.getObject("bounds") val pointObject = call.getObject("point") + val bounds = createLatLngBounds(boundsObject) + val point = createLatLng(pointObject) CoroutineScope(Dispatchers.Main).launch { - val bounds = createLatLngBounds(boundsObject) - val point = createLatLng(pointObject) - val newBounds = bounds.including(point) - val data = JSObject() - data.put("bounds", getLatLngBoundsJSObject(newBounds)) - call.resolve(data) + try { + val newBounds = bounds.including(point) + val data = JSObject() + data.put("bounds", getLatLngBoundsJSObject(newBounds)) + call.resolve(data) + } catch (e: NativeMapsError) { + handleError(call, e) + } catch (e: Exception) { + handleError(call, e) + } } } catch (e: NativeMapsError) { handleError(call, e) diff --git a/bun.lock b/bun.lock index 749c1d2..7a385f4 100644 --- a/bun.lock +++ b/bun.lock @@ -18,6 +18,7 @@ "@ionic/eslint-config": "^0.4.0", "@ionic/prettier-config": "^4.0.0", "@ionic/swiftlint-config": "^2.0.0", + "@rollup/plugin-node-resolve": "^16.0.3", "@types/node": "^24.10.1", "@types/resize-observer-browser": "^0.1.11", "eslint": "^8.57.1", @@ -100,6 +101,10 @@ "@nodelib/fs.walk": ["@nodelib/fs.walk@1.2.8", "", { "dependencies": { "@nodelib/fs.scandir": "2.1.5", "fastq": "^1.6.0" } }, "sha512-oGB+UxlgWcgQkgwo8GcEGwemoTFt3FIO9ababBmaGwXIoBKZ+GTy0pP185beGg7Llih/NSHSV2XAs1lnznocSg=="], + "@rollup/plugin-node-resolve": ["@rollup/plugin-node-resolve@16.0.3", "", { "dependencies": { "@rollup/pluginutils": "^5.0.1", "@types/resolve": "1.20.2", "deepmerge": "^4.2.2", "is-module": "^1.0.0", "resolve": "^1.22.1" }, "peerDependencies": { "rollup": "^2.78.0||^3.0.0||^4.0.0" }, "optionalPeers": ["rollup"] }, "sha512-lUYM3UBGuM93CnMPG1YocWu7X802BrNF3jW2zny5gQyLQgRFJhV1Sq0Zi74+dh/6NBx1DxFC4b4GXg9wUCG5Qg=="], + + "@rollup/pluginutils": ["@rollup/pluginutils@5.4.0", "", { "dependencies": { "@types/estree": "^1.0.0", "estree-walker": "^2.0.2", "picomatch": "^4.0.2" }, "peerDependencies": { "rollup": "^1.20.0||^2.0.0||^3.0.0||^4.0.0" }, "optionalPeers": ["rollup"] }, "sha512-MfPp06CjRLfXQ3wY0R8vJDYBy/MvVcc9OulEfR0B8Iv9ko+GCNaRZ+EpJYFl27LhKsZK0o420sYCRHCjfCgeUg=="], + "@rollup/rollup-android-arm-eabi": ["@rollup/rollup-android-arm-eabi@4.63.5", "", { "os": "android", "cpu": "arm" }, "sha512-J25QJU+B78T4FhhBsNpLJyVWOi31mwtpcMwywHmOKH65Q9IWGA81gPj+dnwlhU8wktVriYE+tFAaQgrnJRzAZg=="], "@rollup/rollup-android-arm64": ["@rollup/rollup-android-arm64@4.63.5", "", { "os": "android", "cpu": "arm64" }, "sha512-LDopB3zuZM5Ux9TT2luNEBJW/tYbGU2g1d+VpKk6I+gSKDb+/7sYE6M225gRQt4RbMX6MSwMsVR/phdjVUgRLg=="], @@ -168,6 +173,8 @@ "@types/resize-observer-browser": ["@types/resize-observer-browser@0.1.11", "", {}, "sha512-cNw5iH8JkMkb3QkCoe7DaZiawbDQEUX8t7iuQaRTyLOyQCR2h+ibBD4GJt7p5yhUHrlOeL7ZtbxNHeipqNsBzQ=="], + "@types/resolve": ["@types/resolve@1.20.2", "", {}, "sha512-60BCwRFOZCQhDncwQdxxeOEEkbc5dIMccYLwbxsS4TUNeVECQ/pBJ0j09mrHOl/JJvpRPGwO9SvE4nR2Nb/a4Q=="], + "@types/semver": ["@types/semver@7.8.0", "", {}, "sha512-1mAINjtQCXXeLkJ9ehXkwOcBpqtLxiVtKhpUf83DdRNdQKV0iXZpaHYqRr7nj+wvxuJzoAmAwXI+sCNMv1CzLQ=="], "@types/slice-ansi": ["@types/slice-ansi@4.0.0", "", {}, "sha512-+OpjSaq85gvlZAYINyzKpLeiFkSC4EsC6IIiT6v6TLSU5k5U83fHGj9Lel8oKEXM0HqgrMVCjXPDPVICtxF7EQ=="], @@ -280,6 +287,8 @@ "deep-is": ["deep-is@0.1.4", "", {}, "sha512-oIPzksmTg4/MriiaYGO+okXDT7ztn/w3Eptv/+gSIdMdKsJo0u4CfYNFJPy+4SKMuCqGw2wxnA+URMg3t8a/bQ=="], + "deepmerge": ["deepmerge@4.3.1", "", {}, "sha512-3sUqbMEc77XqpdNO7FRyRog+eW3ph+GYCbj+rK+uYyRMuwsVy0rMiVtPn+QJlKFvWP/1PYpapqYn0Me2knFn+A=="], + "define-data-property": ["define-data-property@1.1.4", "", { "dependencies": { "es-define-property": "^1.0.0", "es-errors": "^1.3.0", "gopd": "^1.0.1" } }, "sha512-rBMvIzlpA8v6E+SJZoo++HAYqsLrkg7MSfIinMPFhmkorw7X+dOXVJQs+QT69zGkzMyfDnIMN2Wid1+NbL3T+A=="], "define-lazy-prop": ["define-lazy-prop@2.0.0", "", {}, "sha512-Ds09qNh8yw3khSjiJjiUInaGX9xlqZDY7JVryGxdxV7NPeuqQfplOpQ66yJFZut3jLa5zOwkXw1g9EI2uKh4Og=="], @@ -342,6 +351,8 @@ "estraverse": ["estraverse@5.3.0", "", {}, "sha512-MMdARuVEQziNTeJD8DgMqmhwR11BRQ/cBP+pLtYdSTnf3MIO8fFeiINEbX36ZdNlfU/7A9f3gUw49B3oQsvwBA=="], + "estree-walker": ["estree-walker@2.0.2", "", {}, "sha512-Rfkk/Mp/DL7JVje3u18FxFujQlTNR2q6QfMSMB7AvCBx91NGj/ba3kCfza0f6dVDbw7YlRf/nDrn7pQrCCyQ/w=="], + "esutils": ["esutils@2.0.3", "", {}, "sha512-kVscqXk4OCp68SZ0dkgEKVi6/8ij300KBWTJq32P/dYeWTSwK41WyTxalN1eRmA5Z9UU/LX9D7FWSmV9SAYx6g=="], "fast-deep-equal": ["fast-deep-equal@3.1.3", "", {}, "sha512-f3qQ9oQy9j2AhBe/H9VC91wLmKBCCU/gDOnKNAYG5hswO7BLKj09Hc5HYNz9cGI++xlpDCIgDaitVs03ATR84Q=="], @@ -470,6 +481,8 @@ "is-map": ["is-map@2.0.3", "", {}, "sha512-1Qed0/Hr2m+YqxnM09CjA2d/i6YZNfF6R2oRAOj36eUdS6qIV/huPJNSEpKbupewFs+ZsJlxsjjPbc0/afW6Lw=="], + "is-module": ["is-module@1.0.0", "", {}, "sha512-51ypPSPCoTEIN9dy5Oy+h4pShgJmPCygKfyRCISBI+JoWT/2oJvK8QPxmwv7b/p239jXrm9M1mlQbyKJ5A152g=="], + "is-negative-zero": ["is-negative-zero@2.0.3", "", {}, "sha512-5KoIu2Ngpyek75jXodFvnafB6DJgr3u8uuK0LEZJjrU19DrMD3EVERaR8sjz8CCGgpZvxPl9SuE1GMVPFHx1mw=="], "is-number": ["is-number@7.0.0", "", {}, "sha512-41Cifkg6e8TylSpdtTpeLVMqvSBEVzTttHvERD741+pnZ8ANv0004MRL43QKPDlK9cGvNp6NZWZUBlbGXYxxng=="], @@ -606,7 +619,7 @@ "picocolors": ["picocolors@1.1.1", "", {}, "sha512-xceH2snhtb5M9liqDsmEw56le376mTZkEX/jEb/RxNFyegNul7eNslCXP9FDj/Lcu0X8KEyMceP2ntpaHrDEVA=="], - "picomatch": ["picomatch@2.3.2", "", {}, "sha512-V7+vQEJ06Z+c5tSye8S+nHUfI51xoXIXjHQ99cQtKUkQqqO1kO/KCJUfZXuB47h/YBlDhah2H3hdUGXn8ie0oA=="], + "picomatch": ["picomatch@4.0.7", "", {}, "sha512-qcJu88Q2IWqJsDD529JKMdwGm/dvInW4HvQnRwiH9JtihJvzGOscDtHE3x1pBKeUOTysQ8kVmLnJ2kJu7yhcGA=="], "plist": ["plist@3.1.1", "", { "dependencies": { "@xmldom/xmldom": "^0.9.10", "base64-js": "^1.5.1", "xmlbuilder": "^15.1.1" } }, "sha512-ZIfcLJC+7E7FBFnDxm9MPmt7D+DidyQ26lewieO75AdhA2ayMtsJSES0iWzqJQbcVRSrTufQoy0DR94xHue0oA=="], @@ -632,7 +645,7 @@ "regexp.prototype.flags": ["regexp.prototype.flags@1.5.4", "", { "dependencies": { "call-bind": "^1.0.8", "define-properties": "^1.2.1", "es-errors": "^1.3.0", "get-proto": "^1.0.1", "gopd": "^1.2.0", "set-function-name": "^2.0.2" } }, "sha512-dYqgNSZbDwkaJ2ceRd9ojCGjBq+mOm9LmtXnAnEGyHhN/5R7iDW2TRw3h+o/jCFxus3P2LfWIIiwowAjANm7IA=="], - "resolve": ["resolve@2.0.0-next.7", "", { "dependencies": { "es-errors": "^1.3.0", "is-core-module": "^2.16.2", "node-exports-info": "^1.6.0", "object-keys": "^1.1.1", "path-parse": "^1.0.7", "supports-preserve-symlinks-flag": "^1.0.0" }, "bin": { "resolve": "bin/resolve" } }, "sha512-tqt+NBWwyaMgw3zDsnygx4CByWjQEJHOPMdslYhppaQSJUtL/D4JO9CcBBlhPoI8lz9oJIDXkwXfhF4aWqP8xQ=="], + "resolve": ["resolve@1.22.12", "", { "dependencies": { "es-errors": "^1.3.0", "is-core-module": "^2.16.1", "path-parse": "^1.0.7", "supports-preserve-symlinks-flag": "^1.0.0" }, "bin": { "resolve": "bin/resolve" } }, "sha512-TyeJ1zif53BPfHootBGwPRYT1RUt6oGWsaQr8UyZW/eAm9bKoijtvruSDEmZHm92CwS9nj7/fWttqPCgzep8CA=="], "resolve-from": ["resolve-from@4.0.0", "", {}, "sha512-pb/MYmXstAkysRFx8piNI1tGFNQIFA3vkE3Gq4EuA1dF6gHp/+vgZqsCGJapvy8N3Q+4o7FwvquPJcnZ7RYy4g=="], @@ -800,6 +813,8 @@ "eslint-import-resolver-node/debug": ["debug@3.2.7", "", { "dependencies": { "ms": "^2.1.1" } }, "sha512-CFjzYYAi4ThfiQvizrFQevTTXHtnCqWfe7x1AhgEscTz6ZbLbfoLRLPugTQyBth6f8ZERVUSyWHFD/7Wu4t1XQ=="], + "eslint-import-resolver-node/resolve": ["resolve@2.0.0-next.7", "", { "dependencies": { "es-errors": "^1.3.0", "is-core-module": "^2.16.2", "node-exports-info": "^1.6.0", "object-keys": "^1.1.1", "path-parse": "^1.0.7", "supports-preserve-symlinks-flag": "^1.0.0" }, "bin": { "resolve": "bin/resolve" } }, "sha512-tqt+NBWwyaMgw3zDsnygx4CByWjQEJHOPMdslYhppaQSJUtL/D4JO9CcBBlhPoI8lz9oJIDXkwXfhF4aWqP8xQ=="], + "eslint-module-utils/debug": ["debug@3.2.7", "", { "dependencies": { "ms": "^2.1.1" } }, "sha512-CFjzYYAi4ThfiQvizrFQevTTXHtnCqWfe7x1AhgEscTz6ZbLbfoLRLPugTQyBth6f8ZERVUSyWHFD/7Wu4t1XQ=="], "eslint-plugin-import/debug": ["debug@3.2.7", "", { "dependencies": { "ms": "^2.1.1" } }, "sha512-CFjzYYAi4ThfiQvizrFQevTTXHtnCqWfe7x1AhgEscTz6ZbLbfoLRLPugTQyBth6f8ZERVUSyWHFD/7Wu4t1XQ=="], @@ -814,6 +829,8 @@ "glob/minimatch": ["minimatch@10.2.6", "", { "dependencies": { "brace-expansion": "^5.0.8" } }, "sha512-vpLQEs+VLCr1nU0BXS07maYoFwlDAH0gngQuuttxIwutDFEMHq2blX+8vpgxDdK3J1PwjCJiep77OitTZ4Ll1A=="], + "micromatch/picomatch": ["picomatch@2.3.2", "", {}, "sha512-V7+vQEJ06Z+c5tSye8S+nHUfI51xoXIXjHQ99cQtKUkQqqO1kO/KCJUfZXuB47h/YBlDhah2H3hdUGXn8ie0oA=="], + "node-exports-info/semver": ["semver@6.3.1", "", { "bin": { "semver": "bin/semver.js" } }, "sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA=="], "prompts/kleur": ["kleur@3.0.3", "", {}, "sha512-eTIzlVOSUR+JxdDFepEYcBMtZ9Qqdef+rnzWdRZuMbOywu5tO2w2N7rqjoANZ5k9vywhL6Br1VRjUIgTQx4E8w=="], diff --git a/ios/Sources/NativeMapPlugin/CameraEvents.swift b/ios/Sources/NativeMapPlugin/CameraEvents.swift index 1e8e329..d8ae186 100644 --- a/ios/Sources/NativeMapPlugin/CameraEvents.swift +++ b/ios/Sources/NativeMapPlugin/CameraEvents.swift @@ -26,6 +26,14 @@ extension NativeMapPlugin { /// Whether an in-flight region change originates from a user gesture rather /// than a programmatic move. MapKit hangs its pan/pinch/rotate recognizers on /// the map's first subview; if any is mid-recognition the move is a gesture. + static func regionsAreEqual(_ lhs: MKCoordinateRegion, _ rhs: MKCoordinateRegion) -> Bool { + let epsilon = 1e-6 + return abs(lhs.center.latitude - rhs.center.latitude) < epsilon + && abs(lhs.center.longitude - rhs.center.longitude) < epsilon + && abs(lhs.span.latitudeDelta - rhs.span.latitudeDelta) < epsilon + && abs(lhs.span.longitudeDelta - rhs.span.longitudeDelta) < epsilon + } + static func regionChangeIsGesture(_ mapView: MKMapView) -> Bool { guard let gestureHost = mapView.subviews.first, let recognizers = gestureHost.gestureRecognizers else { return false } @@ -48,13 +56,21 @@ extension NativeMapPlugin { map.isAdjustingRegion = false } else if let minZoom = map.config.minZoom, map.currentZoom() < minZoom - 0.01 { // The user zoomed out past the floor; bounce back to it. + let before = mapView.region map.isAdjustingRegion = true map.setCameraInternal(coordinate: mapView.centerCoordinate, zoom: minZoom, animate: true) + if Self.regionsAreEqual(before, mapView.region) { + map.isAdjustingRegion = false + } return } else if let maxZoom = map.config.maxZoom, map.currentZoom() > maxZoom + 0.01 { // The user zoomed in past the ceiling; bounce back to it. + let before = mapView.region map.isAdjustingRegion = true map.setCameraInternal(coordinate: mapView.centerCoordinate, zoom: maxZoom, animate: true) + if Self.regionsAreEqual(before, mapView.region) { + map.isAdjustingRegion = false + } return } diff --git a/ios/Sources/NativeMapPlugin/CapacitorAppleMaps.swift b/ios/Sources/NativeMapPlugin/CapacitorAppleMaps.swift index edf9daf..14d7bd0 100644 --- a/ios/Sources/NativeMapPlugin/CapacitorAppleMaps.swift +++ b/ios/Sources/NativeMapPlugin/CapacitorAppleMaps.swift @@ -203,6 +203,7 @@ public class Map: NSObject, UIGestureRecognizerDelegate { /// Retains the in-flight `MKMapSnapshotter` for the duration of `takeSnapshot`. var pendingSnapshotter: MKMapSnapshotter? + var snapshotRequestId: UInt = 0 /// The user-tracking button (recenter/follow control) when shown, so it can be /// removed again. See setUserTrackingButton in MapControls.swift. diff --git a/ios/Sources/NativeMapPlugin/CapacitorAppleMapsPlugin.swift b/ios/Sources/NativeMapPlugin/CapacitorAppleMapsPlugin.swift index ad76d97..1503bb5 100644 --- a/ios/Sources/NativeMapPlugin/CapacitorAppleMapsPlugin.swift +++ b/ios/Sources/NativeMapPlugin/CapacitorAppleMapsPlugin.swift @@ -74,6 +74,7 @@ public class NativeMapPlugin: CAPPlugin, CAPBridgedPlugin, MKMapViewDelegate { ] var maps = [String: Map]() + private let mapsLock = NSLock() private let searchService = SearchService() private let geocodeService = GeocodeService() @@ -102,7 +103,10 @@ public class NativeMapPlugin: CAPPlugin, CAPBridgedPlugin, MKMapViewDelegate { /// hierarchy, orphaning the native map's touch handling (it still renders but /// gestures stop working). Re-mount each map into its current container. @objc private func handleDidBecomeActive() { - for (_, map) in maps { + mapsLock.lock() + let activeMaps = Array(maps.values) + mapsLock.unlock() + for map in activeMaps { map.remountIntoContainer() } } @@ -122,17 +126,24 @@ public class NativeMapPlugin: CAPPlugin, CAPBridgedPlugin, MKMapViewDelegate { do { let config = try NativeMapConfig(fromJSObject: configObj) - - if maps[id] != nil { - if !forceCreate { - call.resolve() - return - } - maps.removeValue(forKey: id)?.destroy() - } + var alreadyExists = false runOnMainSync { + self.mapsLock.lock() + if self.maps[id] != nil { + if !forceCreate { + alreadyExists = true + self.mapsLock.unlock() + return + } + self.maps.removeValue(forKey: id)?.destroy() + } self.maps[id] = Map(id: id, config: config, delegate: self) + self.mapsLock.unlock() + } + if alreadyExists { + call.resolve() + return } call.resolve() } catch { @@ -141,12 +152,21 @@ public class NativeMapPlugin: CAPPlugin, CAPBridgedPlugin, MKMapViewDelegate { } @objc func destroy(_ call: CAPPluginCall) { - guard let id = call.getString("id"), let map = maps.removeValue(forKey: id) else { + guard let id = call.getString("id") else { call.reject("map not found", PluginError.mapNotFound) return } - map.destroy() - call.resolve() + runOnMainSync { + self.mapsLock.lock() + guard let map = self.maps.removeValue(forKey: id) else { + self.mapsLock.unlock() + call.reject("map not found", PluginError.mapNotFound) + return + } + self.mapsLock.unlock() + map.destroy() + call.resolve() + } } // MARK: - Camera @@ -294,9 +314,8 @@ public class NativeMapPlugin: CAPPlugin, CAPBridgedPlugin, MKMapViewDelegate { // MARK: - Helpers func findMap(for mapView: MKMapView) -> Map? { - for (_, map) in maps where map.mapView === mapView { - return map - } - return nil + mapsLock.lock() + defer { mapsLock.unlock() } + return maps.values.first { $0.mapView === mapView } } } diff --git a/ios/Sources/NativeMapPlugin/Permissions.swift b/ios/Sources/NativeMapPlugin/Permissions.swift index 0081b88..153c805 100644 --- a/ios/Sources/NativeMapPlugin/Permissions.swift +++ b/ios/Sources/NativeMapPlugin/Permissions.swift @@ -56,6 +56,9 @@ extension NativeMapPlugin: CLLocationManagerDelegate { guard let call = pendingPermissionCall else { return } + if manager.authorizationStatus == .notDetermined { + return + } checkPermissions(call) bridge?.releaseCall(withID: call.callbackId) pendingPermissionCall = nil diff --git a/ios/Sources/NativeMapPlugin/Search.swift b/ios/Sources/NativeMapPlugin/Search.swift index c8f3dd6..a4ac160 100644 --- a/ios/Sources/NativeMapPlugin/Search.swift +++ b/ios/Sources/NativeMapPlugin/Search.swift @@ -211,6 +211,12 @@ class SearchService: NSObject, MKLocalSearchCompleterDelegate { return } + DispatchQueue.main.async { + self.resolveOnMain(call, id: id) + } + } + + private func resolveOnMain(_ call: CAPPluginCall, id: String) { // A `places` result already carries its coordinate. if let item = items[id] { let coordinate = item.placemark.coordinate @@ -227,9 +233,9 @@ class SearchService: NSObject, MKLocalSearchCompleterDelegate { call.resolve([:]) return } - DispatchQueue.main.async { - let search = MKLocalSearch(request: MKLocalSearch.Request(completion: completion)) - search.start { response, _ in + let search = MKLocalSearch(request: MKLocalSearch.Request(completion: completion)) + search.start { response, _ in + DispatchQueue.main.async { guard let item = response?.mapItems.first else { call.resolve([:]) return diff --git a/ios/Sources/NativeMapPlugin/Snapshot.swift b/ios/Sources/NativeMapPlugin/Snapshot.swift index 88fdbfb..b77f7e6 100644 --- a/ios/Sources/NativeMapPlugin/Snapshot.swift +++ b/ios/Sources/NativeMapPlugin/Snapshot.swift @@ -27,12 +27,15 @@ extension Map { options.region = self.mapView.region options.mapType = self.mapView.mapType options.size = self.mapView.bounds.size - options.showsBuildings = true + options.showsBuildings = self.mapView.showsBuildings + self.snapshotRequestId += 1 + let requestId = self.snapshotRequestId let snapshotter = MKMapSnapshotter(options: options) self.pendingSnapshotter = snapshotter // Composite on the main thread - it reads live annotation views. snapshotter.start(with: .main) { snapshot, error in + guard requestId == self.snapshotRequestId else { return } self.pendingSnapshotter = nil if let error = error { completion(.failure(error)) diff --git a/ios/Sources/NativeMapPlugin/ViewHelpers.swift b/ios/Sources/NativeMapPlugin/ViewHelpers.swift index c09d3a7..7ec6d82 100644 --- a/ios/Sources/NativeMapPlugin/ViewHelpers.swift +++ b/ios/Sources/NativeMapPlugin/ViewHelpers.swift @@ -33,23 +33,21 @@ extension WKWebView { // MARK: - View tree helpers extension UIView { - private static var allSubviews: [UIView] = [] - - private func viewArray(root: UIView) -> [UIView] { - var index = root.tag + private func collectSubviews(root: UIView, into result: inout [UIView], nextTag: inout Int) { for view in root.subviews { if view.tag == Map.mapTag { continue } - view.tag = index - UIView.allSubviews.append(view) - _ = viewArray(root: view) - index += 1 + view.tag = nextTag + result.append(view) + nextTag += 1 + collectSubviews(root: view, into: &result, nextTag: &nextTag) } - return UIView.allSubviews } func getAllSubViews() -> [UIView] { - UIView.allSubviews = [] - return viewArray(root: self).reversed() + var collected: [UIView] = [] + var nextTag = tag + collectSubviews(root: self, into: &collected, nextTag: &nextTag) + return collected.reversed() } func removeAllSubview() { diff --git a/package.json b/package.json index bbebe16..8f16b7e 100644 --- a/package.json +++ b/package.json @@ -72,6 +72,7 @@ "@ionic/eslint-config": "^0.4.0", "@ionic/prettier-config": "^4.0.0", "@ionic/swiftlint-config": "^2.0.0", + "@rollup/plugin-node-resolve": "^16.0.3", "@types/node": "^24.10.1", "@types/resize-observer-browser": "^0.1.11", "eslint": "^8.57.1", diff --git a/rollup.config.mjs b/rollup.config.mjs index f37393c..cfa7adb 100644 --- a/rollup.config.mjs +++ b/rollup.config.mjs @@ -1,5 +1,8 @@ +import { nodeResolve } from '@rollup/plugin-node-resolve'; + export default { input: 'dist/esm/index.js', + plugins: [nodeResolve({ preferBuiltins: false })], output: [ { file: 'dist/plugin.js', diff --git a/src/map.ts b/src/map.ts index 5895b0c..2cfacc3 100644 --- a/src/map.ts +++ b/src/map.ts @@ -175,8 +175,9 @@ export class NativeMap { newMap.initScrolling(); } + const createOptions: CreateMapArgs = { ...options }; if (Capacitor.isNativePlatform()) { - (options.element as any) = {}; + createOptions.element = {} as HTMLElement; const getMapBounds = () => { const mapRect = newMap.element?.getBoundingClientRect() ?? ({} as DOMRect); @@ -258,7 +259,7 @@ export class NativeMap { await new Promise((resolve, reject) => { setTimeout(async () => { try { - await CapacitorNativeMap.create(options); + await CapacitorNativeMap.create(createOptions); resolve(undefined); } catch (err) { reject(err); diff --git a/src/web.ts b/src/web.ts index cc65817..6b1183e 100644 --- a/src/web.ts +++ b/src/web.ts @@ -202,29 +202,32 @@ export class CapacitorNativeMapWeb extends WebPlugin implements NativeMapPlugin } async enableCurrentLocation(_args: CurrentLocArgs): Promise { - if (_args.enabled) { - if (navigator.geolocation) { - navigator.geolocation.getCurrentPosition( - (position: GeolocationPosition) => { - const pos = { - lat: position.coords.latitude, - lng: position.coords.longitude, - }; - - this.maps[_args.id].map.setCenter(pos); - - this.notifyListeners('onMyLocationButtonClick', {}); - - this.notifyListeners('onMyLocationClick', {}); - }, - () => { - throw new Error('Geolocation not supported on web browser.'); - }, - ); - } else { - throw new Error('Geolocation not supported on web browser.'); - } + if (!_args.enabled) { + return; } + if (!navigator.geolocation) { + throw new Error('Geolocation not supported on web browser.'); + } + await new Promise((resolve, reject) => { + navigator.geolocation.getCurrentPosition( + (position: GeolocationPosition) => { + const pos = { + lat: position.coords.latitude, + lng: position.coords.longitude, + }; + + this.maps[_args.id].map.setCenter(pos); + + this.notifyListeners('onMyLocationButtonClick', {}); + + this.notifyListeners('onMyLocationClick', {}); + resolve(); + }, + () => { + reject(new Error('Geolocation permission denied or unavailable on web browser.')); + }, + ); + }); } async setPadding(_args: PaddingArgs): Promise { const bounds = this.maps[_args.id].map.getBounds(); @@ -302,17 +305,41 @@ export class CapacitorNativeMapWeb extends WebPlugin implements NativeMapPlugin } } + private attachMarkerToMap(mapId: string, marker: google.maps.marker.AdvancedMarkerElement): void { + const mapState = this.maps[mapId]; + if (mapState.markerClusterer) { + mapState.markerClusterer.addMarker(marker); + } else { + marker.map = mapState.map; + } + } + + private detachMarkerFromMap(mapId: string, markerId: string): void { + const mapState = this.maps[mapId]; + const marker = mapState.markers[markerId]; + if (!marker) { + return; + } + if (mapState.markerClusterer) { + mapState.markerClusterer.removeMarker(marker); + } else { + marker.map = null; + } + delete mapState.markers[markerId]; + } + async addMarkers(_args: AddMarkersArgs): Promise<{ ids: string[] }> { const markerIds: string[] = []; const map = this.maps[_args.id]; for (const markerArgs of _args.markers) { - const advancedMarker = this.buildMarkerOpts(markerArgs, map.map); + const advancedMarker = this.buildMarkerOpts(markerArgs); const id = '' + this.currMarkerId; map.markers[id] = advancedMarker; await this.setMarkerListeners(_args.id, id, advancedMarker); + this.attachMarkerToMap(_args.id, advancedMarker); markerIds.push(id); this.currMarkerId++; @@ -328,6 +355,7 @@ export class CapacitorNativeMapWeb extends WebPlugin implements NativeMapPlugin this.maps[_args.id].markers[id] = advancedMarker; await this.setMarkerListeners(_args.id, id, advancedMarker); + this.attachMarkerToMap(_args.id, advancedMarker); this.currMarkerId++; @@ -335,21 +363,13 @@ export class CapacitorNativeMapWeb extends WebPlugin implements NativeMapPlugin } async removeMarkers(_args: RemoveMarkersArgs): Promise { - const map = this.maps[_args.id]; - for (const id of _args.markerIds) { - if (map.markers[id]) { - map.markers[id].map = null; - delete map.markers[id]; - } + this.detachMarkerFromMap(_args.id, id); } } async removeMarker(_args: RemoveMarkerArgs): Promise { - if (this.maps[_args.id].markers[_args.markerId]) { - this.maps[_args.id].markers[_args.markerId].map = null; - delete this.maps[_args.id].markers[_args.markerId]; - } + this.detachMarkerFromMap(_args.id, _args.markerId); } async addPolygons(args: AddPolygonsArgs): Promise<{ ids: string[] }> { @@ -683,7 +703,7 @@ export class CapacitorNativeMapWeb extends WebPlugin implements NativeMapPlugin }); } - private buildMarkerOpts(marker: Marker, map: google.maps.Map): google.maps.marker.AdvancedMarkerElement { + private buildMarkerOpts(marker: Marker, _map: google.maps.Map): google.maps.marker.AdvancedMarkerElement { if (!this.AdvancedMarkerElement || !this.PinElement) { throw new Error('Marker library not loaded'); } @@ -700,7 +720,6 @@ export class CapacitorNativeMapWeb extends WebPlugin implements NativeMapPlugin content = img; } else { const pinOptions: google.maps.marker.PinElementOptions = { - scale: marker.opacity ?? 1, glyph: marker.title, background: marker.tintColor ? `rgb(${marker.tintColor.r}, ${marker.tintColor.g}, ${marker.tintColor.b})` @@ -709,11 +728,13 @@ export class CapacitorNativeMapWeb extends WebPlugin implements NativeMapPlugin const pin = new this.PinElement(pinOptions); content = pin.element; + if (marker.opacity != null) { + content.style.opacity = String(marker.opacity); + } } const advancedMarker = new this.AdvancedMarkerElement({ position: marker.coordinate, - map: map, content: content, title: marker.title, gmpDraggable: marker.draggable, From 6769e33e5962e921e366618a8ab8a93243e7b0ae Mon Sep 17 00:00:00 2001 From: Cursor Agent Date: Thu, 1 Oct 2026 02:00:50 +0000 Subject: [PATCH 11/42] fix: complete buildMarkerOpts signature cleanup for web Co-authored-by: Martin DONADIEU --- src/web.ts | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/web.ts b/src/web.ts index 6b1183e..584c53d 100644 --- a/src/web.ts +++ b/src/web.ts @@ -349,7 +349,7 @@ export class CapacitorNativeMapWeb extends WebPlugin implements NativeMapPlugin } async addMarker(_args: AddMarkerArgs): Promise<{ id: string }> { - const advancedMarker = this.buildMarkerOpts(_args.marker, this.maps[_args.id].map); + const advancedMarker = this.buildMarkerOpts(_args.marker); const id = '' + this.currMarkerId; @@ -703,7 +703,7 @@ export class CapacitorNativeMapWeb extends WebPlugin implements NativeMapPlugin }); } - private buildMarkerOpts(marker: Marker, _map: google.maps.Map): google.maps.marker.AdvancedMarkerElement { + private buildMarkerOpts(marker: Marker): google.maps.marker.AdvancedMarkerElement { if (!this.AdvancedMarkerElement || !this.PinElement) { throw new Error('Marker library not loaded'); } From 51c683fb66d526fda783eaf5527a2217adc646e6 Mon Sep 17 00:00:00 2001 From: Cursor Agent Date: Thu, 1 Oct 2026 02:07:33 +0000 Subject: [PATCH 12/42] fix: follow-up review fixes for map create, web geo, and iOS helpers - Iterative view traversal; snapshotter identity guard; bounds extend center - Web geolocation mapId payloads and destroyed-map guard - Create listener cleanup on failure; orientation timeout cancel on destroy - Android mapBounds null checks; permission guard consolidation Co-authored-by: Martin DONADIEU --- .../nativemap/CapacitorGoogleMapsPlugin.kt | 12 +++++++---- .../NativeMapPlugin/CameraEvents.swift | 8 ++++--- .../NativeMapPlugin/GoogleMapsBridge.swift | 5 ++++- ios/Sources/NativeMapPlugin/Permissions.swift | 6 ++---- ios/Sources/NativeMapPlugin/Snapshot.swift | 4 +++- ios/Sources/NativeMapPlugin/ViewHelpers.swift | 21 +++++++++---------- src/map.ts | 16 ++++++++++++-- src/web.ts | 19 ++++++++++++----- 8 files changed, 60 insertions(+), 31 deletions(-) diff --git a/android/src/main/java/com/capgo/plugins/nativemap/CapacitorGoogleMapsPlugin.kt b/android/src/main/java/com/capgo/plugins/nativemap/CapacitorGoogleMapsPlugin.kt index 11b6d2c..0a60250 100644 --- a/android/src/main/java/com/capgo/plugins/nativemap/CapacitorGoogleMapsPlugin.kt +++ b/android/src/main/java/com/capgo/plugins/nativemap/CapacitorGoogleMapsPlugin.kt @@ -987,8 +987,10 @@ class CapacitorNativeMapPlugin : Plugin(), OnMapsSdkInitializedCallback { @PluginMethod fun mapBoundsContains(call: PluginCall) { try { - val boundsObject = call.getObject("bounds") - val pointObject = call.getObject("point") + val boundsObject = + call.getObject("bounds") ?: throw InvalidArgumentsError("bounds is missing") + val pointObject = + call.getObject("point") ?: throw InvalidArgumentsError("point is missing") val bounds = createLatLngBounds(boundsObject) val point = createLatLng(pointObject) @@ -1048,8 +1050,10 @@ class CapacitorNativeMapPlugin : Plugin(), OnMapsSdkInitializedCallback { @PluginMethod fun mapBoundsExtend(call: PluginCall) { try { - val boundsObject = call.getObject("bounds") - val pointObject = call.getObject("point") + val boundsObject = + call.getObject("bounds") ?: throw InvalidArgumentsError("bounds is missing") + val pointObject = + call.getObject("point") ?: throw InvalidArgumentsError("point is missing") val bounds = createLatLngBounds(boundsObject) val point = createLatLng(pointObject) diff --git a/ios/Sources/NativeMapPlugin/CameraEvents.swift b/ios/Sources/NativeMapPlugin/CameraEvents.swift index d8ae186..049cd86 100644 --- a/ios/Sources/NativeMapPlugin/CameraEvents.swift +++ b/ios/Sources/NativeMapPlugin/CameraEvents.swift @@ -23,9 +23,8 @@ extension NativeMapPlugin { ]) } - /// Whether an in-flight region change originates from a user gesture rather - /// than a programmatic move. MapKit hangs its pan/pinch/rotate recognizers on - /// the map's first subview; if any is mid-recognition the move is a gesture. + /// Compares two regions for equality within a small epsilon (used to detect + /// no-op zoom clamps that would otherwise leave `isAdjustingRegion` set). static func regionsAreEqual(_ lhs: MKCoordinateRegion, _ rhs: MKCoordinateRegion) -> Bool { let epsilon = 1e-6 return abs(lhs.center.latitude - rhs.center.latitude) < epsilon @@ -34,6 +33,9 @@ extension NativeMapPlugin { && abs(lhs.span.longitudeDelta - rhs.span.longitudeDelta) < epsilon } + /// Whether an in-flight region change originates from a user gesture rather + /// than a programmatic move. MapKit hangs its pan/pinch/rotate recognizers on + /// the map's first subview; if any is mid-recognition the move is a gesture. static func regionChangeIsGesture(_ mapView: MKMapView) -> Bool { guard let gestureHost = mapView.subviews.first, let recognizers = gestureHost.gestureRecognizers else { return false } diff --git a/ios/Sources/NativeMapPlugin/GoogleMapsBridge.swift b/ios/Sources/NativeMapPlugin/GoogleMapsBridge.swift index 115fc22..87f6a5f 100644 --- a/ios/Sources/NativeMapPlugin/GoogleMapsBridge.swift +++ b/ios/Sources/NativeMapPlugin/GoogleMapsBridge.swift @@ -105,10 +105,13 @@ extension NativeMapPlugin { let west = min(sw["lng"] as? Double ?? lng, lng) let north = max(ne["lat"] as? Double ?? lat, lat) let east = max(ne["lng"] as? Double ?? lng, lng) + let centerLat = (south + north) / 2 + let centerLng = (west + east) / 2 call.resolve([ "bounds": [ "southwest": ["lat": south, "lng": west], - "northeast": ["lat": north, "lng": east] + "northeast": ["lat": north, "lng": east], + "center": ["lat": centerLat, "lng": centerLng] ] ]) } diff --git a/ios/Sources/NativeMapPlugin/Permissions.swift b/ios/Sources/NativeMapPlugin/Permissions.swift index 153c805..b88c508 100644 --- a/ios/Sources/NativeMapPlugin/Permissions.swift +++ b/ios/Sources/NativeMapPlugin/Permissions.swift @@ -53,10 +53,8 @@ extension NativeMapPlugin: CLLocationManagerDelegate { } public func locationManagerDidChangeAuthorization(_ manager: CLLocationManager) { - guard let call = pendingPermissionCall else { - return - } - if manager.authorizationStatus == .notDetermined { + guard let call = pendingPermissionCall, + manager.authorizationStatus != .notDetermined else { return } checkPermissions(call) diff --git a/ios/Sources/NativeMapPlugin/Snapshot.swift b/ios/Sources/NativeMapPlugin/Snapshot.swift index b77f7e6..4046740 100644 --- a/ios/Sources/NativeMapPlugin/Snapshot.swift +++ b/ios/Sources/NativeMapPlugin/Snapshot.swift @@ -36,7 +36,9 @@ extension Map { // Composite on the main thread - it reads live annotation views. snapshotter.start(with: .main) { snapshot, error in guard requestId == self.snapshotRequestId else { return } - self.pendingSnapshotter = nil + if self.pendingSnapshotter === snapshotter { + self.pendingSnapshotter = nil + } if let error = error { completion(.failure(error)) return diff --git a/ios/Sources/NativeMapPlugin/ViewHelpers.swift b/ios/Sources/NativeMapPlugin/ViewHelpers.swift index 7ec6d82..6739448 100644 --- a/ios/Sources/NativeMapPlugin/ViewHelpers.swift +++ b/ios/Sources/NativeMapPlugin/ViewHelpers.swift @@ -33,20 +33,19 @@ extension WKWebView { // MARK: - View tree helpers extension UIView { - private func collectSubviews(root: UIView, into result: inout [UIView], nextTag: inout Int) { - for view in root.subviews { - if view.tag == Map.mapTag { continue } - view.tag = nextTag - result.append(view) - nextTag += 1 - collectSubviews(root: view, into: &result, nextTag: &nextTag) - } - } - func getAllSubViews() -> [UIView] { var collected: [UIView] = [] var nextTag = tag - collectSubviews(root: self, into: &collected, nextTag: &nextTag) + var stack: [UIView] = [self] + while let root = stack.popLast() { + for view in root.subviews { + if view.tag == Map.mapTag { continue } + view.tag = nextTag + nextTag += 1 + collected.append(view) + stack.append(view) + } + } return collected.reversed() } diff --git a/src/map.ts b/src/map.ts index 2cfacc3..3ce4fdc 100644 --- a/src/map.ts +++ b/src/map.ts @@ -116,8 +116,15 @@ export class NativeMap { private id: string; private element: HTMLElement | null = null; private resizeObserver: ResizeObserver | null = null; + private orientationChangeTimeoutId?: ReturnType; private orientationChangeHandler = (): void => { - setTimeout(() => this.updateMapBounds(), 500); + if (this.orientationChangeTimeoutId != null) { + clearTimeout(this.orientationChangeTimeoutId); + } + this.orientationChangeTimeoutId = setTimeout(() => { + this.orientationChangeTimeoutId = undefined; + this.updateMapBounds(); + }, 500); }; private onBoundsChangedListener?: PluginListenerHandle; @@ -175,7 +182,7 @@ export class NativeMap { newMap.initScrolling(); } - const createOptions: CreateMapArgs = { ...options }; + const createOptions: CreateMapArgs = { ...options, config: { ...options.config } }; if (Capacitor.isNativePlatform()) { createOptions.element = {} as HTMLElement; @@ -262,6 +269,7 @@ export class NativeMap { await CapacitorNativeMap.create(createOptions); resolve(undefined); } catch (err) { + onMapReadyListener?.remove(); reject(err); } }, 200); @@ -640,6 +648,10 @@ export class NativeMap { } disableScrolling(): void { + if (this.orientationChangeTimeoutId != null) { + clearTimeout(this.orientationChangeTimeoutId); + this.orientationChangeTimeoutId = undefined; + } window.removeEventListener('ionScroll', this.handleScrollEvent); window.removeEventListener('scroll', this.handleScrollEvent); window.removeEventListener('resize', this.handleScrollEvent); diff --git a/src/web.ts b/src/web.ts index 584c53d..9367c23 100644 --- a/src/web.ts +++ b/src/web.ts @@ -216,11 +216,20 @@ export class CapacitorNativeMapWeb extends WebPlugin implements NativeMapPlugin lng: position.coords.longitude, }; - this.maps[_args.id].map.setCenter(pos); - - this.notifyListeners('onMyLocationButtonClick', {}); - - this.notifyListeners('onMyLocationClick', {}); + const map = this.maps[_args.id]?.map; + if (!map) { + reject(new Error('Map no longer exists.')); + return; + } + map.setCenter(pos); + + this.notifyListeners('onMyLocationButtonClick', { mapId: _args.id }); + + this.notifyListeners('onMyLocationClick', { + mapId: _args.id, + latitude: pos.lat, + longitude: pos.lng, + }); resolve(); }, () => { From e68fe10fa2c32e4c4ac9bf73adfd6310ff2750d1 Mon Sep 17 00:00:00 2001 From: Cursor Agent Date: Thu, 1 Oct 2026 11:46:50 +0000 Subject: [PATCH 13/42] fix: CodeRabbit review items, README pitch, drop bundled license files - Web create: respect forceCreate; map.create uses cloned config for bounds - Snapshot: complete superseded requests with cancellation error - Remove THIRD_PARTY_LICENSES and legal/; short MIT credit in README and NOTICE - Expand README pitch, features, use cases, quick start; add compressed demo image Co-authored-by: Martin DONADIEU --- NOTICE | 6 +- README.md | 67 ++++++++++++++++++--- THIRD_PARTY_LICENSES | 8 --- assets/readme-demo.webp | Bin 0 -> 7228 bytes ios/Sources/NativeMapPlugin/Snapshot.swift | 5 +- legal/MIT-capacitor-google-maps.txt | 21 ------- legal/MIT-capacitor-plugin-apple-maps.txt | 21 ------- package.json | 3 +- src/map.ts | 22 ++++--- src/web.ts | 3 + 10 files changed, 78 insertions(+), 78 deletions(-) delete mode 100644 THIRD_PARTY_LICENSES create mode 100644 assets/readme-demo.webp delete mode 100644 legal/MIT-capacitor-google-maps.txt delete mode 100644 legal/MIT-capacitor-plugin-apple-maps.txt diff --git a/NOTICE b/NOTICE index 74f9cab..98ac123 100644 --- a/NOTICE +++ b/NOTICE @@ -1,8 +1,4 @@ @capgo/capacitor-native-map Copyright (c) Capgo -This product includes software developed by third parties under the MIT License. -See THIRD_PARTY_LICENSES and the legal/ directory for details. - -Ported Android and web map code derives from @capacitor/google-maps (Copyright (c) Ionic). -Ported iOS map code derives from capacitor-plugin-apple-maps (Copyright Katama Labs contributors). +Portions adapted from ionic-team/capacitor-google-maps and katamalabs/capacitor-plugin-apple-maps (both MIT). diff --git a/README.md b/README.md index 8ea4c7a..bc62103 100644 --- a/README.md +++ b/README.md @@ -1,21 +1,68 @@ # @capgo/capacitor-native-map -Native maps for Capacitor with one JavaScript API: +**One TypeScript API for native maps in Capacitor apps** — Google Maps on Android, Apple MapKit on iOS, and Google Maps JS on the web. Ship the same markers, camera, overlays, clustering, search, and events everywhere without maintaining three separate integrations. -- **Android**: Google Maps (Maps SDK) -- **iOS**: Apple MapKit -- **Web**: Google Maps JavaScript API (requires an API key) +

            + Native map in a Capacitor app +

            -Capacitor 8.x. TypeScript 6.x in the example app. +## Why use it -## Credits +- **Single API** across iOS, Android, and web (`NativeMap.create`, shared listeners, shared types). +- **Native performance** where it matters: platform map views under your HTML, not a slow WebView map on mobile. +- **Feature parity** for common product needs: markers (incl. remote icons), shapes, clustering, camera bounds, padding, snapshots, geocoding/search helpers, and current location. +- **Capacitor 8** and modern TypeScript tooling in the included example app. -Portions of this plugin are adapted from: +## Features -- [@capacitor/google-maps](https://github.com/ionic-team/capacitor-google-maps) (MIT) for Android and web -- [capacitor-plugin-apple-maps](https://github.com/katamalabs/capacitor-plugin-apple-maps) (MIT) for iOS +| Area | Highlights | +| --- | --- | +| **Map lifecycle** | Create, destroy, resize, scroll sync with Ionic/WebView | +| **Camera** | Center, zoom, bearing, tilt, fit bounds, min/max zoom | +| **Markers** | Add/update/remove, drag, selection, callouts, clustering | +| **Overlays** | Polygons, polylines, circles, tile overlays (platform-dependent) | +| **Events** | Map/marker/shape clicks, camera idle/move, clusters, my location | +| **Extras** | Snapshots, autocomplete/places search, geocode/reverse geocode | -See [THIRD_PARTY_LICENSES](./THIRD_PARTY_LICENSES) and the [legal/](./legal/) folder. +## Use cases + +- Store locators and field-service maps with live GPS +- Delivery and fleet dashboards with markers and routes +- Event venues, real-estate listings, and travel apps +- Any Capacitor app that today embeds Google Maps on Android/web and needs a **zero–Google-keys iOS** path via MapKit + +## Quick start + +```bash +npm install @capgo/capacitor-native-map +npx cap sync +``` + +```ts +import { NativeMap } from '@capgo/capacitor-native-map'; + +const map = await NativeMap.create({ + id: 'main-map', + element: document.getElementById('map')!, + apiKey: 'YOUR_GOOGLE_MAPS_API_KEY', // web + Android + config: { + center: { lat: 37.7749, lng: -122.4194 }, + zoom: 12, + }, +}); + +map.setOnMapClickListener((e) => console.log('click', e)); +``` + +**Platform keys** + +- **iOS**: MapKit — no Google API key; add location usage strings in `Info.plist` if you use current location. +- **Android**: Google Maps SDK — set `GOOGLE_MAPS_API_KEY` in the app manifest (see `example-app`). +- **Web**: Google Maps JS + Map ID for Advanced Markers — pass `apiKey` and `config.mapId` to `create`. + +The [example app](./example-app) is the fastest way to run on all three platforms. + +Credits: portions adapted from [katamalabs/capacitor-plugin-apple-maps](https://github.com/katamalabs/capacitor-plugin-apple-maps) and [ionic-team/capacitor-google-maps](https://github.com/ionic-team/capacitor-google-maps) (both MIT). ## Install diff --git a/THIRD_PARTY_LICENSES b/THIRD_PARTY_LICENSES deleted file mode 100644 index 661bb1c..0000000 --- a/THIRD_PARTY_LICENSES +++ /dev/null @@ -1,8 +0,0 @@ -This plugin includes code adapted from the following third-party projects. -See the legal/ directory for full license texts. - -- @capacitor/google-maps (Ionic Team, MIT): Android implementation and web fallback - https://github.com/ionic-team/capacitor-google-maps - -- capacitor-plugin-apple-maps (Katama Labs, MIT): iOS MapKit implementation - https://github.com/katamalabs/capacitor-plugin-apple-maps diff --git a/assets/readme-demo.webp b/assets/readme-demo.webp new file mode 100644 index 0000000000000000000000000000000000000000..8b3241c9e5b05a4f5cd92d8b4eae31e2e41a5599 GIT binary patch literal 7228 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 { console.log(`Create map: ${_args.id}`); + if (this.maps[_args.id] && !_args.forceCreate) { + return; + } if (!_args.apiKey) { throw new Error('apiKey is required when using NativeMap on web'); } From d47bd2a7a416e75bbf2a44cccadff840f406c962 Mon Sep 17 00:00:00 2001 From: Cursor Agent Date: Thu, 1 Oct 2026 11:59:38 +0000 Subject: [PATCH 14/42] chore: remove NOTICE file; README-only third-party credit Co-authored-by: Martin DONADIEU --- .coderabbit.yaml | 3 --- NOTICE | 4 ---- package.json | 1 - 3 files changed, 8 deletions(-) delete mode 100644 NOTICE diff --git a/.coderabbit.yaml b/.coderabbit.yaml index a526602..9ae5b5e 100644 --- a/.coderabbit.yaml +++ b/.coderabbit.yaml @@ -5,9 +5,6 @@ reviews: - "!.github/**" - "!.maestro/**" - "!assets/**" - - "!legal/**" - "!README.md" - "!CHANGELOG.md" - "!AGENTS.md" - - "!NOTICE" - - "!THIRD_PARTY_LICENSES" diff --git a/NOTICE b/NOTICE deleted file mode 100644 index 98ac123..0000000 --- a/NOTICE +++ /dev/null @@ -1,4 +0,0 @@ -@capgo/capacitor-native-map -Copyright (c) Capgo - -Portions adapted from ionic-team/capacitor-google-maps and katamalabs/capacitor-plugin-apple-maps (both MIT). diff --git a/package.json b/package.json index 79179c2..982131e 100644 --- a/package.json +++ b/package.json @@ -15,7 +15,6 @@ "ios/Tests", "Package.swift", "CapgoCapacitorNativeMap.podspec", - "NOTICE", "assets/readme-demo.webp" ], "author": "Martin Donadieu", From bb2840a536958d84f94f60767b5b3d7da419c72e Mon Sep 17 00:00:00 2001 From: Cursor Agent Date: Thu, 1 Oct 2026 14:48:57 +0000 Subject: [PATCH 15/42] chore: update GitHub social preview for native-map Co-authored-by: Martin DONADIEU --- assets/github-social-preview.png | Bin 109623 -> 108166 bytes assets/github-social-template.svg | 46 ++++++++++++------------------ 2 files changed, 19 insertions(+), 27 deletions(-) diff --git a/assets/github-social-preview.png b/assets/github-social-preview.png index 93df11f3a87a6b622b78a3f996883a741e421507..61070ef78862fecef2999b7425426d131b3f583a 100644 GIT binary patch literal 108166 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

            Ex& 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

          1. 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 z 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 diff --git a/assets/github-social-template.svg b/assets/github-social-template.svg index 0105301..e0b6a1f 100644 --- a/assets/github-social-template.svg +++ b/assets/github-social-template.svg @@ -1,5 +1,5 @@ - native audio GitHub social preview + @capgo/capacitor-native-map @@ -13,29 +13,21 @@ - - - + + - - - - - GitHub social preview - Cap-go/capacitor-native-audio - @capgo/capacitor-native-audio - - - Add native audio in one line - for Capacitor apps + Native maps for Capacitor + with HTML on top - - A native plugin for native audio engine + + One API for MapKit, Google Maps, and web. Native map behind your transparent UI. @@ -57,22 +49,22 @@ $ - npm i @capgo/capacitor-native-audio + npm i @capgo/capacitor-native-map - - + - iOS + + + + iOS - - - + - Android + + + + + Android - - - + - Web + + + + + Web From 009cd2412fcde178443a04f3c50ec36cb96f5d9d Mon Sep 17 00:00:00 2001 From: Cursor Agent Date: Thu, 1 Oct 2026 14:57:43 +0000 Subject: [PATCH 16/42] feat: add toBack overlay mode, README, and v8.0.0 release prep - Native map behind transparent WebView with multi-touch routing on Android - iOS toBack mount, hit-test passthrough, updateLayout, show, and hide - Example app overlay demo, marketing README, and mobile screenshots - TypeScript 6, plugin version 8.0.0, full docgen API docs Co-authored-by: Martin DONADIEU --- README.md | 259 ++++++++++++++++-- .../plugins/nativemap/CapacitorGoogleMap.kt | 92 +++++-- .../nativemap/CapacitorGoogleMapsPlugin.kt | 55 ++++ .../nativemap/ToBackCompositorHelper.kt | 19 ++ assets/readme-screenshot-android.webp | Bin 0 -> 4700 bytes assets/readme-screenshot-ios.webp | Bin 0 -> 4982 bytes bun.lock | 4 +- example-app/src/App.css | 71 ++++- example-app/src/App.tsx | 57 +++- example-app/src/index.css | 12 + .../NativeMapPlugin/CapacitorAppleMaps.swift | 45 ++- .../CapacitorAppleMapsPlugin.swift | 9 +- .../NativeMapPlugin/GoogleMapsBridge.swift | 31 +++ .../NativeMapPlugin/ToBackCompositor.swift | 23 ++ ios/Sources/NativeMapPlugin/ViewHelpers.swift | 42 +++ package.json | 10 +- src/definitions.ts | 27 ++ src/implementation.ts | 73 ++++- src/map.ts | 141 +++++++--- src/touch-routing.ts | 42 +++ src/web.ts | 38 ++- tsconfig.json | 6 +- 22 files changed, 933 insertions(+), 123 deletions(-) create mode 100644 android/src/main/java/com/capgo/plugins/nativemap/ToBackCompositorHelper.kt create mode 100644 assets/readme-screenshot-android.webp create mode 100644 assets/readme-screenshot-ios.webp create mode 100644 ios/Sources/NativeMapPlugin/ToBackCompositor.swift create mode 100644 src/touch-routing.ts diff --git a/README.md b/README.md index bc62103..982ba7f 100644 --- a/README.md +++ b/README.md @@ -1,23 +1,41 @@ # @capgo/capacitor-native-map -**One TypeScript API for native maps in Capacitor apps** — Google Maps on Android, Apple MapKit on iOS, and Google Maps JS on the web. Ship the same markers, camera, overlays, clustering, search, and events everywhere without maintaining three separate integrations. +Capgo - Instant updates for Capacitor + + + +![NPM Version](https://img.shields.io/npm/v/%40capgo%2Fcapacitor-native-map) +![NPM Downloads](https://img.shields.io/npm/dy/%40capgo%2Fcapacitor-native-map) +![GitHub Repo stars](https://img.shields.io/github/stars/Cap-go/capacitor-native-map) +![GitHub Actions Workflow Status](https://img.shields.io/github/actions/workflow/status/Cap-go/capacitor-native-map/.github%2Fworkflows%2Ftest.yml) +![GitHub License](https://img.shields.io/github/license/Cap-go/capacitor-native-map) +![Maintenance](https://img.shields.io/maintenance/yes/2026) + +**One TypeScript API for native maps in Capacitor apps:** Google Maps on Android, Apple MapKit on iOS, and Google Maps JS on the web. Ship markers, camera moves, shapes, clustering, search, and events from a single integration.

            - Native map in a Capacitor app + Native map with HTML overlay on iOS + Native map with HTML overlay on Android

            +Docs: [Native Map plugin](https://capgo.app/docs/plugins/native-map/) · Tutorial: [capacitor-native-map](https://capgo.app/plugins/capacitor-native-map/) + ## Why use it -- **Single API** across iOS, Android, and web (`NativeMap.create`, shared listeners, shared types). -- **Native performance** where it matters: platform map views under your HTML, not a slow WebView map on mobile. -- **Feature parity** for common product needs: markers (incl. remote icons), shapes, clustering, camera bounds, padding, snapshots, geocoding/search helpers, and current location. -- **Capacitor 8** and modern TypeScript tooling in the included example app. +- **Single API** on iOS, Android, and web (`NativeMap.create`, shared listeners, shared types). +- **Native map performance** on mobile (platform map views, not a WebView map). +- **Custom map UI** with `toBack`: render the native map behind a transparent WebView and build controls in HTML. +- **Capacitor 8** with TypeScript 6 and an example app you can run locally. ## Features | Area | Highlights | | --- | --- | -| **Map lifecycle** | Create, destroy, resize, scroll sync with Ionic/WebView | +| **Map lifecycle** | Create, destroy, resize, `show` / `hide`, `updateLayout`, scroll sync with Ionic | +| **Background mode** | `toBack` compositing, multi-touch passthrough on transparent HTML (pinch, rotate, tilt, pan) | | **Camera** | Center, zoom, bearing, tilt, fit bounds, min/max zoom | | **Markers** | Add/update/remove, drag, selection, callouts, clustering | | **Overlays** | Polygons, polylines, circles, tile overlays (platform-dependent) | @@ -29,48 +47,169 @@ - Store locators and field-service maps with live GPS - Delivery and fleet dashboards with markers and routes - Event venues, real-estate listings, and travel apps -- Any Capacitor app that today embeds Google Maps on Android/web and needs a **zero–Google-keys iOS** path via MapKit +- Custom-branded map UIs (search bars, filters, bottom sheets) over a native map + +## Compatibility + +| Platform | Map engine | API key | +| --- | --- | --- | +| **iOS** | Apple MapKit | Not required for the map | +| **Android** | Google Maps SDK | `GOOGLE_MAPS_API_KEY` in the app manifest | +| **Web** | Google Maps JavaScript API | `apiKey` + `config.mapId` on `create` | -## Quick start +Requires **Capacitor 8+**. Plugin major version follows Capacitor (this package is **v8**). + +## Install ```bash npm install @capgo/capacitor-native-map npx cap sync ``` +## iOS (MapKit) + +No Google Maps API key is required on iOS. Add location usage strings to `Info.plist` if you enable current location: + +```xml +NSLocationWhenInUseUsageDescription +We use your location to show you on the map. +``` + +Sync the plugin with CocoaPods or Swift Package Manager (both are supported). + +## Android (Google Maps) + +1. Create a Google Maps SDK for Android key in [Google Cloud Console](https://console.cloud.google.com/). +2. Set the key on the application `meta-data` entry (see `example-app/android/app/src/main/AndroidManifest.xml`): + +```xml + +``` + +3. Provide `GOOGLE_MAPS_API_KEY` when building (Gradle placeholder in `example-app/android/app/build.gradle`). + +## Usage + +### Embedded map + ```ts import { NativeMap } from '@capgo/capacitor-native-map'; const map = await NativeMap.create({ id: 'main-map', element: document.getElementById('map')!, - apiKey: 'YOUR_GOOGLE_MAPS_API_KEY', // web + Android + apiKey: 'YOUR_GOOGLE_MAPS_API_KEY', + config: { + center: { lat: 37.7749, lng: -122.4194 }, + zoom: 12, + }, +}); + +map.setOnMapClickListener((e) => console.log('click', e.latitude, e.longitude)); +``` + +### Background map (`toBack`) with HTML overlay + +```ts +const map = await NativeMap.create({ + id: 'overlay-map', + toBack: true, + apiKey: 'YOUR_GOOGLE_MAPS_API_KEY', config: { center: { lat: 37.7749, lng: -122.4194 }, zoom: 12, + x: 0, + y: 0, + width: window.innerWidth, + height: window.innerHeight, }, }); -map.setOnMapClickListener((e) => console.log('click', e)); +await map.updateLayout({ x: 0, y: 0, width: window.innerWidth, height: window.innerHeight }); +await map.hide(); +await map.show(); ``` -**Platform keys** +The [example app](./example-app) opens in **overlay (`toBack`)** mode by default. -- **iOS**: MapKit — no Google API key; add location usage strings in `Info.plist` if you use current location. -- **Android**: Google Maps SDK — set `GOOGLE_MAPS_API_KEY` in the app manifest (see `example-app`). -- **Web**: Google Maps JS + Map ID for Advanced Markers — pass `apiKey` and `config.mapId` to `create`. +## Build your own map UI -The [example app](./example-app) is the fastest way to run on all three platforms. +Product teams often want a **fully custom map screen** (brand colors, filters, bottom sheets) while keeping native map performance. This plugin supports that pattern: -Credits: portions adapted from [katamalabs/capacitor-plugin-apple-maps](https://github.com/katamalabs/capacitor-plugin-apple-maps) and [ionic-team/capacitor-google-maps](https://github.com/ionic-team/capacitor-google-maps) (both MIT). +1. Call `NativeMap.create({ toBack: true, ... })` so MapKit or Google Maps renders **behind** the Capacitor WebView. +2. Make the WebView and page background **transparent** so the map is visible. +3. Build controls in HTML. Use `data-map-overlay` (or interactive elements) on controls that must receive touches; transparent areas pass gestures to the map. -## Install +### Transparent app / page CSS + +```css +html.native-map-to-back, +body.native-map-to-back { + background: transparent !important; +} + +:root { + --ion-background-color: transparent !important; +} + +.map-overlay-root { + position: fixed; + inset: 0; + pointer-events: none; +} + +.map-overlay-root [data-map-overlay] { + pointer-events: auto; +} +``` + +### Full HTML overlay example + +```html +
            +
            +

            Nearby stores

            + +
            +
            +

            Pinch and pan on open areas to move the map.

            +
            +
            +``` + +```ts +const map = await NativeMap.create({ + id: 'stores-map', + toBack: true, + apiKey: GOOGLE_KEY, + config: { + center: { lat: 40.7128, lng: -74.006 }, + zoom: 11, + width: window.innerWidth, + height: window.innerHeight, + }, +}); + +document.getElementById('recenter')?.addEventListener('click', () => { + map.setCamera({ coordinate: { lat: 40.7128, lng: -74.006 }, zoom: 13, animate: true }); +}); +``` + +## Example app ```bash -npm install @capgo/capacitor-native-map -npx cap sync +cd example-app +bun install +bun run build +bunx cap sync ``` +Set `VITE_GOOGLE_MAPS_API_KEY` for web and Android. iOS uses MapKit without a Google key. + +Credits: portions adapted from [katamalabs/capacitor-plugin-apple-maps](https://github.com/katamalabs/capacitor-plugin-apple-maps) and [ionic-team/capacitor-google-maps](https://github.com/ionic-team/capacitor-google-maps) (both MIT). + ## API @@ -539,6 +678,52 @@ mapBoundsExtend(args: MapBoundsExtendArgs) => Promise<{ bounds: LatLngBounds; }> -------------------- +### updateLayout(...) + +```typescript +updateLayout(args: MapLayoutArgs) => Promise +``` + +Updates the native map position and size without recreating the map. +Useful with `toBack` mode to resize or reposition the map layer. + +| Param | Type | +| ---------- | ------------------------------------------------------- | +| **`args`** | MapLayoutArgs | + +-------------------- + + +### show(...) + +```typescript +show(args: { id: string; }) => Promise +``` + +Shows a map that was hidden with {@link NativeMapPlugin.hide}. + +| Param | Type | +| ---------- | ---------------------------- | +| **`args`** | { id: string; } | + +-------------------- + + +### hide(...) + +```typescript +hide(args: { id: string; }) => Promise +``` + +Hides the native map view while keeping the instance alive. + +| Param | Type | +| ---------- | ---------------------------- | +| **`args`** | { id: string; } | + +-------------------- + + ### Interfaces @@ -546,15 +731,16 @@ mapBoundsExtend(args: MapBoundsExtendArgs) => Promise<{ bounds: LatLngBounds; }> An interface containing the options used when creating a map. -| Prop | Type | Description | Default | -| ----------------- | ----------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------ | -| **`id`** | string | A unique identifier for the map instance. | | -| **`apiKey`** | string | Google Maps API key. Required on web. On Android, also set `com.google.android.geo.API_KEY` in the app manifest. Not used on iOS (MapKit). | | -| **`config`** | NativeMapConfig | The initial configuration settings for the map. | | -| **`element`** | HTMLElement | The DOM element that the Google Map View will be mounted on which determines size and positioning. | | -| **`forceCreate`** | boolean | Destroy and re-create the map instance if a map with the supplied id already exists | false | -| **`region`** | string | The region parameter alters your application to serve different map tiles or bias the application (such as biasing geocoding results towards the region). Only available for web. | | -| **`language`** | string | The language parameter affects the names of controls, copyright notices, driving directions, and control labels, as well as the responses to service requests. Only available for web. | | +| Prop | Type | Description | Default | +| ----------------- | ----------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------ | +| **`id`** | string | A unique identifier for the map instance. | | +| **`apiKey`** | string | Google Maps API key. Required on web. On Android, also set `com.google.android.geo.API_KEY` in the app manifest. Not used on iOS (MapKit). | | +| **`config`** | NativeMapConfig | The initial configuration settings for the map. | | +| **`element`** | HTMLElement | The DOM element that determines size and positioning for embedded maps. Optional when `toBack` is `true` (defaults to `document.body`). | | +| **`forceCreate`** | boolean | Destroy and re-create the map instance if a map with the supplied id already exists | false | +| **`region`** | string | The region parameter alters your application to serve different map tiles or bias the application (such as biasing geocoding results towards the region). Only available for web. | | +| **`language`** | string | The language parameter affects the names of controls, copyright notices, driving directions, and control labels, as well as the responses to service requests. Only available for web. | | +| **`toBack`** | boolean | When `true`, renders the native map behind a transparent WebView so your HTML UI can sit on top. Touches on transparent web areas pass through to the map, including multi-touch gestures (pinch zoom, rotate, two-finger tilt, pan). Touches on interactive HTML elements stay in the WebView. On native platforms, set `config.x`, `config.y`, `config.width`, and `config.height` for position and size (defaults to the viewport when omitted). Use {@link NativeMap.updateLayout} to change layout at runtime. | false | #### NativeMapConfig @@ -652,6 +838,8 @@ A marker is an icon placed at a particular point on the map's surface. #### Size +Width and height in pixels. + | Prop | Type | | ------------ | ------------------- | | **`width`** | number | @@ -927,6 +1115,19 @@ Controls for setting padding on the 'visible' region of the view. | **`point`** | LatLng | +#### MapLayoutArgs + +Layout rectangle for {@link NativeMapPlugin.updateLayout}, in CSS pixels relative to the WebView. + +| Prop | Type | Description | +| ------------ | ------------------- | ---------------------------------------------------------- | +| **`id`** | string | Map instance id returned from {@link NativeMap.create}. | +| **`x`** | number | Distance from the left edge of the WebView, in CSS pixels. | +| **`y`** | number | Distance from the top edge of the WebView, in CSS pixels. | +| **`width`** | number | Map width in CSS pixels. | +| **`height`** | number | Map height in CSS pixels. | + + ### Type Aliases diff --git a/android/src/main/java/com/capgo/plugins/nativemap/CapacitorGoogleMap.kt b/android/src/main/java/com/capgo/plugins/nativemap/CapacitorGoogleMap.kt index 0c21b22..fdec7bb 100644 --- a/android/src/main/java/com/capgo/plugins/nativemap/CapacitorGoogleMap.kt +++ b/android/src/main/java/com/capgo/plugins/nativemap/CapacitorGoogleMap.kt @@ -51,6 +51,10 @@ class CapacitorNativeMapView( private val isReadyChannel = Channel() private var debounceJob: Job? = null + private var mapViewParent: FrameLayout? = null + var toBack: Boolean = false + var visible: Boolean = true + private var originalWebViewAlpha: Float? = null init { val bridge = delegate.bridge @@ -73,9 +77,9 @@ class CapacitorNativeMapView( private fun render() { CoroutineScope(Dispatchers.Main).launch { val bridge = delegate.bridge - val mapViewParent = FrameLayout(bridge.context) - mapViewParent.minimumHeight = bridge.webView.height - mapViewParent.minimumWidth = bridge.webView.width + val parent = FrameLayout(bridge.context) + parent.minimumHeight = bridge.webView.height + parent.minimumWidth = bridge.webView.width val layoutParams = FrameLayout.LayoutParams( @@ -85,15 +89,23 @@ class CapacitorNativeMapView( layoutParams.leftMargin = getScaledPixels(bridge, config.x) layoutParams.topMargin = getScaledPixels(bridge, config.y) - mapViewParent.tag = id + parent.tag = id mapView.layoutParams = layoutParams - mapViewParent.addView(mapView) + parent.addView(mapView) - ((bridge.webView.parent) as ViewGroup).addView(mapViewParent) + val webParent = (bridge.webView.parent) as ViewGroup + if (toBack) { + webParent.addView(parent, 0) + applyToBackVisualState(bridge) + } else { + webParent.addView(parent) + bridge.webView.bringToFront() + bridge.webView.setBackgroundColor(Color.TRANSPARENT) + } - bridge.webView.bringToFront() - bridge.webView.setBackgroundColor(Color.TRANSPARENT) + mapViewParent = parent + parent.visibility = if (visible) View.VISIBLE else View.GONE if (config.styles != null) { googleMap?.setMapStyle(MapStyleOptions(config.styles!!)) } @@ -141,20 +153,64 @@ class CapacitorNativeMapView( runBlocking { CoroutineScope(Dispatchers.Main).launch { - val bridge = delegate.bridge - val mapRect = getScaledRect(bridge, updatedBounds) - val mapView = this@CapacitorNativeMapView.mapView; - mapView.x = mapRect.left - mapView.y = mapRect.top - if (mapView.layoutParams.width != config.width || mapView.layoutParams.height != config.height) { - mapView.layoutParams.width = getScaledPixels(bridge, config.width) - mapView.layoutParams.height = getScaledPixels(bridge, config.height) - mapView.requestLayout() - } + applyLayoutFromConfig() } } } + fun updateLayout(x: Int, y: Int, width: Int, height: Int) { + config.x = x + config.y = y + config.width = width + config.height = height + CoroutineScope(Dispatchers.Main).launch { + applyLayoutFromConfig() + } + } + + fun setVisible(isVisible: Boolean) { + visible = isVisible + CoroutineScope(Dispatchers.Main).launch { + mapViewParent?.visibility = if (isVisible) View.VISIBLE else View.GONE + } + } + + private fun applyLayoutFromConfig() { + val bridge = delegate.bridge + val parent = mapViewParent ?: return + val layoutParams = parent.layoutParams as? FrameLayout.LayoutParams + ?: FrameLayout.LayoutParams( + getScaledPixels(bridge, config.width), + getScaledPixels(bridge, config.height), + ) + layoutParams.width = getScaledPixels(bridge, config.width) + layoutParams.height = getScaledPixels(bridge, config.height) + layoutParams.leftMargin = getScaledPixels(bridge, config.x) + layoutParams.topMargin = getScaledPixels(bridge, config.y) + parent.layoutParams = layoutParams + mapView.layoutParams.width = layoutParams.width + mapView.layoutParams.height = layoutParams.height + parent.requestLayout() + } + + private fun applyToBackVisualState(bridge: Bridge) { + val webView = bridge.webView + if (originalWebViewAlpha == null) { + originalWebViewAlpha = webView.alpha + } + if (ToBackCompositorHelper.shouldTransparentizeWebViewParent()) { + (webView.parent as? View)?.setBackgroundColor(ToBackCompositorHelper.resolveWebViewBackgroundColor()) + } + webView.setBackgroundColor(ToBackCompositorHelper.resolveWebViewBackgroundColor()) + webView.setLayerType(ToBackCompositorHelper.resolveWebViewLayerType(), null) + val alpha = ToBackCompositorHelper.resolveWebViewAlpha(originalWebViewAlpha ?: 1f) + webView.alpha = alpha + if (!ToBackCompositorHelper.shouldUseHardwareLayerOnPreviewContainer(true)) { + mapViewParent?.setLayerType(View.LAYER_TYPE_NONE, null) + } + bridge.webView.bringToFront() + } + fun dispatchTouchEvent(event: MotionEvent) { CoroutineScope(Dispatchers.Main).launch { val offsetViewBounds = getMapBounds() diff --git a/android/src/main/java/com/capgo/plugins/nativemap/CapacitorGoogleMapsPlugin.kt b/android/src/main/java/com/capgo/plugins/nativemap/CapacitorGoogleMapsPlugin.kt index 0a60250..38a5f4b 100644 --- a/android/src/main/java/com/capgo/plugins/nativemap/CapacitorGoogleMapsPlugin.kt +++ b/android/src/main/java/com/capgo/plugins/nativemap/CapacitorGoogleMapsPlugin.kt @@ -83,6 +83,7 @@ class CapacitorNativeMapPlugin : Plugin(), OnMapsSdkInitializedCallback { payload.put("x", touchX / map.config.devicePixelRatio) payload.put("y", touchY / map.config.devicePixelRatio) payload.put("mapId", map.id) + payload.put("toBack", map.toBack) notifyListeners("isMapInFocus", payload) return true @@ -155,7 +156,9 @@ class CapacitorNativeMapPlugin : Plugin(), OnMapsSdkInitializedCallback { oldMap?.destroy() } + val toBack = call.getBoolean("toBack", false)!! val newMap = CapacitorNativeMapView(id, config, this) + newMap.toBack = toBack maps[id] = newMap call.resolve() @@ -186,6 +189,58 @@ class CapacitorNativeMapPlugin : Plugin(), OnMapsSdkInitializedCallback { } } + @PluginMethod + fun updateLayout(call: PluginCall) { + try { + val id = call.getString("id") + id ?: throw InvalidMapIdError() + + val map = maps[id] ?: throw MapNotFoundError() + + val x = call.getInt("x", map.config.x) + val y = call.getInt("y", map.config.y) + val width = call.getInt("width", map.config.width) + val height = call.getInt("height", map.config.height) + + map.updateLayout(x, y, width, height) + call.resolve() + } catch (e: NativeMapsError) { + handleError(call, e) + } catch (e: Exception) { + handleError(call, e) + } + } + + @PluginMethod + fun show(call: PluginCall) { + try { + val id = call.getString("id") + id ?: throw InvalidMapIdError() + val map = maps[id] ?: throw MapNotFoundError() + map.setVisible(true) + call.resolve() + } catch (e: NativeMapsError) { + handleError(call, e) + } catch (e: Exception) { + handleError(call, e) + } + } + + @PluginMethod + fun hide(call: PluginCall) { + try { + val id = call.getString("id") + id ?: throw InvalidMapIdError() + val map = maps[id] ?: throw MapNotFoundError() + map.setVisible(false) + call.resolve() + } catch (e: NativeMapsError) { + handleError(call, e) + } catch (e: Exception) { + handleError(call, e) + } + } + @PluginMethod fun enableTouch(call: PluginCall) { try { diff --git a/android/src/main/java/com/capgo/plugins/nativemap/ToBackCompositorHelper.kt b/android/src/main/java/com/capgo/plugins/nativemap/ToBackCompositorHelper.kt new file mode 100644 index 0000000..172b9fc --- /dev/null +++ b/android/src/main/java/com/capgo/plugins/nativemap/ToBackCompositorHelper.kt @@ -0,0 +1,19 @@ +package com.capgo.plugins.nativemap + +import android.graphics.Color +import android.view.View + +/** + * Policy for Android `toBack` compositing: native map behind the Capacitor WebView. + */ +object ToBackCompositorHelper { + fun shouldTransparentizeWebViewParent(): Boolean = true + + fun resolveWebViewBackgroundColor(): Int = Color.TRANSPARENT + + fun resolveWebViewAlpha(originalAlpha: Float): Float = originalAlpha + + fun shouldUseHardwareLayerOnPreviewContainer(toBack: Boolean): Boolean = !toBack + + fun resolveWebViewLayerType(): Int = View.LAYER_TYPE_HARDWARE +} diff --git a/assets/readme-screenshot-android.webp b/assets/readme-screenshot-android.webp new file mode 100644 index 0000000000000000000000000000000000000000..d1e96b3e3bf0987588f0ecbdd69f12b38a223de4 GIT binary patch literal 4700 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 literal 0 HcmV?d00001 diff --git a/assets/readme-screenshot-ios.webp b/assets/readme-screenshot-ios.webp new file mode 100644 index 0000000000000000000000000000000000000000..c303ec709ba29e297d62bdbaa176d811a19c3d2f GIT binary patch literal 4982 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 Avj6}9 literal 0 HcmV?d00001 diff --git a/bun.lock b/bun.lock index 7a385f4..f599a3b 100644 --- a/bun.lock +++ b/bun.lock @@ -29,7 +29,7 @@ "rimraf": "^6.1.0", "rollup": "^4.53.2", "swiftlint": "^2.0.0", - "typescript": "^5.9.3", + "typescript": "^6.0.3", }, "peerDependencies": { "@capacitor/core": ">=8.0.0", @@ -755,7 +755,7 @@ "typed-array-length": ["typed-array-length@1.0.8", "", { "dependencies": { "call-bind": "^1.0.9", "for-each": "^0.3.5", "gopd": "^1.2.0", "is-typed-array": "^1.1.15", "possible-typed-array-names": "^1.1.0", "reflect.getprototypeof": "^1.0.10" } }, "sha512-phPGCwqr2+Qo0fwniCE8e4pKnGu/yFb5nD5Y8bf0EEeiI5GklnACYA9GFy/DrAeRrKHXvHn+1SUsOWgJp6RO+g=="], - "typescript": ["typescript@5.9.3", "", { "bin": { "tsc": "bin/tsc", "tsserver": "bin/tsserver" } }, "sha512-jl1vZzPDinLr9eUt3J/t7V6FgNEw9QjvBPdysz9KfQDD41fQrC2Y4vKQdiaUpFT4bXlb1RHhLpp8wtm6M5TgSw=="], + "typescript": ["typescript@6.0.3", "", { "bin": { "tsc": "bin/tsc", "tsserver": "bin/tsserver" } }, "sha512-y2TvuxSZPDyQakkFRPZHKFm+KKVqIisdg9/CZwm9ftvKXLP8NRWj38/ODjNbr43SsoXqNuAisEf1GdCxqWcdBw=="], "unbox-primitive": ["unbox-primitive@1.1.0", "", { "dependencies": { "call-bound": "^1.0.3", "has-bigints": "^1.0.2", "has-symbols": "^1.1.0", "which-boxed-primitive": "^1.1.1" } }, "sha512-nWJ91DjeOkej/TA8pXQ3myruKpKEYgqvpw9lz4OPHj/NWFNluYrjbz9j01CJ8yKQd2g4jFoOkINCTW2I5LEEyw=="], diff --git a/example-app/src/App.css b/example-app/src/App.css index dff5d1a..46060f3 100644 --- a/example-app/src/App.css +++ b/example-app/src/App.css @@ -5,6 +5,13 @@ font-family: system-ui, sans-serif; } +.app-overlay { + max-width: none; + min-height: 100vh; + padding: 0; + margin: 0; +} + .map-container { width: 100%; height: 420px; @@ -14,12 +21,74 @@ margin-top: 1rem; } +.map-overlay-ui { + position: fixed; + inset: 0; + pointer-events: none; + z-index: 10; +} + +.map-overlay-ui [data-map-overlay] { + pointer-events: auto; +} + +.overlay-bar { + margin: env(safe-area-inset-top) 1rem 0; + padding: 1rem 1.25rem; + border-radius: 14px; + background: rgba(15, 23, 42, 0.82); + color: #f8fafc; + backdrop-filter: blur(8px); +} + +.overlay-bar h1 { + margin: 0 0 0.35rem; + font-size: 1.15rem; +} + +.overlay-bar p { + margin: 0; + font-size: 0.9rem; + opacity: 0.9; +} + +.overlay-actions { + position: fixed; + left: 50%; + bottom: calc(1.25rem + env(safe-area-inset-bottom)); + transform: translateX(-50%); + display: flex; + gap: 0.75rem; +} + +.overlay-actions button, +.mode-switch { + border: 0; + border-radius: 999px; + padding: 0.65rem 1.1rem; + font-weight: 600; + background: #0ea5e9; + color: #fff; + box-shadow: 0 8px 24px rgba(14, 165, 233, 0.35); +} + .tagline { color: #444; } .status-message { - margin-top: 0.5rem; + position: fixed; + left: 1rem; + right: 1rem; + bottom: calc(5rem + env(safe-area-inset-bottom)); + text-align: center; + color: #0f172a; + font-size: 0.85rem; + pointer-events: none; +} + +.app-overlay .status-message { + color: #e2e8f0; } .error { diff --git a/example-app/src/App.tsx b/example-app/src/App.tsx index a7085cd..26b754a 100644 --- a/example-app/src/App.tsx +++ b/example-app/src/App.tsx @@ -6,9 +6,12 @@ import './App.css'; const DEFAULT_CENTER = { lat: 37.7749, lng: -122.4194 }; const API_KEY = import.meta.env.VITE_GOOGLE_MAPS_API_KEY ?? ''; +type DemoMode = 'embedded' | 'overlay'; + const App = () => { const mapRef = useRef(null); const nativeMapRef = useRef(null); + const [mode, setMode] = useState('overlay'); const [status, setStatus] = useState('Initializing map...'); const [error, setError] = useState(null); @@ -16,7 +19,7 @@ const App = () => { let destroyed = false; const init = async () => { - if (!mapRef.current) { + if (mode === 'embedded' && !mapRef.current) { return; } if (Capacitor.getPlatform() !== 'ios' && !API_KEY) { @@ -26,13 +29,22 @@ const App = () => { } try { + await nativeMapRef.current?.destroy().catch(() => undefined); + nativeMapRef.current = null; + + const overlay = mode === 'overlay'; const map = await NativeMap.create({ - id: 'demo-map', - element: mapRef.current, + id: overlay ? 'overlay-map' : 'demo-map', + element: overlay ? document.body : mapRef.current!, + toBack: overlay, apiKey: API_KEY, config: { center: DEFAULT_CENTER, zoom: 12, + width: overlay ? window.innerWidth : undefined, + height: overlay ? window.innerHeight : undefined, + x: 0, + y: 0, }, }); @@ -45,14 +57,14 @@ const App = () => { await map.addMarker({ coordinate: DEFAULT_CENTER, title: 'Hello', - snippet: 'Capgo Native Map', + snippet: overlay ? 'HTML overlay demo' : 'Capgo Native Map', }); await map.setCamera({ coordinate: { lat: 37.7849, lng: -122.4094 }, zoom: 14, animate: true, }); - setStatus('Map ready with marker and camera move.'); + setStatus(overlay ? 'Overlay map ready. Pan and pinch on open areas.' : 'Map ready with marker and camera move.'); setError(null); } catch (e) { setError(e instanceof Error ? e.message : String(e)); @@ -67,15 +79,40 @@ const App = () => { nativeMapRef.current?.destroy().catch(() => undefined); nativeMapRef.current = null; }; - }, []); + }, [mode]); return ( -
            -

            @capgo/capacitor-native-map

            -

            Google Maps on Android, Apple MapKit on iOS, Google Maps JS on web.

            +
            + {mode === 'overlay' && ( +
            +
            +

            Native map behind HTML

            +

            Buttons stay in the WebView. Open areas pass gestures to the map.

            +
            +
            + + +
            +
            + )} + + {mode === 'embedded' && ( + <> +

            @capgo/capacitor-native-map

            +

            Google Maps on Android, Apple MapKit on iOS, Google Maps JS on web.

            + +
            + + )} +

            {status}

            {error &&

            {error}

            } -
            ); }; diff --git a/example-app/src/index.css b/example-app/src/index.css index 065089b..ef214b6 100644 --- a/example-app/src/index.css +++ b/example-app/src/index.css @@ -30,8 +30,20 @@ body { background: linear-gradient(160deg, #e0f2fe 0%, #f8fafc 100%); } +html.native-map-to-back, +body.native-map-to-back { + background: transparent !important; +} + #root { max-width: 960px; margin: 0 auto; padding: 3rem 1.5rem; } + +html.native-map-to-back #root { + max-width: none; + margin: 0; + padding: 0; + min-height: 100vh; +} diff --git a/ios/Sources/NativeMapPlugin/CapacitorAppleMaps.swift b/ios/Sources/NativeMapPlugin/CapacitorAppleMaps.swift index 14d7bd0..8cb94e0 100644 --- a/ios/Sources/NativeMapPlugin/CapacitorAppleMaps.swift +++ b/ios/Sources/NativeMapPlugin/CapacitorAppleMaps.swift @@ -97,10 +97,10 @@ struct NativeMapConfig { let zoom: Double let minZoom: Double? let maxZoom: Double? - let x: Double - let y: Double - let width: Double - let height: Double + var x: Double + var y: Double + var width: Double + var height: Double let clustering: Bool let mapType: String let showInfoWindows: Bool @@ -164,6 +164,8 @@ public class Map: NSObject, UIGestureRecognizerDelegate { let id: String var config: NativeMapConfig let mapView: MKMapView + var toBack: Bool = false + var isMapVisible: Bool = true var markers: [String: NativeMapMarker] = [:] /// Overlays keyed by the id handed back to JS, for removal. @@ -228,11 +230,12 @@ public class Map: NSObject, UIGestureRecognizerDelegate { /// a later render can retry it). var failedIconURLs: Set = [] - init(id: String, config: NativeMapConfig, delegate: NativeMapPlugin) { + init(id: String, config: NativeMapConfig, delegate: NativeMapPlugin, toBack: Bool = false) { self.id = id self.config = config self.mapView = MKMapView() self.delegate = delegate + self.toBack = toBack super.init() // Start clustered when the caller asked for it, so markers added later // cluster on their first render instead of flashing as individual pins. @@ -279,6 +282,20 @@ public class Map: NSObject, UIGestureRecognizerDelegate { markerDrag.delegate = self self.mapView.addGestureRecognizer(markerDrag) + if self.toBack, let webView = self.delegate?.bridge?.webView { + self.mapView.frame = CGRect( + x: self.config.x, + y: self.config.y, + width: self.config.width, + height: self.config.height + ) + self.mapView.autoresizingMask = [.flexibleWidth, .flexibleHeight] + webView.addSubview(self.mapView) + webView.sendSubviewToBack(self.mapView) + ToBackCompositor.applyTransparentWebView(webView) + self.targetView = webView + self.mapView.isHidden = !self.isMapVisible + } else { self.targetView = self.getTargetContainer(refWidth: self.config.width, refHeight: self.config.height) if let target = self.targetView { target.tag = Map.mapTag @@ -297,6 +314,7 @@ public class Map: NSObject, UIGestureRecognizerDelegate { + "(ref=\(self.config.width)x\(self.config.height)); map will not render. " + "Likely a WebKit view-tree change - inspect the WKWebView's scroll views.") } + } self.delegate?.notifyListeners("onMapReady", data: ["mapId": self.id]) } @@ -311,6 +329,23 @@ public class Map: NSObject, UIGestureRecognizerDelegate { } } + func updateLayout(bounds: CGRect) { + config.x = bounds.origin.x + config.y = bounds.origin.y + config.width = bounds.size.width + config.height = bounds.size.height + runOnMainSync { + self.mapView.frame = bounds + } + } + + func setMapVisible(_ visible: Bool) { + isMapVisible = visible + runOnMainSync { + self.mapView.isHidden = !visible + } + } + // MARK: Camera /// Must be called on the main thread. `bearing` (heading, degrees clockwise diff --git a/ios/Sources/NativeMapPlugin/CapacitorAppleMapsPlugin.swift b/ios/Sources/NativeMapPlugin/CapacitorAppleMapsPlugin.swift index 1503bb5..187d0b4 100644 --- a/ios/Sources/NativeMapPlugin/CapacitorAppleMapsPlugin.swift +++ b/ios/Sources/NativeMapPlugin/CapacitorAppleMapsPlugin.swift @@ -70,7 +70,10 @@ public class NativeMapPlugin: CAPPlugin, CAPBridgedPlugin, MKMapViewDelegate { CAPPluginMethod(name: "removePolylines", returnType: CAPPluginReturnPromise), CAPPluginMethod(name: "mapBoundsContains", returnType: CAPPluginReturnPromise), CAPPluginMethod(name: "mapBoundsExtend", returnType: CAPPluginReturnPromise), - CAPPluginMethod(name: "dispatchMapEvent", returnType: CAPPluginReturnPromise) + CAPPluginMethod(name: "dispatchMapEvent", returnType: CAPPluginReturnPromise), + CAPPluginMethod(name: "updateLayout", returnType: CAPPluginReturnPromise), + CAPPluginMethod(name: "show", returnType: CAPPluginReturnPromise), + CAPPluginMethod(name: "hide", returnType: CAPPluginReturnPromise) ] var maps = [String: Map]() @@ -91,6 +94,7 @@ public class NativeMapPlugin: CAPPlugin, CAPBridgedPlugin, MKMapViewDelegate { // MARK: - App lifecycle override public func load() { + WKWebView.registerTouchRouting(plugin: self) NotificationCenter.default.addObserver( self, selector: #selector(handleDidBecomeActive), @@ -138,7 +142,8 @@ public class NativeMapPlugin: CAPPlugin, CAPBridgedPlugin, MKMapViewDelegate { } self.maps.removeValue(forKey: id)?.destroy() } - self.maps[id] = Map(id: id, config: config, delegate: self) + let toBack = call.getBool("toBack", false) + self.maps[id] = Map(id: id, config: config, delegate: self, toBack: toBack) self.mapsLock.unlock() } if alreadyExists { diff --git a/ios/Sources/NativeMapPlugin/GoogleMapsBridge.swift b/ios/Sources/NativeMapPlugin/GoogleMapsBridge.swift index 87f6a5f..d98e982 100644 --- a/ios/Sources/NativeMapPlugin/GoogleMapsBridge.swift +++ b/ios/Sources/NativeMapPlugin/GoogleMapsBridge.swift @@ -119,4 +119,35 @@ extension NativeMapPlugin { @objc func dispatchMapEvent(_ call: CAPPluginCall) { call.resolve() } + + @objc func updateLayout(_ call: CAPPluginCall) { + guard let id = call.getString("id"), let map = maps[id] else { + call.reject("map not found", PluginError.mapNotFound) + return + } + let x = call.getDouble("x") ?? map.config.x + let y = call.getDouble("y") ?? map.config.y + let width = call.getDouble("width") ?? map.config.width + let height = call.getDouble("height") ?? map.config.height + map.updateLayout(bounds: CGRect(x: x, y: y, width: width, height: height)) + call.resolve() + } + + @objc func show(_ call: CAPPluginCall) { + guard let id = call.getString("id"), let map = maps[id] else { + call.reject("map not found", PluginError.mapNotFound) + return + } + map.setMapVisible(true) + call.resolve() + } + + @objc func hide(_ call: CAPPluginCall) { + guard let id = call.getString("id"), let map = maps[id] else { + call.reject("map not found", PluginError.mapNotFound) + return + } + map.setMapVisible(false) + call.resolve() + } } diff --git a/ios/Sources/NativeMapPlugin/ToBackCompositor.swift b/ios/Sources/NativeMapPlugin/ToBackCompositor.swift new file mode 100644 index 0000000..c263ff6 --- /dev/null +++ b/ios/Sources/NativeMapPlugin/ToBackCompositor.swift @@ -0,0 +1,23 @@ +import Capacitor +import UIKit +import WebKit + +enum ToBackCompositor { + static func applyTransparentWebView(_ webView: WKWebView?) { + guard let webView = webView else { return } + DispatchQueue.main.async { + webView.isOpaque = false + webView.backgroundColor = .clear + func clearBackgrounds(_ view: UIView) { + view.backgroundColor = .clear + for subview in view.subviews { + clearBackgrounds(subview) + } + } + clearBackgrounds(webView) + webView.superview?.backgroundColor = .clear + webView.setNeedsLayout() + webView.layoutIfNeeded() + } + } +} diff --git a/ios/Sources/NativeMapPlugin/ViewHelpers.swift b/ios/Sources/NativeMapPlugin/ViewHelpers.swift index 6739448..0f7cdf9 100644 --- a/ios/Sources/NativeMapPlugin/ViewHelpers.swift +++ b/ios/Sources/NativeMapPlugin/ViewHelpers.swift @@ -14,8 +14,23 @@ import Capacitor // Routes touches that land on a WKChildScrollView down to the native map view // mounted inside it. extension WKWebView { + private static weak var touchRoutingPlugin: NativeMapPlugin? + + static func registerTouchRouting(plugin: NativeMapPlugin) { + touchRoutingPlugin = plugin + } + override open func hitTest(_ point: CGPoint, with event: UIEvent?) -> UIView? { var hitView = super.hitTest(point, with: event) + + if let plugin = WKWebView.touchRoutingPlugin, + let map = plugin.toBackMap(containing: point, in: self) { + if shouldPassTouchThroughToMap(hitView) { + let converted = convert(point, to: map.mapView) + return map.mapView.hitTest(converted, with: event) ?? hitView + } + } + if let childScrollClass = NSClassFromString("WKChildScrollView"), let candidate = hitView, candidate.isKind(of: childScrollClass) { for item in candidate.subviews.reversed() { @@ -30,6 +45,33 @@ extension WKWebView { } } +private func shouldPassTouchThroughToMap(_ hitView: UIView?) -> Bool { + guard let hitView = hitView else { return true } + if hitView is UIControl { + return false + } + let name = String(describing: type(of: hitView)) + if name.contains("WK") || hitView is UIScrollView { + return true + } + return hitView.backgroundColor == nil || hitView.backgroundColor == .clear +} + +extension NativeMapPlugin { + func toBackMap(containing point: CGPoint, in webView: WKWebView) -> Map? { + mapsLock.lock() + let candidates = maps.values.filter { $0.toBack && $0.isMapVisible } + mapsLock.unlock() + for map in candidates { + let converted = webView.convert(point, to: map.mapView) + if map.mapView.point(inside: converted, with: nil) { + return map + } + } + return nil + } +} + // MARK: - View tree helpers extension UIView { diff --git a/package.json b/package.json index 982131e..05b42a9 100644 --- a/package.json +++ b/package.json @@ -1,6 +1,6 @@ { "name": "@capgo/capacitor-native-map", - "version": "0.0.1", + "version": "8.0.0", "description": "Native maps for Capacitor: Google Maps on Android, Apple MapKit on iOS, Google Maps JS on web", "license": "MPL-2.0", "main": "dist/plugin.cjs.js", @@ -15,7 +15,11 @@ "ios/Tests", "Package.swift", "CapgoCapacitorNativeMap.podspec", - "assets/readme-demo.webp" + "assets/readme-demo.webp", + "assets/readme-screenshot-ios.webp", + "assets/readme-screenshot-android.webp", + "assets/github-social-preview.png", + "assets/github-social-template.svg" ], "author": "Martin Donadieu", "repository": { @@ -81,7 +85,7 @@ "rimraf": "^6.1.0", "rollup": "^4.53.2", "swiftlint": "^2.0.0", - "typescript": "^5.9.3" + "typescript": "^6.0.3" }, "peerDependencies": { "@capacitor/core": ">=8.0.0" diff --git a/src/definitions.ts b/src/definitions.ts index 817ad7d..a34014d 100644 --- a/src/definitions.ts +++ b/src/definitions.ts @@ -9,9 +9,15 @@ export interface LatLngBoundsInterface { northeast: LatLng; } +/** + * Geographic bounding box with helpers for contains/extend backed by the native plugin. + */ export class LatLngBounds { + /** South-west corner of the bounds. */ southwest: LatLng; + /** Center of the bounds. */ center: LatLng; + /** North-east corner of the bounds. */ northeast: LatLng; constructor(bounds: LatLngBoundsInterface) { @@ -20,6 +26,9 @@ export class LatLngBounds { this.northeast = bounds.northeast; } + /** + * Returns whether `point` lies inside this bounds. + */ async contains(point: LatLng): Promise { const result = await CapacitorNativeMap.mapBoundsContains({ bounds: this, @@ -28,6 +37,9 @@ export class LatLngBounds { return result['contains']; } + /** + * Expands this bounds to include `point` and returns the same instance. + */ async extend(point: LatLng): Promise { const result = await CapacitorNativeMap.mapBoundsExtend({ bounds: this, @@ -55,11 +67,13 @@ export interface LatLng { lng: number; } +/** Width and height in pixels. */ export interface Size { width: number; height: number; } +/** Point in pixel coordinates. */ export interface Point { x: number; y: number; @@ -467,10 +481,13 @@ export interface Marker { */ export type MapListenerCallback = (data: T) => void; +/** Payload for the `onMapReady` event. */ export interface MapReadyCallbackData { + /** Map instance id passed to {@link NativeMap.create}. */ mapId: string; } +/** Base marker fields included in marker-related events. */ export interface MarkerCallbackData { markerId: string; latitude: number; @@ -479,11 +496,13 @@ export interface MarkerCallbackData { snippet: string; } +/** Payload for polyline click events. */ export interface PolylineCallbackData { polylineId: string; tag?: string; } +/** Camera stopped moving; includes visible bounds and camera attitude. */ export interface CameraIdleCallbackData { mapId: string; bounds: LatLngBoundsInterface; @@ -494,11 +513,14 @@ export interface CameraIdleCallbackData { zoom: number; } +/** Camera started moving. */ export interface CameraMoveStartedCallbackData { mapId: string; + /** True when the user gesture started the move. */ isGesture: boolean; } +/** Cluster marker tapped. */ export interface ClusterClickCallbackData { mapId: string; latitude: number; @@ -507,28 +529,33 @@ export interface ClusterClickCallbackData { items: MarkerCallbackData[]; } +/** Map surface tapped (not on a marker). */ export interface MapClickCallbackData { mapId: string; latitude: number; longitude: number; } +/** Marker tapped. */ export interface MarkerClickCallbackData extends MarkerCallbackData { mapId: string; } +/** Polygon tapped. */ export interface PolygonClickCallbackData { mapId: string; polygonId: string; tag?: string; } +/** Circle tapped. */ export interface CircleClickCallbackData { mapId: string; circleId: string; tag?: string; } +/** My-location control tapped (Android). */ export interface MyLocationButtonClickCallbackData { mapId: string; } diff --git a/src/implementation.ts b/src/implementation.ts index a83657c..56cbe42 100644 --- a/src/implementation.ts +++ b/src/implementation.ts @@ -14,6 +14,7 @@ import type { Polyline, TileOverlay, } from './definitions'; +import { shouldRouteTouchToMap } from './touch-routing'; /** * An interface containing the options used when creating a map. @@ -33,9 +34,10 @@ export interface CreateMapArgs { */ config: NativeMapConfig; /** - * The DOM element that the Google Map View will be mounted on which determines size and positioning. + * The DOM element that determines size and positioning for embedded maps. + * Optional when `toBack` is `true` (defaults to `document.body`). */ - element: HTMLElement; + element?: HTMLElement; /** * Destroy and re-create the map instance if a map with the supplied id already exists * @default false @@ -54,6 +56,45 @@ export interface CreateMapArgs { * Only available for web. */ language?: string; + /** + * When `true`, renders the native map behind a transparent WebView so your HTML UI + * can sit on top. Touches on transparent web areas pass through to the map, + * including multi-touch gestures (pinch zoom, rotate, two-finger tilt, pan). + * Touches on interactive HTML elements stay in the WebView. + * + * On native platforms, set `config.x`, `config.y`, `config.width`, and `config.height` + * for position and size (defaults to the viewport when omitted). Use {@link NativeMap.updateLayout} + * to change layout at runtime. + * + * @default false + */ + toBack?: boolean; +} + +/** + * Layout rectangle for {@link NativeMapPlugin.updateLayout}, in CSS pixels relative to the WebView. + */ +export interface MapLayoutArgs { + /** + * Map instance id returned from {@link NativeMap.create}. + */ + id: string; + /** + * Distance from the left edge of the WebView, in CSS pixels. + */ + x?: number; + /** + * Distance from the top edge of the WebView, in CSS pixels. + */ + y?: number; + /** + * Map width in CSS pixels. + */ + width?: number; + /** + * Map height in CSS pixels. + */ + height?: number; } export interface DestroyMapArgs { @@ -216,6 +257,19 @@ export interface NativeMapPlugin extends Plugin { fitBounds(args: FitBoundsArgs): Promise; mapBoundsContains(args: MapBoundsContainsArgs): Promise<{ contains: boolean }>; mapBoundsExtend(args: MapBoundsExtendArgs): Promise<{ bounds: LatLngBounds }>; + /** + * Updates the native map position and size without recreating the map. + * Useful with `toBack` mode to resize or reposition the map layer. + */ + updateLayout(args: MapLayoutArgs): Promise; + /** + * Shows a map that was hidden with {@link NativeMapPlugin.hide}. + */ + show(args: { id: string }): Promise; + /** + * Hides the native map view while keeping the instance alive. + */ + hide(args: { id: string }): Promise; } const CapacitorNativeMap = registerPlugin('NativeMap', { @@ -223,15 +277,12 @@ const CapacitorNativeMap = registerPlugin('NativeMap', { }); CapacitorNativeMap.addListener('isMapInFocus', (data) => { - const x = data.x; - const y = data.y; - - const elem = document.elementFromPoint(x, y) as HTMLElement | null; - const mapElement = elem?.closest('[data-internal-id]') as HTMLElement | null; - const internalId = mapElement?.dataset?.internalId; - const mapInFocus = internalId === data.mapId; - - CapacitorNativeMap.dispatchMapEvent({ id: data.mapId, focus: mapInFocus }); + const x = data.x as number; + const y = data.y as number; + const mapId = data.mapId as string; + const toBack = data.toBack === true; + const mapInFocus = shouldRouteTouchToMap(x, y, mapId, toBack); + CapacitorNativeMap.dispatchMapEvent({ id: mapId, focus: mapInFocus }); }); export { CapacitorNativeMap }; diff --git a/src/map.ts b/src/map.ts index 85fcf6e..2f29ba4 100644 --- a/src/map.ts +++ b/src/map.ts @@ -29,6 +29,14 @@ export interface NativeMapInterface { create(options: CreateMapArgs, callback?: MapListenerCallback): Promise; enableTouch(): Promise; disableTouch(): Promise; + /** + * Updates native map position and size (CSS pixels). Especially useful in `toBack` mode. + */ + updateLayout(layout: { x?: number; y?: number; width?: number; height?: number }): Promise; + /** Shows the native map after {@link NativeMap.hide}. */ + show(): Promise; + /** Hides the native map without destroying it. */ + hide(): Promise; enableClustering( /** * The minimum number of markers that can be clustered together. The default is 4 markers. @@ -115,6 +123,8 @@ customElements.define('capacitor-native-map', MapCustomElement); export class NativeMap { private id: string; private element: HTMLElement | null = null; + private toBack = false; + private windowResizeHandler?: () => void; private resizeObserver: ResizeObserver | null = null; private orientationChangeTimeoutId?: ReturnType; private orientationChangeHandler = (): void => { @@ -160,22 +170,42 @@ export class NativeMap { ): Promise { const newMap = new NativeMap(options.id); - if (!options.element) { + const toBack = options.toBack === true; + newMap.toBack = toBack; + + const hostElement = options.element ?? document.body; + if (!hostElement) { throw new Error('container element is required'); } const createOptions: CreateMapArgs = { ...options, + toBack, config: { ...options.config, androidLiteMode: options.config.androidLiteMode ?? false, }, }; - newMap.element = options.element; - newMap.element.dataset.internalId = options.id; + newMap.element = hostElement; + if (!toBack) { + newMap.element.dataset.internalId = options.id; + } else { + document.documentElement.classList.add('native-map-to-back'); + document.body.classList.add('native-map-to-back'); + } - const elementBounds = await NativeMap.getElementBounds(options.element); + let elementBounds: DOMRect; + if (toBack) { + elementBounds = new DOMRect( + options.config.x ?? 0, + options.config.y ?? 0, + options.config.width ?? window.innerWidth, + options.config.height ?? window.innerHeight, + ); + } else { + elementBounds = await NativeMap.getElementBounds(hostElement); + } createOptions.config.width = elementBounds.width; createOptions.config.height = elementBounds.height; createOptions.config.x = elementBounds.x; @@ -188,15 +218,7 @@ export class NativeMap { if (Capacitor.isNativePlatform()) { createOptions.element = {} as HTMLElement; - const getMapBounds = () => { - const mapRect = newMap.element?.getBoundingClientRect() ?? ({} as DOMRect); - return { - x: mapRect.x, - y: mapRect.y, - width: mapRect.width, - height: mapRect.height, - }; - }; + const getMapBounds = () => NativeMap.layoutBoundsForElement(newMap.element, toBack); const onDisplay = () => { CapacitorNativeMap.onDisplay({ @@ -231,27 +253,32 @@ export class NativeMap { height: elementBounds.height, isHidden: false, }; - newMap.resizeObserver = new ResizeObserver(() => { - if (newMap.element != null) { - const mapRect = newMap.element.getBoundingClientRect(); - - const isHidden = mapRect.width === 0 && mapRect.height === 0; - if (!isHidden) { - if (lastState.isHidden) { - if (Capacitor.getPlatform() === 'ios' && !ionicPage) { - onDisplay(); + if (toBack) { + newMap.windowResizeHandler = onResize; + window.addEventListener('resize', onResize); + } else { + newMap.resizeObserver = new ResizeObserver(() => { + if (newMap.element != null) { + const mapRect = newMap.element.getBoundingClientRect(); + + const isHidden = mapRect.width === 0 && mapRect.height === 0; + if (!isHidden) { + if (lastState.isHidden) { + if (Capacitor.getPlatform() === 'ios' && !ionicPage) { + onDisplay(); + } + } else if (lastState.width !== mapRect.width || lastState.height !== mapRect.height) { + onResize(); } - } else if (lastState.width !== mapRect.width || lastState.height !== mapRect.height) { - onResize(); } - } - lastState.width = mapRect.width; - lastState.height = mapRect.height; - lastState.isHidden = isHidden; - } - }); - newMap.resizeObserver.observe(newMap.element); + lastState.width = mapRect.width; + lastState.height = mapRect.height; + lastState.isHidden = isHidden; + } + }); + newMap.resizeObserver.observe(newMap.element); + } } let onMapReadyListener: PluginListenerHandle | undefined; @@ -325,6 +352,24 @@ export class NativeMap { }); } + async updateLayout(layout: { x?: number; y?: number; width?: number; height?: number }): Promise { + await CapacitorNativeMap.updateLayout({ + id: this.id, + ...layout, + }); + if (layout.width != null || layout.height != null || layout.x != null || layout.y != null) { + this.updateMapBounds(); + } + } + + async show(): Promise { + return CapacitorNativeMap.show({ id: this.id }); + } + + async hide(): Promise { + return CapacitorNativeMap.hide({ id: this.id }); + } + /** * Enable marker clustering * @@ -493,6 +538,15 @@ export class NativeMap { if (Capacitor.isNativePlatform()) { this.resizeObserver?.disconnect(); + if (this.windowResizeHandler) { + window.removeEventListener('resize', this.windowResizeHandler); + this.windowResizeHandler = undefined; + } + } + + if (this.toBack) { + document.documentElement.classList.remove('native-map-to-back'); + document.body.classList.remove('native-map-to-back'); } this.removeAllMapListeners(); @@ -668,20 +722,29 @@ export class NativeMap { private updateMapBounds(): void { if (this.element) { - const mapRect = this.element.getBoundingClientRect(); - CapacitorNativeMap.onScroll({ id: this.id, - mapBounds: { - x: mapRect.x, - y: mapRect.y, - width: mapRect.width, - height: mapRect.height, - }, + mapBounds: NativeMap.layoutBoundsForElement(this.element, this.toBack), }); } } + private static layoutBoundsForElement( + element: HTMLElement | null, + toBack: boolean, + ): { x: number; y: number; width: number; height: number } { + if (toBack) { + return { x: 0, y: 0, width: window.innerWidth, height: window.innerHeight }; + } + const mapRect = element?.getBoundingClientRect() ?? ({} as DOMRect); + return { + x: mapRect.x, + y: mapRect.y, + width: mapRect.width, + height: mapRect.height, + }; + } + /* private findContainerElement(): HTMLElement | null { if (!this.element) { diff --git a/src/touch-routing.ts b/src/touch-routing.ts new file mode 100644 index 0000000..7c1ed6a --- /dev/null +++ b/src/touch-routing.ts @@ -0,0 +1,42 @@ +const INTERACTIVE_SELECTOR = + 'a,button,input,select,textarea,label,summary,details,[role="button"],[contenteditable="true"],[data-map-overlay]'; + +/** + * Decide whether a native touch at (x, y) should be routed to the map or the WebView. + */ +export function shouldRouteTouchToMap(x: number, y: number, mapId: string, toBack: boolean): boolean { + if (!toBack) { + const elem = document.elementFromPoint(x, y) as HTMLElement | null; + const mapElement = elem?.closest('[data-internal-id]') as HTMLElement | null; + return mapElement?.dataset?.internalId === mapId; + } + + const elem = document.elementFromPoint(x, y) as HTMLElement | null; + if (!elem) { + return true; + } + + if (elem.closest(INTERACTIVE_SELECTOR)) { + return false; + } + + const overlayRoot = document.querySelector('[data-native-map-overlay-root]'); + if (overlayRoot && !overlayRoot.contains(elem)) { + return true; + } + + let current: HTMLElement | null = elem; + while (current && current !== document.documentElement) { + const style = window.getComputedStyle(current); + const bg = style.backgroundColor; + if (bg && bg !== 'rgba(0, 0, 0, 0)' && bg !== 'transparent') { + const opacity = parseFloat(style.opacity || '1'); + if (opacity > 0.05) { + return false; + } + } + current = current.parentElement; + } + + return true; +} diff --git a/src/web.ts b/src/web.ts index 524da7c..df1b26d 100644 --- a/src/web.ts +++ b/src/web.ts @@ -148,6 +148,40 @@ export class CapacitorNativeMapWeb extends WebPlugin implements NativeMapPlugin this.maps[_args.id].map.setOptions({ gestureHandling: 'none' }); } + async updateLayout(_args: { id: string; x?: number; y?: number; width?: number; height?: number }): Promise { + const entry = this.maps[_args.id]; + if (!entry) { + return; + } + const el = entry.element; + if (_args.x != null) { + el.style.left = `${_args.x}px`; + } + if (_args.y != null) { + el.style.top = `${_args.y}px`; + } + if (_args.width != null) { + el.style.width = `${_args.width}px`; + } + if (_args.height != null) { + el.style.height = `${_args.height}px`; + } + } + + async show(args: { id: string }): Promise { + const entry = this.maps[args.id]; + if (entry) { + entry.element.style.visibility = 'visible'; + } + } + + async hide(args: { id: string }): Promise { + const entry = this.maps[args.id]; + if (entry) { + entry.element.style.visibility = 'hidden'; + } + } + async setCamera(_args: CameraArgs): Promise { // Animation not supported yet... this.maps[_args.id].map.moveCamera({ @@ -527,8 +561,8 @@ export class CapacitorNativeMapWeb extends WebPlugin implements NativeMapPlugin } this.maps[_args.id] = { - map: new window.google.maps.Map(_args.element, config), - element: _args.element, + map: new window.google.maps.Map(_args.element ?? document.body, config), + element: _args.element ?? document.body, markers: {}, tileOverlays: {}, polygons: {}, diff --git a/tsconfig.json b/tsconfig.json index b2cbfd6..8797203 100644 --- a/tsconfig.json +++ b/tsconfig.json @@ -3,11 +3,13 @@ "allowUnreachableCode": false, "declaration": true, "declarationDir": "dist/typings", + "rootDir": "src", + "ignoreDeprecations": "6.0", "esModuleInterop": true, "inlineSources": true, "lib": ["dom", "es2017"], "module": "esnext", - "moduleResolution": "node", + "moduleResolution": "bundler", "noFallthroughCasesInSwitch": true, "noUnusedLocals": true, "noUnusedParameters": true, @@ -15,6 +17,8 @@ "pretty": true, "sourceMap": true, "strict": true, + "skipLibCheck": true, + "types": ["google.maps"], "target": "es2017" }, "files": ["src/index.ts"] From 28a041acd6caab099a5f279c27f0d6f2506adb43 Mon Sep 17 00:00:00 2001 From: Cursor Agent Date: Thu, 1 Oct 2026 15:06:02 +0000 Subject: [PATCH 17/42] fix: iOS mapsLock access and Android updateLayout nullability Co-authored-by: Martin DONADIEU --- .../CapacitorAppleMapsPlugin.swift | 15 ++++++++++++++- ios/Sources/NativeMapPlugin/ViewHelpers.swift | 14 -------------- 2 files changed, 14 insertions(+), 15 deletions(-) diff --git a/ios/Sources/NativeMapPlugin/CapacitorAppleMapsPlugin.swift b/ios/Sources/NativeMapPlugin/CapacitorAppleMapsPlugin.swift index 187d0b4..5234a89 100644 --- a/ios/Sources/NativeMapPlugin/CapacitorAppleMapsPlugin.swift +++ b/ios/Sources/NativeMapPlugin/CapacitorAppleMapsPlugin.swift @@ -77,7 +77,20 @@ public class NativeMapPlugin: CAPPlugin, CAPBridgedPlugin, MKMapViewDelegate { ] var maps = [String: Map]() - private let mapsLock = NSLock() + fileprivate let mapsLock = NSLock() + + func toBackMap(containing point: CGPoint, in webView: WKWebView) -> Map? { + mapsLock.lock() + let candidates = maps.values.filter { $0.toBack && $0.isMapVisible } + mapsLock.unlock() + for map in candidates { + let converted = webView.convert(point, to: map.mapView) + if map.mapView.point(inside: converted, with: nil) { + return map + } + } + return nil + } private let searchService = SearchService() private let geocodeService = GeocodeService() diff --git a/ios/Sources/NativeMapPlugin/ViewHelpers.swift b/ios/Sources/NativeMapPlugin/ViewHelpers.swift index 0f7cdf9..0375f12 100644 --- a/ios/Sources/NativeMapPlugin/ViewHelpers.swift +++ b/ios/Sources/NativeMapPlugin/ViewHelpers.swift @@ -57,20 +57,6 @@ private func shouldPassTouchThroughToMap(_ hitView: UIView?) -> Bool { return hitView.backgroundColor == nil || hitView.backgroundColor == .clear } -extension NativeMapPlugin { - func toBackMap(containing point: CGPoint, in webView: WKWebView) -> Map? { - mapsLock.lock() - let candidates = maps.values.filter { $0.toBack && $0.isMapVisible } - mapsLock.unlock() - for map in candidates { - let converted = webView.convert(point, to: map.mapView) - if map.mapView.point(inside: converted, with: nil) { - return map - } - } - return nil - } -} // MARK: - View tree helpers From cf62e2f1a973236fee6f5a3a7464073afea8e058 Mon Sep 17 00:00:00 2001 From: Cursor Agent Date: Thu, 1 Oct 2026 15:18:55 +0000 Subject: [PATCH 18/42] fix(android): coerce updateLayout ints from PluginCall Co-authored-by: Martin DONADIEU --- .../capgo/plugins/nativemap/CapacitorGoogleMapsPlugin.kt | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/android/src/main/java/com/capgo/plugins/nativemap/CapacitorGoogleMapsPlugin.kt b/android/src/main/java/com/capgo/plugins/nativemap/CapacitorGoogleMapsPlugin.kt index 38a5f4b..4a15a72 100644 --- a/android/src/main/java/com/capgo/plugins/nativemap/CapacitorGoogleMapsPlugin.kt +++ b/android/src/main/java/com/capgo/plugins/nativemap/CapacitorGoogleMapsPlugin.kt @@ -197,10 +197,10 @@ class CapacitorNativeMapPlugin : Plugin(), OnMapsSdkInitializedCallback { val map = maps[id] ?: throw MapNotFoundError() - val x = call.getInt("x", map.config.x) - val y = call.getInt("y", map.config.y) - val width = call.getInt("width", map.config.width) - val height = call.getInt("height", map.config.height) + val x = call.getInt("x") ?: map.config.x + val y = call.getInt("y") ?: map.config.y + val width = call.getInt("width") ?: map.config.width + val height = call.getInt("height") ?: map.config.height map.updateLayout(x, y, width, height) call.resolve() From 1819e44d1e3dcf393b519eeb4e774152ea014815 Mon Sep 17 00:00:00 2001 From: Cursor Agent Date: Thu, 1 Oct 2026 15:28:34 +0000 Subject: [PATCH 19/42] fix(android): rename visibility setter to avoid JVM clash Co-authored-by: Martin DONADIEU --- .../capgo/plugins/nativemap/CapacitorGoogleMapsPlugin.kt | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/android/src/main/java/com/capgo/plugins/nativemap/CapacitorGoogleMapsPlugin.kt b/android/src/main/java/com/capgo/plugins/nativemap/CapacitorGoogleMapsPlugin.kt index 4a15a72..71507db 100644 --- a/android/src/main/java/com/capgo/plugins/nativemap/CapacitorGoogleMapsPlugin.kt +++ b/android/src/main/java/com/capgo/plugins/nativemap/CapacitorGoogleMapsPlugin.kt @@ -197,10 +197,10 @@ class CapacitorNativeMapPlugin : Plugin(), OnMapsSdkInitializedCallback { val map = maps[id] ?: throw MapNotFoundError() - val x = call.getInt("x") ?: map.config.x - val y = call.getInt("y") ?: map.config.y - val width = call.getInt("width") ?: map.config.width - val height = call.getInt("height") ?: map.config.height + val x = call.getInt("x", map.config.x)!! + val y = call.getInt("y", map.config.y)!! + val width = call.getInt("width", map.config.width)!! + val height = call.getInt("height", map.config.height)!! map.updateLayout(x, y, width, height) call.resolve() From f97647c80ffc6de61f4cc41841279e672b3ada6d Mon Sep 17 00:00:00 2001 From: Cursor Agent Date: Thu, 1 Oct 2026 15:32:38 +0000 Subject: [PATCH 20/42] fix: toBack review fixes, Android layout, and example app gating - Android: keep map offset on parent only; finish visibility rename in map view - iOS: touch passthrough for WKContentView; z-order toBack map selection - TS: toBack layout bounds, refcounted document classes, create cleanup - Example: overlay mode native-only; README env var docs for web vs Android Co-authored-by: Martin DONADIEU --- README.md | 2 +- .../plugins/nativemap/CapacitorGoogleMap.kt | 35 +++++-- .../nativemap/CapacitorGoogleMapsPlugin.kt | 4 +- example-app/src/App.tsx | 4 +- .../CapacitorAppleMapsPlugin.swift | 7 +- ios/Sources/NativeMapPlugin/ViewHelpers.swift | 9 +- src/map.ts | 94 +++++++++++++++---- src/touch-routing.ts | 5 - 8 files changed, 121 insertions(+), 39 deletions(-) diff --git a/README.md b/README.md index 982ba7f..95c7eef 100644 --- a/README.md +++ b/README.md @@ -206,7 +206,7 @@ bun run build bunx cap sync ``` -Set `VITE_GOOGLE_MAPS_API_KEY` for web and Android. iOS uses MapKit without a Google key. +Set `VITE_GOOGLE_MAPS_API_KEY` in `example-app/.env` for the web dev server. Android native builds use `GOOGLE_MAPS_API_KEY` for the Gradle manifest placeholder (see `example-app/android/app/build.gradle`). iOS uses MapKit without a Google key. Credits: portions adapted from [katamalabs/capacitor-plugin-apple-maps](https://github.com/katamalabs/capacitor-plugin-apple-maps) and [ionic-team/capacitor-google-maps](https://github.com/ionic-team/capacitor-google-maps) (both MIT). diff --git a/android/src/main/java/com/capgo/plugins/nativemap/CapacitorGoogleMap.kt b/android/src/main/java/com/capgo/plugins/nativemap/CapacitorGoogleMap.kt index fdec7bb..1a4c28b 100644 --- a/android/src/main/java/com/capgo/plugins/nativemap/CapacitorGoogleMap.kt +++ b/android/src/main/java/com/capgo/plugins/nativemap/CapacitorGoogleMap.kt @@ -53,7 +53,7 @@ class CapacitorNativeMapView( private var debounceJob: Job? = null private var mapViewParent: FrameLayout? = null var toBack: Boolean = false - var visible: Boolean = true + var isMapVisible: Boolean = true private var originalWebViewAlpha: Float? = null init { @@ -81,17 +81,23 @@ class CapacitorNativeMapView( parent.minimumHeight = bridge.webView.height parent.minimumWidth = bridge.webView.width - val layoutParams = + val parentLayoutParams = FrameLayout.LayoutParams( getScaledPixels(bridge, config.width), getScaledPixels(bridge, config.height), ) - layoutParams.leftMargin = getScaledPixels(bridge, config.x) - layoutParams.topMargin = getScaledPixels(bridge, config.y) + parentLayoutParams.leftMargin = getScaledPixels(bridge, config.x) + parentLayoutParams.topMargin = getScaledPixels(bridge, config.y) parent.tag = id + parent.layoutParams = parentLayoutParams - mapView.layoutParams = layoutParams + val mapChildParams = + FrameLayout.LayoutParams( + FrameLayout.LayoutParams.MATCH_PARENT, + FrameLayout.LayoutParams.MATCH_PARENT, + ) + mapView.layoutParams = mapChildParams parent.addView(mapView) val webParent = (bridge.webView.parent) as ViewGroup @@ -105,7 +111,7 @@ class CapacitorNativeMapView( } mapViewParent = parent - parent.visibility = if (visible) View.VISIBLE else View.GONE + parent.visibility = if (isMapVisible) View.VISIBLE else View.GONE if (config.styles != null) { googleMap?.setMapStyle(MapStyleOptions(config.styles!!)) } @@ -168,8 +174,8 @@ class CapacitorNativeMapView( } } - fun setVisible(isVisible: Boolean) { - visible = isVisible + fun applyMapVisibility(isVisible: Boolean) { + isMapVisible = isVisible CoroutineScope(Dispatchers.Main).launch { mapViewParent?.visibility = if (isVisible) View.VISIBLE else View.GONE } @@ -188,8 +194,17 @@ class CapacitorNativeMapView( layoutParams.leftMargin = getScaledPixels(bridge, config.x) layoutParams.topMargin = getScaledPixels(bridge, config.y) parent.layoutParams = layoutParams - mapView.layoutParams.width = layoutParams.width - mapView.layoutParams.height = layoutParams.height + val childParams = + (mapView.layoutParams as? FrameLayout.LayoutParams) + ?: FrameLayout.LayoutParams( + FrameLayout.LayoutParams.MATCH_PARENT, + FrameLayout.LayoutParams.MATCH_PARENT, + ) + childParams.width = FrameLayout.LayoutParams.MATCH_PARENT + childParams.height = FrameLayout.LayoutParams.MATCH_PARENT + childParams.leftMargin = 0 + childParams.topMargin = 0 + mapView.layoutParams = childParams parent.requestLayout() } diff --git a/android/src/main/java/com/capgo/plugins/nativemap/CapacitorGoogleMapsPlugin.kt b/android/src/main/java/com/capgo/plugins/nativemap/CapacitorGoogleMapsPlugin.kt index 71507db..0e469a5 100644 --- a/android/src/main/java/com/capgo/plugins/nativemap/CapacitorGoogleMapsPlugin.kt +++ b/android/src/main/java/com/capgo/plugins/nativemap/CapacitorGoogleMapsPlugin.kt @@ -217,7 +217,7 @@ class CapacitorNativeMapPlugin : Plugin(), OnMapsSdkInitializedCallback { val id = call.getString("id") id ?: throw InvalidMapIdError() val map = maps[id] ?: throw MapNotFoundError() - map.setVisible(true) + map.applyMapVisibility(true) call.resolve() } catch (e: NativeMapsError) { handleError(call, e) @@ -232,7 +232,7 @@ class CapacitorNativeMapPlugin : Plugin(), OnMapsSdkInitializedCallback { val id = call.getString("id") id ?: throw InvalidMapIdError() val map = maps[id] ?: throw MapNotFoundError() - map.setVisible(false) + map.applyMapVisibility(false) call.resolve() } catch (e: NativeMapsError) { handleError(call, e) diff --git a/example-app/src/App.tsx b/example-app/src/App.tsx index 26b754a..1466d49 100644 --- a/example-app/src/App.tsx +++ b/example-app/src/App.tsx @@ -11,7 +11,7 @@ type DemoMode = 'embedded' | 'overlay'; const App = () => { const mapRef = useRef(null); const nativeMapRef = useRef(null); - const [mode, setMode] = useState('overlay'); + const [mode, setMode] = useState(Capacitor.isNativePlatform() ? 'overlay' : 'embedded'); const [status, setStatus] = useState('Initializing map...'); const [error, setError] = useState(null); @@ -32,7 +32,7 @@ const App = () => { await nativeMapRef.current?.destroy().catch(() => undefined); nativeMapRef.current = null; - const overlay = mode === 'overlay'; + const overlay = mode === 'overlay' && Capacitor.isNativePlatform(); const map = await NativeMap.create({ id: overlay ? 'overlay-map' : 'demo-map', element: overlay ? document.body : mapRef.current!, diff --git a/ios/Sources/NativeMapPlugin/CapacitorAppleMapsPlugin.swift b/ios/Sources/NativeMapPlugin/CapacitorAppleMapsPlugin.swift index 5234a89..616447a 100644 --- a/ios/Sources/NativeMapPlugin/CapacitorAppleMapsPlugin.swift +++ b/ios/Sources/NativeMapPlugin/CapacitorAppleMapsPlugin.swift @@ -83,7 +83,12 @@ public class NativeMapPlugin: CAPPlugin, CAPBridgedPlugin, MKMapViewDelegate { mapsLock.lock() let candidates = maps.values.filter { $0.toBack && $0.isMapVisible } mapsLock.unlock() - for map in candidates { + let ordered = candidates.sorted { lhs, rhs in + let left = webView.subviews.firstIndex(of: lhs.mapView) ?? -1 + let right = webView.subviews.firstIndex(of: rhs.mapView) ?? -1 + return left > right + } + for map in ordered { let converted = webView.convert(point, to: map.mapView) if map.mapView.point(inside: converted, with: nil) { return map diff --git a/ios/Sources/NativeMapPlugin/ViewHelpers.swift b/ios/Sources/NativeMapPlugin/ViewHelpers.swift index 0375f12..a4a9aad 100644 --- a/ios/Sources/NativeMapPlugin/ViewHelpers.swift +++ b/ios/Sources/NativeMapPlugin/ViewHelpers.swift @@ -51,7 +51,14 @@ private func shouldPassTouchThroughToMap(_ hitView: UIView?) -> Bool { return false } let name = String(describing: type(of: hitView)) - if name.contains("WK") || hitView is UIScrollView { + if name.contains("WKContentView") { + return false + } + if let childScrollClass = NSClassFromString("WKChildScrollView"), + hitView.isKind(of: childScrollClass) { + return true + } + if hitView is UIScrollView { return true } return hitView.backgroundColor == nil || hitView.backgroundColor == .clear diff --git a/src/map.ts b/src/map.ts index 2f29ba4..fb86101 100644 --- a/src/map.ts +++ b/src/map.ts @@ -121,9 +121,12 @@ class MapCustomElement extends HTMLElement { customElements.define('capacitor-native-map', MapCustomElement); export class NativeMap { + private static toBackMapCount = 0; + private id: string; private element: HTMLElement | null = null; private toBack = false; + private toBackLayout?: { x: number; y: number; width: number; height: number }; private windowResizeHandler?: () => void; private resizeObserver: ResizeObserver | null = null; private orientationChangeTimeoutId?: ReturnType; @@ -173,6 +176,10 @@ export class NativeMap { const toBack = options.toBack === true; newMap.toBack = toBack; + if (!toBack && !options.element) { + throw new Error('element is required when toBack is false'); + } + const hostElement = options.element ?? document.body; if (!hostElement) { throw new Error('container element is required'); @@ -190,9 +197,6 @@ export class NativeMap { newMap.element = hostElement; if (!toBack) { newMap.element.dataset.internalId = options.id; - } else { - document.documentElement.classList.add('native-map-to-back'); - document.body.classList.add('native-map-to-back'); } let elementBounds: DOMRect; @@ -203,6 +207,17 @@ export class NativeMap { options.config.width ?? window.innerWidth, options.config.height ?? window.innerHeight, ); + newMap.toBackLayout = { + x: elementBounds.x, + y: elementBounds.y, + width: elementBounds.width, + height: elementBounds.height, + }; + NativeMap.toBackMapCount += 1; + if (NativeMap.toBackMapCount === 1) { + document.documentElement.classList.add('native-map-to-back'); + document.body.classList.add('native-map-to-back'); + } } else { elementBounds = await NativeMap.getElementBounds(hostElement); } @@ -218,7 +233,7 @@ export class NativeMap { if (Capacitor.isNativePlatform()) { createOptions.element = {} as HTMLElement; - const getMapBounds = () => NativeMap.layoutBoundsForElement(newMap.element, toBack); + const getMapBounds = () => newMap.mapBoundsForNative(); const onDisplay = () => { CapacitorNativeMap.onDisplay({ @@ -292,21 +307,58 @@ export class NativeMap { } // small delay to allow for iOS WKWebView to setup corresponding element sub-scroll views ??? - await new Promise((resolve, reject) => { - setTimeout(async () => { - try { - await CapacitorNativeMap.create(createOptions); - resolve(undefined); - } catch (err) { - onMapReadyListener?.remove(); - reject(err); + const cleanupFailedCreate = (): void => { + onMapReadyListener?.remove(); + if (Capacitor.isNativePlatform()) { + newMap.resizeObserver?.disconnect(); + if (newMap.windowResizeHandler) { + window.removeEventListener('resize', newMap.windowResizeHandler); + newMap.windowResizeHandler = undefined; } - }, 200); - }); + } + if (toBack) { + NativeMap.releaseToBackDocumentClasses(); + newMap.toBackLayout = undefined; + } + }; + + try { + await new Promise((resolve, reject) => { + setTimeout(async () => { + try { + await CapacitorNativeMap.create(createOptions); + resolve(undefined); + } catch (err) { + reject(err); + } + }, 200); + }); + } catch (err) { + cleanupFailedCreate(); + throw err; + } return newMap; } + private mapBoundsForNative(): { x: number; y: number; width: number; height: number } { + if (this.toBack && this.toBackLayout) { + return this.toBackLayout; + } + return NativeMap.layoutBoundsForElement(this.element, this.toBack); + } + + private static releaseToBackDocumentClasses(): void { + if (NativeMap.toBackMapCount <= 0) { + return; + } + NativeMap.toBackMapCount -= 1; + if (NativeMap.toBackMapCount === 0) { + document.documentElement.classList.remove('native-map-to-back'); + document.body.classList.remove('native-map-to-back'); + } + } + private static async getElementBounds(element: HTMLElement): Promise { return new Promise((resolve) => { let elementBounds = element.getBoundingClientRect(); @@ -358,6 +410,14 @@ export class NativeMap { ...layout, }); if (layout.width != null || layout.height != null || layout.x != null || layout.y != null) { + if (this.toBack && this.toBackLayout) { + this.toBackLayout = { + x: layout.x ?? this.toBackLayout.x, + y: layout.y ?? this.toBackLayout.y, + width: layout.width ?? this.toBackLayout.width, + height: layout.height ?? this.toBackLayout.height, + }; + } this.updateMapBounds(); } } @@ -545,8 +605,8 @@ export class NativeMap { } if (this.toBack) { - document.documentElement.classList.remove('native-map-to-back'); - document.body.classList.remove('native-map-to-back'); + NativeMap.releaseToBackDocumentClasses(); + this.toBackLayout = undefined; } this.removeAllMapListeners(); @@ -724,7 +784,7 @@ export class NativeMap { if (this.element) { CapacitorNativeMap.onScroll({ id: this.id, - mapBounds: NativeMap.layoutBoundsForElement(this.element, this.toBack), + mapBounds: this.mapBoundsForNative(), }); } } diff --git a/src/touch-routing.ts b/src/touch-routing.ts index 7c1ed6a..5ccf55c 100644 --- a/src/touch-routing.ts +++ b/src/touch-routing.ts @@ -20,11 +20,6 @@ export function shouldRouteTouchToMap(x: number, y: number, mapId: string, toBac return false; } - const overlayRoot = document.querySelector('[data-native-map-overlay-root]'); - if (overlayRoot && !overlayRoot.contains(elem)) { - return true; - } - let current: HTMLElement | null = elem; while (current && current !== document.documentElement) { const style = window.getComputedStyle(current); From 64a632ce1422357948d578dc16eec30369053096 Mon Sep 17 00:00:00 2001 From: Cursor Agent Date: Thu, 1 Oct 2026 15:46:50 +0000 Subject: [PATCH 21/42] chore: add workflow_dispatch to capture native README screenshots Co-authored-by: Martin DONADIEU --- .github/workflows/readme-screenshots.yml | 136 +++++++++++++++++++++++ 1 file changed, 136 insertions(+) create mode 100644 .github/workflows/readme-screenshots.yml diff --git a/.github/workflows/readme-screenshots.yml b/.github/workflows/readme-screenshots.yml new file mode 100644 index 0000000..9887376 --- /dev/null +++ b/.github/workflows/readme-screenshots.yml @@ -0,0 +1,136 @@ +name: Capture README screenshots + +on: + workflow_dispatch: + +concurrency: + group: readme-screenshots-${{ github.workflow }}-${{ github.ref }} + cancel-in-progress: true + +jobs: + ios: + runs-on: macos-latest + timeout-minutes: 30 + steps: + - name: Check out + uses: actions/checkout@v7 + - uses: oven-sh/setup-bun@v2 + - name: Setup Node.js + uses: actions/setup-node@v7 + with: + node-version: 24.x + - name: Build plugin and example app + run: | + set -euo pipefail + bun install + bun run build + cd example-app + bun install + bun run build + bunx cap sync ios + - name: Build for iOS Simulator + run: | + set -euo pipefail + cd example-app/ios/App + xcodebuild \ + -project App.xcodeproj \ + -scheme App \ + -configuration Debug \ + -sdk iphonesimulator \ + -derivedDataPath "$RUNNER_TEMP/DerivedData" \ + -destination 'platform=iOS Simulator,name=iPhone 16,OS=latest' \ + CODE_SIGNING_ALLOWED=NO + - name: Launch app and capture screenshot + run: | + set -euo pipefail + DEVICE_NAME="iPhone 16" + xcrun simctl boot "$DEVICE_NAME" 2>/dev/null || true + xcrun simctl bootstatus booted -b + APP_PATH="$(find "$RUNNER_TEMP/DerivedData" -name 'App.app' -path '*iphonesimulator*' | head -1)" + if [ -z "$APP_PATH" ]; then + echo "Could not find App.app in DerivedData" + exit 1 + fi + xcrun simctl install booted "$APP_PATH" + xcrun simctl launch booted app.capgo.nativemap + sleep 25 + xcrun simctl io booted screenshot "$GITHUB_WORKSPACE/readme-screenshot-ios.png" + - name: Upload iOS screenshot + uses: actions/upload-artifact@v4 + with: + name: readme-screenshot-ios + path: readme-screenshot-ios.png + if-no-files-found: error + + android: + runs-on: ubuntu-latest + timeout-minutes: 45 + steps: + - name: Check out + uses: actions/checkout@v7 + - uses: oven-sh/setup-bun@v2 + - name: Setup Node.js + uses: actions/setup-node@v7 + with: + node-version: 24.x + - name: Setup Java + uses: actions/setup-java@v6 + with: + distribution: zulu + java-version: 21 + - name: Record Google Maps API key availability + id: maps_key + env: + GOOGLE_MAPS_API_KEY: ${{ secrets.GOOGLE_MAPS_API_KEY }} + run: | + set -euo pipefail + if [ -n "${GOOGLE_MAPS_API_KEY:-}" ]; then + echo "present=true" >> "$GITHUB_OUTPUT" + else + echo "present=false" >> "$GITHUB_OUTPUT" + fi + echo "google_maps_api_key_present=${GOOGLE_MAPS_API_KEY:+true}" > maps-key-status.txt + if [ -z "${GOOGLE_MAPS_API_KEY:-}" ]; then + echo "google_maps_api_key_present=false" > maps-key-status.txt + else + echo "google_maps_api_key_present=true" > maps-key-status.txt + fi + - name: Build plugin and example app + env: + GOOGLE_MAPS_API_KEY: ${{ secrets.GOOGLE_MAPS_API_KEY }} + run: | + set -euo pipefail + bun install + bun run build + cd example-app + bun install + bun run build + bunx cap sync android + - name: Run emulator, install app, capture screenshot + uses: reactivecircus/android-emulator-runner@v2 + env: + GOOGLE_MAPS_API_KEY: ${{ secrets.GOOGLE_MAPS_API_KEY }} + with: + api-level: 34 + arch: x86_64 + target: google_apis + profile: pixel_6 + disable-animations: true + emulator-options: -no-snapshot-save -no-window -gpu swiftshader_indirect -noaudio -no-boot-anim + script: | + set -euo pipefail + cd example-app/android + ./gradlew assembleDebug + adb wait-for-device shell 'while [[ -z $(getprop sys.boot_completed) ]]; do sleep 1; done;' + adb install -r app/build/outputs/apk/debug/app-debug.apk + adb shell am start -n app.capgo.nativemap/.MainActivity + sleep 30 + adb exec-out screencap -p > "$GITHUB_WORKSPACE/readme-screenshot-android.png" + - name: Upload Android screenshot and key status + uses: actions/upload-artifact@v4 + with: + name: readme-screenshot-android + path: | + readme-screenshot-android.png + maps-key-status.txt + if-no-files-found: error From 357afe5a32822df84e4bdfe28fe66a76d5062947 Mon Sep 17 00:00:00 2001 From: Cursor Agent Date: Thu, 1 Oct 2026 15:47:34 +0000 Subject: [PATCH 22/42] chore: trigger README screenshot workflow on branch push Co-authored-by: Martin DONADIEU --- .github/workflows/readme-screenshots.yml | 6 +----- 1 file changed, 1 insertion(+), 5 deletions(-) diff --git a/.github/workflows/readme-screenshots.yml b/.github/workflows/readme-screenshots.yml index 9887376..6235289 100644 --- a/.github/workflows/readme-screenshots.yml +++ b/.github/workflows/readme-screenshots.yml @@ -86,14 +86,10 @@ jobs: set -euo pipefail if [ -n "${GOOGLE_MAPS_API_KEY:-}" ]; then echo "present=true" >> "$GITHUB_OUTPUT" + echo "google_maps_api_key_present=true" > maps-key-status.txt else echo "present=false" >> "$GITHUB_OUTPUT" - fi - echo "google_maps_api_key_present=${GOOGLE_MAPS_API_KEY:+true}" > maps-key-status.txt - if [ -z "${GOOGLE_MAPS_API_KEY:-}" ]; then echo "google_maps_api_key_present=false" > maps-key-status.txt - else - echo "google_maps_api_key_present=true" > maps-key-status.txt fi - name: Build plugin and example app env: From b4c7b2c72c20f465a76d3534e176821f79b74d68 Mon Sep 17 00:00:00 2001 From: Cursor Agent Date: Thu, 1 Oct 2026 15:49:06 +0000 Subject: [PATCH 23/42] chore: run README screenshot workflow on PR workflow changes Co-authored-by: Martin DONADIEU --- .github/workflows/readme-screenshots.yml | 39 ++++++++++++++++++++++-- 1 file changed, 37 insertions(+), 2 deletions(-) diff --git a/.github/workflows/readme-screenshots.yml b/.github/workflows/readme-screenshots.yml index 6235289..dba5096 100644 --- a/.github/workflows/readme-screenshots.yml +++ b/.github/workflows/readme-screenshots.yml @@ -2,6 +2,13 @@ name: Capture README screenshots on: workflow_dispatch: + pull_request: + branches: + - main + paths: + - .github/workflows/readme-screenshots.yml + - assets/readme-screenshot-ios.webp + - assets/readme-screenshot-android.webp concurrency: group: readme-screenshots-${{ github.workflow }}-${{ github.ref }} @@ -28,6 +35,34 @@ jobs: bun install bun run build bunx cap sync ios + - name: Resolve iOS Simulator device + id: sim + run: | + set -euo pipefail + DEVICE_NAME="$(python3 <<'PY' + import json, subprocess, sys + out = subprocess.check_output(["xcrun", "simctl", "list", "devices", "available", "-j"], text=True) + data = json.loads(out) + preferred = ("iPhone 16", "iPhone 15", "iPhone 14") + for name in preferred: + for runtime, devices in data.get("devices", {}).items(): + if "iOS" not in runtime: + continue + for device in devices: + if device.get("isAvailable") and device.get("name") == name: + print(name) + sys.exit(0) + for runtime, devices in data.get("devices", {}).items(): + if "iOS" not in runtime: + continue + for device in devices: + if device.get("isAvailable") and "iPhone" in device.get("name", ""): + print(device["name"]) + sys.exit(0) + sys.exit("No available iPhone simulator found") + PY + )" + echo "device_name=$DEVICE_NAME" >> "$GITHUB_OUTPUT" - name: Build for iOS Simulator run: | set -euo pipefail @@ -38,12 +73,12 @@ jobs: -configuration Debug \ -sdk iphonesimulator \ -derivedDataPath "$RUNNER_TEMP/DerivedData" \ - -destination 'platform=iOS Simulator,name=iPhone 16,OS=latest' \ + -destination "platform=iOS Simulator,name=${{ steps.sim.outputs.device_name }}" \ CODE_SIGNING_ALLOWED=NO - name: Launch app and capture screenshot run: | set -euo pipefail - DEVICE_NAME="iPhone 16" + DEVICE_NAME="${{ steps.sim.outputs.device_name }}" xcrun simctl boot "$DEVICE_NAME" 2>/dev/null || true xcrun simctl bootstatus booted -b APP_PATH="$(find "$RUNNER_TEMP/DerivedData" -name 'App.app' -path '*iphonesimulator*' | head -1)" From e2ddcf9f47d41982898cf1ac16dda7d8aae8c210 Mon Sep 17 00:00:00 2001 From: Cursor Agent Date: Thu, 1 Oct 2026 16:05:32 +0000 Subject: [PATCH 24/42] fix: Android screenshot script for emulator runner sh Co-authored-by: Martin DONADIEU --- .github/workflows/readme-screenshots.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/readme-screenshots.yml b/.github/workflows/readme-screenshots.yml index dba5096..a56906f 100644 --- a/.github/workflows/readme-screenshots.yml +++ b/.github/workflows/readme-screenshots.yml @@ -149,7 +149,7 @@ jobs: disable-animations: true emulator-options: -no-snapshot-save -no-window -gpu swiftshader_indirect -noaudio -no-boot-anim script: | - set -euo pipefail + set -eu cd example-app/android ./gradlew assembleDebug adb wait-for-device shell 'while [[ -z $(getprop sys.boot_completed) ]]; do sleep 1; done;' From fefc496e3e5af7f104bdb3694b8076c6657814e5 Mon Sep 17 00:00:00 2001 From: Cursor Agent Date: Thu, 1 Oct 2026 16:22:29 +0000 Subject: [PATCH 25/42] fix: speed up Android README screenshot capture on emulator Co-authored-by: Martin DONADIEU --- .github/workflows/readme-screenshots.yml | 24 +++++++++++++++--------- 1 file changed, 15 insertions(+), 9 deletions(-) diff --git a/.github/workflows/readme-screenshots.yml b/.github/workflows/readme-screenshots.yml index a56906f..9772364 100644 --- a/.github/workflows/readme-screenshots.yml +++ b/.github/workflows/readme-screenshots.yml @@ -11,8 +11,8 @@ on: - assets/readme-screenshot-android.webp concurrency: - group: readme-screenshots-${{ github.workflow }}-${{ github.ref }} - cancel-in-progress: true + group: readme-screenshots-${{ github.workflow }}-${{ github.ref }}-${{ github.run_id }} + cancel-in-progress: false jobs: ios: @@ -99,7 +99,7 @@ jobs: android: runs-on: ubuntu-latest - timeout-minutes: 45 + timeout-minutes: 60 steps: - name: Check out uses: actions/checkout@v7 @@ -137,25 +137,31 @@ jobs: bun install bun run build bunx cap sync android + - name: Assemble debug APK + env: + GOOGLE_MAPS_API_KEY: ${{ secrets.GOOGLE_MAPS_API_KEY }} + run: | + set -euo pipefail + cd example-app/android + ./gradlew assembleDebug - name: Run emulator, install app, capture screenshot uses: reactivecircus/android-emulator-runner@v2 env: GOOGLE_MAPS_API_KEY: ${{ secrets.GOOGLE_MAPS_API_KEY }} with: - api-level: 34 + api-level: 30 arch: x86_64 target: google_apis - profile: pixel_6 + profile: pixel_4 disable-animations: true + emulator-boot-timeout-minutes: 45 emulator-options: -no-snapshot-save -no-window -gpu swiftshader_indirect -noaudio -no-boot-anim script: | set -eu - cd example-app/android - ./gradlew assembleDebug adb wait-for-device shell 'while [[ -z $(getprop sys.boot_completed) ]]; do sleep 1; done;' - adb install -r app/build/outputs/apk/debug/app-debug.apk + adb install -r example-app/android/app/build/outputs/apk/debug/app-debug.apk adb shell am start -n app.capgo.nativemap/.MainActivity - sleep 30 + sleep 35 adb exec-out screencap -p > "$GITHUB_WORKSPACE/readme-screenshot-android.png" - name: Upload Android screenshot and key status uses: actions/upload-artifact@v4 From c2807dd85d87be6c5db9239790b5a27f05d66245 Mon Sep 17 00:00:00 2001 From: Cursor Agent Date: Thu, 1 Oct 2026 16:44:18 +0000 Subject: [PATCH 26/42] fix: skip emulator animation disable for README screenshots Co-authored-by: Martin DONADIEU --- .github/workflows/readme-screenshots.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/readme-screenshots.yml b/.github/workflows/readme-screenshots.yml index 9772364..a403b64 100644 --- a/.github/workflows/readme-screenshots.yml +++ b/.github/workflows/readme-screenshots.yml @@ -153,7 +153,7 @@ jobs: arch: x86_64 target: google_apis profile: pixel_4 - disable-animations: true + disable-animations: false emulator-boot-timeout-minutes: 45 emulator-options: -no-snapshot-save -no-window -gpu swiftshader_indirect -noaudio -no-boot-anim script: | From aef070b307436db98e1dff1fd817f0af33747861 Mon Sep 17 00:00:00 2001 From: Cursor Agent Date: Thu, 1 Oct 2026 17:11:45 +0000 Subject: [PATCH 27/42] fix: run Android README screenshot capture as one bash script Co-authored-by: Martin DONADIEU --- .../capture-android-readme-screenshot.sh | 26 +++++++++++++++++++ .github/workflows/readme-screenshots.yml | 8 +----- 2 files changed, 27 insertions(+), 7 deletions(-) create mode 100755 .github/scripts/capture-android-readme-screenshot.sh diff --git a/.github/scripts/capture-android-readme-screenshot.sh b/.github/scripts/capture-android-readme-screenshot.sh new file mode 100755 index 0000000..454d142 --- /dev/null +++ b/.github/scripts/capture-android-readme-screenshot.sh @@ -0,0 +1,26 @@ +#!/usr/bin/env bash +set -euo pipefail + +ROOT="${GITHUB_WORKSPACE:-$(cd "$(dirname "$0")/../.." && pwd)}" +APK="$ROOT/example-app/android/app/build/outputs/apk/debug/app-debug.apk" + +adb wait-for-device +adb shell 'while [[ -z $(getprop sys.boot_completed) ]]; do sleep 2; done;' +sleep 15 +adb shell input keyevent 82 || true +sleep 5 + +for attempt in 1 2 3; do + if adb install -r "$APK"; then + break + fi + echo "adb install attempt $attempt failed, retrying..." + sleep 10 + if [ "$attempt" = 3 ]; then + exit 1 + fi +done + +adb shell am start -n app.capgo.nativemap/.MainActivity +sleep 40 +adb exec-out screencap -p > "$ROOT/readme-screenshot-android.png" diff --git a/.github/workflows/readme-screenshots.yml b/.github/workflows/readme-screenshots.yml index a403b64..73f915f 100644 --- a/.github/workflows/readme-screenshots.yml +++ b/.github/workflows/readme-screenshots.yml @@ -156,13 +156,7 @@ jobs: disable-animations: false emulator-boot-timeout-minutes: 45 emulator-options: -no-snapshot-save -no-window -gpu swiftshader_indirect -noaudio -no-boot-anim - script: | - set -eu - adb wait-for-device shell 'while [[ -z $(getprop sys.boot_completed) ]]; do sleep 1; done;' - adb install -r example-app/android/app/build/outputs/apk/debug/app-debug.apk - adb shell am start -n app.capgo.nativemap/.MainActivity - sleep 35 - adb exec-out screencap -p > "$GITHUB_WORKSPACE/readme-screenshot-android.png" + script: bash .github/scripts/capture-android-readme-screenshot.sh - name: Upload Android screenshot and key status uses: actions/upload-artifact@v4 with: From a10e2616963b7b257e5686aca07bd1ba948f94fc Mon Sep 17 00:00:00 2001 From: Cursor Agent Date: Thu, 1 Oct 2026 17:43:49 +0000 Subject: [PATCH 28/42] fix: wait for package manager before Android screenshot install Co-authored-by: Martin DONADIEU --- .github/workflows/readme-screenshots.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/readme-screenshots.yml b/.github/workflows/readme-screenshots.yml index 73f915f..50174f4 100644 --- a/.github/workflows/readme-screenshots.yml +++ b/.github/workflows/readme-screenshots.yml @@ -98,7 +98,7 @@ jobs: if-no-files-found: error android: - runs-on: ubuntu-latest + runs-on: ubuntu-latest-4-cores timeout-minutes: 60 steps: - name: Check out From 2ff079ec63143e2ac5bb7fecd283195ae9abe920 Mon Sep 17 00:00:00 2001 From: Cursor Agent Date: Thu, 1 Oct 2026 17:44:08 +0000 Subject: [PATCH 29/42] fix: stabilize Android emulator before README screenshot install Co-authored-by: Martin DONADIEU --- .../capture-android-readme-screenshot.sh | 20 +++++++++++++------ .github/workflows/readme-screenshots.yml | 2 +- 2 files changed, 15 insertions(+), 7 deletions(-) diff --git a/.github/scripts/capture-android-readme-screenshot.sh b/.github/scripts/capture-android-readme-screenshot.sh index 454d142..c257c26 100755 --- a/.github/scripts/capture-android-readme-screenshot.sh +++ b/.github/scripts/capture-android-readme-screenshot.sh @@ -6,21 +6,29 @@ APK="$ROOT/example-app/android/app/build/outputs/apk/debug/app-debug.apk" adb wait-for-device adb shell 'while [[ -z $(getprop sys.boot_completed) ]]; do sleep 2; done;' -sleep 15 + +echo "Waiting for Android package manager..." +for _ in $(seq 1 90); do + if adb shell cmd package list packages 2>/dev/null | head -1 | grep -q package; then + break + fi + sleep 3 +done +sleep 20 adb shell input keyevent 82 || true sleep 5 -for attempt in 1 2 3; do - if adb install -r "$APK"; then +for attempt in 1 2 3 4 5; do + if adb install -r -g "$APK"; then break fi echo "adb install attempt $attempt failed, retrying..." - sleep 10 - if [ "$attempt" = 3 ]; then + sleep 15 + if [ "$attempt" = 5 ]; then exit 1 fi done adb shell am start -n app.capgo.nativemap/.MainActivity -sleep 40 +sleep 45 adb exec-out screencap -p > "$ROOT/readme-screenshot-android.png" diff --git a/.github/workflows/readme-screenshots.yml b/.github/workflows/readme-screenshots.yml index 50174f4..a163d14 100644 --- a/.github/workflows/readme-screenshots.yml +++ b/.github/workflows/readme-screenshots.yml @@ -155,7 +155,7 @@ jobs: profile: pixel_4 disable-animations: false emulator-boot-timeout-minutes: 45 - emulator-options: -no-snapshot-save -no-window -gpu swiftshader_indirect -noaudio -no-boot-anim + emulator-options: -no-snapshot-save -no-window -gpu swiftshader_indirect -noaudio -no-boot-anim -memory 4096 script: bash .github/scripts/capture-android-readme-screenshot.sh - name: Upload Android screenshot and key status uses: actions/upload-artifact@v4 From a53205e450d1614c2a55764d9b73474a72c50335 Mon Sep 17 00:00:00 2001 From: Cursor Agent Date: Thu, 1 Oct 2026 18:52:00 +0000 Subject: [PATCH 30/42] chore: use ubuntu-latest for Android screenshots and update iOS README image Co-authored-by: Martin DONADIEU --- .github/workflows/readme-screenshots.yml | 2 +- assets/readme-screenshot-ios.webp | Bin 4982 -> 1526 bytes 2 files changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/readme-screenshots.yml b/.github/workflows/readme-screenshots.yml index a163d14..6a31473 100644 --- a/.github/workflows/readme-screenshots.yml +++ b/.github/workflows/readme-screenshots.yml @@ -98,7 +98,7 @@ jobs: if-no-files-found: error android: - runs-on: ubuntu-latest-4-cores + runs-on: ubuntu-latest timeout-minutes: 60 steps: - name: Check out diff --git a/assets/readme-screenshot-ios.webp b/assets/readme-screenshot-ios.webp index c303ec709ba29e297d62bdbaa176d811a19c3d2f..b16c70d0868a502e80628f61ccc8ea96b152eac0 100644 GIT binary patch literal 1526 zcmYk1dpOg39LFcBMaexqX>`bK%zaGQvYN)!DyfWI!b!Q+5V=fpse@5DmbE<#89H7cnh_$_4fx$ z5M4}HS)qi%1;1A)-o@x*%(Ci98Gr*|_t{|KW5cgsYX(;Xgun;0ki2G+j+qGPvi_ zrQJA%_R(mY@j8fbIfHquP=uy145wI9ro@P=cylE&ZoUwn-DMmbS-6&35VB`$5>uW) zrbxM0RlaKPtY%DnE-MN^(|kaJvmy)it$6@Hz8_`X2OvLy0ZbpF1-~~G+4Jh!g@GiC z_HDQHFRw?nNYB=@xfCf;l^&r2xicc9Ba2Ehe$L737nJAd?2uH^i8Q5TyCbH& zo-5=*<3Zinl|8mKQ;E5c7Q=vaYiTvAR*BS*_N0kSwAE#&z*5bNy*u(fX;7CAL0+^9 z-OJyz9Eymt(4j;(KGijy^_6oR@2IT0#F(A_B~-C~_o3tm-nH!u-2DK6&ShnAPRrH^ z3i&;^`qLyS({1U%IE*pdwMsaMvrJKC?;OgMc=2@6?n;n(o9M0dxcBe`p%ogH&M8$= zeKowwbjSsdoYN+{F)k>i3)}=n*>({p!Za#XZJ z3@#0;?r+Lituhau3B4&wm{K5_OvJr8HI1(Q^=)50_eFb*{B}grVsqWssAR*qPPvzq zl6n7bAS6B}{h?K3*+5cCXpw@uvDFCIUEZYQ;d>paj_l*h-bj~9@{MnrEs*A3`6O}V zKKPmqJgwn$kucZ!Y+U|MvKHlzrmJF>*$~`ON$)#^-hiOK!)A*o)EfIX&J|jf3LQ^% zU(;V*dcjdFDlX;|Av>H{IxRO&;(arJAW3iO{#q-ME0ZX90vDL(@q8rz>h}|!SYCw? zFMVlf(?7%ZWQLFo`Qenw+?YN;OaL1;_UgF_HCii*wY>nL@LcKQU|QzawJMq{dLiMS z`_mpN;c79ne}|-*#K&(z(hjj7&n$M(J`565YS@u+H|jb4OO}x&CG#X2X8BH0>;Br~eaR=9N^xtHfBB?x1+LzBbu9JQl7RujLR1MH(LbTc|# zfzT4NyTef?nr{KaQP}>j_KiAJe7Pq*{yo9S2h(2vOf)PpW?CiH&$nkX$Pi|&Lhz#{u-TZb zCR)bM>yxlew_XC9^ZW_hWTtb(*=&OU_-Q})>*KNq%D)+S7;&i#=rxnJ+syp-flk)( zZr{9_#0MO@jIKawq_Vtc2#VV6W;Dm!>sU<~)u!fR85T7Ap~LR7sz=1>rliM;_9eHW ze4=Fxl;!6i=3*Vf&?t7 zJi;eNmUmR6hOP|lLd!`SR;>Y5z|80O?s}|}qW(-j@a2s8X;Ae*mH!owTtCW(57G;d|9;sNh7_Dj?U?C+6Zx(`4P z?O)}(!F>dLw|$TQxc}Dl*446OKjS<>@Vn&CbA51g*VfLWKOp;I`!DXkdViAeKi;SG z9-zOB|1tkb;v=%W0De9F1O7+%FBY%sy%GGo`j`42a1Z1k(ZA7px&CLuOYXnsKVv@- zKEOYl|7QQg{tMlI`XBut=REg*gZ^v(SNV^CZ|A?;zwq`d^mF~#4;`-+;BbG2HMRL- zKu70O*5meQ{}zLwA-M$1a9QWlpn`GJ4nTeoCz|%79`BWGVLGAdi+!egXKX-*nhAI0 z7`_^%xekQYiVjyX1^2N!4f6^|4zYCGOZ^`~;kLnlZi!1ca+?BOxQLT<{MhTAtK!}L#g#mKv3a>zM@EzK|#dt;3i&L;e zN)fIJO4klp&V*8`jO{T%HwmKbo#I`>C@T`A;Ht?H$G0x^2C6U5&EmPmx46UwQU}}ImbBX7dV7toO6ylYoX3L$2jKIJFu;OSZFJ? zrQnS-?+d-*&N;_8^1eN#oasw4(_2<#?+* z>c%vfRzxW6G4?Y=3^wS8A|QVN0~pY8#F(i+ZY2uYmw5MUP@Q$?#dq1Y!>nkB5*w@o zHsu2iMJ1|dwv4UvGSGX_OUS<91pD%6b= zUWQ!p{Gk^z4^`DIa7`2Vu9mZ&qtJ!u`cX|nU%y@j$)ZitE^WGZEx4cj<_E+?o`_l1 zzlu&k)G*)NAy)EaSt zyKo$D72&}IrzvK9#!j>jsAW@1a&pX`oU9YP)G{vAC5M(yW%|aARQ#EPT7?*|SXb)e z{W^^`ZY$cj)Be)PL> z_)G0tc&}A}H7V41PB*?TQ3e+hf6qf$TM=y7+S_{I1{<9Re?s`+VU!y4KZJ8++p8Oy z)6;H?;j$^UgY9?T3~rdU!6#f4S=IsZFy;9lKu}G}{TH*tfY+GEY~;S;x8qwJr92K{ z{);aE%_U(BHC6rOi#gr-+&!7JE6is4`B`M{Zp5x33nuo9>oqR?iCRd1 z%xw;bd)V`9#%wrJGa=^YwpZdAQZ|_LvK)-jg|BHjicJtcfRr9e5n1@*<|%7=14)j$ z!a+4G4Qs}HnQ=mLd3*cCZ3)3e%wZhAdcfgdR+WjpafkM8{vYOeb#8-rKQ>tEAB`7t^`$HgITz+KOYkH)BPwfBjS6%i8M9&&Ms*Rx(a!8{Z>Rg!UkUgIU@aJY9y zGq!K=S(o6k0xB^F+C31?a>DTR7M@+Te{`3h?8eF5-W-oG{vU~QLsdyX~X44SLT2Zot&0Htxeb9%wTbb>t>7J zPx^ts}@;=LVr<@c3f?WLWx6O59F*Z$;Fg%) ziu(qZ1&9pPA=q{G6{7Lhf&C(Wtx5(5o?XTVCFfYBHPUJ(78yDUgCcxDxumJMO z#Y-=~Tt7F*{iX5ei#0<8SoGKyIv=G8y-jNkQgyfx-M$KPCy7h?6O@dG8wr6Ykl_Wz z4ZE@#r1gED;u1MFdPZK6MnCw#8KZ7|>ds%75Mh!4KRTMpwFgkV`nmnB zn%oG&;IXr=zLAu{BF36Kt7>kDmk2}^cGx$RfGl51$&=mOA!~Gb!703fpi|ZBxn*(0Z^$@iMts+9(GZUTlR*A zn^_#F6pQ}&vGajaCsDR{C!y|O5;EhdR_Lg?uSflXQ$ci>E9)x@{3?M^RDG$_<9PSi z)(Af?{8-P$7fs@*Us)fIkI3!CfolVG8N55{fuM{N<3NE16n=Nf*4vT7hS~( zrv7$O3VnPJZ;zv2edT^gr&AO8d}Kbn41Lq7XTaYot{UzMSQxSnx@UT-;Vz8{co&as47ERm0dydqFehA^B;=S6jh(Y?9MVLQ((Tg1%8+EILwNyh#==uon!K3Py1SpQ@q1 z4>WA|fUT5J$`VZ^N=l~(z#W=F>)@uXksKAq*(5w$2)^x-cNO#K3F!I`q;K&{V8cAm z|6VYme0%KfJSPh$8(f{iCxcO=@0q5!g&_Q)8HmyKHpXS&L$hx=Ty+&&5skROH>cVw zwa3V5>DC50M1PECHtDpQ@l$95_Rq&|&d@9uI1Q8YgC^s6)FFjAaZW^J{lNLg3@vfR zr8;LyEGFQwH+TNOxA`FF*`x^h&xFK__KaN^yMV;s!e=0`b$hQ45hQtgY+EVgNl{j8 zU_RxopiCv)jGW;|wKa=I4LUwTA%R_vuOM&SF=weTNIqgFxKl~bepH)_eQm(H0gbPT z`Mk#vgoxRhYnR>KR0d_2A#19dZz6oD3tPiPq1VDnI!C~xWoeZ7v1-jhtS~=eNe9Er z(PSCRJ34%mj|bHBh>1m^h_aP(>4gs&jXZ3(qX^QlmaSej?(vU)!pCAp54OQE#lMsJ zq5|G#1{Mt^Xtge}7FkzgRCzM`gFE6Qn#CRsFjU_TsSxjb4%yX7&z*hd7yxl9b{UImN zXT@CTmj5@MqH_AGIqHUg_Uto{b)go88dD1qVK{kaC=RYt z$&u#c7MbIR$>QHI*~&OYvY$$=qqSU!G4hxTqw{lC-eIoEP-xz& zsBjm3&5I@6D={aw@BbTnb-amRyxv5@`CVCwKN2`yh4r#o=Y9kPAVLa{Xq_E+Ezd~! ziPSg|Aox@4!2N82p6k|2lfakF;}$!?cJxwWu||@~Vl+fuAT3IpL}}qMGBTTt_|1yE z#kk55hAjk)4sA7y3x1d=gz9(Xg~%Xoo91L+?}wpvMf@jF-bOL_W;Pyx^msy^O(A7> zT1?O499=+g73qjnL&y_``=?&ekx2J(025206b=ap+8b0L)9tJ6gf_TQ2S9a4lMTrF zGW+Ie;ev2WkkQ_FI-9y)KVD*_dV@C)h@8gvQhia>WsS_@a?kcyD0O@j`AZiW09eZS! z>VTQly*02gdx?vawJiI}fMD#%*7D;?Jo)wUf$pO=_vGageS*{f^P$fNmHgtTtFE=} zje7dsum?yIRgVhMwYx=k%e6Uu;=_TB^OM_LK z%{G#j8e&*CKbDhO=2&T1L`l_lv0l^U%54#CzvODHTX^%O5AL!&xlR2>3a$k58KQ-# zo++N^8mIPiyq~xSqltMTZ}VKL9Dpur!5n!9zw_rP+tO5_!XRWz3O9(m(;mKf;`o+b z;^pyahQ7nV*s20%_SAC@e3Sa7T_NSAIu_-zX$!^qawU8`kMBZW&1}%kYpGI?Uxtdb z#&A}rb8(VtB&^WHkRcwm#5rq30k2Orumm6!n1eZ2nftys{``?h@+X^b#MP`4zFWp8 zPVeNYl?(j6#%+dVuE(Ej!ROQK4J?z-^NU5N4gy_1|10Yh-GY@0cM2 zS6b8G$IJ39&4{JG*VIKjw_Sc~83b!tThndwoOOGv`Lja2pI{7b*AB_+hsT#UxSN!> z1pqcND~}PSd2bq7MrvpxoKd@ez7tKc=nz4GbC%IHLyoaaRs{3IIA>>u0@a+Gfu@G{ zEwrS$DwWULzu`_4aze-(qO=+u8tcmUWVXLk_60@w*@)N2Criz2ok*J6|87R~)TfkQ z_Q_6!+?bVv0<}#W70YiCfv#}`lR>sWHV#Q5WJ5jT{%rbKCCCa{O$r9GtcAVDoI-od!|A&1CrGJ6IB-zpPu>~zdLQf`k>q69 z7BL~+{hgklFNx-6=3m~&E$%I0_`}^1M*k6o`^Ko?YxA6~3O%5Y715#uYE{9z`LH&Q zLu=QSMbxJC-rjEk zg+NON?x5%=li$h5IP<>cgh|bGNj9;Qvo0dIfID@JonWd3@)~MhjM0X4j)papTzpJB zt*cEE{5J3HZTX$V(lVW_wAn<}PsE7(r1y=TC}XK((?K8MJcxjr(0$c8I_K_S;yg%? zJIajL!tJ&tdIuH%IKb_=aGy9m%MG085^t Avj6}9 From df87f39d3f0bb92279bee57957650e329f8271db Mon Sep 17 00:00:00 2001 From: Cursor Agent Date: Thu, 1 Oct 2026 19:23:28 +0000 Subject: [PATCH 31/42] chore: native iOS README screenshot and harden Android capture Co-authored-by: Martin DONADIEU --- .../capture-android-readme-screenshot.sh | 10 ++++------ .github/workflows/readme-screenshots.yml | 6 +++--- assets/readme-screenshot-ios.webp | Bin 1526 -> 41822 bytes 3 files changed, 7 insertions(+), 9 deletions(-) diff --git a/.github/scripts/capture-android-readme-screenshot.sh b/.github/scripts/capture-android-readme-screenshot.sh index c257c26..876f3a6 100755 --- a/.github/scripts/capture-android-readme-screenshot.sh +++ b/.github/scripts/capture-android-readme-screenshot.sh @@ -8,27 +8,25 @@ adb wait-for-device adb shell 'while [[ -z $(getprop sys.boot_completed) ]]; do sleep 2; done;' echo "Waiting for Android package manager..." -for _ in $(seq 1 90); do +for _ in $(seq 1 120); do if adb shell cmd package list packages 2>/dev/null | head -1 | grep -q package; then break fi sleep 3 done -sleep 20 -adb shell input keyevent 82 || true -sleep 5 +sleep 30 for attempt in 1 2 3 4 5; do if adb install -r -g "$APK"; then break fi echo "adb install attempt $attempt failed, retrying..." - sleep 15 + sleep 20 if [ "$attempt" = 5 ]; then exit 1 fi done adb shell am start -n app.capgo.nativemap/.MainActivity -sleep 45 +sleep 50 adb exec-out screencap -p > "$ROOT/readme-screenshot-android.png" diff --git a/.github/workflows/readme-screenshots.yml b/.github/workflows/readme-screenshots.yml index 6a31473..2f37704 100644 --- a/.github/workflows/readme-screenshots.yml +++ b/.github/workflows/readme-screenshots.yml @@ -88,7 +88,7 @@ jobs: fi xcrun simctl install booted "$APP_PATH" xcrun simctl launch booted app.capgo.nativemap - sleep 25 + sleep 45 xcrun simctl io booted screenshot "$GITHUB_WORKSPACE/readme-screenshot-ios.png" - name: Upload iOS screenshot uses: actions/upload-artifact@v4 @@ -149,13 +149,13 @@ jobs: env: GOOGLE_MAPS_API_KEY: ${{ secrets.GOOGLE_MAPS_API_KEY }} with: - api-level: 30 + api-level: 29 arch: x86_64 target: google_apis profile: pixel_4 disable-animations: false emulator-boot-timeout-minutes: 45 - emulator-options: -no-snapshot-save -no-window -gpu swiftshader_indirect -noaudio -no-boot-anim -memory 4096 + emulator-options: -no-snapshot-save -no-window -gpu swiftshader_indirect -noaudio -no-boot-anim script: bash .github/scripts/capture-android-readme-screenshot.sh - name: Upload Android screenshot and key status uses: actions/upload-artifact@v4 diff --git a/assets/readme-screenshot-ios.webp b/assets/readme-screenshot-ios.webp index b16c70d0868a502e80628f61ccc8ea96b152eac0..4e6fc967b32c9db965dd998512d51246295c2145 100644 GIT binary patch literal 41822 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 Date: Thu, 1 Oct 2026 19:34:58 +0000 Subject: [PATCH 32/42] chore: commit native iOS README screenshot from simulator capture Co-authored-by: Martin DONADIEU --- .github/workflows/readme-screenshots.yml | 9 ++------- assets/readme-screenshot-ios.webp | Bin 41822 -> 41804 bytes 2 files changed, 2 insertions(+), 7 deletions(-) diff --git a/.github/workflows/readme-screenshots.yml b/.github/workflows/readme-screenshots.yml index 2f37704..75f77d8 100644 --- a/.github/workflows/readme-screenshots.yml +++ b/.github/workflows/readme-screenshots.yml @@ -2,13 +2,6 @@ name: Capture README screenshots on: workflow_dispatch: - pull_request: - branches: - - main - paths: - - .github/workflows/readme-screenshots.yml - - assets/readme-screenshot-ios.webp - - assets/readme-screenshot-android.webp concurrency: group: readme-screenshots-${{ github.workflow }}-${{ github.ref }}-${{ github.run_id }} @@ -126,6 +119,8 @@ jobs: echo "present=false" >> "$GITHUB_OUTPUT" echo "google_maps_api_key_present=false" > maps-key-status.txt fi + - name: Report Maps API key availability + run: cat maps-key-status.txt - name: Build plugin and example app env: GOOGLE_MAPS_API_KEY: ${{ secrets.GOOGLE_MAPS_API_KEY }} diff --git a/assets/readme-screenshot-ios.webp b/assets/readme-screenshot-ios.webp index 4e6fc967b32c9db965dd998512d51246295c2145..b693b4399377dc8e289ddb0003e3949f601fd737 100644 GIT binary patch literal 41804 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%0Db+>n+=JNqnX3u>SMRQ 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 iH9QLZ4uRATyOcS99XlZSlw Date: Thu, 1 Oct 2026 19:44:23 +0000 Subject: [PATCH 33/42] chore: bump upload-artifact to v7 and show iOS README screenshot only Co-authored-by: Martin DONADIEU --- .github/workflows/readme-screenshots.yml | 4 ++-- README.md | 3 +-- 2 files changed, 3 insertions(+), 4 deletions(-) diff --git a/.github/workflows/readme-screenshots.yml b/.github/workflows/readme-screenshots.yml index 75f77d8..f3798aa 100644 --- a/.github/workflows/readme-screenshots.yml +++ b/.github/workflows/readme-screenshots.yml @@ -84,7 +84,7 @@ jobs: sleep 45 xcrun simctl io booted screenshot "$GITHUB_WORKSPACE/readme-screenshot-ios.png" - name: Upload iOS screenshot - uses: actions/upload-artifact@v4 + uses: actions/upload-artifact@v7 with: name: readme-screenshot-ios path: readme-screenshot-ios.png @@ -153,7 +153,7 @@ jobs: emulator-options: -no-snapshot-save -no-window -gpu swiftshader_indirect -noaudio -no-boot-anim script: bash .github/scripts/capture-android-readme-screenshot.sh - name: Upload Android screenshot and key status - uses: actions/upload-artifact@v4 + uses: actions/upload-artifact@v7 with: name: readme-screenshot-android path: | diff --git a/README.md b/README.md index 95c7eef..a89a1cf 100644 --- a/README.md +++ b/README.md @@ -17,8 +17,7 @@ **One TypeScript API for native maps in Capacitor apps:** Google Maps on Android, Apple MapKit on iOS, and Google Maps JS on the web. Ship markers, camera moves, shapes, clustering, search, and events from a single integration.

            - Native map with HTML overlay on iOS - Native map with HTML overlay on Android + Native map with HTML overlay on iOS (example app, toBack overlay mode)

            Docs: [Native Map plugin](https://capgo.app/docs/plugins/native-map/) · Tutorial: [capacitor-native-map](https://capgo.app/plugins/capacitor-native-map/) From 18bec01f4231bfc7cef4cb29feaa8db6e3a34009 Mon Sep 17 00:00:00 2001 From: Cursor Agent Date: Thu, 1 Oct 2026 19:44:31 +0000 Subject: [PATCH 34/42] chore: bump action-gh-release to latest major v3 Co-authored-by: Martin DONADIEU --- .github/workflows/build.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml index 6284c6d..c1e788e 100644 --- a/.github/workflows/build.yml +++ b/.github/workflows/build.yml @@ -74,7 +74,7 @@ jobs: -f "client_payload[package]=$(node -p "require('./package.json').name")" - name: Create GitHub release id: create_release - uses: softprops/action-gh-release@v2 + uses: softprops/action-gh-release@v3 with: body: | ## 🆕 Changelog From ddbd5ed5ae45e3be7d75002a8453d0edd6cf55a6 Mon Sep 17 00:00:00 2001 From: Cursor Agent Date: Sun, 4 Oct 2026 22:12:01 +0000 Subject: [PATCH 35/42] fix: address PR review threads for toBack, web, and CI - iOS: preserve toBack mount on resume, layout and compositor restore, DOM touch routing - Android: skip hidden maps in hit tests, restore WebView parent background on destroy - Web: dedicated map host element and positioned updateLayout - Example README overlay docs; screenshot workflow timeouts and adb script fixes Co-authored-by: Martin DONADIEU --- .../capture-android-readme-screenshot.sh | 5 +- .github/workflows/readme-screenshots.yml | 8 +-- README.md | 2 +- .../plugins/nativemap/CapacitorGoogleMap.kt | 4 ++ .../nativemap/CapacitorGoogleMapsPlugin.kt | 3 + .../nativemap/ToBackCompositorHelper.kt | 42 +++++++++++++ example-app/src/App.css | 10 ++-- example-app/src/App.tsx | 2 +- .../NativeMapPlugin/CapacitorAppleMaps.swift | 12 +++- ios/Sources/NativeMapPlugin/MapMounting.swift | 18 ++++++ .../NativeMapPlugin/ToBackCompositor.swift | 59 ++++++++++++++++++- .../NativeMapPlugin/TouchRoutingJs.swift | 39 ++++++++++++ ios/Sources/NativeMapPlugin/ViewHelpers.swift | 11 +++- src/map.ts | 1 + src/web.ts | 26 +++++++- 15 files changed, 223 insertions(+), 19 deletions(-) create mode 100644 ios/Sources/NativeMapPlugin/TouchRoutingJs.swift diff --git a/.github/scripts/capture-android-readme-screenshot.sh b/.github/scripts/capture-android-readme-screenshot.sh index 876f3a6..0570724 100755 --- a/.github/scripts/capture-android-readme-screenshot.sh +++ b/.github/scripts/capture-android-readme-screenshot.sh @@ -9,11 +9,14 @@ adb shell 'while [[ -z $(getprop sys.boot_completed) ]]; do sleep 2; done;' echo "Waiting for Android package manager..." for _ in $(seq 1 120); do - if adb shell cmd package list packages 2>/dev/null | head -1 | grep -q package; then + packages="$(adb shell cmd package list packages 2>/dev/null || true)" + if echo "$packages" | grep -q package; then break fi sleep 3 done +adb shell input keyevent KEYCODE_WAKEUP +adb shell input keyevent 82 sleep 30 for attempt in 1 2 3 4 5; do diff --git a/.github/workflows/readme-screenshots.yml b/.github/workflows/readme-screenshots.yml index f3798aa..1a1620f 100644 --- a/.github/workflows/readme-screenshots.yml +++ b/.github/workflows/readme-screenshots.yml @@ -4,13 +4,13 @@ on: workflow_dispatch: concurrency: - group: readme-screenshots-${{ github.workflow }}-${{ github.ref }}-${{ github.run_id }} + group: readme-screenshots-${{ github.workflow }}-${{ github.ref }} cancel-in-progress: false jobs: ios: runs-on: macos-latest - timeout-minutes: 30 + timeout-minutes: 10 steps: - name: Check out uses: actions/checkout@v7 @@ -92,7 +92,7 @@ jobs: android: runs-on: ubuntu-latest - timeout-minutes: 60 + timeout-minutes: 10 steps: - name: Check out uses: actions/checkout@v7 @@ -149,7 +149,7 @@ jobs: target: google_apis profile: pixel_4 disable-animations: false - emulator-boot-timeout-minutes: 45 + emulator-boot-timeout-minutes: 10 emulator-options: -no-snapshot-save -no-window -gpu swiftshader_indirect -noaudio -no-boot-anim script: bash .github/scripts/capture-android-readme-screenshot.sh - name: Upload Android screenshot and key status diff --git a/README.md b/README.md index a89a1cf..b794737 100644 --- a/README.md +++ b/README.md @@ -167,7 +167,7 @@ body.native-map-to-back { ### Full HTML overlay example ```html -
            +

            Nearby stores

            diff --git a/android/src/main/java/com/capgo/plugins/nativemap/CapacitorGoogleMap.kt b/android/src/main/java/com/capgo/plugins/nativemap/CapacitorGoogleMap.kt index 1a4c28b..1c36a0d 100644 --- a/android/src/main/java/com/capgo/plugins/nativemap/CapacitorGoogleMap.kt +++ b/android/src/main/java/com/capgo/plugins/nativemap/CapacitorGoogleMap.kt @@ -103,6 +103,7 @@ class CapacitorNativeMapView( val webParent = (bridge.webView.parent) as ViewGroup if (toBack) { webParent.addView(parent, 0) + ToBackCompositorHelper.onToBackMapCreated(webView) applyToBackVisualState(bridge) } else { webParent.addView(parent) @@ -259,6 +260,9 @@ class CapacitorNativeMapView( if (null != viewToRemove) { ((bridge.webView.parent) as ViewGroup).removeView(viewToRemove) } + if (toBack) { + ToBackCompositorHelper.onToBackMapDestroyed(bridge.webView) + } mapView.onDestroy() googleMap = null clusterManager = null diff --git a/android/src/main/java/com/capgo/plugins/nativemap/CapacitorGoogleMapsPlugin.kt b/android/src/main/java/com/capgo/plugins/nativemap/CapacitorGoogleMapsPlugin.kt index 0e469a5..4dd985c 100644 --- a/android/src/main/java/com/capgo/plugins/nativemap/CapacitorGoogleMapsPlugin.kt +++ b/android/src/main/java/com/capgo/plugins/nativemap/CapacitorGoogleMapsPlugin.kt @@ -66,6 +66,9 @@ class CapacitorNativeMapPlugin : Plugin(), OnMapsSdkInitializedCallback { if (touchEnabled[id] == false) { continue } + if (!map.isMapVisible) { + continue + } val mapRect = map.getMapBounds() if (mapRect.contains(touchX.toInt(), touchY.toInt())) { if (event.action == MotionEvent.ACTION_DOWN) { diff --git a/android/src/main/java/com/capgo/plugins/nativemap/ToBackCompositorHelper.kt b/android/src/main/java/com/capgo/plugins/nativemap/ToBackCompositorHelper.kt index 172b9fc..49aa4d0 100644 --- a/android/src/main/java/com/capgo/plugins/nativemap/ToBackCompositorHelper.kt +++ b/android/src/main/java/com/capgo/plugins/nativemap/ToBackCompositorHelper.kt @@ -1,12 +1,17 @@ package com.capgo.plugins.nativemap import android.graphics.Color +import android.graphics.drawable.ColorDrawable import android.view.View +import android.webkit.WebView /** * Policy for Android `toBack` compositing: native map behind the Capacitor WebView. */ object ToBackCompositorHelper { + private var toBackMapCount = 0 + private var savedParentBackgroundColor: Int? = null + fun shouldTransparentizeWebViewParent(): Boolean = true fun resolveWebViewBackgroundColor(): Int = Color.TRANSPARENT @@ -16,4 +21,41 @@ object ToBackCompositorHelper { fun shouldUseHardwareLayerOnPreviewContainer(toBack: Boolean): Boolean = !toBack fun resolveWebViewLayerType(): Int = View.LAYER_TYPE_HARDWARE + + fun onToBackMapCreated(webView: WebView) { + toBackMapCount += 1 + if (toBackMapCount != 1) { + return + } + val parent = webView.parent as? View + savedParentBackgroundColor = + (parent?.background as? ColorDrawable)?.color ?: parent?.solidBackgroundColor() + } + + fun onToBackMapDestroyed(webView: WebView) { + if (toBackMapCount <= 0) { + return + } + toBackMapCount -= 1 + if (toBackMapCount != 0) { + return + } + val parent = webView.parent as? View + val restore = savedParentBackgroundColor + savedParentBackgroundColor = null + if (restore != null) { + parent?.setBackgroundColor(restore) + } else { + parent?.background = null + } + } + + private fun View.solidBackgroundColor(): Int? { + val drawable = background + return if (drawable is ColorDrawable) { + drawable.color + } else { + null + } + } } diff --git a/example-app/src/App.css b/example-app/src/App.css index 46060f3..26f49f5 100644 --- a/example-app/src/App.css +++ b/example-app/src/App.css @@ -77,10 +77,7 @@ } .status-message { - position: fixed; - left: 1rem; - right: 1rem; - bottom: calc(5rem + env(safe-area-inset-bottom)); + margin-top: 0.75rem; text-align: center; color: #0f172a; font-size: 0.85rem; @@ -88,6 +85,11 @@ } .app-overlay .status-message { + position: fixed; + left: 1rem; + right: 1rem; + bottom: calc(5rem + env(safe-area-inset-bottom)); + margin-top: 0; color: #e2e8f0; } diff --git a/example-app/src/App.tsx b/example-app/src/App.tsx index 1466d49..6d0433a 100644 --- a/example-app/src/App.tsx +++ b/example-app/src/App.tsx @@ -84,7 +84,7 @@ const App = () => { return (
            {mode === 'overlay' && ( -
            +

            Native map behind HTML

            Buttons stay in the WebView. Open areas pass gestures to the map.

            diff --git a/ios/Sources/NativeMapPlugin/CapacitorAppleMaps.swift b/ios/Sources/NativeMapPlugin/CapacitorAppleMaps.swift index 8cb94e0..4b86a6b 100644 --- a/ios/Sources/NativeMapPlugin/CapacitorAppleMaps.swift +++ b/ios/Sources/NativeMapPlugin/CapacitorAppleMaps.swift @@ -292,7 +292,7 @@ public class Map: NSObject, UIGestureRecognizerDelegate { self.mapView.autoresizingMask = [.flexibleWidth, .flexibleHeight] webView.addSubview(self.mapView) webView.sendSubviewToBack(self.mapView) - ToBackCompositor.applyTransparentWebView(webView) + ToBackCompositor.acquireTransparentWebView(webView) self.targetView = webView self.mapView.isHidden = !self.isMapVisible } else { @@ -323,9 +323,13 @@ public class Map: NSObject, UIGestureRecognizerDelegate { func destroy() { DispatchQueue.main.async { self.dismissCallout() + let webView = self.delegate?.bridge?.webView self.mapView.removeFromSuperview() self.mapView.delegate = nil self.targetView?.tag = 0 + if self.toBack { + ToBackCompositor.releaseTransparentWebView(webView) + } } } @@ -335,7 +339,11 @@ public class Map: NSObject, UIGestureRecognizerDelegate { config.width = bounds.size.width config.height = bounds.size.height runOnMainSync { - self.mapView.frame = bounds + if self.toBack { + self.mapView.frame = bounds + } else { + self.mapView.frame = CGRect(origin: .zero, size: bounds.size) + } } } diff --git a/ios/Sources/NativeMapPlugin/MapMounting.swift b/ios/Sources/NativeMapPlugin/MapMounting.swift index b1f2b51..40fbc6d 100644 --- a/ios/Sources/NativeMapPlugin/MapMounting.swift +++ b/ios/Sources/NativeMapPlugin/MapMounting.swift @@ -51,6 +51,24 @@ extension Map { /// touch handling. Keeps the existing mount if a container can't be found. func remountIntoContainer() { DispatchQueue.main.async { + if self.toBack, let webView = self.delegate?.bridge?.webView { + let frame = CGRect( + x: self.config.x, + y: self.config.y, + width: self.config.width, + height: self.config.height + ) + if self.mapView.superview !== webView { + self.mapView.removeFromSuperview() + webView.addSubview(self.mapView) + } + self.mapView.frame = frame + webView.sendSubviewToBack(self.mapView) + self.targetView = webView + self.mapView.isHidden = !self.isMapVisible + return + } + let width = round(Double(self.mapView.bounds.width)) let height = round(Double(self.mapView.bounds.height)) guard width > 0, height > 0 else { return } diff --git a/ios/Sources/NativeMapPlugin/ToBackCompositor.swift b/ios/Sources/NativeMapPlugin/ToBackCompositor.swift index c263ff6..da43423 100644 --- a/ios/Sources/NativeMapPlugin/ToBackCompositor.swift +++ b/ios/Sources/NativeMapPlugin/ToBackCompositor.swift @@ -3,9 +3,38 @@ import UIKit import WebKit enum ToBackCompositor { - static func applyTransparentWebView(_ webView: WKWebView?) { + private struct SavedWebViewAppearance { + var isOpaque: Bool + var backgroundColor: UIColor? + var superviewBackgroundColor: UIColor? + var descendantBackgrounds: [ObjectIdentifier: UIColor?] + } + + private static var toBackMapCount = 0 + private static var savedAppearance: SavedWebViewAppearance? + + static func acquireTransparentWebView(_ webView: WKWebView?) { guard let webView = webView else { return } DispatchQueue.main.async { + toBackMapCount += 1 + guard toBackMapCount == 1 else { return } + + var descendantBackgrounds: [ObjectIdentifier: UIColor?] = [:] + func recordBackgrounds(_ view: UIView) { + descendantBackgrounds[ObjectIdentifier(view)] = view.backgroundColor + for subview in view.subviews { + recordBackgrounds(subview) + } + } + recordBackgrounds(webView) + + savedAppearance = SavedWebViewAppearance( + isOpaque: webView.isOpaque, + backgroundColor: webView.backgroundColor, + superviewBackgroundColor: webView.superview?.backgroundColor, + descendantBackgrounds: descendantBackgrounds + ) + webView.isOpaque = false webView.backgroundColor = .clear func clearBackgrounds(_ view: UIView) { @@ -20,4 +49,32 @@ enum ToBackCompositor { webView.layoutIfNeeded() } } + + static func releaseTransparentWebView(_ webView: WKWebView?) { + guard let webView = webView else { return } + DispatchQueue.main.async { + guard toBackMapCount > 0 else { return } + toBackMapCount -= 1 + guard toBackMapCount == 0, let saved = savedAppearance else { return } + + webView.isOpaque = saved.isOpaque + webView.backgroundColor = saved.backgroundColor + webView.superview?.backgroundColor = saved.superviewBackgroundColor + + func restoreBackgrounds(_ view: UIView) { + let key = ObjectIdentifier(view) + if let prior = saved.descendantBackgrounds[key] { + view.backgroundColor = prior + } + for subview in view.subviews { + restoreBackgrounds(subview) + } + } + restoreBackgrounds(webView) + + savedAppearance = nil + webView.setNeedsLayout() + webView.layoutIfNeeded() + } + } } diff --git a/ios/Sources/NativeMapPlugin/TouchRoutingJs.swift b/ios/Sources/NativeMapPlugin/TouchRoutingJs.swift new file mode 100644 index 0000000..585ac77 --- /dev/null +++ b/ios/Sources/NativeMapPlugin/TouchRoutingJs.swift @@ -0,0 +1,39 @@ +import Foundation +import WebKit + +extension NativeMapPlugin { + /// Mirrors `src/touch-routing.ts` for synchronous native hit testing. + func shouldRouteTouchToMap(at point: CGPoint, in webView: WKWebView) -> Bool { + let x = point.x + let y = point.y + let js = """ + (function() { + const interactive = 'a,button,input,select,textarea,label,summary,details,[role="button"],[contenteditable="true"],[data-map-overlay]'; + const elem = document.elementFromPoint(\(x), \(y)); + if (!elem) { return true; } + if (elem.closest(interactive)) { return false; } + let current = elem; + while (current && current !== document.documentElement) { + const style = window.getComputedStyle(current); + const bg = style.backgroundColor; + if (bg && bg !== 'rgba(0, 0, 0, 0)' && bg !== 'transparent') { + const opacity = parseFloat(style.opacity || '1'); + if (opacity > 0.05) { return false; } + } + current = current.parentElement; + } + return true; + })(); + """ + var routeToMap = true + let semaphore = DispatchSemaphore(value: 0) + webView.evaluateJavaScript(js) { result, _ in + if let value = result as? Bool { + routeToMap = value + } + semaphore.signal() + } + semaphore.wait() + return routeToMap + } +} diff --git a/ios/Sources/NativeMapPlugin/ViewHelpers.swift b/ios/Sources/NativeMapPlugin/ViewHelpers.swift index a4a9aad..7348e3b 100644 --- a/ios/Sources/NativeMapPlugin/ViewHelpers.swift +++ b/ios/Sources/NativeMapPlugin/ViewHelpers.swift @@ -25,7 +25,7 @@ extension WKWebView { if let plugin = WKWebView.touchRoutingPlugin, let map = plugin.toBackMap(containing: point, in: self) { - if shouldPassTouchThroughToMap(hitView) { + if shouldPassTouchThroughToMap(hitView, at: point, in: self, plugin: plugin) { let converted = convert(point, to: map.mapView) return map.mapView.hitTest(converted, with: event) ?? hitView } @@ -45,14 +45,19 @@ extension WKWebView { } } -private func shouldPassTouchThroughToMap(_ hitView: UIView?) -> Bool { +private func shouldPassTouchThroughToMap( + _ hitView: UIView?, + at point: CGPoint, + in webView: WKWebView, + plugin: NativeMapPlugin +) -> Bool { guard let hitView = hitView else { return true } if hitView is UIControl { return false } let name = String(describing: type(of: hitView)) if name.contains("WKContentView") { - return false + return plugin.shouldRouteTouchToMap(at: point, in: webView) } if let childScrollClass = NSClassFromString("WKChildScrollView"), hitView.isKind(of: childScrollClass) { diff --git a/src/map.ts b/src/map.ts index fb86101..28cfbda 100644 --- a/src/map.ts +++ b/src/map.ts @@ -315,6 +315,7 @@ export class NativeMap { window.removeEventListener('resize', newMap.windowResizeHandler); newMap.windowResizeHandler = undefined; } + newMap.disableScrolling(); } if (toBack) { NativeMap.releaseToBackDocumentClasses(); diff --git a/src/web.ts b/src/web.ts index df1b26d..3853589 100644 --- a/src/web.ts +++ b/src/web.ts @@ -38,6 +38,7 @@ export class CapacitorNativeMapWeb extends WebPlugin implements NativeMapPlugin private maps: { [id: string]: { element: HTMLElement; + ownsElement: boolean; map: google.maps.Map; markers: { [id: string]: google.maps.marker.AdvancedMarkerElement; @@ -148,12 +149,27 @@ export class CapacitorNativeMapWeb extends WebPlugin implements NativeMapPlugin this.maps[_args.id].map.setOptions({ gestureHandling: 'none' }); } + private createOwnedMapHost(id: string): HTMLElement { + const host = document.createElement('div'); + host.dataset.capacitorNativeMapHost = id; + host.style.position = 'absolute'; + host.style.left = '0'; + host.style.top = '0'; + host.style.width = '100%'; + host.style.height = '100%'; + document.body.appendChild(host); + return host; + } + async updateLayout(_args: { id: string; x?: number; y?: number; width?: number; height?: number }): Promise { const entry = this.maps[_args.id]; if (!entry) { return; } const el = entry.element; + if (_args.x != null || _args.y != null) { + el.style.position = 'absolute'; + } if (_args.x != null) { el.style.left = `${_args.x}px`; } @@ -560,9 +576,12 @@ export class CapacitorNativeMapWeb extends WebPlugin implements NativeMapPlugin throw new Error('config.mapId is required on web (create a Map ID in Google Cloud Console for Advanced Markers)'); } + const ownsElement = _args.element == null; + const element = _args.element ?? this.createOwnedMapHost(_args.id); this.maps[_args.id] = { - map: new window.google.maps.Map(_args.element ?? document.body, config), - element: _args.element ?? document.body, + map: new window.google.maps.Map(element, config), + element, + ownsElement, markers: {}, tileOverlays: {}, polygons: {}, @@ -577,6 +596,9 @@ export class CapacitorNativeMapWeb extends WebPlugin implements NativeMapPlugin const mapItem = this.maps[_args.id]; mapItem.element.innerHTML = ''; mapItem.map.unbindAll(); + if (mapItem.ownsElement) { + mapItem.element.remove(); + } delete this.maps[_args.id]; } From 9666ef1911619c46617591245a71f06dae4664bb Mon Sep 17 00:00:00 2001 From: Cursor Agent Date: Sun, 4 Oct 2026 22:21:30 +0000 Subject: [PATCH 36/42] fix(android): use bridge.webView in toBack compositor hook Co-authored-by: Martin DONADIEU --- .../main/java/com/capgo/plugins/nativemap/CapacitorGoogleMap.kt | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/android/src/main/java/com/capgo/plugins/nativemap/CapacitorGoogleMap.kt b/android/src/main/java/com/capgo/plugins/nativemap/CapacitorGoogleMap.kt index 1c36a0d..eb75919 100644 --- a/android/src/main/java/com/capgo/plugins/nativemap/CapacitorGoogleMap.kt +++ b/android/src/main/java/com/capgo/plugins/nativemap/CapacitorGoogleMap.kt @@ -103,7 +103,7 @@ class CapacitorNativeMapView( val webParent = (bridge.webView.parent) as ViewGroup if (toBack) { webParent.addView(parent, 0) - ToBackCompositorHelper.onToBackMapCreated(webView) + ToBackCompositorHelper.onToBackMapCreated(bridge.webView) applyToBackVisualState(bridge) } else { webParent.addView(parent) From b82f91d7109793d932d1621dc1491d593bdd8753 Mon Sep 17 00:00:00 2001 From: Cursor Agent Date: Sun, 4 Oct 2026 23:28:36 +0000 Subject: [PATCH 37/42] fix: cubic follow-up for touch cache, compositor, and web host - iOS: sync touch routing from JS rect cache; per-WebView toBack compositor state - Android: track toBack acquisition per map id before restore - Web: insert owned map host behind overlay UI; README manifest variable wording Co-authored-by: Martin DONADIEU --- README.md | 4 +- .../plugins/nativemap/CapacitorGoogleMap.kt | 4 +- .../nativemap/ToBackCompositorHelper.kt | 17 +-- .../CapacitorAppleMapsPlugin.swift | 1 + ios/Sources/NativeMapPlugin/MapMounting.swift | 2 +- .../NativeMapPlugin/ToBackCompositor.swift | 51 +++++++-- .../NativeMapPlugin/TouchRoutingCache.swift | 90 +++++++++++++++ .../NativeMapPlugin/TouchRoutingJs.swift | 33 +----- src/map.ts | 7 ++ src/touch-routing.ts | 103 ++++++++++++++++++ src/web.ts | 8 +- 11 files changed, 263 insertions(+), 57 deletions(-) create mode 100644 ios/Sources/NativeMapPlugin/TouchRoutingCache.swift diff --git a/README.md b/README.md index b794737..dfcd5ff 100644 --- a/README.md +++ b/README.md @@ -87,7 +87,7 @@ Sync the plugin with CocoaPods or Swift Package Manager (both are supported). android:value="${GOOGLE_MAPS_API_KEY}" /> ``` -3. Provide `GOOGLE_MAPS_API_KEY` when building (Gradle placeholder in `example-app/android/app/build.gradle`). +3. Provide `GOOGLE_MAPS_API_KEY` when building (Gradle manifest variable in `example-app/android/app/build.gradle`). ## Usage @@ -205,7 +205,7 @@ bun run build bunx cap sync ``` -Set `VITE_GOOGLE_MAPS_API_KEY` in `example-app/.env` for the web dev server. Android native builds use `GOOGLE_MAPS_API_KEY` for the Gradle manifest placeholder (see `example-app/android/app/build.gradle`). iOS uses MapKit without a Google key. +Set `VITE_GOOGLE_MAPS_API_KEY` in `example-app/.env` for the web dev server. Android native builds use `GOOGLE_MAPS_API_KEY` for the Gradle manifest variable (see `example-app/android/app/build.gradle`). iOS uses MapKit without a Google key. Credits: portions adapted from [katamalabs/capacitor-plugin-apple-maps](https://github.com/katamalabs/capacitor-plugin-apple-maps) and [ionic-team/capacitor-google-maps](https://github.com/ionic-team/capacitor-google-maps) (both MIT). diff --git a/android/src/main/java/com/capgo/plugins/nativemap/CapacitorGoogleMap.kt b/android/src/main/java/com/capgo/plugins/nativemap/CapacitorGoogleMap.kt index eb75919..2f98f58 100644 --- a/android/src/main/java/com/capgo/plugins/nativemap/CapacitorGoogleMap.kt +++ b/android/src/main/java/com/capgo/plugins/nativemap/CapacitorGoogleMap.kt @@ -103,7 +103,7 @@ class CapacitorNativeMapView( val webParent = (bridge.webView.parent) as ViewGroup if (toBack) { webParent.addView(parent, 0) - ToBackCompositorHelper.onToBackMapCreated(bridge.webView) + ToBackCompositorHelper.onToBackMapCreated(bridge.webView, id) applyToBackVisualState(bridge) } else { webParent.addView(parent) @@ -261,7 +261,7 @@ class CapacitorNativeMapView( ((bridge.webView.parent) as ViewGroup).removeView(viewToRemove) } if (toBack) { - ToBackCompositorHelper.onToBackMapDestroyed(bridge.webView) + ToBackCompositorHelper.onToBackMapDestroyed(bridge.webView, id) } mapView.onDestroy() googleMap = null diff --git a/android/src/main/java/com/capgo/plugins/nativemap/ToBackCompositorHelper.kt b/android/src/main/java/com/capgo/plugins/nativemap/ToBackCompositorHelper.kt index 49aa4d0..fd2af1e 100644 --- a/android/src/main/java/com/capgo/plugins/nativemap/ToBackCompositorHelper.kt +++ b/android/src/main/java/com/capgo/plugins/nativemap/ToBackCompositorHelper.kt @@ -9,7 +9,7 @@ import android.webkit.WebView * Policy for Android `toBack` compositing: native map behind the Capacitor WebView. */ object ToBackCompositorHelper { - private var toBackMapCount = 0 + private val acquiredMapIds: MutableSet = mutableSetOf() private var savedParentBackgroundColor: Int? = null fun shouldTransparentizeWebViewParent(): Boolean = true @@ -22,9 +22,11 @@ object ToBackCompositorHelper { fun resolveWebViewLayerType(): Int = View.LAYER_TYPE_HARDWARE - fun onToBackMapCreated(webView: WebView) { - toBackMapCount += 1 - if (toBackMapCount != 1) { + fun onToBackMapCreated(webView: WebView, mapId: String) { + if (!acquiredMapIds.add(mapId)) { + return + } + if (acquiredMapIds.size != 1) { return } val parent = webView.parent as? View @@ -32,12 +34,11 @@ object ToBackCompositorHelper { (parent?.background as? ColorDrawable)?.color ?: parent?.solidBackgroundColor() } - fun onToBackMapDestroyed(webView: WebView) { - if (toBackMapCount <= 0) { + fun onToBackMapDestroyed(webView: WebView, mapId: String) { + if (!acquiredMapIds.remove(mapId)) { return } - toBackMapCount -= 1 - if (toBackMapCount != 0) { + if (acquiredMapIds.isNotEmpty()) { return } val parent = webView.parent as? View diff --git a/ios/Sources/NativeMapPlugin/CapacitorAppleMapsPlugin.swift b/ios/Sources/NativeMapPlugin/CapacitorAppleMapsPlugin.swift index 616447a..b421a31 100644 --- a/ios/Sources/NativeMapPlugin/CapacitorAppleMapsPlugin.swift +++ b/ios/Sources/NativeMapPlugin/CapacitorAppleMapsPlugin.swift @@ -113,6 +113,7 @@ public class NativeMapPlugin: CAPPlugin, CAPBridgedPlugin, MKMapViewDelegate { override public func load() { WKWebView.registerTouchRouting(plugin: self) + TouchRoutingBridge.install(on: bridge?.webView) NotificationCenter.default.addObserver( self, selector: #selector(handleDidBecomeActive), diff --git a/ios/Sources/NativeMapPlugin/MapMounting.swift b/ios/Sources/NativeMapPlugin/MapMounting.swift index 40fbc6d..8800541 100644 --- a/ios/Sources/NativeMapPlugin/MapMounting.swift +++ b/ios/Sources/NativeMapPlugin/MapMounting.swift @@ -61,9 +61,9 @@ extension Map { if self.mapView.superview !== webView { self.mapView.removeFromSuperview() webView.addSubview(self.mapView) + webView.sendSubviewToBack(self.mapView) } self.mapView.frame = frame - webView.sendSubviewToBack(self.mapView) self.targetView = webView self.mapView.isHidden = !self.isMapVisible return diff --git a/ios/Sources/NativeMapPlugin/ToBackCompositor.swift b/ios/Sources/NativeMapPlugin/ToBackCompositor.swift index da43423..dad115f 100644 --- a/ios/Sources/NativeMapPlugin/ToBackCompositor.swift +++ b/ios/Sources/NativeMapPlugin/ToBackCompositor.swift @@ -10,14 +10,36 @@ enum ToBackCompositor { var descendantBackgrounds: [ObjectIdentifier: UIColor?] } - private static var toBackMapCount = 0 - private static var savedAppearance: SavedWebViewAppearance? + private struct WebViewCompositorState { + var toBackMapCount: Int = 0 + var savedAppearance: SavedWebViewAppearance? + } + + private static var states: [ObjectIdentifier: WebViewCompositorState] = [:] + + private static func state(for webView: WKWebView) -> WebViewCompositorState { + let key = ObjectIdentifier(webView) + if let existing = states[key] { + return existing + } + let fresh = WebViewCompositorState() + states[key] = fresh + return fresh + } + + private static func setState(_ state: WebViewCompositorState, for webView: WKWebView) { + states[ObjectIdentifier(webView)] = state + } static func acquireTransparentWebView(_ webView: WKWebView?) { guard let webView = webView else { return } DispatchQueue.main.async { - toBackMapCount += 1 - guard toBackMapCount == 1 else { return } + var state = state(for: webView) + state.toBackMapCount += 1 + guard state.toBackMapCount == 1 else { + setState(state, for: webView) + return + } var descendantBackgrounds: [ObjectIdentifier: UIColor?] = [:] func recordBackgrounds(_ view: UIView) { @@ -28,7 +50,7 @@ enum ToBackCompositor { } recordBackgrounds(webView) - savedAppearance = SavedWebViewAppearance( + state.savedAppearance = SavedWebViewAppearance( isOpaque: webView.isOpaque, backgroundColor: webView.backgroundColor, superviewBackgroundColor: webView.superview?.backgroundColor, @@ -47,15 +69,20 @@ enum ToBackCompositor { webView.superview?.backgroundColor = .clear webView.setNeedsLayout() webView.layoutIfNeeded() + setState(state, for: webView) } } static func releaseTransparentWebView(_ webView: WKWebView?) { guard let webView = webView else { return } DispatchQueue.main.async { - guard toBackMapCount > 0 else { return } - toBackMapCount -= 1 - guard toBackMapCount == 0, let saved = savedAppearance else { return } + var state = state(for: webView) + guard state.toBackMapCount > 0 else { return } + state.toBackMapCount -= 1 + guard state.toBackMapCount == 0, let saved = state.savedAppearance else { + setState(state, for: webView) + return + } webView.isOpaque = saved.isOpaque webView.backgroundColor = saved.backgroundColor @@ -72,9 +99,11 @@ enum ToBackCompositor { } restoreBackgrounds(webView) - savedAppearance = nil - webView.setNeedsLayout() - webView.layoutIfNeeded() + state.savedAppearance = nil + setState(state, for: webView) + if state.toBackMapCount == 0 { + states.removeValue(forKey: ObjectIdentifier(webView)) + } } } } diff --git a/ios/Sources/NativeMapPlugin/TouchRoutingCache.swift b/ios/Sources/NativeMapPlugin/TouchRoutingCache.swift new file mode 100644 index 0000000..44f36af --- /dev/null +++ b/ios/Sources/NativeMapPlugin/TouchRoutingCache.swift @@ -0,0 +1,90 @@ +import Foundation +import UIKit +import WebKit + +/// Synchronous toBack touch routing from rects pushed by the WebView (see `touch-routing.ts`). +enum TouchRoutingCache { + private static var webCaptureRects: [ObjectIdentifier: [CGRect]] = [:] + private static let lock = NSLock() + + static func updateRects(for webView: WKWebView, rects: [CGRect]) { + lock.lock() + webCaptureRects[ObjectIdentifier(webView)] = rects + lock.unlock() + } + + static func shouldRouteTouchToMap(at point: CGPoint, in webView: WKWebView) -> Bool { + lock.lock() + let rects = webCaptureRects[ObjectIdentifier(webView)] ?? [] + lock.unlock() + for rect in rects where rect.contains(point) { + return false + } + return true + } + + static func clearRects(for webView: WKWebView) { + lock.lock() + webCaptureRects.removeValue(forKey: ObjectIdentifier(webView)) + lock.unlock() + } +} + +final class TouchRoutingMessageHandler: NSObject, WKScriptMessageHandler { + static let handlerName = "nativeMapTouchRouting" + private weak var webView: WKWebView? + + init(webView: WKWebView) { + self.webView = webView + super.init() + } + + func userContentController(_ userContentController: WKUserContentController, didReceive message: WKScriptMessage) { + guard message.name == Self.handlerName, let webView = webView else { return } + guard let body = message.body as? [[String: Any]] else { return } + let rects = body.compactMap { item -> CGRect? in + guard let x = item["x"] as? Double, + let y = item["y"] as? Double, + let width = item["width"] as? Double, + let height = item["height"] as? Double else { return nil } + return CGRect(x: x, y: y, width: width, height: height) + } + TouchRoutingCache.updateRects(for: webView, rects: rects) + } +} + +enum TouchRoutingBridge { + private static var installedWebViews: [ObjectIdentifier: (proxy: TouchRoutingMessageProxy, handler: TouchRoutingMessageHandler)] = [:] + + static func install(on webView: WKWebView?) { + guard let webView = webView else { return } + let key = ObjectIdentifier(webView) + guard installedWebViews[key] == nil else { return } + + let handler = TouchRoutingMessageHandler(webView: webView) + let proxy = TouchRoutingMessageProxy(handler: handler) + webView.configuration.userContentController.add(proxy, name: TouchRoutingMessageHandler.handlerName) + installedWebViews[key] = (proxy, handler) + } + + static func uninstall(from webView: WKWebView?) { + guard let webView = webView else { return } + let key = ObjectIdentifier(webView) + guard let pair = installedWebViews.removeValue(forKey: key) else { return } + webView.configuration.userContentController.removeScriptMessageHandler(forName: TouchRoutingMessageHandler.handlerName) + TouchRoutingCache.clearRects(for: webView) + } +} + +private final class TouchRoutingMessageProxy: NSObject, WKScriptMessageHandler { + private let handler: TouchRoutingMessageHandler + + init(handler: TouchRoutingMessageHandler) { + self.handler = handler + super.init() + } + + func userContentController(_ userContentController: WKUserContentController, didReceive message: WKScriptMessage) { + handler.userContentController(userContentController, didReceive: message) + } +} diff --git a/ios/Sources/NativeMapPlugin/TouchRoutingJs.swift b/ios/Sources/NativeMapPlugin/TouchRoutingJs.swift index 585ac77..8c0f91c 100644 --- a/ios/Sources/NativeMapPlugin/TouchRoutingJs.swift +++ b/ios/Sources/NativeMapPlugin/TouchRoutingJs.swift @@ -2,38 +2,7 @@ import Foundation import WebKit extension NativeMapPlugin { - /// Mirrors `src/touch-routing.ts` for synchronous native hit testing. func shouldRouteTouchToMap(at point: CGPoint, in webView: WKWebView) -> Bool { - let x = point.x - let y = point.y - let js = """ - (function() { - const interactive = 'a,button,input,select,textarea,label,summary,details,[role="button"],[contenteditable="true"],[data-map-overlay]'; - const elem = document.elementFromPoint(\(x), \(y)); - if (!elem) { return true; } - if (elem.closest(interactive)) { return false; } - let current = elem; - while (current && current !== document.documentElement) { - const style = window.getComputedStyle(current); - const bg = style.backgroundColor; - if (bg && bg !== 'rgba(0, 0, 0, 0)' && bg !== 'transparent') { - const opacity = parseFloat(style.opacity || '1'); - if (opacity > 0.05) { return false; } - } - current = current.parentElement; - } - return true; - })(); - """ - var routeToMap = true - let semaphore = DispatchSemaphore(value: 0) - webView.evaluateJavaScript(js) { result, _ in - if let value = result as? Bool { - routeToMap = value - } - semaphore.signal() - } - semaphore.wait() - return routeToMap + TouchRoutingCache.shouldRouteTouchToMap(at: point, in: webView) } } diff --git a/src/map.ts b/src/map.ts index 28cfbda..63f8920 100644 --- a/src/map.ts +++ b/src/map.ts @@ -24,6 +24,7 @@ import type { import { LatLngBounds, MapType } from './definitions'; import type { CreateMapArgs } from './implementation'; import { CapacitorNativeMap } from './implementation'; +import { installIosTouchRoutingCachePublisher, uninstallIosTouchRoutingCachePublisher } from './touch-routing'; export interface NativeMapInterface { create(options: CreateMapArgs, callback?: MapListenerCallback): Promise; @@ -217,6 +218,9 @@ export class NativeMap { if (NativeMap.toBackMapCount === 1) { document.documentElement.classList.add('native-map-to-back'); document.body.classList.add('native-map-to-back'); + if (Capacitor.getPlatform() === 'ios') { + installIosTouchRoutingCachePublisher(); + } } } else { elementBounds = await NativeMap.getElementBounds(hostElement); @@ -357,6 +361,9 @@ export class NativeMap { if (NativeMap.toBackMapCount === 0) { document.documentElement.classList.remove('native-map-to-back'); document.body.classList.remove('native-map-to-back'); + if (Capacitor.getPlatform() === 'ios') { + uninstallIosTouchRoutingCachePublisher(); + } } } diff --git a/src/touch-routing.ts b/src/touch-routing.ts index 5ccf55c..0cd7cf3 100644 --- a/src/touch-routing.ts +++ b/src/touch-routing.ts @@ -1,6 +1,109 @@ const INTERACTIVE_SELECTOR = 'a,button,input,select,textarea,label,summary,details,[role="button"],[contenteditable="true"],[data-map-overlay]'; +const IOS_TOUCH_ROUTING_HANDLER = 'nativeMapTouchRouting'; + +export type WebCaptureRect = { x: number; y: number; width: number; height: number }; + +/** Regions where the WebView should keep the touch (not the native map). */ +export function collectWebCaptureRects(): WebCaptureRect[] { + const out: WebCaptureRect[] = []; + const seen = new WeakSet(); + + const addRect = (el: Element): void => { + if (seen.has(el)) { + return; + } + seen.add(el); + const r = el.getBoundingClientRect(); + if (r.width === 0 || r.height === 0) { + return; + } + out.push({ x: r.left, y: r.top, width: r.width, height: r.height }); + }; + + document.querySelectorAll(INTERACTIVE_SELECTOR).forEach((el) => addRect(el)); + + const nodes = document.body?.querySelectorAll('*') ?? []; + for (const el of nodes) { + if (!(el instanceof HTMLElement)) { + continue; + } + if (el.closest(INTERACTIVE_SELECTOR)) { + continue; + } + const style = window.getComputedStyle(el); + const bg = style.backgroundColor; + if (bg && bg !== 'rgba(0, 0, 0, 0)' && bg !== 'transparent') { + const opacity = parseFloat(style.opacity || '1'); + if (opacity > 0.05) { + addRect(el); + } + } + } + + return out; +} + +export function publishIosTouchRoutingCache(): void { + const handlers = ( + window as Window & { webkit?: { messageHandlers?: Record void }> } } + ).webkit?.messageHandlers; + const handler = handlers?.[IOS_TOUCH_ROUTING_HANDLER]; + if (!handler) { + return; + } + handler.postMessage(collectWebCaptureRects()); +} + +let iosTouchRoutingPublisherCount = 0; +let iosTouchRoutingRafId = 0; +let iosTouchRoutingMutationObserver: MutationObserver | undefined; +const iosTouchRoutingOnLayout = (): void => { + if (iosTouchRoutingRafId) { + cancelAnimationFrame(iosTouchRoutingRafId); + } + iosTouchRoutingRafId = requestAnimationFrame(() => { + iosTouchRoutingRafId = 0; + publishIosTouchRoutingCache(); + }); +}; + +export function installIosTouchRoutingCachePublisher(): void { + iosTouchRoutingPublisherCount += 1; + if (iosTouchRoutingPublisherCount !== 1) { + return; + } + window.addEventListener('resize', iosTouchRoutingOnLayout); + window.addEventListener('scroll', iosTouchRoutingOnLayout, true); + iosTouchRoutingMutationObserver = new MutationObserver(iosTouchRoutingOnLayout); + iosTouchRoutingMutationObserver.observe(document.documentElement, { + childList: true, + subtree: true, + attributes: true, + attributeFilter: ['class', 'style'], + }); + iosTouchRoutingOnLayout(); +} + +export function uninstallIosTouchRoutingCachePublisher(): void { + if (iosTouchRoutingPublisherCount <= 0) { + return; + } + iosTouchRoutingPublisherCount -= 1; + if (iosTouchRoutingPublisherCount !== 0) { + return; + } + window.removeEventListener('resize', iosTouchRoutingOnLayout); + window.removeEventListener('scroll', iosTouchRoutingOnLayout, true); + iosTouchRoutingMutationObserver?.disconnect(); + iosTouchRoutingMutationObserver = undefined; + if (iosTouchRoutingRafId) { + cancelAnimationFrame(iosTouchRoutingRafId); + iosTouchRoutingRafId = 0; + } +} + /** * Decide whether a native touch at (x, y) should be routed to the map or the WebView. */ diff --git a/src/web.ts b/src/web.ts index 3853589..faea0c4 100644 --- a/src/web.ts +++ b/src/web.ts @@ -157,7 +157,13 @@ export class CapacitorNativeMapWeb extends WebPlugin implements NativeMapPlugin host.style.top = '0'; host.style.width = '100%'; host.style.height = '100%'; - document.body.appendChild(host); + host.style.zIndex = '0'; + const firstChild = document.body.firstChild; + if (firstChild) { + document.body.insertBefore(host, firstChild); + } else { + document.body.appendChild(host); + } return host; } From 22974cee8bf56ed969373d62ea25e5a6ac307482 Mon Sep 17 00:00:00 2001 From: Cursor Agent Date: Sun, 4 Oct 2026 23:44:36 +0000 Subject: [PATCH 38/42] fix: address cubic r3 touch cache, compositor, and forceCreate leaks Co-authored-by: Martin DONADIEU --- .../CapacitorAppleMapsPlugin.swift | 5 ++ .../NativeMapPlugin/ToBackCompositor.swift | 2 + .../NativeMapPlugin/TouchRoutingCache.swift | 37 ++++++++-- src/map.ts | 35 ++++++++++ src/touch-routing.ts | 70 +++++++++++++++---- 5 files changed, 128 insertions(+), 21 deletions(-) diff --git a/ios/Sources/NativeMapPlugin/CapacitorAppleMapsPlugin.swift b/ios/Sources/NativeMapPlugin/CapacitorAppleMapsPlugin.swift index b421a31..4b47502 100644 --- a/ios/Sources/NativeMapPlugin/CapacitorAppleMapsPlugin.swift +++ b/ios/Sources/NativeMapPlugin/CapacitorAppleMapsPlugin.swift @@ -122,6 +122,11 @@ public class NativeMapPlugin: CAPPlugin, CAPBridgedPlugin, MKMapViewDelegate { ) } + deinit { + NotificationCenter.default.removeObserver(self) + TouchRoutingBridge.uninstall(from: bridge?.webView) + } + /// After the app returns to the foreground WebKit can rebuild its scroll-view /// hierarchy, orphaning the native map's touch handling (it still renders but /// gestures stop working). Re-mount each map into its current container. diff --git a/ios/Sources/NativeMapPlugin/ToBackCompositor.swift b/ios/Sources/NativeMapPlugin/ToBackCompositor.swift index dad115f..fbd2080 100644 --- a/ios/Sources/NativeMapPlugin/ToBackCompositor.swift +++ b/ios/Sources/NativeMapPlugin/ToBackCompositor.swift @@ -104,6 +104,8 @@ enum ToBackCompositor { if state.toBackMapCount == 0 { states.removeValue(forKey: ObjectIdentifier(webView)) } + webView.setNeedsLayout() + webView.layoutIfNeeded() } } } diff --git a/ios/Sources/NativeMapPlugin/TouchRoutingCache.swift b/ios/Sources/NativeMapPlugin/TouchRoutingCache.swift index 44f36af..de2be40 100644 --- a/ios/Sources/NativeMapPlugin/TouchRoutingCache.swift +++ b/ios/Sources/NativeMapPlugin/TouchRoutingCache.swift @@ -23,11 +23,15 @@ enum TouchRoutingCache { return true } - static func clearRects(for webView: WKWebView) { + static func clearRects(forWebViewKey key: ObjectIdentifier) { lock.lock() - webCaptureRects.removeValue(forKey: ObjectIdentifier(webView)) + webCaptureRects.removeValue(forKey: key) lock.unlock() } + + static func clearRects(for webView: WKWebView) { + clearRects(forWebViewKey: ObjectIdentifier(webView)) + } } final class TouchRoutingMessageHandler: NSObject, WKScriptMessageHandler { @@ -40,7 +44,9 @@ final class TouchRoutingMessageHandler: NSObject, WKScriptMessageHandler { } func userContentController(_ userContentController: WKUserContentController, didReceive message: WKScriptMessage) { - guard message.name == Self.handlerName, let webView = webView else { return } + guard message.name == Self.handlerName, + let webView = webView, + message.webView === webView else { return } guard let body = message.body as? [[String: Any]] else { return } let rects = body.compactMap { item -> CGRect? in guard let x = item["x"] as? Double, @@ -54,23 +60,40 @@ final class TouchRoutingMessageHandler: NSObject, WKScriptMessageHandler { } enum TouchRoutingBridge { - private static var installedWebViews: [ObjectIdentifier: (proxy: TouchRoutingMessageProxy, handler: TouchRoutingMessageHandler)] = [:] + private struct Installation { + weak var webView: WKWebView? + let proxy: TouchRoutingMessageProxy + let handler: TouchRoutingMessageHandler + } + + private static var installedWebViews: [ObjectIdentifier: Installation] = [:] + + private static func purgeStaleInstallations() { + for (key, install) in installedWebViews where install.webView == nil { + installedWebViews.removeValue(forKey: key) + TouchRoutingCache.clearRects(forWebViewKey: key) + } + } static func install(on webView: WKWebView?) { + purgeStaleInstallations() guard let webView = webView else { return } let key = ObjectIdentifier(webView) - guard installedWebViews[key] == nil else { return } + if let existing = installedWebViews[key], existing.webView === webView { + return + } let handler = TouchRoutingMessageHandler(webView: webView) let proxy = TouchRoutingMessageProxy(handler: handler) webView.configuration.userContentController.add(proxy, name: TouchRoutingMessageHandler.handlerName) - installedWebViews[key] = (proxy, handler) + installedWebViews[key] = Installation(webView: webView, proxy: proxy, handler: handler) } static func uninstall(from webView: WKWebView?) { + purgeStaleInstallations() guard let webView = webView else { return } let key = ObjectIdentifier(webView) - guard let pair = installedWebViews.removeValue(forKey: key) else { return } + guard installedWebViews.removeValue(forKey: key) != nil else { return } webView.configuration.userContentController.removeScriptMessageHandler(forName: TouchRoutingMessageHandler.handlerName) TouchRoutingCache.clearRects(for: webView) } diff --git a/src/map.ts b/src/map.ts index 63f8920..422f4fe 100644 --- a/src/map.ts +++ b/src/map.ts @@ -123,6 +123,7 @@ customElements.define('capacitor-native-map', MapCustomElement); export class NativeMap { private static toBackMapCount = 0; + private static activeMapsById = new Map(); private id: string; private element: HTMLElement | null = null; @@ -172,6 +173,13 @@ export class NativeMap { options: CreateMapArgs, callback?: MapListenerCallback, ): Promise { + if (options.forceCreate) { + const replaced = NativeMap.activeMapsById.get(options.id); + if (replaced) { + replaced.abandonAfterNativeForceReplace(); + } + } + const newMap = new NativeMap(options.id); const toBack = options.toBack === true; @@ -343,9 +351,34 @@ export class NativeMap { throw err; } + NativeMap.activeMapsById.set(options.id, newMap); return newMap; } + /** + * Native `forceCreate` already destroyed the map instance; release JS-side toBack ownership only. + */ + private abandonAfterNativeForceReplace(): void { + NativeMap.activeMapsById.delete(this.id); + + if (Capacitor.isNativePlatform()) { + this.resizeObserver?.disconnect(); + if (this.windowResizeHandler) { + window.removeEventListener('resize', this.windowResizeHandler); + this.windowResizeHandler = undefined; + } + this.disableScrolling(); + } + + if (this.toBack) { + NativeMap.releaseToBackDocumentClasses(); + this.toBackLayout = undefined; + this.toBack = false; + } + + this.removeAllMapListeners(); + } + private mapBoundsForNative(): { x: number; y: number; width: number; height: number } { if (this.toBack && this.toBackLayout) { return this.toBackLayout; @@ -619,6 +652,8 @@ export class NativeMap { this.removeAllMapListeners(); + NativeMap.activeMapsById.delete(this.id); + return CapacitorNativeMap.destroy({ id: this.id, }); diff --git a/src/touch-routing.ts b/src/touch-routing.ts index 0cd7cf3..3d423d3 100644 --- a/src/touch-routing.ts +++ b/src/touch-routing.ts @@ -3,15 +3,65 @@ const INTERACTIVE_SELECTOR = const IOS_TOUCH_ROUTING_HANDLER = 'nativeMapTouchRouting'; +const MUTATION_ATTRIBUTE_FILTER = ['class', 'style', 'role', 'contenteditable', 'data-map-overlay']; + export type WebCaptureRect = { x: number; y: number; width: number; height: number }; +function parseBackgroundAlpha(color: string): number { + if (color === 'transparent') { + return 0; + } + const rgbaMatch = color.match(/rgba?\(\s*([^)]+)\)/i); + if (rgbaMatch) { + const parts = rgbaMatch[1].split(',').map((part) => part.trim()); + if (parts.length >= 4) { + return parseFloat(parts[3]); + } + return 1; + } + return 1; +} + +function backgroundBlocksTouches(style: CSSStyleDeclaration): boolean { + const bg = style.backgroundColor; + if (!bg || bg === 'transparent') { + return false; + } + if (parseBackgroundAlpha(bg) <= 0.05) { + return false; + } + const opacity = parseFloat(style.opacity || '1'); + return opacity > 0.05; +} + +function isCaptureEligible(el: Element): boolean { + if (!(el instanceof HTMLElement)) { + return false; + } + let current: HTMLElement | null = el; + while (current && current !== document.documentElement) { + const style = window.getComputedStyle(current); + if (style.display === 'none' || style.visibility === 'hidden') { + return false; + } + if (parseFloat(style.opacity || '1') <= 0.05) { + return false; + } + if (style.pointerEvents === 'none') { + return false; + } + current = current.parentElement; + } + return true; +} + /** Regions where the WebView should keep the touch (not the native map). */ export function collectWebCaptureRects(): WebCaptureRect[] { const out: WebCaptureRect[] = []; const seen = new WeakSet(); const addRect = (el: Element): void => { - if (seen.has(el)) { + if (seen.has(el) || !isCaptureEligible(el)) { return; } seen.add(el); @@ -33,12 +83,8 @@ export function collectWebCaptureRects(): WebCaptureRect[] { continue; } const style = window.getComputedStyle(el); - const bg = style.backgroundColor; - if (bg && bg !== 'rgba(0, 0, 0, 0)' && bg !== 'transparent') { - const opacity = parseFloat(style.opacity || '1'); - if (opacity > 0.05) { - addRect(el); - } + if (backgroundBlocksTouches(style)) { + addRect(el); } } @@ -81,7 +127,7 @@ export function installIosTouchRoutingCachePublisher(): void { childList: true, subtree: true, attributes: true, - attributeFilter: ['class', 'style'], + attributeFilter: MUTATION_ATTRIBUTE_FILTER, }); iosTouchRoutingOnLayout(); } @@ -126,12 +172,8 @@ export function shouldRouteTouchToMap(x: number, y: number, mapId: string, toBac let current: HTMLElement | null = elem; while (current && current !== document.documentElement) { const style = window.getComputedStyle(current); - const bg = style.backgroundColor; - if (bg && bg !== 'rgba(0, 0, 0, 0)' && bg !== 'transparent') { - const opacity = parseFloat(style.opacity || '1'); - if (opacity > 0.05) { - return false; - } + if (backgroundBlocksTouches(style)) { + return false; } current = current.parentElement; } From f778108862d94184bfa42adc4ded036827a5acde Mon Sep 17 00:00:00 2001 From: Cursor Agent Date: Sun, 4 Oct 2026 23:55:14 +0000 Subject: [PATCH 39/42] fix: safe forceCreate and active map registry lifecycle Co-authored-by: Martin DONADIEU --- src/map.ts | 24 ++++++++++++++++++++---- 1 file changed, 20 insertions(+), 4 deletions(-) diff --git a/src/map.ts b/src/map.ts index 422f4fe..9c5aafc 100644 --- a/src/map.ts +++ b/src/map.ts @@ -173,11 +173,17 @@ export class NativeMap { options: CreateMapArgs, callback?: MapListenerCallback, ): Promise { - if (options.forceCreate) { - const replaced = NativeMap.activeMapsById.get(options.id); - if (replaced) { - replaced.abandonAfterNativeForceReplace(); + const existingMap = NativeMap.activeMapsById.get(options.id); + if (existingMap && !options.forceCreate) { + if (callback) { + const onMapReadyListener = await CapacitorNativeMap.addListener('onMapReady', (data: MapReadyCallbackData) => { + if (data.mapId === options.id) { + callback(data); + onMapReadyListener.remove(); + } + }); } + return existingMap; } const newMap = new NativeMap(options.id); @@ -339,6 +345,12 @@ export class NativeMap { await new Promise((resolve, reject) => { setTimeout(async () => { try { + if (options.forceCreate) { + const replaced = NativeMap.activeMapsById.get(options.id); + if (replaced && replaced !== newMap) { + replaced.abandonAfterNativeForceReplace(); + } + } await CapacitorNativeMap.create(createOptions); resolve(undefined); } catch (err) { @@ -633,6 +645,10 @@ export class NativeMap { * Destroy the current instance of the map */ async destroy(): Promise { + if (NativeMap.activeMapsById.get(this.id) !== this) { + return; + } + if (Capacitor.getPlatform() == 'android') { this.disableScrolling(); } From 243074cc2f7080911bfd55eda2e06d039fd1c627 Mon Sep 17 00:00:00 2001 From: Cursor Agent Date: Mon, 5 Oct 2026 00:07:16 +0000 Subject: [PATCH 40/42] fix: deliver map ready callbacks for duplicate create() Co-authored-by: Martin DONADIEU --- bun.lock | 34 +++++++++ bunfig.toml | 2 + package.json | 5 +- src/map-ready.test.ts | 162 ++++++++++++++++++++++++++++++++++++++++++ src/map-ready.ts | 35 +++++++++ src/map.ts | 47 ++++++++---- src/test-setup.ts | 3 + 7 files changed, 273 insertions(+), 15 deletions(-) create mode 100644 bunfig.toml create mode 100644 src/map-ready.test.ts create mode 100644 src/map-ready.ts create mode 100644 src/test-setup.ts diff --git a/bun.lock b/bun.lock index f599a3b..1d29921 100644 --- a/bun.lock +++ b/bun.lock @@ -15,6 +15,7 @@ "@capacitor/core": "^8.0.0", "@capacitor/docgen": "^0.3.1", "@capacitor/ios": "^8.0.0", + "@happy-dom/global-registrator": "^20.14.5", "@ionic/eslint-config": "^0.4.0", "@ionic/prettier-config": "^4.0.0", "@ionic/swiftlint-config": "^2.0.0", @@ -23,6 +24,7 @@ "@types/resize-observer-browser": "^0.1.11", "eslint": "^8.57.1", "eslint-plugin-import": "^2.31.0", + "happy-dom": "^20.14.5", "prettier": "^3.6.2", "prettier-plugin-java": "^2.7.7", "prettier-pretty-check": "^0.2.0", @@ -63,6 +65,8 @@ "@googlemaps/markerclusterer": ["@googlemaps/markerclusterer@2.6.2", "", { "dependencies": { "@types/supercluster": "^7.1.3", "fast-equals": "^5.2.2", "supercluster": "^8.0.1" } }, "sha512-U6uVhq8iWhiIckA89sgRu8OK35mjd6/3CuoZKWakKEf0QmRRWpatlsPb3kqXkoWSmbcZkopRiI4dnW6DQSd7bQ=="], + "@happy-dom/global-registrator": ["@happy-dom/global-registrator@20.14.5", "", { "dependencies": { "@types/node": ">=20.0.0", "happy-dom": "^20.14.5" } }, "sha512-B05ID9DhSwLs6mlm1fzlkAtTIvB3duCvjJjfr19LBrlTK7VZtRjDqoTRIVv13GuYuNdhByu8LSZgThwV3Rkj7g=="], + "@humanwhocodes/config-array": ["@humanwhocodes/config-array@0.13.0", "", { "dependencies": { "@humanwhocodes/object-schema": "^2.0.3", "debug": "^4.3.1", "minimatch": "^3.0.5" } }, "sha512-DZLEEqFWQFiyK6h5YIeynKx7JlvCYWL0cImfSRXZ9l4Sg2efkFGTuFf6vzXjK1cq6IYkU+Eg/JizXw+TD2vRNw=="], "@humanwhocodes/module-importer": ["@humanwhocodes/module-importer@1.0.1", "", {}, "sha512-bxveV4V8v5Yb4ncFTT3rPSgZBOpCkjfK0y4oVVVJwIuDVBRMDXrPyXRL988i5ap9m9bnyEEjWfm5WkBmtffLfA=="], @@ -181,6 +185,10 @@ "@types/supercluster": ["@types/supercluster@7.1.3", "", { "dependencies": { "@types/geojson": "*" } }, "sha512-Z0pOY34GDFl3Q6hUFYf3HkTwKEE02e7QgtJppBt+beEAxnyOpJua+voGFvxINBHa06GwLFFym7gRPY2SiKIfIA=="], + "@types/whatwg-mimetype": ["@types/whatwg-mimetype@3.0.2", "", {}, "sha512-c2AKvDT8ToxLIOUlN51gTiHXflsfIFisS4pO7pDPoKouJCESkhZnEy623gwP9laCy5lnLDAw1vAzu2vM2YLOrA=="], + + "@types/ws": ["@types/ws@8.18.2", "", { "dependencies": { "@types/node": "*" } }, "sha512-67MQl+fpWKVTT1NYdnmo3U4sc/xPo/zQBncVnI74qmQa0z/b+1g6iYqNmGCPbxO+zz2aklb08a0oHfegiVd0/w=="], + "@typescript-eslint/eslint-plugin": ["@typescript-eslint/eslint-plugin@5.62.0", "", { "dependencies": { "@eslint-community/regexpp": "^4.4.0", "@typescript-eslint/scope-manager": "5.62.0", "@typescript-eslint/type-utils": "5.62.0", "@typescript-eslint/utils": "5.62.0", "debug": "^4.3.4", "graphemer": "^1.4.0", "ignore": "^5.2.0", "natural-compare-lite": "^1.4.0", "semver": "^7.3.7", "tsutils": "^3.21.0" }, "peerDependencies": { "@typescript-eslint/parser": "^5.0.0", "eslint": "^6.0.0 || ^7.0.0 || ^8.0.0", "typescript": "*" }, "optionalPeers": ["typescript"] }, "sha512-TiZzBSJja/LbhNPvk6yc0JrX9XqhQ0hdh6M2svYfsHGejaKFIAGd9MQ+ERIMzLGlN/kZoYIgdxFV0PuljTKXag=="], "@typescript-eslint/parser": ["@typescript-eslint/parser@5.62.0", "", { "dependencies": { "@typescript-eslint/scope-manager": "5.62.0", "@typescript-eslint/types": "5.62.0", "@typescript-eslint/typescript-estree": "5.62.0", "debug": "^4.3.4" }, "peerDependencies": { "eslint": "^6.0.0 || ^7.0.0 || ^8.0.0", "typescript": "*" }, "optionalPeers": ["typescript"] }, "sha512-VlJEV0fOQ7BExOsHYAGrgbEiZoi8D+Bl2+f6V2RrXerRSylnp+ZBHmPvaIa8cz0Ajx7WO7Z5RqfgYg7ED1nRhA=="], @@ -251,6 +259,8 @@ "buffer-crc32": ["buffer-crc32@0.2.13", "", {}, "sha512-VO9Ht/+p3SN7SKWqcrgEzjGbRSJYTx+Q1pTQC0wrWqHx0vpJraQ6GtHx8tvcg1rlK1byhU5gccxgOgj7B0TDkQ=="], + "buffer-image-size": ["buffer-image-size@0.6.4", "", { "dependencies": { "@types/node": "*" } }, "sha512-nEh+kZOPY1w+gcCMobZ6ETUp9WfibndnosbpwB1iJk/8Gt5ZF2bhS6+B6bPYz424KtwsR6Rflc3tCz1/ghX2dQ=="], + "call-bind": ["call-bind@1.0.9", "", { "dependencies": { "call-bind-apply-helpers": "^1.0.2", "es-define-property": "^1.0.1", "get-intrinsic": "^1.3.0", "set-function-length": "^1.2.2" } }, "sha512-a/hy+pNsFUTR+Iz8TCJvXudKVLAnz/DyeSUo10I5yvFDQJBFU2s9uqQpoSrJlroHUKoKqzg+epxyP9lqFdzfBQ=="], "call-bind-apply-helpers": ["call-bind-apply-helpers@1.0.2", "", { "dependencies": { "es-errors": "^1.3.0", "function-bind": "^1.1.2" } }, "sha512-Sp1ablJ0ivDkSzjcaJdxEunN5/XvksFJ2sMBFfq6x0ryhQV/2b/KwFe21cMpmHtPOSij8K99/wSfoEuTObmuMQ=="], @@ -307,6 +317,8 @@ "emoji-regex": ["emoji-regex@8.0.0", "", {}, "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A=="], + "entities": ["entities@7.0.1", "", {}, "sha512-TWrgLOFUQTH994YUyl1yT4uyavY5nNB5muff+RtWaqNVCAK408b5ZnnbNAUEWLTCpum9w6arT70i1XdQ4UeOPA=="], + "env-paths": ["env-paths@2.2.1", "", {}, "sha512-+h1lkLKhZMTYjog1VEpJNG7NZJWcuc2DDk/qsqSTRRCOXiLjeQ1d1/udrUGhqMxUgAlwKNZ0cf2uqan5GLuS2A=="], "error-ex": ["error-ex@1.3.4", "", { "dependencies": { "is-arrayish": "^0.2.1" } }, "sha512-sqQamAnR14VgCr1A618A3sGrygcpK+HEbenA/HiEAkkUwcZIIB/tgWqHFxWgOyDh4nB4JCRimh79dR5Ywc9MDQ=="], @@ -419,6 +431,8 @@ "graphemer": ["graphemer@1.4.0", "", {}, "sha512-EtKwoO6kxCL9WO5xipiHTZlSzBm7WLT627TqC/uVRd0HKmq8NXyebnNYxDoBi7wt8eTWrUrKXCOVaFq9x1kgag=="], + "happy-dom": ["happy-dom@20.14.5", "", { "dependencies": { "@types/node": ">=20.0.0", "@types/whatwg-mimetype": "^3.0.2", "@types/ws": "^8.18.1", "buffer-image-size": "^0.6.4", "entities": "^7.0.1", "whatwg-mimetype": "^3.0.0", "ws": "^8.21.0" } }, "sha512-x/RzkpWO40bTjIoT30iQtt64FLLmH/iRcUCN2X//bLx7H3ifkdfPXyqsro/OYtqzIAhiLMMA7mmiOR9C3NOKjQ=="], + "has-bigints": ["has-bigints@1.1.0", "", {}, "sha512-R3pbpkcIqv2Pm3dUwgjclDRVmWpTJW2DcMzcIhEXEx1oh/CEMObMm3KLmRJOdvhM7o4uQBnwr8pzRK2sJWIqfg=="], "has-flag": ["has-flag@4.0.0", "", {}, "sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ=="], @@ -773,6 +787,8 @@ "web-tree-sitter": ["web-tree-sitter@0.27.0", "", {}, "sha512-XK08gj6RwTMQatAG7uVRP8MunqotL/XC19vHgkSPKmELgbGPBj4ECvB8haHOUnyj6ls2B8t42UTro14zxGgAHg=="], + "whatwg-mimetype": ["whatwg-mimetype@3.0.0", "", {}, "sha512-nt+N2dzIutVRxARx1nghPKGv1xHikU7HKdfafKkLNLindmPU/ch3U31NOCGGA/dmPcmb1VlofO0vnKAcsm0o/Q=="], + "which": ["which@2.0.2", "", { "dependencies": { "isexe": "^2.0.0" }, "bin": { "node-which": "./bin/node-which" } }, "sha512-BLI3Tl1TW3Pvl70l3yq3Y64i+awpwXqsGBYWkkqMtnbXgrMD+yj7rhW0kuEDxzJaYXGjEW5ogapKNMEKNMjibA=="], "which-boxed-primitive": ["which-boxed-primitive@1.1.1", "", { "dependencies": { "is-bigint": "^1.1.0", "is-boolean-object": "^1.2.1", "is-number-object": "^1.1.1", "is-string": "^1.1.1", "is-symbol": "^1.1.1" } }, "sha512-TbX3mj8n0odCBFVlY8AxkqcHASw3L60jIuF8jFP78az3C2YhmGvqbHBpAjTRH2/xqYunrJ9g1jSyjCjpoWzIAA=="], @@ -789,6 +805,8 @@ "wrappy": ["wrappy@1.0.2", "", {}, "sha512-l4Sp/DRseor9wL6EvV2+TuQn63dMkPjZ/sp9XkghTEbV9KlPS1xUsZ3u7/IQO4wxtcFB4bgpQPRcR3QCvezPcQ=="], + "ws": ["ws@8.22.0", "", { "peerDependencies": { "bufferutil": "^4.0.1", "utf-8-validate": ">=5.0.2" }, "optionalPeers": ["bufferutil", "utf-8-validate"] }, "sha512-Ydggc987+RO0AnWtZ/7Wq9FtNvcrL1b/RO0ud9mWjUPgDrsAAwQSF51sm2hm1XofbU/4jkpGEsLFsZZxU+1DOg=="], + "xcode": ["xcode@3.0.1", "", { "dependencies": { "simple-plist": "^1.1.0", "uuid": "^7.0.3" } }, "sha512-kCz5k7J7XbJtjABOvkc5lJmkiDh8VhjVCGNiqdKCscmVpdVUpEAyXv1xmCLkQJ5dsHqx3IPO4XW+NTDhU/fatA=="], "xml2js": ["xml2js@0.6.2", "", { "dependencies": { "sax": ">=0.6.0", "xmlbuilder": "~11.0.0" } }, "sha512-T4rieHaC1EXcES0Kxxj4JWgaUQHDk+qwHcYOCFHfiwKz7tOVPLq7Hjq9dM1WCMhylqMEfP7hMcOIChvotiZegA=="], @@ -803,12 +821,18 @@ "@capacitor/docgen/typescript": ["typescript@4.2.4", "", { "bin": { "tsc": "bin/tsc", "tsserver": "bin/tsserver" } }, "sha512-V+evlYHZnQkaz8TRBuxTA92yZBPotr5H+WhQ7bD3hZUndx5tGOa1fuCgeSjxAzM1RiN5IzvadIXTVefuuwZCRg=="], + "@happy-dom/global-registrator/@types/node": ["@types/node@26.6.3", "", { "dependencies": { "undici-types": "~8.9.0" } }, "sha512-dsqMQQoeTLqu9wynDD00q573mNzso3IdQOAfHRJqLCcmCFPoGo9A1bDpUcv/9tnKpErQWv9uKeGfl37EIS02Yg=="], + "@ionic/utils-fs/fs-extra": ["fs-extra@9.1.0", "", { "dependencies": { "at-least-node": "^1.0.0", "graceful-fs": "^4.2.0", "jsonfile": "^6.0.1", "universalify": "^2.0.0" } }, "sha512-hcg3ZmepS30/7BSFqRvoo3DOMQu7IjqxO5nCDt+zM9XWjb33Wg7ziNT+Qvqbuc3+gWpzO02JubVyk2G4Zvo1OQ=="], "@types/fs-extra/@types/node": ["@types/node@26.6.3", "", { "dependencies": { "undici-types": "~8.9.0" } }, "sha512-dsqMQQoeTLqu9wynDD00q573mNzso3IdQOAfHRJqLCcmCFPoGo9A1bDpUcv/9tnKpErQWv9uKeGfl37EIS02Yg=="], + "@types/ws/@types/node": ["@types/node@26.6.3", "", { "dependencies": { "undici-types": "~8.9.0" } }, "sha512-dsqMQQoeTLqu9wynDD00q573mNzso3IdQOAfHRJqLCcmCFPoGo9A1bDpUcv/9tnKpErQWv9uKeGfl37EIS02Yg=="], + "@typescript-eslint/utils/eslint-scope": ["eslint-scope@5.1.1", "", { "dependencies": { "esrecurse": "^4.3.0", "estraverse": "^4.1.1" } }, "sha512-2NxwbF/hZ0KpepYN0cNbo+FN6XoK7GaHlQhgx/hIZl6Va0bF45RQOOwhLIy8lQDbuCiadSLCBnH2CFYquit5bw=="], + "buffer-image-size/@types/node": ["@types/node@26.6.3", "", { "dependencies": { "undici-types": "~8.9.0" } }, "sha512-dsqMQQoeTLqu9wynDD00q573mNzso3IdQOAfHRJqLCcmCFPoGo9A1bDpUcv/9tnKpErQWv9uKeGfl37EIS02Yg=="], + "elementtree/sax": ["sax@1.1.4", "", {}, "sha512-5f3k2PbGGp+YtKJjOItpg3P99IMD84E4HOvcfleTb5joCHNXYLsR9yWFPOYGgaeMPDubQILTCMdsFb2OMeOjtg=="], "eslint-import-resolver-node/debug": ["debug@3.2.7", "", { "dependencies": { "ms": "^2.1.1" } }, "sha512-CFjzYYAi4ThfiQvizrFQevTTXHtnCqWfe7x1AhgEscTz6ZbLbfoLRLPugTQyBth6f8ZERVUSyWHFD/7Wu4t1XQ=="], @@ -829,6 +853,8 @@ "glob/minimatch": ["minimatch@10.2.6", "", { "dependencies": { "brace-expansion": "^5.0.8" } }, "sha512-vpLQEs+VLCr1nU0BXS07maYoFwlDAH0gngQuuttxIwutDFEMHq2blX+8vpgxDdK3J1PwjCJiep77OitTZ4Ll1A=="], + "happy-dom/@types/node": ["@types/node@26.6.3", "", { "dependencies": { "undici-types": "~8.9.0" } }, "sha512-dsqMQQoeTLqu9wynDD00q573mNzso3IdQOAfHRJqLCcmCFPoGo9A1bDpUcv/9tnKpErQWv9uKeGfl37EIS02Yg=="], + "micromatch/picomatch": ["picomatch@2.3.2", "", {}, "sha512-V7+vQEJ06Z+c5tSye8S+nHUfI51xoXIXjHQ99cQtKUkQqqO1kO/KCJUfZXuB47h/YBlDhah2H3hdUGXn8ie0oA=="], "node-exports-info/semver": ["semver@6.3.1", "", { "bin": { "semver": "bin/semver.js" } }, "sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA=="], @@ -841,14 +867,22 @@ "xml2js/xmlbuilder": ["xmlbuilder@11.0.1", "", {}, "sha512-fDlsI/kFEx7gLvbecc0/ohLG50fugQp8ryHzMTuW9vSa1GJ0XYWKnhsUx7oie3G98+r56aTQIUB4kht42R3JvA=="], + "@happy-dom/global-registrator/@types/node/undici-types": ["undici-types@8.9.0", "", {}, "sha512-KTDyRTYX8sWmKXAikPHHSyc63CRPETMctyjKFupcC6OBLXT3xsN0e9aF7m+mIXutFWpUXuedtowG7iLOzp0kQg=="], + "@types/fs-extra/@types/node/undici-types": ["undici-types@8.9.0", "", {}, "sha512-KTDyRTYX8sWmKXAikPHHSyc63CRPETMctyjKFupcC6OBLXT3xsN0e9aF7m+mIXutFWpUXuedtowG7iLOzp0kQg=="], + "@types/ws/@types/node/undici-types": ["undici-types@8.9.0", "", {}, "sha512-KTDyRTYX8sWmKXAikPHHSyc63CRPETMctyjKFupcC6OBLXT3xsN0e9aF7m+mIXutFWpUXuedtowG7iLOzp0kQg=="], + "@typescript-eslint/utils/eslint-scope/estraverse": ["estraverse@4.3.0", "", {}, "sha512-39nnKffWz8xN1BU/2c79n9nB9HDzo0niYUqx6xyqUnyoAnQyyWpOTdZEeiCch8BBu515t4wp9ZmgVfVhn9EBpw=="], + "buffer-image-size/@types/node/undici-types": ["undici-types@8.9.0", "", {}, "sha512-KTDyRTYX8sWmKXAikPHHSyc63CRPETMctyjKFupcC6OBLXT3xsN0e9aF7m+mIXutFWpUXuedtowG7iLOzp0kQg=="], + "flat-cache/rimraf/glob": ["glob@7.2.3", "", { "dependencies": { "fs.realpath": "^1.0.0", "inflight": "^1.0.4", "inherits": "2", "minimatch": "^3.1.1", "once": "^1.3.0", "path-is-absolute": "^1.0.0" } }, "sha512-nFR0zLpU2YCaRxwoCJvL6UvCH2JFyFVIvwTLsIf21AuHlMskA1hhTdk+LlYJtOlYt9v6dvszD2BGRqBL+iQK9Q=="], "glob/minimatch/brace-expansion": ["brace-expansion@5.0.12", "", { "dependencies": { "balanced-match": "^4.0.2" } }, "sha512-YovQ3rzhaLMIrDjNDMkNS01tea93qhEhG5xy8f6+R0l+dw3Ki+5sCoIoI942iuLZTHWogWktgwVDhU09iNEimQ=="], + "happy-dom/@types/node/undici-types": ["undici-types@8.9.0", "", {}, "sha512-KTDyRTYX8sWmKXAikPHHSyc63CRPETMctyjKFupcC6OBLXT3xsN0e9aF7m+mIXutFWpUXuedtowG7iLOzp0kQg=="], + "glob/minimatch/brace-expansion/balanced-match": ["balanced-match@4.0.4", "", {}, "sha512-BLrgEcRTwX2o6gGxGOCNyMvGSp35YofuYzw9h1IMTRmKqttAZZVU67bdb9Pr2vUHA8+j3i2tJfjO6C6+4myGTA=="], } } diff --git a/bunfig.toml b/bunfig.toml new file mode 100644 index 0000000..2216136 --- /dev/null +++ b/bunfig.toml @@ -0,0 +1,2 @@ +[test] +preload = ["./src/test-setup.ts"] diff --git a/package.json b/package.json index 05b42a9..98ee402 100644 --- a/package.json +++ b/package.json @@ -43,7 +43,8 @@ "verify": "bun run verify:ios && bun run verify:android && bun run verify:web", "verify:ios": "xcodebuild -scheme CapgoCapacitorNativeMap -destination generic/platform=iOS", "verify:android": "cd android && ./gradlew clean build test && cd ..", - "verify:web": "bun run build", + "test": "bun test", + "verify:web": "bun run build && bun test", "lint": "bun run eslint && bun run prettier -- --check && bun run swiftlint -- lint", "fmt": "bun run eslint -- --fix && bun run prettier -- --write && bun run swiftlint -- --fix --format", "eslint": "eslint . --ext .ts", @@ -71,6 +72,7 @@ "@capacitor/core": "^8.0.0", "@capacitor/docgen": "^0.3.1", "@capacitor/ios": "^8.0.0", + "@happy-dom/global-registrator": "^20.14.5", "@ionic/eslint-config": "^0.4.0", "@ionic/prettier-config": "^4.0.0", "@ionic/swiftlint-config": "^2.0.0", @@ -79,6 +81,7 @@ "@types/resize-observer-browser": "^0.1.11", "eslint": "^8.57.1", "eslint-plugin-import": "^2.31.0", + "happy-dom": "^20.14.5", "prettier": "^3.6.2", "prettier-plugin-java": "^2.7.7", "prettier-pretty-check": "^0.2.0", diff --git a/src/map-ready.test.ts b/src/map-ready.test.ts new file mode 100644 index 0000000..d03e6e7 --- /dev/null +++ b/src/map-ready.test.ts @@ -0,0 +1,162 @@ +import { afterEach, beforeEach, describe, expect, mock, test } from 'bun:test'; + +import type { MapReadyCallbackData } from './definitions'; +import { MapReadyQueue } from './map-ready'; + +type MapReadyListener = (data: MapReadyCallbackData) => void; + +const onMapReadyListeners: MapReadyListener[] = []; +const createImpl = mock(async (): Promise => undefined); + +mock.module('@capacitor/core', () => ({ + Capacitor: { + getPlatform: () => 'web', + isNativePlatform: () => false, + }, +})); + +mock.module('./implementation', () => ({ + CapacitorNativeMap: { + create: createImpl, + addListener: mock(async (event: string, cb: MapReadyListener) => { + if (event === 'onMapReady') { + onMapReadyListeners.push(cb); + } + return { remove: mock((): void => undefined) }; + }), + destroy: mock(async (): Promise => undefined), + }, +})); + +const { NativeMap } = await import('./map'); + +function emitMapReady(mapId: string): void { + const data: MapReadyCallbackData = { mapId }; + for (const listener of onMapReadyListeners) { + listener(data); + } +} + +function makeHostElement(): HTMLElement { + const element = document.createElement('div'); + element.getBoundingClientRect = () => + ({ + x: 0, + y: 0, + width: 320, + height: 240, + top: 0, + left: 0, + right: 320, + bottom: 240, + toJSON: () => ({}), + }) as DOMRect; + document.body.appendChild(element); + return element; +} + +async function waitForNativeCreate(): Promise { + await new Promise((resolve) => setTimeout(resolve, 250)); +} + +async function flushMicrotasks(): Promise { + await new Promise((resolve) => queueMicrotask(resolve)); +} + +describe('MapReadyQueue', () => { + test('fires queued callback once on deliver', () => { + const queue = new MapReadyQueue(); + let calls = 0; + queue.whenReady(() => { + calls += 1; + }); + expect(calls).toBe(0); + queue.deliver({ mapId: 'a' }); + expect(calls).toBe(1); + queue.deliver({ mapId: 'a' }); + expect(calls).toBe(1); + }); +}); + +describe('NativeMap.create map ready', () => { + beforeEach(() => { + onMapReadyListeners.length = 0; + createImpl.mockClear(); + (NativeMap as unknown as { activeMapsById: Map }).activeMapsById.clear(); + }); + + afterEach(async () => { + const active = (NativeMap as unknown as { activeMapsById: Map }).activeMapsById; + for (const map of [...active.values()]) { + await map.destroy(); + } + active.clear(); + document.body.innerHTML = ''; + }); + + test('second create after ready runs callback on microtask', async () => { + const element = makeHostElement(); + const readyData: MapReadyCallbackData[] = []; + + await NativeMap.create( + { + id: 'map-dup', + apiKey: 'test', + config: { center: { lat: 0, lng: 0 }, zoom: 1 }, + element, + }, + (data) => { + readyData.push(data); + }, + ); + await waitForNativeCreate(); + emitMapReady('map-dup'); + await flushMicrotasks(); + expect(readyData).toHaveLength(1); + + let secondCalled = false; + const secondCreate = NativeMap.create( + { + id: 'map-dup', + apiKey: 'test', + config: { center: { lat: 0, lng: 0 }, zoom: 1 }, + element, + }, + () => { + secondCalled = true; + }, + ); + expect(secondCalled).toBe(false); + await secondCreate; + await flushMicrotasks(); + expect(secondCalled).toBe(true); + }); + + test('first create before ready fires callback once on deliver', async () => { + const element = makeHostElement(); + let calls = 0; + + const createPromise = NativeMap.create( + { + id: 'map-first', + apiKey: 'test', + config: { center: { lat: 0, lng: 0 }, zoom: 1 }, + element, + }, + () => { + calls += 1; + }, + ); + + expect(calls).toBe(0); + await waitForNativeCreate(); + expect(calls).toBe(0); + + emitMapReady('map-first'); + await createPromise; + expect(calls).toBe(1); + + emitMapReady('map-first'); + expect(calls).toBe(1); + }); +}); diff --git a/src/map-ready.ts b/src/map-ready.ts new file mode 100644 index 0000000..43572eb --- /dev/null +++ b/src/map-ready.ts @@ -0,0 +1,35 @@ +import type { MapReadyCallbackData } from './definitions'; + +export class MapReadyQueue { + private ready = false; + private readyData?: MapReadyCallbackData; + private pending: ((data: MapReadyCallbackData) => void)[] = []; + + deliver(data: MapReadyCallbackData): void { + if (this.ready) { + return; + } + this.ready = true; + this.readyData = data; + const callbacks = this.pending; + this.pending = []; + for (const cb of callbacks) { + cb(data); + } + } + + whenReady(cb: (data: MapReadyCallbackData) => void): void { + if (this.ready && this.readyData != null) { + const data = this.readyData; + queueMicrotask(() => cb(data)); + return; + } + this.pending.push(cb); + } + + clear(): void { + this.ready = false; + this.readyData = undefined; + this.pending = []; + } +} diff --git a/src/map.ts b/src/map.ts index 9c5aafc..20e1d46 100644 --- a/src/map.ts +++ b/src/map.ts @@ -24,6 +24,7 @@ import type { import { LatLngBounds, MapType } from './definitions'; import type { CreateMapArgs } from './implementation'; import { CapacitorNativeMap } from './implementation'; +import { MapReadyQueue } from './map-ready'; import { installIosTouchRoutingCachePublisher, uninstallIosTouchRoutingCachePublisher } from './touch-routing'; export interface NativeMapInterface { @@ -159,6 +160,9 @@ export class NativeMap { private onMyLocationButtonClickListener?: PluginListenerHandle; private onMyLocationClickListener?: PluginListenerHandle; + private readonly mapReadyQueue = new MapReadyQueue(); + private onMapReadyListener?: PluginListenerHandle; + private constructor(id: string) { this.id = id; } @@ -176,12 +180,7 @@ export class NativeMap { const existingMap = NativeMap.activeMapsById.get(options.id); if (existingMap && !options.forceCreate) { if (callback) { - const onMapReadyListener = await CapacitorNativeMap.addListener('onMapReady', (data: MapReadyCallbackData) => { - if (data.mapId === options.id) { - callback(data); - onMapReadyListener.remove(); - } - }); + existingMap.whenMapReady(callback); } return existingMap; } @@ -314,19 +313,14 @@ export class NativeMap { } } - let onMapReadyListener: PluginListenerHandle | undefined; + await newMap.attachMapReadyListener(); if (callback) { - onMapReadyListener = await CapacitorNativeMap.addListener('onMapReady', (data: MapReadyCallbackData) => { - if (data.mapId == newMap.id) { - callback(data); - onMapReadyListener?.remove(); - } - }); + newMap.whenMapReady(callback); } // small delay to allow for iOS WKWebView to setup corresponding element sub-scroll views ??? const cleanupFailedCreate = (): void => { - onMapReadyListener?.remove(); + newMap.clearMapReadyState(); if (Capacitor.isNativePlatform()) { newMap.resizeObserver?.disconnect(); if (newMap.windowResizeHandler) { @@ -373,6 +367,8 @@ export class NativeMap { private abandonAfterNativeForceReplace(): void { NativeMap.activeMapsById.delete(this.id); + this.clearMapReadyState(); + if (Capacitor.isNativePlatform()) { this.resizeObserver?.disconnect(); if (this.windowResizeHandler) { @@ -667,6 +663,7 @@ export class NativeMap { } this.removeAllMapListeners(); + this.clearMapReadyState(); NativeMap.activeMapsById.delete(this.id); @@ -1303,4 +1300,26 @@ export class NativeMap { } }; } + + whenMapReady(callback: MapListenerCallback): void { + this.mapReadyQueue.whenReady(callback); + } + + private async attachMapReadyListener(): Promise { + if (this.onMapReadyListener) { + return; + } + const mapId = this.id; + this.onMapReadyListener = await CapacitorNativeMap.addListener('onMapReady', (data: MapReadyCallbackData) => { + if (data.mapId === mapId) { + this.mapReadyQueue.deliver(data); + } + }); + } + + private clearMapReadyState(): void { + this.mapReadyQueue.clear(); + this.onMapReadyListener?.remove(); + this.onMapReadyListener = undefined; + } } diff --git a/src/test-setup.ts b/src/test-setup.ts new file mode 100644 index 0000000..1512a7e --- /dev/null +++ b/src/test-setup.ts @@ -0,0 +1,3 @@ +import { GlobalRegistrator } from '@happy-dom/global-registrator'; + +GlobalRegistrator.register(); From 9d94f9ac8d19eb2e89e86f6bf48ce150a586fbcd Mon Sep 17 00:00:00 2001 From: Cursor Agent Date: Mon, 5 Oct 2026 04:47:17 +0000 Subject: [PATCH 41/42] fix: address PR review threads on map ready and forceCreate Co-authored-by: Martin DONADIEU --- .../plugins/nativemap/CapacitorGoogleMap.kt | 3 ++ .../NativeMapPlugin/TouchRoutingCache.swift | 1 + src/map-ready.test.ts | 43 +++++++++++++++++++ src/map-ready.ts | 6 ++- src/map.ts | 8 +++- src/web.ts | 3 ++ 6 files changed, 62 insertions(+), 2 deletions(-) diff --git a/android/src/main/java/com/capgo/plugins/nativemap/CapacitorGoogleMap.kt b/android/src/main/java/com/capgo/plugins/nativemap/CapacitorGoogleMap.kt index 2f98f58..2e8d759 100644 --- a/android/src/main/java/com/capgo/plugins/nativemap/CapacitorGoogleMap.kt +++ b/android/src/main/java/com/capgo/plugins/nativemap/CapacitorGoogleMap.kt @@ -52,6 +52,7 @@ class CapacitorNativeMapView( private val isReadyChannel = Channel() private var debounceJob: Job? = null private var mapViewParent: FrameLayout? = null + private var isDestroyed = false var toBack: Boolean = false var isMapVisible: Boolean = true private var originalWebViewAlpha: Float? = null @@ -76,6 +77,7 @@ class CapacitorNativeMapView( private fun render() { CoroutineScope(Dispatchers.Main).launch { + if (isDestroyed) return@launch val bridge = delegate.bridge val parent = FrameLayout(bridge.context) parent.minimumHeight = bridge.webView.height @@ -253,6 +255,7 @@ class CapacitorNativeMapView( runBlocking { val job = CoroutineScope(Dispatchers.Main).launch { + isDestroyed = true val bridge = delegate.bridge val viewToRemove: View? = diff --git a/ios/Sources/NativeMapPlugin/TouchRoutingCache.swift b/ios/Sources/NativeMapPlugin/TouchRoutingCache.swift index de2be40..57fcca7 100644 --- a/ios/Sources/NativeMapPlugin/TouchRoutingCache.swift +++ b/ios/Sources/NativeMapPlugin/TouchRoutingCache.swift @@ -45,6 +45,7 @@ final class TouchRoutingMessageHandler: NSObject, WKScriptMessageHandler { func userContentController(_ userContentController: WKUserContentController, didReceive message: WKScriptMessage) { guard message.name == Self.handlerName, + message.frameInfo.isMainFrame, let webView = webView, message.webView === webView else { return } guard let body = message.body as? [[String: Any]] else { return } diff --git a/src/map-ready.test.ts b/src/map-ready.test.ts index d03e6e7..e035fbd 100644 --- a/src/map-ready.test.ts +++ b/src/map-ready.test.ts @@ -76,6 +76,19 @@ describe('MapReadyQueue', () => { queue.deliver({ mapId: 'a' }); expect(calls).toBe(1); }); + + test('continues draining when a callback throws', () => { + const queue = new MapReadyQueue(); + let secondCalls = 0; + queue.whenReady(() => { + throw new Error('boom'); + }); + queue.whenReady(() => { + secondCalls += 1; + }); + queue.deliver({ mapId: 'a' }); + expect(secondCalls).toBe(1); + }); }); describe('NativeMap.create map ready', () => { @@ -159,4 +172,34 @@ describe('NativeMap.create map ready', () => { emitMapReady('map-first'); expect(calls).toBe(1); }); + + test('web forceCreate keeps prior instance when replacement create fails', async () => { + const element = makeHostElement(); + createImpl.mockImplementation(async () => undefined); + + const first = await NativeMap.create({ + id: 'force-web', + apiKey: 'test', + config: { center: { lat: 0, lng: 0 }, zoom: 1 }, + element, + }); + await waitForNativeCreate(); + + createImpl.mockImplementation(async () => { + throw new Error('create failed'); + }); + + await expect( + NativeMap.create({ + id: 'force-web', + forceCreate: true, + apiKey: 'test', + config: { center: { lat: 0, lng: 0 }, zoom: 1 }, + element, + }), + ).rejects.toThrow('create failed'); + + const active = (NativeMap as unknown as { activeMapsById: Map }).activeMapsById; + expect(active.get('force-web')).toBe(first); + }); }); diff --git a/src/map-ready.ts b/src/map-ready.ts index 43572eb..30f7f57 100644 --- a/src/map-ready.ts +++ b/src/map-ready.ts @@ -14,7 +14,11 @@ export class MapReadyQueue { const callbacks = this.pending; this.pending = []; for (const cb of callbacks) { - cb(data); + try { + cb(data); + } catch { + // Keep draining remaining ready callbacks. + } } } diff --git a/src/map.ts b/src/map.ts index 20e1d46..7bf8a46 100644 --- a/src/map.ts +++ b/src/map.ts @@ -341,11 +341,17 @@ export class NativeMap { try { if (options.forceCreate) { const replaced = NativeMap.activeMapsById.get(options.id); - if (replaced && replaced !== newMap) { + if (replaced && replaced !== newMap && Capacitor.isNativePlatform()) { replaced.abandonAfterNativeForceReplace(); } } await CapacitorNativeMap.create(createOptions); + if (options.forceCreate && !Capacitor.isNativePlatform()) { + const replaced = NativeMap.activeMapsById.get(options.id); + if (replaced && replaced !== newMap) { + replaced.abandonAfterNativeForceReplace(); + } + } resolve(undefined); } catch (err) { reject(err); diff --git a/src/web.ts b/src/web.ts index faea0c4..a4f5912 100644 --- a/src/web.ts +++ b/src/web.ts @@ -583,6 +583,9 @@ export class CapacitorNativeMapWeb extends WebPlugin implements NativeMapPlugin } const ownsElement = _args.element == null; + if (this.maps[_args.id]) { + await this.destroy({ id: _args.id }); + } const element = _args.element ?? this.createOwnedMapHost(_args.id); this.maps[_args.id] = { map: new window.google.maps.Map(element, config), From ab626971bb0056eddac3f19334499689839990bf Mon Sep 17 00:00:00 2001 From: Cursor Agent Date: Fri, 16 Oct 2026 18:41:15 +0000 Subject: [PATCH 42/42] fix: guard destroyed map onMapReady and report ready callback errors Co-authored-by: Martin DONADIEU --- .../java/com/capgo/plugins/nativemap/CapacitorGoogleMap.kt | 6 ++++++ src/map-ready.ts | 6 ++++-- 2 files changed, 10 insertions(+), 2 deletions(-) diff --git a/android/src/main/java/com/capgo/plugins/nativemap/CapacitorGoogleMap.kt b/android/src/main/java/com/capgo/plugins/nativemap/CapacitorGoogleMap.kt index 2e8d759..8dd562f 100644 --- a/android/src/main/java/com/capgo/plugins/nativemap/CapacitorGoogleMap.kt +++ b/android/src/main/java/com/capgo/plugins/nativemap/CapacitorGoogleMap.kt @@ -1013,6 +1013,9 @@ class CapacitorNativeMapView( } override fun onMapReady(map: GoogleMap) { + if (isDestroyed) { + return + } googleMap = map setListeners() @@ -1021,6 +1024,9 @@ class CapacitorNativeMapView( delegate.notify("onMapReady", data) CoroutineScope(Dispatchers.Main).launch { + if (isDestroyed) { + return@launch + } isReadyChannel.send(true) isReadyChannel.close() } diff --git a/src/map-ready.ts b/src/map-ready.ts index 30f7f57..3bec210 100644 --- a/src/map-ready.ts +++ b/src/map-ready.ts @@ -16,8 +16,10 @@ export class MapReadyQueue { for (const cb of callbacks) { try { cb(data); - } catch { - // Keep draining remaining ready callbacks. + } catch (error) { + queueMicrotask(() => { + throw error; + }); } } }

            2. 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 Z?ClBiczWuC^9CRgRb`FKA1;~r{~x|){M!Hk literal 109623 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 z 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