MapViewStore | @mappedin/react-native-sdk

Hierarchy

RNMappedinController
- MapViewStore

Properties

BlueDot

BlueDot: { disable: (() => Promise<undefined>); enable: ((options?: TEnableBlueDotOptionsBase) => Promise<undefined>) } = ...

BlueDot control interface

Type declaration

disable: (() => Promise<undefined>)
- - (): Promise<undefined>
  - Disable BlueDot
    
    Returns Promise<undefined>
enable: ((options?: TEnableBlueDotOptionsBase) => Promise<undefined>)
- - (options?: TEnableBlueDotOptionsBase): Promise<undefined>
  - Enable BlueDot
    
    Parameters
    - Optional options: TEnableBlueDotOptionsBase
    Returns Promise<undefined>

BlueDotState

BlueDotState: E_BLUEDOT_STATE = E_BLUEDOT_STATE.NOT_LISTENING

deprecated: Use BlueDot Events instead

Camera

Camera: { rotation: number; set: ((positionOptions?: TAnimatePositionOptions) => Promise<unknown>); setMaxTilt: ((radians: number) => Promise<unknown>); setMaxZoom: ((meters: number) => Promise<unknown>); setMinZoom: ((meters: number) => Promise<unknown>); setSafeAreaInsets: ((safeAreaInsets: { bottom: number; left: number; right: number; top: number }) => void); tilt: number; translate: ((options: TMoveCameraOptions) => Promise<unknown>); focusOn: any } = ...

Camera controls interface

Type declaration

rotation: number

The current rotation in radians from north.
set: ((positionOptions?: TAnimatePositionOptions) => Promise<unknown>)
- - (positionOptions?: TAnimatePositionOptions): Promise<unknown>
  - Set Camera options immediately
    
    Parameters
    - Optional positionOptions: TAnimatePositionOptions
    Returns Promise<unknown>
setMaxTilt: ((radians: number) => Promise<unknown>)
- - (radians: number): Promise<unknown>
  - Sets the maximum tilt angle (in radians) the camera is allowed to use.
    
    As tilt angle approaches π/2 radians, this will impact overall touch controls and should be used sparingly.
    
    Parameters
    - radians: number
      
      Maximum allowed tilt angle. This value is clamped to be within the range [0, π/2]
    Returns Promise<unknown>
setMaxZoom: ((meters: number) => Promise<unknown>)
- - (meters: number): Promise<unknown>
  - Sets the maximum distance (in meters) the camera is allowed to get from the ground.
    
    Parameters
    - meters: number
      
      Maximum allowed meters.
    Returns Promise<unknown>
setMinZoom: ((meters: number) => Promise<unknown>)
- - (meters: number): Promise<unknown>
  - Sets the minimum distance (in meters) the camera is allowed to get to the ground.
    
    Parameters
    - meters: number
      
      Minimum allowed meters.
    Returns Promise<unknown>
setSafeAreaInsets: ((safeAreaInsets: { bottom: number; left: number; right: number; top: number }) => void)
- - (safeAreaInsets: { bottom: number; left: number; right: number; top: number }): void
  - This is so that the map can be positioned on a portion of the screen, (example padding)
    
    Parameters
    - safeAreaInsets: { bottom: number; left: number; right: number; top: number }
      - bottom: number
      - left: number
      - right: number
      - top: number
    Returns void
tilt: number

The current tilt in radians from top-down view.
translate: ((options: TMoveCameraOptions) => Promise<unknown>)
- - (options: TMoveCameraOptions): Promise<unknown>
  - Translate Camera view in a relative direction by a given distance in meters
    
    Parameters
    - options: TMoveCameraOptions
    Returns Promise<unknown>
focusOn:function
- focusOn(focusOptions: TFocusOnOptions & { animationOptions?: TAnimatePositionOptions }): Promise<unknown>
- Parameters
  - focusOptions: TFocusOnOptions & { animationOptions?: TAnimatePositionOptions }
    
    You should provide at least one Node or Polygon, but everything else is optional.
  Returns Promise<unknown>

CameraControls

CameraControls: { rotation: number; setRotation: ((rotation: number) => Promise<undefined>); setTilt: ((tilt: number) => Promise<undefined>); tilt: number } = ...

V3 Camera controls interface

Type declaration

rotation: number

