diff --git a/.gitignore b/.gitignore index 949fee6f..8bfe04d9 100644 --- a/.gitignore +++ b/.gitignore @@ -1,5 +1,4 @@ .DS_Store -build/ *.pbxuser !default.pbxuser *.mode1v3 @@ -27,7 +26,6 @@ android/.project ios/Carthage/Checkouts ios/Carthage/Build junit.xml -dist/ example2 react-native-radar-*.tgz diff --git a/dist/package.json b/dist/package.json new file mode 100644 index 00000000..2229e361 --- /dev/null +++ b/dist/package.json @@ -0,0 +1,84 @@ +{ + "name": "react-native-radar", + "description": "React Native module for Radar, the leading geofencing and location tracking platform", + "homepage": "https://radar.com", + "license": "Apache-2.0", + "version": "3.12.1", + "main": "dist/src/index.js", + "files": [ + "android", + "ios", + "src", + "README.md", + "react-native-radar.podspec", + "/dist" + ], + "types": "dist/src/index.d.ts", + "scripts": { + "test": "jest ./test/*.test.js", + "check-latest-tag": "node ./scripts/check-latest-tag.cjs", + "check-beta-tag": "node ./scripts/check-beta-tag.cjs", + "build": "tsc", + "copy-assets": "./copyAssets.sh" + }, + "jest": { + "preset": "react-native", + "clearMocks": true, + "reporters": [ + "default", + "jest-junit" + ], + "modulePathIgnorePatterns": [ + "example", + "example2" + ] + }, + "peerDependencies": { + "@maplibre/maplibre-react-native": "^10.0.0-alpha.4", + "react": ">= 16.8.6", + "react-native": ">= 0.60.0" + }, + "peerDependenciesMeta": { + "@maplibre/maplibre-react-native": { + "optional": true + } + }, + "devDependencies": { + "@babel/core": "^7.2.2", + "@babel/preset-env": "^7.2.3", + "@babel/preset-react": "^7.0.0", + "@babel/register": "^7.0.0", + "@types/node": "^20.11.7", + "@types/react-native": "^0.73.0", + "babel-core": "^7.0.0-bridge.0", + "babel-eslint": "^10.0.1", + "babel-jest": "^23.4.2", + "braces": ">=2.3.2", + "eslint": "^5.6.1", + "eslint-config-airbnb": "^17.1.0", + "eslint-plugin-import": "^2.14.0", + "eslint-plugin-jest": "^22.1.2", + "eslint-plugin-jsx-a11y": "^6.1.1", + "eslint-plugin-react": "^7.11.1", + "jest": "^23.6.0", + "jest-junit": "^5.2.0", + "logkitty": ">=0.7.1", + "metro-react-native-babel-preset": "^0.51.1", + "npm-run-all": "^4.1.5", + "react": "16.8.6", + "react-native": "0.60.0", + "typescript": "^5.3.3" + }, + "bugs": { + "url": "https://github.com/radarlabs/react-native-radar/issues" + }, + "repository": { + "type": "git", + "url": "https://github.com/radarlabs/react-native-radar.git" + }, + "dependencies": { + "@babel/runtime": "^7.21.0", + "@react-native-community/netinfo": "^7.1.3", + "radar-sdk-js": "^3.6.0" + } +} diff --git a/dist/src/@types/RadarNativeInterface.d.ts b/dist/src/@types/RadarNativeInterface.d.ts new file mode 100644 index 00000000..4d22a8b5 --- /dev/null +++ b/dist/src/@types/RadarNativeInterface.d.ts @@ -0,0 +1,52 @@ +import { Location, RadarAutocompleteOptions, RadarContextCallback, RadarAddressCallback, RadarEventChannel, RadarGeocodeOptions, RadarGetDistanceOptions, RadarLocationCallback, RadarLogConversionCallback, RadarLogConversionOptions, RadarLogLevel, RadarMockTrackingOptions, RadarNotificationOptions, RadarPermissionsStatus, RadarReverseGeocodeOptions, RadarRouteCallback, RadarRouteMatrix, RadarSearchGeofencesCallback, RadarSearchGeofencesOptions, RadarSearchPlacesCallback, RadarSearchPlacesOptions, RadarStartTripOptions, RadarTrackCallback, RadarTrackOnceOptions, RadarTrackVerifiedCallback, RadarTrackingOptions, RadarTrackingOptionsDesiredAccuracy, RadarTrackingOptionsForegroundService, RadarTrackVerifiedOptions, RadarTripCallback, RadarTripOptions, RadarUpdateTripOptions, RadarVerifiedTrackingOptions, RadarListenerCallback, RadarGetMatrixOptions, RadarMetadata, RadarIPGeocodeCallback } from "./types"; +export interface RadarNativeInterface { + initialize: (publishableKey: string, fraud?: boolean) => void; + setLogLevel: (level: RadarLogLevel) => void; + setUserId: (userId: string) => void; + getUserId: () => Promise; + setDescription: (description: string) => void; + getDescription: () => Promise; + setMetadata: (metadata: RadarMetadata) => void; + getMetadata: () => Promise; + setAnonymousTrackingEnabled: (enabled: boolean) => void; + getPermissionsStatus: () => Promise; + requestPermissions: (background: boolean) => Promise; + getLocation: (desiredAccuracy?: RadarTrackingOptionsDesiredAccuracy) => Promise; + trackOnce: (options?: RadarTrackOnceOptions | Location) => Promise; + trackVerified: (options?: RadarTrackVerifiedOptions) => Promise; + getVerifiedLocationToken: () => Promise; + startTrackingEfficient: () => void; + startTrackingResponsive: () => void; + startTrackingContinuous: () => void; + startTrackingCustom: (options: RadarTrackingOptions) => void; + startTrackingVerified: (options?: RadarVerifiedTrackingOptions) => void; + mockTracking: (options: RadarMockTrackingOptions) => void; + stopTracking: () => void; + getTrackingOptions: () => Promise; + isUsingRemoteTrackingOptions: () => Promise; + isTracking: () => boolean; + setForegroundServiceOptions: (options: RadarTrackingOptionsForegroundService) => void; + setNotificationOptions: (options: RadarNotificationOptions) => void; + getTripOptions: () => Promise; + startTrip: (options: RadarStartTripOptions) => Promise; + completeTrip: () => Promise; + cancelTrip: () => Promise; + updateTrip: (options: RadarUpdateTripOptions) => Promise; + acceptEvent: (eventId: string, verifiedPlaceId: string) => void; + rejectEvent: (eventId: string) => void; + getContext: (location?: Location) => Promise; + searchPlaces: (options: RadarSearchPlacesOptions) => Promise; + searchGeofences: (options: RadarSearchGeofencesOptions) => Promise; + autocomplete: (options: RadarAutocompleteOptions) => Promise; + geocode: (options: RadarGeocodeOptions) => Promise; + reverseGeocode: (options?: RadarReverseGeocodeOptions) => Promise; + ipGeocode: () => Promise; + getDistance: (option: RadarGetDistanceOptions) => Promise; + getMatrix: (option: RadarGetMatrixOptions) => Promise; + logConversion: (options: RadarLogConversionOptions) => Promise; + sendEvent: (name: string, metadata: RadarMetadata) => void; + on: (channel: RadarEventChannel, callback: RadarListenerCallback) => void; + off: (channel: RadarEventChannel, callback?: Function | undefined) => void; + nativeSdkVersion: () => Promise; + rnSdkVersion: () => string; +} diff --git a/dist/src/@types/RadarNativeInterface.js b/dist/src/@types/RadarNativeInterface.js new file mode 100644 index 00000000..c8ad2e54 --- /dev/null +++ b/dist/src/@types/RadarNativeInterface.js @@ -0,0 +1,2 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); diff --git a/dist/src/@types/types.d.ts b/dist/src/@types/types.d.ts new file mode 100644 index 00000000..88df0a17 --- /dev/null +++ b/dist/src/@types/types.d.ts @@ -0,0 +1,514 @@ +export type RadarMetadata = Record; +export interface RadarTrackOnceOptions { + location?: Location; + desiredAccuracy?: RadarTrackingOptionsDesiredAccuracy; + beacons?: boolean; +} +export interface RadarTrackVerifiedOptions { + beacons?: boolean; +} +/** + * Options for tracking the user's location. + * @see {@link https://radar.com/documentation/sdk/tracking} + */ +export interface RadarTrackingOptions { + desiredStoppedUpdateInterval: number; + fastestStoppedUpdateInterval?: number; + desiredMovingUpdateInterval: number; + fastestMovingUpdateInterval?: number; + desiredSyncInterval: number; + desiredAccuracy: RadarTrackingOptionsDesiredAccuracy; + stopDuration: number; + stopDistance: number; + sync: "all" | "stopsAndExits" | "none"; + replay: "all" | "stops" | "none"; + useStoppedGeofence: boolean; + showBlueBar?: boolean; + startTrackingAfter?: number; + stopTrackingAfter?: number; + stoppedGeofenceRadius: number; + useMovingGeofence: boolean; + movingGeofenceRadius: number; + syncGeofences: boolean; + useVisits?: boolean; + useSignificantLocationChanges?: boolean; + beacons: boolean; + syncGeofencesLimit?: number; + foregroundServiceEnabled?: boolean; +} +export declare const presetContinuousIOS: RadarTrackingOptions; +export declare const presetContinuousAndroid: RadarTrackingOptions; +export declare const presetContinuous: RadarTrackingOptions; +export declare const presetResponsiveIOS: RadarTrackingOptions; +export declare const presetResponsiveAndroid: RadarTrackingOptions; +export declare const presetResponsive: RadarTrackingOptions; +export declare const presetEfficientIOS: RadarTrackingOptions; +export declare const presetEfficientAndroid: RadarTrackingOptions; +export declare const presetEfficient: RadarTrackingOptions; +export interface RadarMockTrackingOptions { + origin: Location; + destination: Location; + mode: RadarRouteMode; + steps: number; + interval: number; +} +export interface RadarVerifiedTrackingOptions { + interval?: number; + beacons?: boolean; +} +export interface RadarVerifiedLocationToken { + user: RadarUser; + events: RadarEvent[]; + token: string; + expiresAt: Date; + expiresIn: number; + passed: boolean; +} +export interface RadarGetDistanceOptions { + origin?: Location; + destination?: Location; + modes?: RadarRouteMode[]; + units?: "metric" | "imperial"; +} +export interface RadarGetMatrixOptions { + origins?: Location[]; + destinations?: Location[]; + mode?: RadarRouteMode; + units?: "metric" | "imperial"; +} +export interface RadarUpdateTripOptions { + options: RadarTripOptions; + status: RadarTripStatus; +} +export interface RadarStartTripOptions { + tripOptions: RadarTripOptions; + trackingOptions?: RadarTrackingOptions; +} +export interface RadarSearchGeofencesOptions { + near?: Location; + radius?: number; + metadata?: RadarMetadata; + tags?: string[]; + limit?: number; + includeGeometry: boolean; +} +export interface RadarTrackingOptionsForegroundServiceOptions { + text?: string; + title?: string; + updatesOnly: boolean; + activity?: string; + importance?: number; + id?: number; + channelName?: string; + iconString?: string; + iconColor?: string; +} +export interface RadarSearchPlacesOptions { + near?: Location; + radius?: number; + chains?: string[]; + chainMetadata?: RadarMetadata; + categories?: string[]; + groups?: string[]; + limit?: number; +} +export interface RadarAutocompleteOptions { + query: string; + near?: Location; + layers?: string[]; + limit: number; + country?: string; + /** @deprecated this is always true, regardless of the value passed here */ + expandUnits?: boolean; + mailable?: boolean; +} +export interface RadarGeocodeOptions { + address: string; + layers?: string[]; + countries?: string[]; +} +export interface RadarReverseGeocodeOptions { + location?: Location; + layers?: string[]; +} +export interface RadarNotificationOptions { + iconString?: string; + iconColor?: string; + foregroundServiceIconString?: string; + foregroundServiceIconColor?: string; + eventIconString?: string; + eventIconColor?: string; +} +export interface RadarLogConversionOptions { + name: string; + revenue?: number; + metadata?: RadarMetadata; +} +export interface RadarTripOptions { + externalId: string; + metadata?: RadarMetadata; + destinationGeofenceTag?: string; + destinationGeofenceExternalId?: string; + mode?: RadarRouteMode; + scheduledArrivalAt?: number; + approachingThreshold?: number; +} +export interface RadarTrackCallback { + status: string; + location?: Location; + user?: RadarUser; + events?: RadarEvent[]; +} +export interface RadarLocationCallback { + status: string; + location?: Location; + stopped: boolean; +} +export interface RadarTripCallback { + status: string; + trip?: RadarTrip; + events?: RadarEvent[]; +} +export interface RadarContextCallback { + status: string; + location?: Location; + context?: RadarContext; +} +export interface RadarSearchPlacesCallback { + status: string; + location?: Location; + places?: RadarPlace[]; +} +export interface RadarSearchGeofencesCallback { + status: string; + location?: Location; + geofences?: RadarGeofence[]; +} +export interface RadarAddressCallback { + status: string; + addresses?: RadarAddress[]; +} +export interface RadarIPGeocodeCallback { + status: string; + address?: RadarAddress; + proxy?: boolean; +} +export interface RadarValidateAddressCallback { + status: string; + address?: RadarAddress; + verificationStatus?: RadarVerificationStatus; +} +export interface RadarIPGeocodeCallback { + status: string; + address?: RadarAddress; + proxy?: boolean; +} +export interface RadarRouteCallback { + status: string; + routes?: RadarRoutes; +} +export interface RadarLogConversionCallback { + status: string; + event?: RadarEvent; +} +export interface RadarTrackVerifiedCallback { + status: string; + token?: RadarVerifiedLocationToken; +} +export interface RadarEventUpdate { + user?: RadarUser; + events: RadarEvent[]; +} +export interface RadarEventUpdateCallback { + (args: RadarEventUpdate): void; +} +export interface RadarLocationUpdate { + location: Location; + user: RadarUser; +} +export interface RadarLocationUpdateCallback { + (args: RadarLocationUpdate): void; +} +export interface RadarClientLocationUpdate { + location: Location; + stopped: boolean; + source: RadarLocationSource; +} +export interface RadarClientLocationUpdateCallback { + (args: RadarClientLocationUpdate): void; +} +export interface RadarErrorCallback { + (status: string): void; +} +export interface RadarLogUpdateCallback { + (status: string): void; +} +export interface RadarLocationPermissionStatusCallback { + (status: RadarLocationPermissionStatus): void; +} +export type RadarListenerCallback = RadarEventUpdateCallback | RadarLocationUpdateCallback | RadarClientLocationUpdateCallback | RadarErrorCallback | RadarLogUpdateCallback | RadarLocationPermissionStatusCallback; +export type RadarPermissionsStatus = "GRANTED_FOREGROUND" | "GRANTED_BACKGROUND" | "DENIED" | "NOT_DETERMINED" | "UNKNOWN"; +export type RadarLocationSource = "FOREGROUND_LOCATION" | "BACKGROUND_LOCATION" | "MANUAL_LOCATION" | "VISIT_ARRIVAL" | "VISIT_DEPARTURE" | "GEOFENCE_ENTER" | "GEOFENCE_DWELL" | "GEOFENCE_EXIT" | "MOCK_LOCATION" | "BEACON_ENTER" | "BEACON_EXIT" | "UNKNOWN"; +export type RadarEventChannel = "clientLocation" | "location" | "error" | "events" | "log" | "token" | "locationPermissionStatus"; +export type RadarLogLevel = "info" | "debug" | "warning" | "error" | "none"; +export interface RadarRouteMatrix { + status: string; + matrix?: RadarRoute[][]; +} +export interface Location { + latitude: number; + longitude: number; + accuracy?: number; + speed?: number; + altitude?: number; + course?: number; + verticalAccuracy?: number; + speedAccuracy?: number; + courseAccuracy?: number; + mocked?: boolean; +} +export interface RadarUser { + _id: string; + userId?: string; + deviceId?: string; + description?: string; + metadata?: RadarMetadata; + location?: RadarCoordinate; + geofences?: RadarGeofence[]; + place?: RadarPlace; + beacons?: RadarBeacon[]; + stopped?: boolean; + foreground?: boolean; + country?: RadarRegion; + state?: RadarRegion; + dma?: RadarRegion; + postalCode?: RadarRegion; + nearbyPlaceChains?: RadarChain[]; + segments?: RadarSegment[]; + topChains?: RadarChain[]; + source?: LocationSource; + trip?: RadarTrip; + debug?: boolean; + fraud?: RadarFraud; +} +export interface RadarCoordinate { + type: string; + coordinates: [number, number]; +} +export type LocationSource = "FOREGROUND_LOCATION" | "BACKGROUND_LOCATION" | "MANUAL_LOCATION" | "VISIT_ARRIVAL" | "VISIT_DEPARTURE" | "GEOFENCE_ENTER" | "GEOFENCE_EXIT" | "MOCK_LOCATION" | "BEACON_ENTER" | "BEACON_EXIT" | "UNKNOWN"; +export interface RadarTrip { + _id: string; + externalId: string; + metadata?: RadarMetadata; + destinationGeofenceTag?: string; + destinationGeofenceExternalId?: string; + mode?: RadarRouteMode; + eta?: RadarTripEta; + status: RadarTripStatus; + scheduledArrivalAt?: Date; + destinationLocation: Location; + delay: RadarDelay; +} +export interface RadarDelay { + delayed: boolean; + scheduledArrivalTimeDelay: number; +} +export interface RadarSegment { + description: string; + externalId: string; +} +export interface RadarContext { + geofences?: RadarGeofence[]; + place?: RadarPlace; + country?: RadarRegion; + state?: RadarRegion; + dma?: RadarRegion; + postalCode?: RadarRegion; +} +export interface RadarEvent { + _id: string; + live: boolean; + type: RadarEventType; + geofence?: RadarGeofence; + place?: RadarPlace; + region?: RadarRegion; + confidence: RadarEventConfidence; + duration?: number; + beacon?: RadarBeacon; + trip?: RadarTrip; + alternatePlaces?: RadarPlace[]; + location?: RadarCoordinate; + metadata?: RadarMetadata; + replayed?: boolean; + createdAt: string; + actualCreatedAt: string; + fraud?: RadarFraud; +} +export declare enum RadarEventConfidence { + none = 0, + low = 1, + medium = 2, + high = 3 +} +export type RadarEventType = "unknown" | "user.entered_geofence" | "user.entered_beacon" | "user.dwelled_in_geofence" | "user.entered_place" | "user.entered_region_country" | "user.entered_region_dma" | "user.entered_region_state" | "user.entered_region_postal_code" | "user.exited_geofence" | "user.exited_beacon" | "user.exited_place" | "user.exited_region_country" | "user.exited_region_dma" | "user.exited_region_state" | "user.exited_region_postal_code" | "user.nearby_place_chain" | "user.started_trip" | "user.updated_trip" | "user.approaching_trip_destination" | "user.arrived_at_trip_destination" | "user.stopped_trip" | "user.arrived_at_wrong_trip_destination" | "user.delayed_during_trip" | "user.failed_fraud"; +export type RadarTrackingOptionsDesiredAccuracy = "high" | "medium" | "low" | "none"; +export declare enum RadarEventVerification { + accept = 1, + unverify = 0, + reject = -1 +} +export type RadarBeaconType = "eddystone" | "ibeacon"; +export interface RadarGeofence { + _id: string; + description: string; + tag?: string; + externalId?: string; + metadata?: RadarMetadata; + type?: "Circle" | "Polygon"; + geometryRadius?: number; + geometryCenter?: RadarCoordinate; + coordinates?: number[][]; +} +export interface RadarBeacon { + _id: string; + metadata?: RadarMetadata; + type: RadarBeaconType; + uuid?: string; + instance?: string; + major?: string; + minor?: string; + geometry?: RadarCoordinate; + rss?: number; +} +export interface RadarPlace { + _id: string; + name: string; + categories: string[]; + chain?: RadarChain; + location: Location; + metadata?: RadarMetadata; + group?: string; + address?: RadarAddress; +} +export interface RadarChain { + name: string; + slug: string; + externalId?: string; + metadata?: RadarMetadata; +} +export interface RadarRegion { + _id: string; + type: string; + code: string; + name: string; + allowed?: boolean; + flag?: string; + passed?: boolean; + inExclusionZone?: boolean; + inBufferZone?: boolean; + distanceToBorder?: number; +} +export interface RadarAddress { + addressLabel?: string; + borough?: string; + city?: string; + confidence?: string; + country?: string; + countryCode?: string; + countryFlag?: string; + county?: string; + distance?: number; + dma?: string; + dmaCode?: string; + formattedAddress?: string; + latitude: number; + layer?: string; + longitude: number; + metadata?: RadarMetadata; + neighborhood?: string; + number?: string; + placeLabel?: string; + plus4?: string; + postalCode?: string; + state?: string; + stateCode?: string; + street?: string; + unit?: string; +} +export type RadarVerificationStatus = "verified" | "partially verified" | "ambiguous" | "unverified"; +export interface RadarRoutes { + geodesic?: RadarRouteDistance; + foot?: RadarRoute; + bike?: RadarRoute; + car?: RadarRoute; + truck?: RadarRoute; + motorbike?: RadarRoute; +} +export interface RadarRouteGeometry { + type: string; + coordinates: number[][]; +} +export interface RadarRoute { + distance?: RadarRouteDistance; + duration?: RadarRouteDuration; + geometry?: RadarRouteGeometry; +} +export interface RadarRouteDistance { + value: number; + text: string; +} +export interface RadarRouteDuration { + value: number; + text: string; +} +export interface RadarTripEta { + distance?: number; + duration?: number; +} +export interface RadarFraud { + passed: boolean; + bypassed: boolean; + verified: boolean; + proxy: boolean; + mocked: boolean; + compromised: boolean; + jumped: boolean; + inaccurate: boolean; +} +export type RadarTrackingOptionsReplay = "all" | "stops" | "none"; +export type RadarTrackingOptionsSync = "none" | "stopsAndExits" | "all"; +export type RadarRouteMode = "foot" | "bike" | "car" | "truck" | "motorbike"; +export interface RadarTrackingOptionsForegroundService { + text?: string; + title?: string; + icon?: number; + updatesOnly?: boolean; + activity?: string; + importance?: number; + id?: number; + channelName?: string; + iconString?: string; + iconColor?: string; +} +export type RadarTripStatus = "unknown" | "started" | "approaching" | "arrived" | "expired" | "completed" | "canceled"; +export interface RadarLocationPermissionStatusAndroid { + status: LocationPermissionState; + foregroundPermissionResult: boolean; + backgroundPermissionResult: boolean; + shouldShowRequestPermissionRationaleFG: boolean; + shouldShowRequestPermissionRationaleBG: boolean; + previouslyDeniedForeground: boolean; + inLocationPopup: boolean; + approximatePermissionResult: boolean; + previouslyDeniedBackground: boolean; +} +export interface RadarLocationPermissionStatusIOS { + status: LocationPermissionState; + locationManagerStatus: LocationManagerStatus; + backgroundPopupAvailable: boolean; + inForegroundPopup: boolean; + userRejectedBackgroundPermission: boolean; +} +export type RadarLocationPermissionStatus = RadarLocationPermissionStatusAndroid | RadarLocationPermissionStatusIOS; +export type LocationPermissionState = "NO_PERMISSION_GRANTED" | "FOREGROUND_PERMISSION_GRANTED" | "APPROXIMATE_PERMISSION_GRANTED" | "FOREGROUND_PERMISSION_REJECTED_ONCE" | "FOREGROUND_PERMISSION_REJECTED" | "FOREGROUND_PERMISSION_PENDING" | "BACKGROUND_PERMISSION_GRANTED" | "BACKGROUND_PERMISSION_REJECTED" | "BACKGROUND_PERMISSION_REJECTED_ONCE" | "PERMISSION_RESTRICTED" | "UNKNOWN"; +export type LocationManagerStatus = "NotDetermined" | "Restricted" | "Denied" | "AuthorizedAlways" | "AuthorizedWhenInUse" | "Unknown"; diff --git a/dist/src/@types/types.js b/dist/src/@types/types.js new file mode 100644 index 00000000..727af65f --- /dev/null +++ b/dist/src/@types/types.js @@ -0,0 +1,149 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.RadarEventVerification = exports.RadarEventConfidence = exports.presetEfficient = exports.presetEfficientAndroid = exports.presetEfficientIOS = exports.presetResponsive = exports.presetResponsiveAndroid = exports.presetResponsiveIOS = exports.presetContinuous = exports.presetContinuousAndroid = exports.presetContinuousIOS = void 0; +const react_native_1 = require("react-native"); +exports.presetContinuousIOS = { + desiredStoppedUpdateInterval: 30, + desiredMovingUpdateInterval: 30, + desiredSyncInterval: 20, + desiredAccuracy: 'high', + stopDuration: 140, + stopDistance: 70, + replay: 'none', + useStoppedGeofence: false, + showBlueBar: true, + startTrackingAfter: undefined, + stopTrackingAfter: undefined, + stoppedGeofenceRadius: 0, + useMovingGeofence: false, + movingGeofenceRadius: 0, + syncGeofences: true, + useVisits: false, + useSignificantLocationChanges: false, + beacons: false, + sync: 'all', +}; +exports.presetContinuousAndroid = { + desiredStoppedUpdateInterval: 30, + fastestStoppedUpdateInterval: 30, + desiredMovingUpdateInterval: 30, + fastestMovingUpdateInterval: 30, + desiredSyncInterval: 20, + desiredAccuracy: 'high', + stopDuration: 140, + stopDistance: 70, + replay: 'none', + sync: 'all', + useStoppedGeofence: false, + stoppedGeofenceRadius: 0, + useMovingGeofence: false, + movingGeofenceRadius: 0, + syncGeofences: true, + syncGeofencesLimit: 0, + foregroundServiceEnabled: true, + beacons: false, + startTrackingAfter: undefined, + stopTrackingAfter: undefined, +}; +exports.presetContinuous = react_native_1.Platform.OS === 'ios' ? exports.presetContinuousIOS : exports.presetContinuousAndroid; +exports.presetResponsiveIOS = { + desiredStoppedUpdateInterval: 0, + desiredMovingUpdateInterval: 150, + desiredSyncInterval: 20, + desiredAccuracy: 'medium', + stopDuration: 140, + stopDistance: 70, + replay: 'stops', + useStoppedGeofence: true, + showBlueBar: false, + startTrackingAfter: undefined, + stopTrackingAfter: undefined, + stoppedGeofenceRadius: 100, + useMovingGeofence: true, + movingGeofenceRadius: 100, + syncGeofences: true, + useVisits: true, + useSignificantLocationChanges: true, + beacons: false, + sync: 'all', +}; +exports.presetResponsiveAndroid = { + desiredStoppedUpdateInterval: 0, + fastestStoppedUpdateInterval: 0, + desiredMovingUpdateInterval: 150, + fastestMovingUpdateInterval: 30, + desiredSyncInterval: 20, + desiredAccuracy: "medium", + stopDuration: 140, + stopDistance: 70, + replay: 'stops', + sync: 'all', + useStoppedGeofence: true, + stoppedGeofenceRadius: 100, + useMovingGeofence: true, + movingGeofenceRadius: 100, + syncGeofences: true, + syncGeofencesLimit: 10, + foregroundServiceEnabled: false, + beacons: false, + startTrackingAfter: undefined, + stopTrackingAfter: undefined, +}; +exports.presetResponsive = react_native_1.Platform.OS === 'ios' ? exports.presetResponsiveIOS : exports.presetResponsiveAndroid; +exports.presetEfficientIOS = { + desiredStoppedUpdateInterval: 0, + desiredMovingUpdateInterval: 0, + desiredSyncInterval: 0, + desiredAccuracy: "medium", + stopDuration: 0, + stopDistance: 0, + replay: 'stops', + useStoppedGeofence: false, + showBlueBar: false, + startTrackingAfter: undefined, + stopTrackingAfter: undefined, + stoppedGeofenceRadius: 0, + useMovingGeofence: false, + movingGeofenceRadius: 0, + syncGeofences: true, + useVisits: true, + useSignificantLocationChanges: false, + beacons: false, + sync: 'all', +}; +exports.presetEfficientAndroid = { + desiredStoppedUpdateInterval: 3600, + fastestStoppedUpdateInterval: 1200, + desiredMovingUpdateInterval: 1200, + fastestMovingUpdateInterval: 360, + desiredSyncInterval: 140, + desiredAccuracy: 'medium', + stopDuration: 140, + stopDistance: 70, + replay: 'stops', + sync: 'all', + useStoppedGeofence: false, + stoppedGeofenceRadius: 0, + useMovingGeofence: false, + movingGeofenceRadius: 0, + syncGeofences: true, + syncGeofencesLimit: 10, + foregroundServiceEnabled: false, + beacons: false, + startTrackingAfter: undefined, + stopTrackingAfter: undefined, +}; +exports.presetEfficient = react_native_1.Platform.OS === 'ios' ? exports.presetEfficientIOS : exports.presetEfficientAndroid; +var RadarEventConfidence; +(function (RadarEventConfidence) { + RadarEventConfidence[RadarEventConfidence["none"] = 0] = "none"; + RadarEventConfidence[RadarEventConfidence["low"] = 1] = "low"; + RadarEventConfidence[RadarEventConfidence["medium"] = 2] = "medium"; + RadarEventConfidence[RadarEventConfidence["high"] = 3] = "high"; +})(RadarEventConfidence || (exports.RadarEventConfidence = RadarEventConfidence = {})); +var RadarEventVerification; +(function (RadarEventVerification) { + RadarEventVerification[RadarEventVerification["accept"] = 1] = "accept"; + RadarEventVerification[RadarEventVerification["unverify"] = 0] = "unverify"; + RadarEventVerification[RadarEventVerification["reject"] = -1] = "reject"; +})(RadarEventVerification || (exports.RadarEventVerification = RadarEventVerification = {})); diff --git a/dist/src/helpers.d.ts b/dist/src/helpers.d.ts new file mode 100644 index 00000000..c7bb7b76 --- /dev/null +++ b/dist/src/helpers.d.ts @@ -0,0 +1,2 @@ +export function getHost(): any; +export function getPublishableKey(): any; diff --git a/dist/src/helpers.js b/dist/src/helpers.js new file mode 100644 index 00000000..cc834434 --- /dev/null +++ b/dist/src/helpers.js @@ -0,0 +1,11 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.getPublishableKey = exports.getHost = void 0; +const react_native_1 = require("react-native"); +if (!react_native_1.NativeModules.RNRadar && (react_native_1.Platform.OS === 'ios' || react_native_1.Platform.OS === 'android')) { + throw new Error('NativeModules.RNRadar is undefined'); +} +const getHost = () => (react_native_1.NativeModules.RNRadar.getHost()); +exports.getHost = getHost; +const getPublishableKey = () => (react_native_1.NativeModules.RNRadar.getPublishableKey()); +exports.getPublishableKey = getPublishableKey; diff --git a/dist/src/index.d.ts b/dist/src/index.d.ts new file mode 100644 index 00000000..b7aa5106 --- /dev/null +++ b/dist/src/index.d.ts @@ -0,0 +1,11 @@ +import { RadarNativeInterface } from "./@types/RadarNativeInterface"; +declare let module: RadarNativeInterface; +export default module; +declare let RadarRNWeb: any; +export { RadarRNWeb }; +declare let Autocomplete: any; +export { Autocomplete }; +declare let Map: any; +export { Map }; +export * from "./@types/types"; +export * from "./@types/RadarNativeInterface"; diff --git a/dist/src/index.js b/dist/src/index.js new file mode 100644 index 00000000..bd07bac7 --- /dev/null +++ b/dist/src/index.js @@ -0,0 +1,29 @@ +"use strict"; +var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { return m[k]; } }; + } + Object.defineProperty(o, k2, desc); +}) : (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + o[k2] = m[k]; +})); +var __exportStar = (this && this.__exportStar) || function(m, exports) { + for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p); +}; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.Map = exports.Autocomplete = exports.RadarRNWeb = void 0; +const react_native_1 = require("react-native"); +let module; +module = require("./index.native").default; +exports.default = module; +let RadarRNWeb = react_native_1.Platform.OS === "web" ? require("./index.web").default : {}; +exports.RadarRNWeb = RadarRNWeb; +let Autocomplete = react_native_1.Platform.OS !== "web" ? require("./ui/autocomplete").default : {}; +exports.Autocomplete = Autocomplete; +let Map = react_native_1.Platform.OS !== "web" ? require("./ui/map").default : {}; +exports.Map = Map; +__exportStar(require("./@types/types"), exports); +__exportStar(require("./@types/RadarNativeInterface"), exports); diff --git a/dist/src/index.native.d.ts b/dist/src/index.native.d.ts new file mode 100644 index 00000000..823b147e --- /dev/null +++ b/dist/src/index.native.d.ts @@ -0,0 +1,3 @@ +import { RadarNativeInterface } from "./@types/RadarNativeInterface"; +declare const Radar: RadarNativeInterface; +export default Radar; diff --git a/dist/src/index.native.js b/dist/src/index.native.js new file mode 100644 index 00000000..679cd5b5 --- /dev/null +++ b/dist/src/index.native.js @@ -0,0 +1,136 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +const react_native_1 = require("react-native"); +const package_json_1 = require("../package.json"); +if (!react_native_1.NativeModules.RNRadar && + (react_native_1.Platform.OS === "ios" || react_native_1.Platform.OS === "android")) { + throw new Error("NativeModules.RNRadar is undefined"); +} +const eventEmitter = new react_native_1.NativeEventEmitter(react_native_1.NativeModules.RNRadar); +const initialize = (publishableKey, fraud = false) => { + react_native_1.NativeModules.RNRadar.initialize(publishableKey, fraud); +}; +const setLogLevel = (level) => { + react_native_1.NativeModules.RNRadar.setLogLevel(level); +}; +const setUserId = (userId) => { + react_native_1.NativeModules.RNRadar.setUserId(userId); +}; +const getUserId = () => react_native_1.NativeModules.RNRadar.getUserId(); +const setDescription = (description) => { + react_native_1.NativeModules.RNRadar.setDescription(description); +}; +const getDescription = () => react_native_1.NativeModules.RNRadar.getDescription(); +const setMetadata = (metadata) => { + react_native_1.NativeModules.RNRadar.setMetadata(metadata); +}; +const getMetadata = () => react_native_1.NativeModules.RNRadar.getMetadata(); +const setAnonymousTrackingEnabled = (enabled) => react_native_1.NativeModules.RNRadar.setAnonymousTrackingEnabled(enabled); +const getPermissionsStatus = () => react_native_1.NativeModules.RNRadar.getPermissionsStatus(); +const requestPermissions = (background) => react_native_1.NativeModules.RNRadar.requestPermissions(background); +const getLocation = (desiredAccuracy) => react_native_1.NativeModules.RNRadar.getLocation(desiredAccuracy); +const trackOnce = (options) => { + let backCompatibleOptions = options; + if (options && "latitude" in options) { + backCompatibleOptions = { + location: Object.assign({}, options), + }; + } + return react_native_1.NativeModules.RNRadar.trackOnce(backCompatibleOptions); +}; +const trackVerified = (options) => react_native_1.NativeModules.RNRadar.trackVerified(options); +const getVerifiedLocationToken = () => react_native_1.NativeModules.RNRadar.getVerifiedLocationToken(); +const startTrackingEfficient = () => react_native_1.NativeModules.RNRadar.startTrackingEfficient(); +const startTrackingResponsive = () => react_native_1.NativeModules.RNRadar.startTrackingResponsive(); +const startTrackingContinuous = () => react_native_1.NativeModules.RNRadar.startTrackingContinuous(); +const startTrackingCustom = (options) => react_native_1.NativeModules.RNRadar.startTrackingCustom(options); +const startTrackingVerified = (options) => react_native_1.NativeModules.RNRadar.startTrackingVerified(options); +const mockTracking = (options) => react_native_1.NativeModules.RNRadar.mockTracking(options); +const stopTracking = () => react_native_1.NativeModules.RNRadar.stopTracking(); +const getTrackingOptions = () => react_native_1.NativeModules.RNRadar.getTrackingOptions(); +const isUsingRemoteTrackingOptions = () => react_native_1.NativeModules.RNRadar.isUsingRemoteTrackingOptions(); +const isTracking = () => react_native_1.NativeModules.RNRadar.isTracking(); +const setForegroundServiceOptions = (options) => react_native_1.NativeModules.RNRadar.setForegroundServiceOptions(options); +const setNotificationOptions = (options) => react_native_1.NativeModules.RNRadar.setNotificationOptions(options); +const getTripOptions = () => react_native_1.NativeModules.RNRadar.getTripOptions(); +const startTrip = (options) => react_native_1.NativeModules.RNRadar.startTrip(options); +const completeTrip = () => react_native_1.NativeModules.RNRadar.completeTrip(); +const cancelTrip = () => react_native_1.NativeModules.RNRadar.cancelTrip(); +const updateTrip = (options) => react_native_1.NativeModules.RNRadar.updateTrip(options); +const acceptEvent = (eventId, verifiedPlaceId) => react_native_1.NativeModules.RNRadar.acceptEvent(eventId, verifiedPlaceId); +const rejectEvent = (eventId) => react_native_1.NativeModules.RNRadar.rejectEvent(eventId); +const getContext = (location) => react_native_1.NativeModules.RNRadar.getContext(location); +const searchPlaces = (options) => react_native_1.NativeModules.RNRadar.searchPlaces(options); +const searchGeofences = (options) => react_native_1.NativeModules.RNRadar.searchGeofences(options); +const autocomplete = (options) => react_native_1.NativeModules.RNRadar.autocomplete(options); +const geocode = (options) => react_native_1.NativeModules.RNRadar.geocode(options); +const reverseGeocode = (options) => react_native_1.NativeModules.RNRadar.reverseGeocode(options); +const ipGeocode = () => react_native_1.NativeModules.RNRadar.ipGeocode(); +const getDistance = (options) => react_native_1.NativeModules.RNRadar.getDistance(options); +const getMatrix = (options) => react_native_1.NativeModules.RNRadar.getMatrix(options); +const logConversion = (options) => react_native_1.NativeModules.RNRadar.logConversion(options); +const sendEvent = (name, metadata) => react_native_1.NativeModules.RNRadar.sendEvent(name, metadata); +const on = (channel, callback) => eventEmitter.addListener(channel, callback); +const off = (channel, callback) => { + if (callback) { + // @ts-ignore + eventEmitter.removeListener(channel, callback); + } + else { + eventEmitter.removeAllListeners(channel); + } +}; +const nativeSdkVersion = () => react_native_1.NativeModules.RNRadar.nativeSdkVersion(); +const rnSdkVersion = () => package_json_1.version; +const Radar = { + initialize, + setLogLevel, + setUserId, + getUserId, + setDescription, + getDescription, + setMetadata, + getMetadata, + setAnonymousTrackingEnabled, + isUsingRemoteTrackingOptions, + getPermissionsStatus, + requestPermissions, + getLocation, + trackOnce, + trackVerified, + getVerifiedLocationToken, + startTrackingEfficient, + startTrackingResponsive, + startTrackingContinuous, + startTrackingCustom, + startTrackingVerified, + mockTracking, + stopTracking, + isTracking, + getTrackingOptions, + setForegroundServiceOptions, + setNotificationOptions, + acceptEvent, + rejectEvent, + getTripOptions, + startTrip, + updateTrip, + completeTrip, + cancelTrip, + getContext, + searchPlaces, + searchGeofences, + autocomplete, + geocode, + reverseGeocode, + ipGeocode, + getDistance, + getMatrix, + logConversion, + sendEvent, + on, + off, + nativeSdkVersion, + rnSdkVersion, +}; +exports.default = Radar; diff --git a/dist/src/index.web.d.ts b/dist/src/index.web.d.ts new file mode 100644 index 00000000..0b40795a --- /dev/null +++ b/dist/src/index.web.d.ts @@ -0,0 +1,73 @@ +export default Radar; +declare namespace Radar { + export { initialize }; + export { setLogLevel }; + export { setUserId }; + export { setDescription }; + export { setMetadata }; + export { getPermissionsStatus }; + export { requestPermissions }; + export { getLocation }; + export { trackOnce }; + export { trackVerified }; + export { trackVerifiedToken }; + export { startTrackingEfficient }; + export { startTrackingResponsive }; + export { startTrackingContinuous }; + export { startTrackingCustom }; + export { mockTracking }; + export { stopTracking }; + export { setForegroundServiceOptions }; + export { acceptEvent }; + export { rejectEvent }; + export { startTrip }; + export { updateTrip }; + export { completeTrip }; + export { cancelTrip }; + export { getContext }; + export { searchPlaces }; + export { searchGeofences }; + export { autocomplete }; + export { geocode }; + export { reverseGeocode }; + export { ipGeocode }; + export { getDistance }; + export { getMatrix }; + export { on }; + export { off }; +} +declare function initialize(publishableKey: any): void; +declare function setLogLevel(level: any): void; +declare function setUserId(userId: any): void; +declare function setDescription(description: any): void; +declare function setMetadata(metadata: any): void; +declare function getPermissionsStatus(): Promise; +declare function requestPermissions(background: any): void; +declare function getLocation(): Promise; +declare function trackOnce(options: any): Promise; +declare function trackVerified(): void; +declare function trackVerifiedToken(): void; +declare function startTrackingEfficient(): void; +declare function startTrackingResponsive(): void; +declare function startTrackingContinuous(): void; +declare function startTrackingCustom(options: any): void; +declare function mockTracking(options: any): void; +declare function stopTracking(): void; +declare function setForegroundServiceOptions(options: any): void; +declare function acceptEvent(eventId: any, verifiedPlaceId: any): void; +declare function rejectEvent(eventId: any): void; +declare function startTrip(options: any): Promise; +declare function updateTrip(tripOptions: any): Promise; +declare function completeTrip(): Promise; +declare function cancelTrip(): Promise; +declare function getContext(options: any): Promise; +declare function searchPlaces(options: any): Promise; +declare function searchGeofences(options: any): Promise; +declare function autocomplete(options: any): Promise; +declare function geocode(options: any): Promise; +declare function reverseGeocode(options: any): Promise; +declare function ipGeocode(): Promise; +declare function getDistance(options: any): Promise; +declare function getMatrix(options: any): Promise; +declare function on(event: any, callback: any): void; +declare function off(event: any, callback: any): void; diff --git a/dist/src/index.web.js b/dist/src/index.web.js new file mode 100644 index 00000000..50333ddd --- /dev/null +++ b/dist/src/index.web.js @@ -0,0 +1,385 @@ +"use strict"; +var __importDefault = (this && this.__importDefault) || function (mod) { + return (mod && mod.__esModule) ? mod : { "default": mod }; +}; +Object.defineProperty(exports, "__esModule", { value: true }); +const radar_sdk_js_1 = __importDefault(require("radar-sdk-js")); +const initialize = (publishableKey) => { + radar_sdk_js_1.default.initialize(publishableKey); +}; +const setLogLevel = (level) => { + // not implemented +}; +const setUserId = (userId) => { + radar_sdk_js_1.default.setUserId(userId); +}; +const setDeviceId = (deviceId, installId) => { + radar_sdk_js_1.default.setDeviceId(deviceId, installId); +}; +const setDeviceType = (deviceType) => { + radar_sdk_js_1.default.setDeviceType(deviceType); +}; +const setRequestHeaders = (headers) => { + radar_sdk_js_1.default.setRequestHeaders(headers); +}; +const setDescription = (description) => { + radar_sdk_js_1.default.setDescription(description); +}; +const setMetadata = (metadata) => { + radar_sdk_js_1.default.setMetadata(metadata); +}; +const getPermissionsStatus = () => { + return new Promise(resolve => { + const navigator = window.navigator; + if (!navigator.permissions) { + resolve({ + status: 'UNKNOWN' + }); + } + else { + navigator.permissions.query({ name: 'geolocation' }).then((result) => { + resolve({ + status: result.state === 'granted' ? 'GRANTED_FOREGROUND' : 'DENIED', + }); + }); + } + }); +}; +const requestPermissions = background => { + // not implemented +}; +const getLocation = () => { + return new Promise((resolve, reject) => { + radar_sdk_js_1.default.getLocation((err, result) => { + if (err) + reject(err); + else + resolve(result); + }); + }); +}; +const trackOnce = options => { + return new Promise((resolve, reject) => { + const callback = (err, { status, location, user, events }) => { + if (err) { + reject(err); + } + else { + resolve({ + status, + location, + user, + events, + }); + } + }; + if (options) { + radar_sdk_js_1.default.trackOnce(options.location ? options.location : options, callback); + } + else { + radar_sdk_js_1.default.trackOnce(callback); + } + }); +}; +const trackVerified = () => { + // not implemented +}; +const trackVerifiedToken = () => { + // not implemented +}; +const startTrackingEfficient = () => { + // not implemented +}; +const startTrackingResponsive = () => { + // not implemented +}; +const startTrackingContinuous = () => { + // not implemented +}; +const startTrackingCustom = options => { + // not implemented +}; +const mockTracking = options => { + // not implemented +}; +const stopTracking = () => { + // not implemented +}; +const setForegroundServiceOptions = options => { + // not implemented +}; +const startTrip = options => { + return new Promise((resolve, reject) => { + const callback = (err, { trip, events, status }) => { + if (err) { + reject(err); + } + else { + resolve({ + trip, + events, + status + }); + } + }; + radar_sdk_js_1.default.startTrip(options, callback); + }); +}; +const completeTrip = () => { + return new Promise((resolve, reject) => { + const callback = (err, { trip, events, status }) => { + if (err) { + reject(err); + } + else { + resolve({ + trip, + events, + status + }); + } + }; + radar_sdk_js_1.default.completeTrip(callback); + }); +}; +const cancelTrip = () => { + return new Promise((resolve, reject) => { + const callback = (err, { trip, events, status }) => { + if (err) { + reject(err); + } + else { + resolve({ + trip, + events, + status + }); + } + }; + radar_sdk_js_1.default.cancelTrip(callback); + }); +}; +const updateTrip = (tripOptions) => { + return new Promise((resolve, reject) => { + const callback = (err, { trip, events, status }) => { + if (err) { + reject(err); + } + else { + resolve({ + trip, + events, + status + }); + } + }; + radar_sdk_js_1.default.updateTrip(tripOptions.options, tripOptions.status, callback); + }); +}; +const acceptEvent = (eventId, verifiedPlaceId) => { + // not implemented +}; +const rejectEvent = eventId => { + // not implemented +}; +const getContext = options => { + return new Promise((resolve, reject) => { + const callback = (err, { status, location, context }) => { + if (err) { + reject(err); + } + else { + resolve({ + status, + location, + context, + }); + } + }; + if (options) { + radar_sdk_js_1.default.getContext(options, callback); + } + else { + radar_sdk_js_1.default.getContext(callback); + } + }); +}; +const searchPlaces = options => { + return new Promise((resolve, reject) => { + radar_sdk_js_1.default.searchPlaces(options, (err, { status, location, places }) => { + if (err) { + reject(err); + } + else { + resolve({ + status, + location, + places, + }); + } + }); + }); +}; +const searchGeofences = options => { + return new Promise((resolve, reject) => { + radar_sdk_js_1.default.searchGeofences(options, (err, { status, location, geofences }) => { + if (err) { + reject(err); + } + else { + resolve({ + status, + location, + geofences, + }); + } + }); + }); +}; +const autocomplete = options => { + return new Promise((resolve, reject) => { + radar_sdk_js_1.default.autocomplete(options, (err, { status, addresses }) => { + if (err) { + reject(err); + } + else { + resolve({ + status, + addresses, + }); + } + }); + }); +}; +const geocode = options => { + return new Promise((resolve, reject) => { + let newOptions = options; + if (typeof options === 'string') + newOptions = { + query: options + }; + radar_sdk_js_1.default.geocode(newOptions, (err, { status, addresses }) => { + if (err) { + reject(err); + } + else { + resolve({ + status, + addresses, + }); + } + }); + }); +}; +const reverseGeocode = options => { + return new Promise((resolve, reject) => { + const callback = (err, { status, addresses }) => { + if (err) { + reject(err); + } + else { + resolve({ + status, + addresses, + }); + } + }; + if (options) { + radar_sdk_js_1.default.reverseGeocode(options, callback); + } + else { + radar_sdk_js_1.default.reverseGeocode(callback); + } + }); +}; +const ipGeocode = () => { + return new Promise((resolve, reject) => { + radar_sdk_js_1.default.ipGeocode((err, { status, address }) => { + if (err) { + reject(err); + } + else { + resolve({ + status, + address, + }); + } + }); + }); +}; +const getDistance = options => { + return new Promise((resolve, reject) => { + radar_sdk_js_1.default.getDistance(options, (err, { status, routes }) => { + if (err) { + reject(err); + } + else { + resolve({ + status, + routes, + }); + } + }); + }); +}; +const getMatrix = options => { + return new Promise((resolve, reject) => { + radar_sdk_js_1.default.getMatrix(options, (err, { origins, destinations, matrix, status }) => { + if (err) { + reject(err); + } + else { + resolve({ + origins, + destinations, + matrix, + status, + }); + } + }); + }); +}; +const on = (event, callback) => { + // not implemented +}; +const off = (event, callback) => { + // not implemented +}; +const Radar = { + initialize, + setLogLevel, + setUserId, + setDescription, + setMetadata, + getPermissionsStatus, + requestPermissions, + getLocation, + trackOnce, + trackVerified, + trackVerifiedToken, + startTrackingEfficient, + startTrackingResponsive, + startTrackingContinuous, + startTrackingCustom, + mockTracking, + stopTracking, + setForegroundServiceOptions, + acceptEvent, + rejectEvent, + startTrip, + updateTrip, + completeTrip, + cancelTrip, + getContext, + searchPlaces, + searchGeofences, + autocomplete, + geocode, + reverseGeocode, + ipGeocode, + getDistance, + getMatrix, + on, + off, +}; +exports.default = Radar; diff --git a/dist/src/ui/autocomplete.d.ts b/dist/src/ui/autocomplete.d.ts new file mode 100644 index 00000000..5481ca2e --- /dev/null +++ b/dist/src/ui/autocomplete.d.ts @@ -0,0 +1,4 @@ +export default autocompleteUI; +declare function autocompleteUI({ options }: { + options?: {} | undefined; +}): any; diff --git a/dist/src/ui/autocomplete.js b/dist/src/ui/autocomplete.js new file mode 100644 index 00000000..cbb4f25d --- /dev/null +++ b/dist/src/ui/autocomplete.js @@ -0,0 +1,206 @@ +"use strict"; +var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { return m[k]; } }; + } + Object.defineProperty(o, k2, desc); +}) : (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + o[k2] = m[k]; +})); +var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); +}) : function(o, v) { + o["default"] = v; +}); +var __importStar = (this && this.__importStar) || function (mod) { + if (mod && mod.__esModule) return mod; + var result = {}; + if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k); + __setModuleDefault(result, mod); + return result; +}; +var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) { + function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); } + return new (P || (P = Promise))(function (resolve, reject) { + function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } + function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } + function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); } + step((generator = generator.apply(thisArg, _arguments || [])).next()); + }); +}; +var __importDefault = (this && this.__importDefault) || function (mod) { + return (mod && mod.__esModule) ? mod : { "default": mod }; +}; +Object.defineProperty(exports, "__esModule", { value: true }); +// Autocomplete.js +const react_1 = __importStar(require("react")); +const react_native_1 = require("react-native"); +const index_native_1 = __importDefault(require("../index.native")); +const images_1 = require("./images"); +const styles_1 = __importDefault(require("./styles")); +const defaultAutocompleteOptions = { + debounceMS: 200, // Debounce time in milliseconds + minCharacters: 3, // Minimum number of characters to trigger autocomplete + limit: 8, // Maximum number of results to return + placeholder: "Search address", // Placeholder text for the input field + showMarkers: true, + disabled: false, +}; +const autocompleteUI = ({ options = {} }) => { + const [query, setQuery] = (0, react_1.useState)(""); + const [results, setResults] = (0, react_1.useState)([]); + const [isOpen, setIsOpen] = (0, react_1.useState)(false); + const animationValue = (0, react_1.useRef)(new react_native_1.Animated.Value(0)).current; // animation value + const timerRef = (0, react_1.useRef)(null); + const textInputRef = (0, react_1.useRef)(null); + const config = Object.assign(Object.assign({}, defaultAutocompleteOptions), options); + const style = config.style || {}; + const fetchResults = (0, react_1.useCallback)((searchQuery) => __awaiter(void 0, void 0, void 0, function* () { + if (searchQuery.length < config.minCharacters) + return; + const { limit, layers, countryCode } = config; + const params = { query: searchQuery, limit, layers, countryCode }; + if (config.near && config.near.latitude && config.near.longitude) { + params.near = config.near; + } + try { + const result = yield index_native_1.default.autocomplete(params); + if (config.onResults && typeof config.onResults === "function") { + config.onResults(result.addresses); + } + setResults(result.addresses); + setIsOpen(true); + } + catch (error) { + if (config.onError && typeof config.onError === "function") { + config.onError(error); + } + } + }), [config]); + const handleInput = (0, react_1.useCallback)((text) => { + setQuery(text); + // Clear the existing timer + if (timerRef.current) { + clearTimeout(timerRef.current); + } + if (text.length < config.minCharacters) { + return; + } + // Set the new timer + timerRef.current = setTimeout(() => { + fetchResults(text); + }, config.debounceMS); + }, [config, fetchResults]); + const handleSelect = (item) => { + setQuery(item.formattedAddress); + setIsOpen(false); + if (typeof config.onSelection === "function") { + config.onSelection(item); + } + }; + const renderFooter = () => { + if (results.length === 0) + return null; + return ( + + Powered by + + + ); + }; + const renderItem = ({ item }) => { + var _a; + return ( [ + Object.assign(Object.assign({}, styles.resultItem), { backgroundColor: pressed + ? styles.resultItem.pressedBackgroundColor + : styles.resultItem.backgroundColor }), + ]} onPress={() => handleSelect(item)}> + + + {config.showMarkers ? () : null} + + + + {item.addressLabel || (item === null || item === void 0 ? void 0 : item.placeLabel)} + + {(item === null || item === void 0 ? void 0 : item.formattedAddress.length) > 0 && ( + {(_a = item === null || item === void 0 ? void 0 : item.formattedAddress) === null || _a === void 0 ? void 0 : _a.replace(`${(item === null || item === void 0 ? void 0 : item.addressLabel) || (item === null || item === void 0 ? void 0 : item.placeLabel)}, `, "")} + )} + + + ); + }; + const styles = Object.assign(Object.assign({}, styles_1.default), { container: react_native_1.StyleSheet.compose(styles_1.default.container, style.container), input: react_native_1.StyleSheet.compose(styles_1.default.input, style.input), inputContainer: react_native_1.StyleSheet.compose(styles_1.default.inputContainer, style.inputContainer), modalInputContainer: react_native_1.StyleSheet.compose(styles_1.default.modalInputContainer, style.modalInputContainer), resultList: react_native_1.StyleSheet.compose(styles_1.default.resultList, style.resultList), resultItem: react_native_1.StyleSheet.compose(Object.assign(Object.assign({}, styles_1.default.resultItem), { pressedBackgroundColor: '#F6FAFC' }), style.resultItem), addressContainer: react_native_1.StyleSheet.compose(styles_1.default.addressContainer, style.addressContainer), pinIconContainer: react_native_1.StyleSheet.compose(styles_1.default.pinIconContainer, style.pinIconContainer), pinIcon: react_native_1.StyleSheet.compose(styles_1.default.pinIcon, style.pinIcon), addressTextContainer: react_native_1.StyleSheet.compose(styles_1.default.addressTextContainer, style.addressTextContainer), addressText: react_native_1.StyleSheet.compose(styles_1.default.addressText, style.addressText), addressSubtext: react_native_1.StyleSheet.compose(styles_1.default.addressSubtext, style.addressSubtext), footerContainer: react_native_1.StyleSheet.compose(styles_1.default.footerContainer, style.footerContainer), footerText: react_native_1.StyleSheet.compose(styles_1.default.footerText, style.footerText) }); + (0, react_1.useEffect)(() => { + react_native_1.Animated.timing(animationValue, { + toValue: isOpen ? 1 : 0, + duration: 300, + easing: react_native_1.Easing.inOut(react_native_1.Easing.ease), + useNativeDriver: false, + }).start(); + }, [isOpen]); + const screenHeight = react_native_1.Dimensions.get("window").height; + const inputHeight = animationValue.interpolate({ + inputRange: [0, 1], + outputRange: [40, screenHeight], + }); + const modalOpacity = animationValue.interpolate({ + inputRange: [0, 0.5, 1], + outputRange: [0, 0, 1], + }); + return ( + + { + if (config.disabled) + return; + setIsOpen(true); + // Set the focus on the other textinput after it opens + setTimeout(() => { + textInputRef.current.focus(); + }, 100); + }}> + + { + setIsOpen(true); + setTimeout(() => { + textInputRef.current.focus(); + }, 100); + }} value={query} returnKeyType="done" placeholder={config.placeholder} placeholderTextColor="#acbdc8"/> + + + setIsOpen(false)}> + + + + + { + setIsOpen(false); + }}> + + + { + setIsOpen(false); + }} placeholderTextColor="#acbdc8"/> + { + setQuery(""); + }}> + + + + {results.length > 0 && ( + { + textInputRef.current.blur(); + react_native_1.Keyboard.dismiss(); + }} keyboardShouldPersistTaps="handled" renderItem={renderItem} keyExtractor={(item) => item.formattedAddress + item.postalCode}/> + {renderFooter()} + )} + + + + + ); +}; +exports.default = autocompleteUI; diff --git a/dist/src/ui/back.png b/dist/src/ui/back.png new file mode 100644 index 00000000..71016aec Binary files /dev/null and b/dist/src/ui/back.png differ diff --git a/dist/src/ui/close.png b/dist/src/ui/close.png new file mode 100644 index 00000000..a996c8dc Binary files /dev/null and b/dist/src/ui/close.png differ diff --git a/dist/src/ui/images.d.ts b/dist/src/ui/images.d.ts new file mode 100644 index 00000000..fbc52b94 --- /dev/null +++ b/dist/src/ui/images.d.ts @@ -0,0 +1,5 @@ +export const BACK_ICON: any; +export const SEARCH_ICON: any; +export const RADAR_LOGO: any; +export const MARKER_ICON: any; +export const CLOSE_ICON: any; diff --git a/dist/src/ui/images.js b/dist/src/ui/images.js new file mode 100644 index 00000000..f4fe9718 --- /dev/null +++ b/dist/src/ui/images.js @@ -0,0 +1,8 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.CLOSE_ICON = exports.MARKER_ICON = exports.RADAR_LOGO = exports.SEARCH_ICON = exports.BACK_ICON = void 0; +exports.BACK_ICON = require('./back.png'); +exports.SEARCH_ICON = require('./search.png'); +exports.RADAR_LOGO = require('./radar-logo.png'); +exports.MARKER_ICON = require('./marker.png'); +exports.CLOSE_ICON = require('./close.png'); diff --git a/dist/src/ui/map-logo.png b/dist/src/ui/map-logo.png new file mode 100644 index 00000000..d5aca076 Binary files /dev/null and b/dist/src/ui/map-logo.png differ diff --git a/dist/src/ui/map.d.ts b/dist/src/ui/map.d.ts new file mode 100644 index 00000000..cf11a4fb --- /dev/null +++ b/dist/src/ui/map.d.ts @@ -0,0 +1,5 @@ +export default RadarMap; +declare function RadarMap({ mapOptions, children }: { + mapOptions: any; + children: any; +}): any; diff --git a/dist/src/ui/map.js b/dist/src/ui/map.js new file mode 100644 index 00000000..4a0a1e9c --- /dev/null +++ b/dist/src/ui/map.js @@ -0,0 +1,122 @@ +"use strict"; +var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { return m[k]; } }; + } + Object.defineProperty(o, k2, desc); +}) : (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + o[k2] = m[k]; +})); +var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); +}) : function(o, v) { + o["default"] = v; +}); +var __importStar = (this && this.__importStar) || function (mod) { + if (mod && mod.__esModule) return mod; + var result = {}; + if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k); + __setModuleDefault(result, mod); + return result; +}; +var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) { + function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); } + return new (P || (P = Promise))(function (resolve, reject) { + function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } + function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } + function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); } + step((generator = generator.apply(thisArg, _arguments || [])).next()); + }); +}; +var __importDefault = (this && this.__importDefault) || function (mod) { + return (mod && mod.__esModule) ? mod : { "default": mod }; +}; +Object.defineProperty(exports, "__esModule", { value: true }); +const react_1 = __importStar(require("react")); +const react_native_1 = require("react-native"); +const index_native_1 = __importDefault(require("../index.native")); +const helpers_1 = require("../helpers"); +const styles_1 = __importDefault(require("./styles")); +let MapLibreGL; +try { + MapLibreGL = require('@maplibre/maplibre-react-native'); +} +catch (e) { + MapLibreGL = null; +} +const DEFAULT_STYLE = 'radar-default-v1'; +const createStyleURL = (style = DEFAULT_STYLE) => __awaiter(void 0, void 0, void 0, function* () { + const host = yield (0, helpers_1.getHost)(); + const publishableKey = yield (0, helpers_1.getPublishableKey)(); + return `${host}/maps/styles/${style}?publishableKey=${publishableKey}`; +}); +const RadarMap = ({ mapOptions, children }) => { + const [styleURL, setStyleURL] = (0, react_1.useState)(null); + const [userLocation, setUserLocation] = (0, react_1.useState)(null); + (0, react_1.useEffect)(() => { + createStyleURL((mapOptions === null || mapOptions === void 0 ? void 0 : mapOptions.mapStyle) || DEFAULT_STYLE).then((result) => { + setStyleURL(result); + }); + }, [mapOptions]); + (0, react_1.useEffect)(() => { + index_native_1.default.getLocation().then((result) => { + var _a, _b; + if (((_a = result === null || result === void 0 ? void 0 : result.location) === null || _a === void 0 ? void 0 : _a.latitude) && ((_b = result === null || result === void 0 ? void 0 : result.location) === null || _b === void 0 ? void 0 : _b.longitude)) { + setUserLocation({ + latitude: result.location.latitude, + longitude: result.location.longitude, + }); + } + }).catch((err) => { + // eslint-disable-next-line no-console + console.warn(`Radar SDK: Failed to get location: ${err}`); + }); + }, [mapOptions]); + if (!styleURL) { + return null; + } + if (!MapLibreGL) { + return null; + } + const geoJSONUserLocation = { + type: 'FeatureCollection', + features: (userLocation === null || userLocation === void 0 ? void 0 : userLocation.longitude) !== undefined ? [ + { + type: 'Feature', + geometry: { + type: 'Point', + coordinates: [userLocation.longitude, userLocation.latitude], + }, + }, + ] : [], + }; + const userLocationMapIndicator = ( + + + + ); + return ( + + {userLocationMapIndicator} + {children} + + + ); +}; +exports.default = RadarMap; diff --git a/dist/src/ui/marker.png b/dist/src/ui/marker.png new file mode 100644 index 00000000..eaaa8894 Binary files /dev/null and b/dist/src/ui/marker.png differ diff --git a/dist/src/ui/radar-logo.png b/dist/src/ui/radar-logo.png new file mode 100644 index 00000000..ffe8f94e Binary files /dev/null and b/dist/src/ui/radar-logo.png differ diff --git a/dist/src/ui/search.png b/dist/src/ui/search.png new file mode 100644 index 00000000..5ff33393 Binary files /dev/null and b/dist/src/ui/search.png differ diff --git a/dist/src/ui/styles.d.ts b/dist/src/ui/styles.d.ts new file mode 100644 index 00000000..981f4b65 --- /dev/null +++ b/dist/src/ui/styles.d.ts @@ -0,0 +1,2 @@ +export default styles; +declare const styles: any; diff --git a/dist/src/ui/styles.js b/dist/src/ui/styles.js new file mode 100644 index 00000000..4f531b17 --- /dev/null +++ b/dist/src/ui/styles.js @@ -0,0 +1,125 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +const react_native_1 = require("react-native"); +const styles = react_native_1.StyleSheet.create({ + container: { + width: '100%', + height: '100%', + alignItems: 'center', + paddingTop: 8, + }, + inputContainer: { + flexDirection: 'row', + alignItems: 'center', + marginHorizontal: 16, + backgroundColor: 'white', + borderRadius: 5, + borderColor: '#DBE5EB', + borderWidth: 1, + width: '95%', // only difference between this and the modalInputContainer + }, + modalInputContainer: { + flexDirection: 'row', + alignItems: 'center', + marginHorizontal: 16, + backgroundColor: 'white', + borderRadius: 5, + borderColor: '#DBE5EB', + borderWidth: 1, + }, + inputIcon: { + marginLeft: 10, + height: 18, + width: 18, + backgroundColor: 'white', + }, + closeIcon: { + marginRight: 10, + height: 18, + width: 18, + backgroundColor: 'white', + }, + input: { + flex: 1, + backgroundColor: 'white', + height: 40, + fontSize: 14, + paddingHorizontal: 8, + borderRadius: 5, + }, + resultListWrapper: { + width: '100%', + marginBottom: 30, + backgroundColor: 'white', + borderRadius: 5, + paddingVertical: 8, + }, + resultList: { + width: '100%', + }, + resultItem: { + paddingRight: 16, + paddingVertical: 8, + paddingHorizontal: 16, + fontSize: 12, + backgroundColor: 'white', + }, + addressContainer: { + flexDirection: 'row', + alignItems: 'center', + }, + pinIconContainer: { + width: 28, + marginRight: 8, + }, + pinIcon: { + height: 26, + width: 26, + }, + addressTextContainer: { + flex: 1, + }, + addressText: { + fontSize: 14, + lineHeight: 24, + color: '#000', + fontWeight: '600', + }, + addressSubtext: { + fontSize: 14, + color: '#5A6872', + }, + footerContainer: { + flexDirection: 'row', + alignItems: 'center', + paddingVertical: 10, + marginRight: 16, + alignSelf: 'flex-end', + }, + footerText: { + marginTop: 2, + marginRight: 4, + fontSize: 10, + color: '#5A6872', + }, + logo: { + width: 50, + height: 15, + resizeMode: 'contain', + }, + mapContainer: { + flex: 1, + }, + map: { + flex: 1, + }, + mapLogo: { + position: 'absolute', + bottom: -10, + left: 5, + width: 50, + height: 50, + resizeMode: 'contain', + }, +}); +exports.default = styles; diff --git a/package-lock.json b/package-lock.json index 143525b4..cc2af63a 100644 --- a/package-lock.json +++ b/package-lock.json @@ -40,7 +40,7 @@ "typescript": "^5.3.3" }, "peerDependencies": { - "@maplibre/maplibre-react-native": "^9.0.1", + "@maplibre/maplibre-react-native": "^10.0.0-alpha.5", "react": ">= 16.8.6", "react-native": ">= 0.60.0" }, @@ -1876,353 +1876,6 @@ "resolved": "https://registry.npmjs.org/exec-sh/-/exec-sh-0.3.6.tgz", "integrity": "sha512-nQn+hI3yp+oD0huYhKwvYI32+JFeq+XkNcD1GAo3Y/MjxsfVGmrrzrnzjWiNY6f+pUCP440fThsFh5gZrRAU/w==" }, - "node_modules/@expo/config-plugins": { - "version": "4.1.5", - "resolved": "https://registry.npmjs.org/@expo/config-plugins/-/config-plugins-4.1.5.tgz", - "integrity": "sha512-RVvU40RtZt12HavuDAe+LDIq9lHj7sheOfMEHdmpJ/uTA8pgvkbc56XF6JHQD+yRr6+uhhb+JnAasGq49dsQbw==", - "optional": true, - "peer": true, - "dependencies": { - "@expo/config-types": "^45.0.0", - "@expo/json-file": "8.2.36", - "@expo/plist": "0.0.18", - "@expo/sdk-runtime-versions": "^1.0.0", - "@react-native/normalize-color": "^2.0.0", - "chalk": "^4.1.2", - "debug": "^4.3.1", - "find-up": "~5.0.0", - "getenv": "^1.0.0", - "glob": "7.1.6", - "resolve-from": "^5.0.0", - "semver": "^7.3.5", - "slash": "^3.0.0", - "xcode": "^3.0.1", - "xml2js": "0.4.23" - } - }, - "node_modules/@expo/config-plugins/node_modules/ansi-styles": { - "version": "4.3.0", - "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz", - "integrity": "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==", - "optional": true, - "peer": true, - "dependencies": { - "color-convert": "^2.0.1" - }, - "engines": { - "node": ">=8" - }, - "funding": { - "url": "https://github.com/chalk/ansi-styles?sponsor=1" - } - }, - "node_modules/@expo/config-plugins/node_modules/chalk": { - "version": "4.1.2", - "resolved": "https://registry.npmjs.org/chalk/-/chalk-4.1.2.tgz", - "integrity": "sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA==", - "optional": true, - "peer": true, - "dependencies": { - "ansi-styles": "^4.1.0", - "supports-color": "^7.1.0" - }, - "engines": { - "node": ">=10" - }, - "funding": { - "url": "https://github.com/chalk/chalk?sponsor=1" - } - }, - "node_modules/@expo/config-plugins/node_modules/color-convert": { - "version": "2.0.1", - "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-2.0.1.tgz", - "integrity": "sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==", - "optional": true, - "peer": true, - "dependencies": { - "color-name": "~1.1.4" - }, - "engines": { - "node": ">=7.0.0" - } - }, - "node_modules/@expo/config-plugins/node_modules/color-name": { - "version": "1.1.4", - "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.4.tgz", - "integrity": "sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==", - "optional": true, - "peer": true - }, - "node_modules/@expo/config-plugins/node_modules/find-up": { - "version": "5.0.0", - "resolved": "https://registry.npmjs.org/find-up/-/find-up-5.0.0.tgz", - "integrity": "sha512-78/PXT1wlLLDgTzDs7sjq9hzz0vXD+zn+7wypEe4fXQxCmdmqfGsEPQxmiCSQI3ajFV91bVSsvNtrJRiW6nGng==", - "optional": true, - "peer": true, - "dependencies": { - "locate-path": "^6.0.0", - "path-exists": "^4.0.0" - }, - "engines": { - "node": ">=10" - }, - "funding": { - "url": "https://github.com/sponsors/sindresorhus" - } - }, - "node_modules/@expo/config-plugins/node_modules/glob": { - "version": "7.1.6", - "resolved": "https://registry.npmjs.org/glob/-/glob-7.1.6.tgz", - "integrity": "sha512-LwaxwyZ72Lk7vZINtNNrywX0ZuLyStrdDtabefZKAY5ZGJhVtgdznluResxNmPitE0SAO+O26sWTHeKSI2wMBA==", - "optional": true, - "peer": true, - "dependencies": { - "fs.realpath": "^1.0.0", - "inflight": "^1.0.4", - "inherits": "2", - "minimatch": "^3.0.4", - "once": "^1.3.0", - "path-is-absolute": "^1.0.0" - }, - "engines": { - "node": "*" - }, - "funding": { - "url": "https://github.com/sponsors/isaacs" - } - }, - "node_modules/@expo/config-plugins/node_modules/has-flag": { - "version": "4.0.0", - "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-4.0.0.tgz", - "integrity": "sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==", - "optional": true, - "peer": true, - "engines": { - "node": ">=8" - } - }, - "node_modules/@expo/config-plugins/node_modules/locate-path": { - "version": "6.0.0", - "resolved": "https://registry.npmjs.org/locate-path/-/locate-path-6.0.0.tgz", - "integrity": "sha512-iPZK6eYjbxRu3uB4/WZ3EsEIMJFMqAoopl3R+zuq0UjcAm/MO6KCweDgPfP3elTztoKP3KtnVHxTn2NHBSDVUw==", - "optional": true, - "peer": true, - "dependencies": { - "p-locate": "^5.0.0" - }, - "engines": { - "node": ">=10" - }, - "funding": { - "url": "https://github.com/sponsors/sindresorhus" - } - }, - "node_modules/@expo/config-plugins/node_modules/lru-cache": { - "version": "6.0.0", - "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-6.0.0.tgz", - "integrity": "sha512-Jo6dJ04CmSjuznwJSS3pUeWmd/H0ffTlkXXgwZi+eq1UCmqQwCh+eLsYOYCwY991i2Fah4h1BEMCx4qThGbsiA==", - "optional": true, - "peer": true, - "dependencies": { - "yallist": "^4.0.0" - }, - "engines": { - "node": ">=10" - } - }, - "node_modules/@expo/config-plugins/node_modules/p-limit": { - "version": "3.1.0", - "resolved": "https://registry.npmjs.org/p-limit/-/p-limit-3.1.0.tgz", - "integrity": "sha512-TYOanM3wGwNGsZN2cVTYPArw454xnXj5qmWF1bEoAc4+cU/ol7GVh7odevjp1FNHduHc3KZMcFduxU5Xc6uJRQ==", - "optional": true, - "peer": true, - "dependencies": { - "yocto-queue": "^0.1.0" - }, - "engines": { - "node": ">=10" - }, - "funding": { - "url": "https://github.com/sponsors/sindresorhus" - } - }, - "node_modules/@expo/config-plugins/node_modules/p-locate": { - "version": "5.0.0", - "resolved": "https://registry.npmjs.org/p-locate/-/p-locate-5.0.0.tgz", - "integrity": "sha512-LaNjtRWUBY++zB5nE/NwcaoMylSPk+S+ZHNB1TzdbMJMny6dynpAGt7X/tl/QYq3TIeE6nxHppbo2LGymrG5Pw==", - "optional": true, - "peer": true, - "dependencies": { - "p-limit": "^3.0.2" - }, - "engines": { - "node": ">=10" - }, - "funding": { - "url": "https://github.com/sponsors/sindresorhus" - } - }, - "node_modules/@expo/config-plugins/node_modules/path-exists": { - "version": "4.0.0", - "resolved": "https://registry.npmjs.org/path-exists/-/path-exists-4.0.0.tgz", - "integrity": "sha512-ak9Qy5Q7jYb2Wwcey5Fpvg2KoAc/ZIhLSLOSBmRmygPsGwkVVt0fZa0qrtMz+m6tJTAHfZQ8FnmB4MG4LWy7/w==", - "optional": true, - "peer": true, - "engines": { - "node": ">=8" - } - }, - "node_modules/@expo/config-plugins/node_modules/resolve-from": { - "version": "5.0.0", - "resolved": "https://registry.npmjs.org/resolve-from/-/resolve-from-5.0.0.tgz", - "integrity": "sha512-qYg9KP24dD5qka9J47d0aVky0N+b4fTU89LN9iDnjB5waksiC49rvMB0PrUJQGoTmH50XPiqOvAjDfaijGxYZw==", - "optional": true, - "peer": true, - "engines": { - "node": ">=8" - } - }, - "node_modules/@expo/config-plugins/node_modules/semver": { - "version": "7.5.3", - "resolved": "https://registry.npmjs.org/semver/-/semver-7.5.3.tgz", - "integrity": "sha512-QBlUtyVk/5EeHbi7X0fw6liDZc7BBmEaSYn01fMU1OUYbf6GPsbTtd8WmnqbI20SeycoHSeiybkE/q1Q+qlThQ==", - "optional": true, - "peer": true, - "dependencies": { - "lru-cache": "^6.0.0" - }, - "bin": { - "semver": "bin/semver.js" - }, - "engines": { - "node": ">=10" - } - }, - "node_modules/@expo/config-plugins/node_modules/slash": { - "version": "3.0.0", - "resolved": "https://registry.npmjs.org/slash/-/slash-3.0.0.tgz", - "integrity": "sha512-g9Q1haeby36OSStwb4ntCGGGaKsaVSjQ68fBxoQcutl5fS1vuY18H3wSt3jFyFtrkx+Kz0V1G85A4MyAdDMi2Q==", - "optional": true, - "peer": true, - "engines": { - "node": ">=8" - } - }, - "node_modules/@expo/config-plugins/node_modules/supports-color": { - "version": "7.2.0", - "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-7.2.0.tgz", - "integrity": "sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==", - "optional": true, - "peer": true, - "dependencies": { - "has-flag": "^4.0.0" - }, - "engines": { - "node": ">=8" - } - }, - "node_modules/@expo/config-plugins/node_modules/uuid": { - "version": "7.0.3", - "resolved": "https://registry.npmjs.org/uuid/-/uuid-7.0.3.tgz", - "integrity": "sha512-DPSke0pXhTZgoF/d+WSt2QaKMCFSfx7QegxEWT+JOuHF5aWrKEn0G+ztjuJg/gG8/ItK+rbPCD/yNv8yyih6Cg==", - "optional": true, - "peer": true, - "bin": { - "uuid": "dist/bin/uuid" - } - }, - "node_modules/@expo/config-plugins/node_modules/xcode": { - "version": "3.0.1", - "resolved": "https://registry.npmjs.org/xcode/-/xcode-3.0.1.tgz", - "integrity": "sha512-kCz5k7J7XbJtjABOvkc5lJmkiDh8VhjVCGNiqdKCscmVpdVUpEAyXv1xmCLkQJ5dsHqx3IPO4XW+NTDhU/fatA==", - "optional": true, - "peer": true, - "dependencies": { - "simple-plist": "^1.1.0", - "uuid": "^7.0.3" - }, - "engines": { - "node": ">=10.0.0" - } - }, - "node_modules/@expo/config-plugins/node_modules/yallist": { - "version": "4.0.0", - "resolved": "https://registry.npmjs.org/yallist/-/yallist-4.0.0.tgz", - "integrity": "sha512-3wdGidZyq5PB084XLES5TpOSRA3wjXAlIWMhum2kRcv/41Sn2emQ0dycQW4uZXLejwKvg6EsvbdlVL+FYEct7A==", - "optional": true, - "peer": true - }, - "node_modules/@expo/config-types": { - "version": "45.0.0", - "resolved": "https://registry.npmjs.org/@expo/config-types/-/config-types-45.0.0.tgz", - "integrity": "sha512-/QGhhLWyaGautgEyU50UJr5YqKJix5t77ePTwreOVAhmZH+ff3nrrtYTTnccx+qF08ZNQmfAyYMCD3rQfzpiJA==", - "optional": true, - "peer": true - }, - "node_modules/@expo/json-file": { - "version": "8.2.36", - "resolved": "https://registry.npmjs.org/@expo/json-file/-/json-file-8.2.36.tgz", - "integrity": "sha512-tOZfTiIFA5KmMpdW9KF7bc6CFiGjb0xnbieJhTGlHrLL+ps2G0OkqmuZ3pFEXBOMnJYUVpnSy++52LFxvpa5ZQ==", - "optional": true, - "peer": true, - "dependencies": { - "@babel/code-frame": "~7.10.4", - "json5": "^1.0.1", - "write-file-atomic": "^2.3.0" - } - }, - "node_modules/@expo/json-file/node_modules/@babel/code-frame": { - "version": "7.10.4", - "resolved": "https://registry.npmjs.org/@babel/code-frame/-/code-frame-7.10.4.tgz", - "integrity": "sha512-vG6SvB6oYEhvgisZNFRmRCUkLz11c7rp+tbNTynGqc6mS1d5ATd/sGyV6W0KZZnXRKMTzZDRgQT3Ou9jhpAfUg==", - "optional": true, - "peer": true, - "dependencies": { - "@babel/highlight": "^7.10.4" - } - }, - "node_modules/@expo/json-file/node_modules/json5": { - "version": "1.0.2", - "resolved": "https://registry.npmjs.org/json5/-/json5-1.0.2.tgz", - "integrity": "sha512-g1MWMLBiz8FKi1e4w0UyVL3w+iJceWAFBAaBnnGKOpNa5f8TLktkbre1+s6oICydWAm+HRUGTmI+//xv2hvXYA==", - "optional": true, - "peer": true, - "dependencies": { - "minimist": "^1.2.0" - }, - "bin": { - "json5": "lib/cli.js" - } - }, - "node_modules/@expo/plist": { - "version": "0.0.18", - "resolved": "https://registry.npmjs.org/@expo/plist/-/plist-0.0.18.tgz", - "integrity": "sha512-+48gRqUiz65R21CZ/IXa7RNBXgAI/uPSdvJqoN9x1hfL44DNbUoWHgHiEXTx7XelcATpDwNTz6sHLfy0iNqf+w==", - "optional": true, - "peer": true, - "dependencies": { - "@xmldom/xmldom": "~0.7.0", - "base64-js": "^1.2.3", - "xmlbuilder": "^14.0.0" - } - }, - "node_modules/@expo/plist/node_modules/xmlbuilder": { - "version": "14.0.0", - "resolved": "https://registry.npmjs.org/xmlbuilder/-/xmlbuilder-14.0.0.tgz", - "integrity": "sha512-ts+B2rSe4fIckR6iquDjsKbQFK2NlUk6iG5nf14mDEyldgoc2nEKZ3jZWMPTxGQwVgToSjt6VGIho1H8/fNFTg==", - "optional": true, - "peer": true, - "engines": { - "node": ">=8.0" - } - }, - "node_modules/@expo/sdk-runtime-versions": { - "version": "1.0.0", - "resolved": "https://registry.npmjs.org/@expo/sdk-runtime-versions/-/sdk-runtime-versions-1.0.0.tgz", - "integrity": "sha512-Doz2bfiPndXYFPMRwPyGa1k5QaKDVpY806UJj570epIiMzWaYyCtobasyfC++qfIXVb5Ocy7r3tP9d62hAQ7IQ==", - "optional": true, - "peer": true - }, "node_modules/@hapi/address": { "version": "2.1.4", "resolved": "https://registry.npmjs.org/@hapi/address/-/address-2.1.4.tgz", @@ -2763,38 +2416,41 @@ } }, "node_modules/@maplibre/maplibre-react-native": { - "version": "9.0.1", - "resolved": "https://registry.npmjs.org/@maplibre/maplibre-react-native/-/maplibre-react-native-9.0.1.tgz", - "integrity": "sha512-i9lgOCusD9KNAktDcGcNyqoytdu7BdvAovEJurunWuiT6JYFYwvTip78bCEPOTLo5eX9+OG6mOifr3Yz8NMB9w==", + "version": "10.0.0-alpha.5", + "resolved": "https://registry.npmjs.org/@maplibre/maplibre-react-native/-/maplibre-react-native-10.0.0-alpha.5.tgz", + "integrity": "sha512-xITqPYnBJxfyM3TpRVjLC+8iLYXrogeTdOqGXLbgK9HbpuW/lIERUez++oPzO/h17tkjFUQ3Rd4ZaXdjYjPxkA==", "optional": true, "peer": true, "dependencies": { - "@expo/config-plugins": "^4.0.3", "@mapbox/geo-viewport": ">= 0.4.0", "@turf/along": "6.5.0", "@turf/distance": "6.5.0", "@turf/helpers": "6.5.0", "@turf/length": "6.5.0", "@turf/nearest-point-on-line": "6.5.0", - "@types/geojson": "^7946.0.7", - "@types/node": "^18.11.18", - "debounce": "^1.2.0", - "deprecated-react-native-prop-types": "^2.3.0" + "@types/geojson": "^7946.0.10", + "@types/react-native": "0.67.8", + "debounce": "^2.0.0" }, "peerDependencies": { - "prop-types": "^15.8.1", + "@expo/config-plugins": ">=7", "react": ">=16.6.1", "react-native": ">=0.59.9" + }, + "peerDependenciesMeta": { + "@expo/config-plugins": { + "optional": true + } } }, - "node_modules/@maplibre/maplibre-react-native/node_modules/@types/node": { - "version": "18.19.10", - "resolved": "https://registry.npmjs.org/@types/node/-/node-18.19.10.tgz", - "integrity": "sha512-IZD8kAM02AW1HRDTPOlz3npFava678pr8Ie9Vp8uRhBROXAv8MXT2pCnGZZAKYdromsNQLHQcfWQ6EOatVLtqA==", + "node_modules/@maplibre/maplibre-react-native/node_modules/@types/react-native": { + "version": "0.67.8", + "resolved": "https://registry.npmjs.org/@types/react-native/-/react-native-0.67.8.tgz", + "integrity": "sha512-xA8rYiTHvO6RoZv/LFnmEeqRuhA2y34mGB8zX3bGHe/pCt9jEStUPyUO4q1KcDc9GiGIOBD8ArfRtThprAjSfQ==", "optional": true, "peer": true, "dependencies": { - "undici-types": "~5.26.4" + "@types/react": "*" } }, "node_modules/@react-native-community/cli-platform-android": { @@ -2953,13 +2609,6 @@ "react-native": ">=0.59" } }, - "node_modules/@react-native/normalize-color": { - "version": "2.1.0", - "resolved": "https://registry.npmjs.org/@react-native/normalize-color/-/normalize-color-2.1.0.tgz", - "integrity": "sha512-Z1jQI2NpdFJCVgpY+8Dq/Bt3d+YUi1928Q+/CZm/oh66fzM0RUl54vvuXlPJKybH4pdCZey1eDTPaLHkMPNgWA==", - "optional": true, - "peer": true - }, "node_modules/@turf/along": { "version": "6.5.0", "resolved": "https://registry.npmjs.org/@turf/along/-/along-6.5.0.tgz", @@ -3185,6 +2834,24 @@ "undici-types": "~5.26.4" } }, + "node_modules/@types/prop-types": { + "version": "15.7.12", + "resolved": "https://registry.npmjs.org/@types/prop-types/-/prop-types-15.7.12.tgz", + "integrity": "sha512-5zvhXYtRNRluoE/jAp4GVsSduVUzNWKkOZrCDBWYtE7biZywwdC2AcEzg+cSMLFRfVgeAFqpfNabiPjxFddV1Q==", + "optional": true, + "peer": true + }, + "node_modules/@types/react": { + "version": "18.3.3", + "resolved": "https://registry.npmjs.org/@types/react/-/react-18.3.3.tgz", + "integrity": "sha512-hti/R0pS0q1/xx+TsI73XIqk26eBsISZ2R0wUijXIngRK9R/e7Xw/cXVxQK7R5JjW+SV4zGcn5hXjudkN/pLIw==", + "optional": true, + "peer": true, + "dependencies": { + "@types/prop-types": "*", + "csstype": "^3.0.2" + } + }, "node_modules/@types/react-native": { "version": "0.73.0", "resolved": "https://registry.npmjs.org/@types/react-native/-/react-native-0.73.0.tgz", @@ -3235,16 +2902,6 @@ "semver": "bin/semver" } }, - "node_modules/@xmldom/xmldom": { - "version": "0.7.11", - "resolved": "https://registry.npmjs.org/@xmldom/xmldom/-/xmldom-0.7.11.tgz", - "integrity": "sha512-UDi3g6Jss/W5FnSzO9jCtQwEpfymt0M+sPPlmLhDH6h2TJ8j4ESE/LpmNPBij15J5NKkk4/cg/qoVMdWI3vnlQ==", - "optional": true, - "peer": true, - "engines": { - "node": ">=10.0.0" - } - }, "node_modules/abab": { "version": "2.0.6", "resolved": "https://registry.npmjs.org/abab/-/abab-2.0.6.tgz", @@ -5304,6 +4961,13 @@ "cssom": "0.3.x" } }, + "node_modules/csstype": { + "version": "3.1.3", + "resolved": "https://registry.npmjs.org/csstype/-/csstype-3.1.3.tgz", + "integrity": "sha512-M1uQkMl8rQK/szD0LNhtqxIPLpimGm8sOBwU7lLnCpSbTyY3yeU1Vc7l4KT5zT4s/yOxHH5O7tIuuLOCnLADRw==", + "optional": true, + "peer": true + }, "node_modules/damerau-levenshtein": { "version": "1.0.8", "resolved": "https://registry.npmjs.org/damerau-levenshtein/-/damerau-levenshtein-1.0.8.tgz", @@ -5350,11 +5014,17 @@ "integrity": "sha512-CAdX5Q3YW3Gclyo5Vpqkgpj8fSdLQcRuzfX6mC6Phy0nfJ0eGYOeS7m4mt2plDWLAtA4TqTakvbboHvUxfe4iA==" }, "node_modules/debounce": { - "version": "1.2.1", - "resolved": "https://registry.npmjs.org/debounce/-/debounce-1.2.1.tgz", - "integrity": "sha512-XRRe6Glud4rd/ZGQfiV1ruXSfbvfJedlV9Y6zOlP+2K04vBYiJEte6stfFkCP03aMnY5tsipamumUjL14fofug==", + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/debounce/-/debounce-2.1.0.tgz", + "integrity": "sha512-OkL3+0pPWCqoBc/nhO9u6TIQNTK44fnBnzuVtJAbp13Naxw9R6u21x+8tVTka87AhDZ3htqZ2pSSsZl9fqL2Wg==", "optional": true, - "peer": true + "peer": true, + "engines": { + "node": ">=18" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } }, "node_modules/debug": { "version": "4.3.4", @@ -5471,18 +5141,6 @@ "node": ">= 0.8" } }, - "node_modules/deprecated-react-native-prop-types": { - "version": "2.3.0", - "resolved": "https://registry.npmjs.org/deprecated-react-native-prop-types/-/deprecated-react-native-prop-types-2.3.0.tgz", - "integrity": "sha512-pWD0voFtNYxrVqvBMYf5gq3NA2GCpfodS1yNynTPc93AYA/KEMGeWDqqeUB6R2Z9ZofVhks2aeJXiuQqKNpesA==", - "optional": true, - "peer": true, - "dependencies": { - "@react-native/normalize-color": "*", - "invariant": "*", - "prop-types": "*" - } - }, "node_modules/destroy": { "version": "1.2.0", "resolved": "https://registry.npmjs.org/destroy/-/destroy-1.2.0.tgz", @@ -6866,16 +6524,6 @@ "node": ">=0.10.0" } }, - "node_modules/getenv": { - "version": "1.0.0", - "resolved": "https://registry.npmjs.org/getenv/-/getenv-1.0.0.tgz", - "integrity": "sha512-7yetJWqbS9sbn0vIfliPsFgoXMKn/YMF+Wuiog97x+urnSRRRZ7xB+uVkwGKzRgq9CDFfMQnE9ruL5DHv9c6Xg==", - "optional": true, - "peer": true, - "engines": { - "node": ">=6" - } - }, "node_modules/getpass": { "version": "0.1.7", "resolved": "https://registry.npmjs.org/getpass/-/getpass-0.1.7.tgz", @@ -15058,7 +14706,7 @@ "version": "5.26.5", "resolved": "https://registry.npmjs.org/undici-types/-/undici-types-5.26.5.tgz", "integrity": "sha512-JlCMO+ehdEIKqlFxk6IfVoAUVmgz7cU7zD/h9XZ0qzeosSHmUJVOzSQvvYSYWXkFXC+IfLKSIffhv0sVZup6pA==", - "devOptional": true + "dev": true }, "node_modules/unicode-canonical-property-names-ecmascript": { "version": "2.0.0", @@ -15501,7 +15149,7 @@ "version": "2.4.3", "resolved": "https://registry.npmjs.org/write-file-atomic/-/write-file-atomic-2.4.3.tgz", "integrity": "sha512-GaETH5wwsX+GcnzhPgKcKjJ6M2Cq3/iZp1WyY/X1CSqrW+jVNM9Y7D8EC2sM4ZG/V8wZlSniJnCKWPmBYAucRQ==", - "devOptional": true, + "dev": true, "dependencies": { "graceful-fs": "^4.1.11", "imurmurhash": "^0.1.4", @@ -15541,30 +15189,6 @@ "integrity": "sha512-A5CUptxDsvxKJEU3yO6DuWBSJz/qizqzJKOMIfUJHETbBw/sFaDxgd6fxm1ewUaM0jZ444Fc5vC5ROYurg/4Pw==", "dev": true }, - "node_modules/xml2js": { - "version": "0.4.23", - "resolved": "https://registry.npmjs.org/xml2js/-/xml2js-0.4.23.tgz", - "integrity": "sha512-ySPiMjM0+pLDftHgXY4By0uswI3SPKLDw/i3UXbnO8M/p28zqexCUoPmQFrYD+/1BzhGJSs2i1ERWKJAtiLrug==", - "optional": true, - "peer": true, - "dependencies": { - "sax": ">=0.6.0", - "xmlbuilder": "~11.0.0" - }, - "engines": { - "node": ">=4.0.0" - } - }, - "node_modules/xml2js/node_modules/xmlbuilder": { - "version": "11.0.1", - "resolved": "https://registry.npmjs.org/xmlbuilder/-/xmlbuilder-11.0.1.tgz", - "integrity": "sha512-fDlsI/kFEx7gLvbecc0/ohLG50fugQp8ryHzMTuW9vSa1GJ0XYWKnhsUx7oie3G98+r56aTQIUB4kht42R3JvA==", - "optional": true, - "peer": true, - "engines": { - "node": ">=4.0" - } - }, "node_modules/xmlbuilder": { "version": "15.1.1", "resolved": "https://registry.npmjs.org/xmlbuilder/-/xmlbuilder-15.1.1.tgz", @@ -15632,19 +15256,6 @@ "dependencies": { "camelcase": "^4.1.0" } - }, - "node_modules/yocto-queue": { - "version": "0.1.0", - "resolved": "https://registry.npmjs.org/yocto-queue/-/yocto-queue-0.1.0.tgz", - "integrity": "sha512-rVksvsnNCdJ/ohGc6xgPwyN8eheCxsiLM8mxuE/t/mOVqJewPuO1miLpTHQiRgTKCLexL4MeAFVagts7HmNZ2Q==", - "optional": true, - "peer": true, - "engines": { - "node": ">=10" - }, - "funding": { - "url": "https://github.com/sponsors/sindresorhus" - } } }, "dependencies": { @@ -16877,278 +16488,6 @@ } } }, - "@expo/config-plugins": { - "version": "4.1.5", - "resolved": "https://registry.npmjs.org/@expo/config-plugins/-/config-plugins-4.1.5.tgz", - "integrity": "sha512-RVvU40RtZt12HavuDAe+LDIq9lHj7sheOfMEHdmpJ/uTA8pgvkbc56XF6JHQD+yRr6+uhhb+JnAasGq49dsQbw==", - "optional": true, - "peer": true, - "requires": { - "@expo/config-types": "^45.0.0", - "@expo/json-file": "8.2.36", - "@expo/plist": "0.0.18", - "@expo/sdk-runtime-versions": "^1.0.0", - "@react-native/normalize-color": "^2.0.0", - "chalk": "^4.1.2", - "debug": "^4.3.1", - "find-up": "~5.0.0", - "getenv": "^1.0.0", - "glob": "7.1.6", - "resolve-from": "^5.0.0", - "semver": "^7.3.5", - "slash": "^3.0.0", - "xcode": "^3.0.1", - "xml2js": "0.4.23" - }, - "dependencies": { - "ansi-styles": { - "version": "4.3.0", - "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz", - "integrity": "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==", - "optional": true, - "peer": true, - "requires": { - "color-convert": "^2.0.1" - } - }, - "chalk": { - "version": "4.1.2", - "resolved": "https://registry.npmjs.org/chalk/-/chalk-4.1.2.tgz", - "integrity": "sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA==", - "optional": true, - "peer": true, - "requires": { - "ansi-styles": "^4.1.0", - "supports-color": "^7.1.0" - } - }, - "color-convert": { - "version": "2.0.1", - "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-2.0.1.tgz", - "integrity": "sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==", - "optional": true, - "peer": true, - "requires": { - "color-name": "~1.1.4" - } - }, - "color-name": { - "version": "1.1.4", - "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.4.tgz", - "integrity": "sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==", - "optional": true, - "peer": true - }, - "find-up": { - "version": "5.0.0", - "resolved": "https://registry.npmjs.org/find-up/-/find-up-5.0.0.tgz", - "integrity": "sha512-78/PXT1wlLLDgTzDs7sjq9hzz0vXD+zn+7wypEe4fXQxCmdmqfGsEPQxmiCSQI3ajFV91bVSsvNtrJRiW6nGng==", - "optional": true, - "peer": true, - "requires": { - "locate-path": "^6.0.0", - "path-exists": "^4.0.0" - } - }, - "glob": { - "version": "7.1.6", - "resolved": "https://registry.npmjs.org/glob/-/glob-7.1.6.tgz", - "integrity": "sha512-LwaxwyZ72Lk7vZINtNNrywX0ZuLyStrdDtabefZKAY5ZGJhVtgdznluResxNmPitE0SAO+O26sWTHeKSI2wMBA==", - "optional": true, - "peer": true, - "requires": { - "fs.realpath": "^1.0.0", - "inflight": "^1.0.4", - "inherits": "2", - "minimatch": "^3.0.4", - "once": "^1.3.0", - "path-is-absolute": "^1.0.0" - } - }, - "has-flag": { - "version": "4.0.0", - "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-4.0.0.tgz", - "integrity": "sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==", - "optional": true, - "peer": true - }, - "locate-path": { - "version": "6.0.0", - "resolved": "https://registry.npmjs.org/locate-path/-/locate-path-6.0.0.tgz", - "integrity": "sha512-iPZK6eYjbxRu3uB4/WZ3EsEIMJFMqAoopl3R+zuq0UjcAm/MO6KCweDgPfP3elTztoKP3KtnVHxTn2NHBSDVUw==", - "optional": true, - "peer": true, - "requires": { - "p-locate": "^5.0.0" - } - }, - "lru-cache": { - "version": "6.0.0", - "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-6.0.0.tgz", - "integrity": "sha512-Jo6dJ04CmSjuznwJSS3pUeWmd/H0ffTlkXXgwZi+eq1UCmqQwCh+eLsYOYCwY991i2Fah4h1BEMCx4qThGbsiA==", - "optional": true, - "peer": true, - "requires": { - "yallist": "^4.0.0" - } - }, - "p-limit": { - "version": "3.1.0", - "resolved": "https://registry.npmjs.org/p-limit/-/p-limit-3.1.0.tgz", - "integrity": "sha512-TYOanM3wGwNGsZN2cVTYPArw454xnXj5qmWF1bEoAc4+cU/ol7GVh7odevjp1FNHduHc3KZMcFduxU5Xc6uJRQ==", - "optional": true, - "peer": true, - "requires": { - "yocto-queue": "^0.1.0" - } - }, - "p-locate": { - "version": "5.0.0", - "resolved": "https://registry.npmjs.org/p-locate/-/p-locate-5.0.0.tgz", - "integrity": "sha512-LaNjtRWUBY++zB5nE/NwcaoMylSPk+S+ZHNB1TzdbMJMny6dynpAGt7X/tl/QYq3TIeE6nxHppbo2LGymrG5Pw==", - "optional": true, - "peer": true, - "requires": { - "p-limit": "^3.0.2" - } - }, - "path-exists": { - "version": "4.0.0", - "resolved": "https://registry.npmjs.org/path-exists/-/path-exists-4.0.0.tgz", - "integrity": "sha512-ak9Qy5Q7jYb2Wwcey5Fpvg2KoAc/ZIhLSLOSBmRmygPsGwkVVt0fZa0qrtMz+m6tJTAHfZQ8FnmB4MG4LWy7/w==", - "optional": true, - "peer": true - }, - "resolve-from": { - "version": "5.0.0", - "resolved": "https://registry.npmjs.org/resolve-from/-/resolve-from-5.0.0.tgz", - "integrity": "sha512-qYg9KP24dD5qka9J47d0aVky0N+b4fTU89LN9iDnjB5waksiC49rvMB0PrUJQGoTmH50XPiqOvAjDfaijGxYZw==", - "optional": true, - "peer": true - }, - "semver": { - "version": "7.5.3", - "resolved": "https://registry.npmjs.org/semver/-/semver-7.5.3.tgz", - "integrity": "sha512-QBlUtyVk/5EeHbi7X0fw6liDZc7BBmEaSYn01fMU1OUYbf6GPsbTtd8WmnqbI20SeycoHSeiybkE/q1Q+qlThQ==", - "optional": true, - "peer": true, - "requires": { - "lru-cache": "^6.0.0" - } - }, - "slash": { - "version": "3.0.0", - "resolved": "https://registry.npmjs.org/slash/-/slash-3.0.0.tgz", - "integrity": "sha512-g9Q1haeby36OSStwb4ntCGGGaKsaVSjQ68fBxoQcutl5fS1vuY18H3wSt3jFyFtrkx+Kz0V1G85A4MyAdDMi2Q==", - "optional": true, - "peer": true - }, - "supports-color": { - "version": "7.2.0", - "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-7.2.0.tgz", - "integrity": "sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==", - "optional": true, - "peer": true, - "requires": { - "has-flag": "^4.0.0" - } - }, - "uuid": { - "version": "7.0.3", - "resolved": "https://registry.npmjs.org/uuid/-/uuid-7.0.3.tgz", - "integrity": "sha512-DPSke0pXhTZgoF/d+WSt2QaKMCFSfx7QegxEWT+JOuHF5aWrKEn0G+ztjuJg/gG8/ItK+rbPCD/yNv8yyih6Cg==", - "optional": true, - "peer": true - }, - "xcode": { - "version": "3.0.1", - "resolved": "https://registry.npmjs.org/xcode/-/xcode-3.0.1.tgz", - "integrity": "sha512-kCz5k7J7XbJtjABOvkc5lJmkiDh8VhjVCGNiqdKCscmVpdVUpEAyXv1xmCLkQJ5dsHqx3IPO4XW+NTDhU/fatA==", - "optional": true, - "peer": true, - "requires": { - "simple-plist": "^1.1.0", - "uuid": "^7.0.3" - } - }, - "yallist": { - "version": "4.0.0", - "resolved": "https://registry.npmjs.org/yallist/-/yallist-4.0.0.tgz", - "integrity": "sha512-3wdGidZyq5PB084XLES5TpOSRA3wjXAlIWMhum2kRcv/41Sn2emQ0dycQW4uZXLejwKvg6EsvbdlVL+FYEct7A==", - "optional": true, - "peer": true - } - } - }, - "@expo/config-types": { - "version": "45.0.0", - "resolved": "https://registry.npmjs.org/@expo/config-types/-/config-types-45.0.0.tgz", - "integrity": "sha512-/QGhhLWyaGautgEyU50UJr5YqKJix5t77ePTwreOVAhmZH+ff3nrrtYTTnccx+qF08ZNQmfAyYMCD3rQfzpiJA==", - "optional": true, - "peer": true - }, - "@expo/json-file": { - "version": "8.2.36", - "resolved": "https://registry.npmjs.org/@expo/json-file/-/json-file-8.2.36.tgz", - "integrity": "sha512-tOZfTiIFA5KmMpdW9KF7bc6CFiGjb0xnbieJhTGlHrLL+ps2G0OkqmuZ3pFEXBOMnJYUVpnSy++52LFxvpa5ZQ==", - "optional": true, - "peer": true, - "requires": { - "@babel/code-frame": "~7.10.4", - "json5": "^1.0.1", - "write-file-atomic": "^2.3.0" - }, - "dependencies": { - "@babel/code-frame": { - "version": "7.10.4", - "resolved": "https://registry.npmjs.org/@babel/code-frame/-/code-frame-7.10.4.tgz", - "integrity": "sha512-vG6SvB6oYEhvgisZNFRmRCUkLz11c7rp+tbNTynGqc6mS1d5ATd/sGyV6W0KZZnXRKMTzZDRgQT3Ou9jhpAfUg==", - "optional": true, - "peer": true, - "requires": { - "@babel/highlight": "^7.10.4" - } - }, - "json5": { - "version": "1.0.2", - "resolved": "https://registry.npmjs.org/json5/-/json5-1.0.2.tgz", - "integrity": "sha512-g1MWMLBiz8FKi1e4w0UyVL3w+iJceWAFBAaBnnGKOpNa5f8TLktkbre1+s6oICydWAm+HRUGTmI+//xv2hvXYA==", - "optional": true, - "peer": true, - "requires": { - "minimist": "^1.2.0" - } - } - } - }, - "@expo/plist": { - "version": "0.0.18", - "resolved": "https://registry.npmjs.org/@expo/plist/-/plist-0.0.18.tgz", - "integrity": "sha512-+48gRqUiz65R21CZ/IXa7RNBXgAI/uPSdvJqoN9x1hfL44DNbUoWHgHiEXTx7XelcATpDwNTz6sHLfy0iNqf+w==", - "optional": true, - "peer": true, - "requires": { - "@xmldom/xmldom": "~0.7.0", - "base64-js": "^1.2.3", - "xmlbuilder": "^14.0.0" - }, - "dependencies": { - "xmlbuilder": { - "version": "14.0.0", - "resolved": "https://registry.npmjs.org/xmlbuilder/-/xmlbuilder-14.0.0.tgz", - "integrity": "sha512-ts+B2rSe4fIckR6iquDjsKbQFK2NlUk6iG5nf14mDEyldgoc2nEKZ3jZWMPTxGQwVgToSjt6VGIho1H8/fNFTg==", - "optional": true, - "peer": true - } - } - }, - "@expo/sdk-runtime-versions": { - "version": "1.0.0", - "resolved": "https://registry.npmjs.org/@expo/sdk-runtime-versions/-/sdk-runtime-versions-1.0.0.tgz", - "integrity": "sha512-Doz2bfiPndXYFPMRwPyGa1k5QaKDVpY806UJj570epIiMzWaYyCtobasyfC++qfIXVb5Ocy7r3tP9d62hAQ7IQ==", - "optional": true, - "peer": true - }, "@hapi/address": { "version": "2.1.4", "resolved": "https://registry.npmjs.org/@hapi/address/-/address-2.1.4.tgz", @@ -17586,33 +16925,31 @@ "peer": true }, "@maplibre/maplibre-react-native": { - "version": "9.0.1", - "resolved": "https://registry.npmjs.org/@maplibre/maplibre-react-native/-/maplibre-react-native-9.0.1.tgz", - "integrity": "sha512-i9lgOCusD9KNAktDcGcNyqoytdu7BdvAovEJurunWuiT6JYFYwvTip78bCEPOTLo5eX9+OG6mOifr3Yz8NMB9w==", + "version": "10.0.0-alpha.5", + "resolved": "https://registry.npmjs.org/@maplibre/maplibre-react-native/-/maplibre-react-native-10.0.0-alpha.5.tgz", + "integrity": "sha512-xITqPYnBJxfyM3TpRVjLC+8iLYXrogeTdOqGXLbgK9HbpuW/lIERUez++oPzO/h17tkjFUQ3Rd4ZaXdjYjPxkA==", "optional": true, "peer": true, "requires": { - "@expo/config-plugins": "^4.0.3", "@mapbox/geo-viewport": ">= 0.4.0", "@turf/along": "6.5.0", "@turf/distance": "6.5.0", "@turf/helpers": "6.5.0", "@turf/length": "6.5.0", "@turf/nearest-point-on-line": "6.5.0", - "@types/geojson": "^7946.0.7", - "@types/node": "^18.11.18", - "debounce": "^1.2.0", - "deprecated-react-native-prop-types": "^2.3.0" + "@types/geojson": "^7946.0.10", + "@types/react-native": "0.67.8", + "debounce": "^2.0.0" }, "dependencies": { - "@types/node": { - "version": "18.19.10", - "resolved": "https://registry.npmjs.org/@types/node/-/node-18.19.10.tgz", - "integrity": "sha512-IZD8kAM02AW1HRDTPOlz3npFava678pr8Ie9Vp8uRhBROXAv8MXT2pCnGZZAKYdromsNQLHQcfWQ6EOatVLtqA==", + "@types/react-native": { + "version": "0.67.8", + "resolved": "https://registry.npmjs.org/@types/react-native/-/react-native-0.67.8.tgz", + "integrity": "sha512-xA8rYiTHvO6RoZv/LFnmEeqRuhA2y34mGB8zX3bGHe/pCt9jEStUPyUO4q1KcDc9GiGIOBD8ArfRtThprAjSfQ==", "optional": true, "peer": true, "requires": { - "undici-types": "~5.26.4" + "@types/react": "*" } } } @@ -17746,13 +17083,6 @@ "integrity": "sha512-fkCRkOgzfdD0sr8JTasDgm716l8bJPkCNjXIyllG8K+UyixVa68lroQmgW9pewE5G5p43I9MWPtGZR/kVowBzg==", "requires": {} }, - "@react-native/normalize-color": { - "version": "2.1.0", - "resolved": "https://registry.npmjs.org/@react-native/normalize-color/-/normalize-color-2.1.0.tgz", - "integrity": "sha512-Z1jQI2NpdFJCVgpY+8Dq/Bt3d+YUi1928Q+/CZm/oh66fzM0RUl54vvuXlPJKybH4pdCZey1eDTPaLHkMPNgWA==", - "optional": true, - "peer": true - }, "@turf/along": { "version": "6.5.0", "resolved": "https://registry.npmjs.org/@turf/along/-/along-6.5.0.tgz", @@ -17942,6 +17272,24 @@ "undici-types": "~5.26.4" } }, + "@types/prop-types": { + "version": "15.7.12", + "resolved": "https://registry.npmjs.org/@types/prop-types/-/prop-types-15.7.12.tgz", + "integrity": "sha512-5zvhXYtRNRluoE/jAp4GVsSduVUzNWKkOZrCDBWYtE7biZywwdC2AcEzg+cSMLFRfVgeAFqpfNabiPjxFddV1Q==", + "optional": true, + "peer": true + }, + "@types/react": { + "version": "18.3.3", + "resolved": "https://registry.npmjs.org/@types/react/-/react-18.3.3.tgz", + "integrity": "sha512-hti/R0pS0q1/xx+TsI73XIqk26eBsISZ2R0wUijXIngRK9R/e7Xw/cXVxQK7R5JjW+SV4zGcn5hXjudkN/pLIw==", + "optional": true, + "peer": true, + "requires": { + "@types/prop-types": "*", + "csstype": "^3.0.2" + } + }, "@types/react-native": { "version": "0.73.0", "resolved": "https://registry.npmjs.org/@types/react-native/-/react-native-0.73.0.tgz", @@ -17987,13 +17335,6 @@ } } }, - "@xmldom/xmldom": { - "version": "0.7.11", - "resolved": "https://registry.npmjs.org/@xmldom/xmldom/-/xmldom-0.7.11.tgz", - "integrity": "sha512-UDi3g6Jss/W5FnSzO9jCtQwEpfymt0M+sPPlmLhDH6h2TJ8j4ESE/LpmNPBij15J5NKkk4/cg/qoVMdWI3vnlQ==", - "optional": true, - "peer": true - }, "abab": { "version": "2.0.6", "resolved": "https://registry.npmjs.org/abab/-/abab-2.0.6.tgz", @@ -19670,6 +19011,13 @@ "cssom": "0.3.x" } }, + "csstype": { + "version": "3.1.3", + "resolved": "https://registry.npmjs.org/csstype/-/csstype-3.1.3.tgz", + "integrity": "sha512-M1uQkMl8rQK/szD0LNhtqxIPLpimGm8sOBwU7lLnCpSbTyY3yeU1Vc7l4KT5zT4s/yOxHH5O7tIuuLOCnLADRw==", + "optional": true, + "peer": true + }, "damerau-levenshtein": { "version": "1.0.8", "resolved": "https://registry.npmjs.org/damerau-levenshtein/-/damerau-levenshtein-1.0.8.tgz", @@ -19715,9 +19063,9 @@ "integrity": "sha512-CAdX5Q3YW3Gclyo5Vpqkgpj8fSdLQcRuzfX6mC6Phy0nfJ0eGYOeS7m4mt2plDWLAtA4TqTakvbboHvUxfe4iA==" }, "debounce": { - "version": "1.2.1", - "resolved": "https://registry.npmjs.org/debounce/-/debounce-1.2.1.tgz", - "integrity": "sha512-XRRe6Glud4rd/ZGQfiV1ruXSfbvfJedlV9Y6zOlP+2K04vBYiJEte6stfFkCP03aMnY5tsipamumUjL14fofug==", + "version": "2.1.0", + "resolved": "https://registry.npmjs.org/debounce/-/debounce-2.1.0.tgz", + "integrity": "sha512-OkL3+0pPWCqoBc/nhO9u6TIQNTK44fnBnzuVtJAbp13Naxw9R6u21x+8tVTka87AhDZ3htqZ2pSSsZl9fqL2Wg==", "optional": true, "peer": true }, @@ -19801,18 +19149,6 @@ "resolved": "https://registry.npmjs.org/depd/-/depd-2.0.0.tgz", "integrity": "sha512-g7nH6P6dyDioJogAAGprGpCtVImJhpPk/roCzdb3fIh61/s/nPsfR6onyMwkCAR/OlC3yBC0lESvUoQEAssIrw==" }, - "deprecated-react-native-prop-types": { - "version": "2.3.0", - "resolved": "https://registry.npmjs.org/deprecated-react-native-prop-types/-/deprecated-react-native-prop-types-2.3.0.tgz", - "integrity": "sha512-pWD0voFtNYxrVqvBMYf5gq3NA2GCpfodS1yNynTPc93AYA/KEMGeWDqqeUB6R2Z9ZofVhks2aeJXiuQqKNpesA==", - "optional": true, - "peer": true, - "requires": { - "@react-native/normalize-color": "*", - "invariant": "*", - "prop-types": "*" - } - }, "destroy": { "version": "1.2.0", "resolved": "https://registry.npmjs.org/destroy/-/destroy-1.2.0.tgz", @@ -20919,13 +20255,6 @@ "resolved": "https://registry.npmjs.org/get-value/-/get-value-2.0.6.tgz", "integrity": "sha512-Ln0UQDlxH1BapMu3GPtf7CuYNwRZf2gwCuPqbyG6pB8WfmFpzqcy4xtAaAMUhnNqjMKTiCPZG2oMT3YSx8U2NA==" }, - "getenv": { - "version": "1.0.0", - "resolved": "https://registry.npmjs.org/getenv/-/getenv-1.0.0.tgz", - "integrity": "sha512-7yetJWqbS9sbn0vIfliPsFgoXMKn/YMF+Wuiog97x+urnSRRRZ7xB+uVkwGKzRgq9CDFfMQnE9ruL5DHv9c6Xg==", - "optional": true, - "peer": true - }, "getpass": { "version": "0.1.7", "resolved": "https://registry.npmjs.org/getpass/-/getpass-0.1.7.tgz", @@ -27561,7 +26890,7 @@ "version": "5.26.5", "resolved": "https://registry.npmjs.org/undici-types/-/undici-types-5.26.5.tgz", "integrity": "sha512-JlCMO+ehdEIKqlFxk6IfVoAUVmgz7cU7zD/h9XZ0qzeosSHmUJVOzSQvvYSYWXkFXC+IfLKSIffhv0sVZup6pA==", - "devOptional": true + "dev": true }, "unicode-canonical-property-names-ecmascript": { "version": "2.0.0", @@ -27909,7 +27238,7 @@ "version": "2.4.3", "resolved": "https://registry.npmjs.org/write-file-atomic/-/write-file-atomic-2.4.3.tgz", "integrity": "sha512-GaETH5wwsX+GcnzhPgKcKjJ6M2Cq3/iZp1WyY/X1CSqrW+jVNM9Y7D8EC2sM4ZG/V8wZlSniJnCKWPmBYAucRQ==", - "devOptional": true, + "dev": true, "requires": { "graceful-fs": "^4.1.11", "imurmurhash": "^0.1.4", @@ -27946,26 +27275,6 @@ "integrity": "sha512-A5CUptxDsvxKJEU3yO6DuWBSJz/qizqzJKOMIfUJHETbBw/sFaDxgd6fxm1ewUaM0jZ444Fc5vC5ROYurg/4Pw==", "dev": true }, - "xml2js": { - "version": "0.4.23", - "resolved": "https://registry.npmjs.org/xml2js/-/xml2js-0.4.23.tgz", - "integrity": "sha512-ySPiMjM0+pLDftHgXY4By0uswI3SPKLDw/i3UXbnO8M/p28zqexCUoPmQFrYD+/1BzhGJSs2i1ERWKJAtiLrug==", - "optional": true, - "peer": true, - "requires": { - "sax": ">=0.6.0", - "xmlbuilder": "~11.0.0" - }, - "dependencies": { - "xmlbuilder": { - "version": "11.0.1", - "resolved": "https://registry.npmjs.org/xmlbuilder/-/xmlbuilder-11.0.1.tgz", - "integrity": "sha512-fDlsI/kFEx7gLvbecc0/ohLG50fugQp8ryHzMTuW9vSa1GJ0XYWKnhsUx7oie3G98+r56aTQIUB4kht42R3JvA==", - "optional": true, - "peer": true - } - } - }, "xmlbuilder": { "version": "15.1.1", "resolved": "https://registry.npmjs.org/xmlbuilder/-/xmlbuilder-15.1.1.tgz", @@ -28027,13 +27336,6 @@ "requires": { "camelcase": "^4.1.0" } - }, - "yocto-queue": { - "version": "0.1.0", - "resolved": "https://registry.npmjs.org/yocto-queue/-/yocto-queue-0.1.0.tgz", - "integrity": "sha512-rVksvsnNCdJ/ohGc6xgPwyN8eheCxsiLM8mxuE/t/mOVqJewPuO1miLpTHQiRgTKCLexL4MeAFVagts7HmNZ2Q==", - "optional": true, - "peer": true } } } diff --git a/package.json b/package.json index 97151ff2..e7ecbf99 100644 --- a/package.json +++ b/package.json @@ -34,7 +34,7 @@ ] }, "peerDependencies": { - "@maplibre/maplibre-react-native": "^9.0.1", + "@maplibre/maplibre-react-native": "^10.0.0-alpha.5", "react": ">= 16.8.6", "react-native": ">= 0.60.0" },