Class MapViewStore

Hierarchy

MappedinController
- MapViewStore

Properties

Optional Private #iframe

#iframe: undefined | HTMLIFrameElement

BlueDot

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

BlueDot control interface

Type declaration

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

Optional currentMap

currentMap: undefined | IMappedinMap

Current map of Venue

Optional options

options: undefined | TGetVenueOptions

Optional venueData

venueData: undefined | IMappedin

Venue Data

Methods

addInteractivePolygon

addInteractivePolygon(polygonId: string): Promise<null>
addInteractivePolygon(polygon: IMappedinPolygon): Promise<null>

Make polygons clickable

Parameters
- polygonId: string
Returns Promise<null>
Parameters
- polygon: IMappedinPolygon
Returns Promise<null>

clearAllPolygonColors

clearAllPolygonColors(): Promise<unknown>

Clear all polygon colors

Returns Promise<unknown>

clearJourney

clearJourney(): Promise<unknown>

Remove any paths and markers associated with journey

Returns Promise<unknown>

clearPolygonColor

clearPolygonColor(polygon: IMappedinPolygon): Promise<null>
clearPolygonColor(polygonId: string): Promise<null>

Clear Polygon Color

Parameters
- polygon: IMappedinPolygon
Returns Promise<null>
Parameters
- polygonId: string
Returns Promise<null>

disableBlueDot

disableBlueDot(): Promise<unknown>

Disable Blue Dot (use mapView.BlueDot.disable() instead)

deprecated

Returns Promise<unknown>

drawJourney

drawJourney(directions: TMappedinDirections, options?: TSerializableJourneyOptions): Promise<TMappedinDirections>

Visualize directions by drawing paths, and adding connection markers

Parameters
- directions: TMappedinDirections
- options: TSerializableJourneyOptions = ...
Returns Promise<TMappedinDirections>

drawPath

drawPath(path: string[], pathOptions: TPathOptions): Promise<null>
drawPath(path: IMappedinNode[], pathOptions: TPathOptions): Promise<null>

Draw a path based on a list of Nodes

Parameters
- path: string[]
- pathOptions: TPathOptions
Returns Promise<null>
Parameters
- path: IMappedinNode[]
- pathOptions: TPathOptions
Returns Promise<null>

enableBlueDot

enableBlueDot(options?: TBlueDotOptions): Promise<unknown>

Enable Blue Dot (use mapView.BlueDot.enable() instead)

deprecated

Parameters
- Optional options: TBlueDotOptions
Returns Promise<unknown>

focusOn

focusOn(focusOptions: TFocusOptions): Promise<unknown>

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

getDirections

getDirections(props: { accessible?: undefined | boolean; from: IMappedinPolygon | IMappedinLocation | IMappedinNode; to: IMappedinPolygon | IMappedinLocation | IMappedinNode }): Promise<TMappedinDirections>

Get Directions

Parameters
- props: { accessible?: undefined | boolean; from: IMappedinPolygon | IMappedinLocation | IMappedinNode; to: IMappedinPolygon | IMappedinLocation | IMappedinNode }
  - Optional accessible?: undefined | boolean
  - from: IMappedinPolygon | IMappedinLocation | IMappedinNode
  - to: IMappedinPolygon | IMappedinLocation | IMappedinNode
Returns Promise<TMappedinDirections>

getNearestNodeByScreenCoordinates

getNearestNodeByScreenCoordinates(x: number, y: number, map?: IMappedinMap): Promise<null | IMappedinNode>
getNearestNodeByScreenCoordinates(x: number, y: number, mapId?: string): Promise<null | IMappedinNode>

Gets the nearest node by screen coordinate

Parameters
- x: number
- y: number
- Optional map: IMappedinMap
Returns Promise<null | IMappedinNode>
Parameters
- x: number
- y: number
- Optional mapId: string
Returns Promise<null | IMappedinNode>

labelAllLocations

labelAllLocations(options?: TLabelOptions & { locations?: undefined | (string | IMappedinLocation)[] | [] }): Promise<unknown>

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

Parameters
- Optional options: TLabelOptions & { locations?: undefined | (string | IMappedinLocation)[] | [] }
Returns Promise<unknown>

labelPolygon

labelPolygon(polygon: IMappedinPolygon, options?: TLabelOptions): Promise<null>
labelPolygon(polygonId: string, options?: TLabelOptions): Promise<null>

Parameters
- polygon: IMappedinPolygon
- Optional options: TLabelOptions
Returns Promise<null>
Parameters
- polygonId: string
- Optional options: TLabelOptions
Returns Promise<null>

removeAllInteractivePolygons

removeAllInteractivePolygons(): Promise<void>

Remove all interactive polygons

Returns Promise<void>

removeAllPaths

removeAllPaths(): Promise<unknown>

Remove all paths

Returns Promise<unknown>

setMap

setMap(map: IMappedinMap): Promise<null>
setMap(mapId: string): Promise<null>

Change Map/Level

Parameters
- map: IMappedinMap
Returns Promise<null>
Parameters
- mapId: string
Returns Promise<null>

setPolygonColor

setPolygonColor(polygonId: string, color: string, opacity?: number, textColor?: string): Promise<null>
setPolygonColor(polygon: IMappedinPolygon, color: string, opacity?: number, textColor?: string): Promise<null>

Set Polygon Color

Parameters
- polygonId: string
- color: string
- Optional opacity: number
- Optional textColor: string
Returns Promise<null>
Parameters
- polygon: IMappedinPolygon
- color: string
- Optional opacity: number
- Optional textColor: string
Returns Promise<null>

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

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>