The current rotation in radians from north.

deprecated
Use CameraControls.rotation instead
setRotation: ((rotation: number) => Promise<undefined>)
- - (rotation: number): Promise<undefined>
  - deprecated
    Use CameraControls.setRotation instead
    
    Parameters
    - rotation: number
      
      The new value to set the rotation to, in radians from north..
    Returns Promise<undefined>
setTilt: ((tilt: number) => Promise<undefined>)
- - (tilt: number): Promise<undefined>
  - deprecated
    Use CameraControls.setTilt instead
    
    Parameters
    - tilt: number
      
      The new value to set the tilt to, in radians from top-down view.
    Returns Promise<undefined>
tilt: number

The current tilt in radians from top-down view.

deprecated
Use CameraControls.tilt instead

Journey

Journey: { clear: (() => Promise<undefined>); draw: ((directions: MappedinDirections | MappedinDirections[], options?: TSerializableJourneyOptions) => Promise<undefined>); setStep: ((step: number) => Promise<undefined>) } = ...

Journey management interface

Type declaration

clear: (() => Promise<undefined>)
- - (): Promise<undefined>
  - Remove any paths and markers associated with journey
    
    Returns Promise<undefined>
draw: ((directions: MappedinDirections | MappedinDirections[], options?: TSerializableJourneyOptions) => Promise<undefined>)
- - (directions: MappedinDirections | MappedinDirections[], options?: TSerializableJourneyOptions): Promise<undefined>
  - Visualize directions by drawing paths, and adding connection markers
    
    Parameters
    - directions: MappedinDirections | MappedinDirections[]
    - options: TSerializableJourneyOptions = {}
    Returns Promise<undefined>
setStep: ((step: number) => Promise<undefined>)
- - (step: number): Promise<undefined>
  - Set the current step of a multi-part journey
    
    Parameters
    - step: number
    Returns Promise<undefined>

OfflineSearch

OfflineSearch: { addQuery: ((params: { object: MappedinLocation | MappedinCategory | Record<string, unknown>; query: string; weight?: number }) => Promise<unknown>); search: ((query: string) => Promise<TMappedinOfflineSearchResult[]>); suggest: ((query: string) => Promise<TMappedinOfflineSearchSuggestions>) } = ...

Type declaration

addQuery: ((params: { object: MappedinLocation | MappedinCategory | Record<string, unknown>; query: string; weight?: number }) => Promise<unknown>)
- - (params: { object: MappedinLocation | MappedinCategory | Record<string, unknown>; query: string; weight?: number }): Promise<unknown>
  - Parameters
    - params: { object: MappedinLocation | MappedinCategory | Record<string, unknown>; query: string; weight?: number }
      - object: MappedinLocation | MappedinCategory | Record<string, unknown>
        
        Object that is returned when query matches
      - query: string
        
        Query string to match for this object
      - Optional weight?: number
        
        Optional weight to multiply by the score
    Returns Promise<unknown>
search: ((query: string) => Promise<TMappedinOfflineSearchResult[]>)
- - (query: string): Promise<TMappedinOfflineSearchResult[]>
  - Parameters
    - query: string
      
      String to search for
    Returns Promise<TMappedinOfflineSearchResult[]>
suggest: ((query: string) => Promise<TMappedinOfflineSearchSuggestions>)
- - (query: string): Promise<TMappedinOfflineSearchSuggestions>
  - Parameters
    - query: string
      
      Get a list of suggestions for query
    Returns Promise<TMappedinOfflineSearchSuggestions>

Optional currentMap

currentMap?: MappedinMap

Current map of Venue

Optional options

options?: TGetVenueOptions

state

state: STATE = STATE.EXPLORE

Optional venueData

venueData?: Mappedin

Venue Data

Methods

addInteractivePolygon

addInteractivePolygon(polygonOrPolygonId: string | MappedinPolygon): Promise<unknown>

Make polygons clickable

Parameters
- polygonOrPolygonId: string | MappedinPolygon
Returns Promise<unknown>

clearAllPolygonColors

clearAllPolygonColors(): Promise<unknown>

Clear all polygon colors

Returns Promise<unknown>

clearBundleCache

clearBundleCache(): Promise<void>

Clear any cached venue bundles that were downloaded as part of LOAD_VENUE with useBundle: true This ensure that the next time keys are passed in, we get a fresh bundle

Returns Promise<void>

clearJourney

clearJourney(): Promise<unknown>

Remove any paths and markers associated with journey

deprecated
Use mapView.Journey.clear instead

Returns Promise<unknown>

clearPolygonColor

clearPolygonColor(polygonOrPolygonId: string | MappedinPolygon): Promise<unknown>

Clear Polygon Color

Parameters
- polygonOrPolygonId: string | MappedinPolygon
Returns Promise<unknown>

createMarker

createMarker(nodeOrCoordinate: MappedinNode | MappedinCoordinate, contentHtml: string, options: TCreateMarkerOptions): string

Create a marker attached to a MappedinNode, with any abitrary HTML code inside.

Parameters
- nodeOrCoordinate: MappedinNode | MappedinCoordinate
- contentHtml: string
- options: TCreateMarkerOptions
Returns string
markerId This marker id can later be used to remove the marker

drawJourney

drawJourney(directions: MappedinDirections | MappedinDirections[], options?: TSerializableJourneyOptions): Promise<unknown>

Visualize directions by drawing paths, and adding connection markers

deprecated
Use MapViewStore.Journey's draw method instead

Parameters
- directions: MappedinDirections | MappedinDirections[]
- options: TSerializableJourneyOptions = {}
Returns Promise<unknown>

drawPath

drawPath(pathNodesOrNodeIds: (string | MappedinNode)[], pathOptions: TPathOptions): Promise<unknown>

Draw a path based on a list of Nodes

Parameters
- pathNodesOrNodeIds: (string | MappedinNode)[]
- pathOptions: TPathOptions
Returns Promise<unknown>

focusOn

focusOn(focusOptions: TFocusOptionsLegacy): Promise<unknown>

deprecated
Use Camera.focusOn instead

Parameters
- focusOptions: TFocusOptionsLegacy
  
  You should provide at least one Node or Polygon, but everything else is optional.
Returns Promise<unknown>

getDirections

getDirections(props: { accessible?: boolean; from: MappedinPolygon | MappedinLocation | MappedinNode; to: MappedinPolygon | MappedinLocation | MappedinNode | MappedinDestinationSet }): Promise<MappedinDirections | MappedinDirections[]>

Get Directions

Parameters
- props: { accessible?: boolean; from: MappedinPolygon | MappedinLocation | MappedinNode; to: MappedinPolygon | MappedinLocation | MappedinNode | MappedinDestinationSet }
  - Optional accessible?: boolean
  - from: MappedinPolygon | MappedinLocation | MappedinNode
  - to: MappedinPolygon | MappedinLocation | MappedinNode | MappedinDestinationSet
Returns Promise<MappedinDirections | MappedinDirections[]>

getNearestNodeByScreenCoordinates

getNearestNodeByScreenCoordinates(x: number, y: number, mapIdOrMap?: string | MappedinMap): Promise<undefined | null | MappedinNode>

Gets the nearest node by screen coordinate

Parameters
- x: number
- y: number
- Optional mapIdOrMap: string | MappedinMap
Returns Promise<undefined | null | MappedinNode>

labelAllLocations

labelAllLocations(options?: TLabelAllLocationFloatingLabelOptions): Promise<unknown>
labelAllLocations(options?: TReactNativeFlatLabelAllLocations | TReactNativeFlatLabelAllLocationsLegacy): Promise<unknown>

Label all polygons with locations either loaded via the API or passed in

Parameters
- Optional options: TLabelAllLocationFloatingLabelOptions
Returns Promise<unknown>
Label all polygons with locations either loaded via the API or passed in

Parameters
- Optional options: TReactNativeFlatLabelAllLocations | TReactNativeFlatLabelAllLocationsLegacy
Returns Promise<unknown>

labelPolygon

labelPolygon(polygonOrPolygonId: string | MappedinPolygon, options: TReactNativeFloatingLabelPolygonOptions): Promise<unknown>
labelPolygon(polygonOrPolygonId: string | MappedinPolygon, options: TReactNativeFlatLabelPolygonOptions): Promise<unknown>

Parameters
- polygonOrPolygonId: string | MappedinPolygon
- options: TReactNativeFloatingLabelPolygonOptions
Returns Promise<unknown>
Parameters
- polygonOrPolygonId: string | MappedinPolygon
- options: TReactNativeFlatLabelPolygonOptions
Returns Promise<unknown>

removeAllInteractivePolygons

removeAllInteractivePolygons(): Promise<unknown>

Remove all interactive polygons

Returns Promise<unknown>

removeAllPaths

removeAllPaths(): Promise<unknown>

Remove all paths

Returns Promise<unknown>

removeMarker

removeMarker(markerId: string): Promise<void>

Remove marker by id

Parameters
- markerId: string
Returns Promise<void>

setMap

setMap(mapIdOrMap: string | MappedinMap): Promise<unknown>

Change Map/Level

Parameters
- mapIdOrMap: string | MappedinMap
Returns Promise<unknown>

setPolygonColor

setPolygonColor(polygonIdOrPolygon: string | MappedinPolygon, color: string, opacity?: number, textColor?: string): Promise<unknown>

Set Polygon Color

Parameters
- polygonIdOrPolygon: string | MappedinPolygon
- color: string
- opacity: number = 1
- Optional textColor: string
Returns Promise<unknown>

setSafeArea

setSafeArea(padding: { bottom: number; left: number; right: number; top: number }): void

Padding - this is so that the map can be positioned on a portion of the screen

deprecated
Use Camera.setSafeAreaInsets instead

Parameters
- padding: { bottom: number; left: number; right: number; top: number }
  - bottom: number
  - left: number
  - right: number
  - top: number
Returns void

setState

setState(state: STATE): Promise<undefined>

Set SDK state, which controls camera and other features geared towards a particular experience

EXPLORE (default)

FOLLOW - Lock Camera to the BlueDot so it follows it around the screen

Parameters
- state: STATE
Returns Promise<undefined>

Hierarchy

Index

Properties

Methods

Properties

BlueDot

Type declaration

disable: (() => Promise<undefined>)

Returns Promise<undefined>

enable: ((options?: TEnableBlueDotOptionsBase) => Promise<undefined>)

Parameters

Optional options: TEnableBlueDotOptionsBase

Returns Promise<undefined>

BlueDotState

Camera

Type declaration

rotation: number

set: ((positionOptions?: TAnimatePositionOptions) => Promise<unknown>)

Parameters

Optional positionOptions: TAnimatePositionOptions

Returns Promise<unknown>

setMaxTilt: ((radians: number) => Promise<unknown>)

Parameters

radians: number

Returns Promise<unknown>

setMaxZoom: ((meters: number) => Promise<unknown>)

Parameters

meters: number

Returns Promise<unknown>

setMinZoom: ((meters: number) => Promise<unknown>)

Parameters

meters: number

Returns Promise<unknown>

setSafeAreaInsets: ((safeAreaInsets: { bottom: number; left: number; right: number; top: number }) => void)

Parameters

safeAreaInsets: { bottom: number; left: number; right: number; top: number }

bottom: number

left: number

right: number

top: number

Returns void

tilt: number

translate: ((options: TMoveCameraOptions) => Promise<unknown>)

Parameters

options: TMoveCameraOptions

Returns Promise<unknown>

focusOn:function

Parameters

focusOptions: TFocusOnOptions & { animationOptions?: TAnimatePositionOptions }

Returns Promise<unknown>

CameraControls

Type declaration

rotation: number

setRotation: ((rotation: number) => Promise<undefined>)

Parameters

rotation: number

Returns Promise<undefined>

setTilt: ((tilt: number) => Promise<undefined>)

Parameters

tilt: number

Returns Promise<undefined>

tilt: number

Journey

Type declaration

clear: (() => Promise<undefined>)

Returns Promise<undefined>

draw: ((directions: MappedinDirections | MappedinDirections[], options?: TSerializableJourneyOptions) => Promise<undefined>)

Parameters

directions: MappedinDirections | MappedinDirections[]

options: TSerializableJourneyOptions = {}

Returns Promise<undefined>

setStep: ((step: number) => Promise<undefined>)

Parameters

step: number

Returns Promise<undefined>

OfflineSearch

Type declaration

addQuery: ((params: { object: MappedinLocation | MappedinCategory | Record<string, unknown>; query: string; weight?: number }) => Promise<unknown>)

Parameters

params: { object: MappedinLocation | MappedinCategory | Record<string, unknown>; query: string; weight?: number }