Class MapViewStore

Hierarchy

RNMappedinController
- MapViewStore

Properties

BlueDot

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

BlueDot control interface

Type declaration

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

Camera

Camera: TCameraManager = ...

Camera controls interface

FlatLabels

FlatLabels: IFlatLabels<Promise<void>> = ...

FloatingLabels

FloatingLabels: IFloatingLabels<Promise<void>> = ...

Journey

Journey: {
    clear: (() => Promise<undefined>);
    draw: ((directions, options?) => Promise<undefined>);
    setStep: ((step) => Promise<undefined>);
    setStepByPath: ((path) => Promise<unknown>);
} = ...

Journey management interface

Type declaration

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

Markers

Markers: {
    add: ((nodeOrCoordinate, contentHtml, options) => string);
    animate: ((markerId, nodeOrCoordinate, animationOptions) => Promise<void>);
    remove: ((markerId) => Promise<void>);
    setPosition: ((markerId, nodeOrCoordinate) => Promise<void>);
} = ...

Type declaration

add: ((nodeOrCoordinate, contentHtml, options) => string)
- - (nodeOrCoordinate, contentHtml, options): string
  - Parameters
    - nodeOrCoordinate: MappedinNode | MappedinCoordinate
    - contentHtml: string
    - options: TCreateMarkerOptions
    Returns string
animate: ((markerId, nodeOrCoordinate, animationOptions) => Promise<void>)
- - (markerId, nodeOrCoordinate, animationOptions): Promise<void>
  - Parameters
    - markerId: string
    - nodeOrCoordinate: MappedinNode | MappedinCoordinate
    - animationOptions: TAnimationOptions
    Returns Promise<void>
remove: ((markerId) => Promise<void>)
- - (markerId): Promise<void>
  - Parameters
    - markerId: string
    Returns Promise<void>
setPosition: ((markerId, nodeOrCoordinate) => Promise<void>)
- - (markerId, nodeOrCoordinate): Promise<void>
  - Parameters
    - markerId: string
    - nodeOrCoordinate: MappedinNode | MappedinCoordinate
    Returns Promise<void>

OfflineSearch

OfflineSearch: {
    addQuery: ((params) => Promise<unknown>);
    search: ((query) => Promise<TMappedinOfflineSearchResult[]>);
    suggest: ((query) => Promise<TMappedinOfflineSearchSuggestions>);
} = ...

Type declaration

addQuery: ((params) => Promise<unknown>)
- - (params): 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) => Promise<TMappedinOfflineSearchResult[]>)
- - (query): Promise<TMappedinOfflineSearchResult[]>
  - Parameters
    - query: string
      
      String to search for
    Returns Promise<TMappedinOfflineSearchResult[]>
suggest: ((query) => Promise<TMappedinOfflineSearchSuggestions>)
- - (query): Promise<TMappedinOfflineSearchSuggestions>
  - Parameters
    - query: string
      
      Get a list of suggestions for query
    Returns Promise<TMappedinOfflineSearchSuggestions>

Paths

Paths: {
    add: ((nodes, options?) => Promise<unknown>);
    remove: ((path) => Promise<void>);
    removeAll: (() => Promise<void>);
} = ...

Add or remove paths from the map

Type declaration

add: ((nodes, options?) => Promise<unknown>)
- - (nodes, options?): Promise<unknown>
  - Parameters
    - nodes: MappedinNode[]
    - Optional options: TPathOptions
    Returns Promise<unknown>
remove: ((path) => Promise<void>)
- - (path): Promise<void>
  - Parameters
    - path: {
      id: string;
      }
      
      id: string
    Returns Promise<void>
removeAll: (() => Promise<void>)
- - (): Promise<void>
  - Returns Promise<void>

`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): 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>

clearPolygonColor

clearPolygonColor(polygonOrPolygonId): Promise<unknown>
Clear Polygon Color
Parameters
- polygonOrPolygonId: string | MappedinPolygon
Returns Promise<unknown>

createCustomTooltip

createCustomTooltip(nodeOrCoordinate, contentHtml, selector, options?): Promise<string>
Creates a custom tooltip attached to a MappedinNode or a MappedinCoordinate, with any abitrary HTML code inside.
Parameters
- nodeOrCoordinate: MappedinNode | MappedinCoordinate
  
  Node or Coordinate to attach the tooltip to
- contentHtml: string
- selector: string
- Optional options: TCreateTooltipCommonOptions
Returns Promise<string>

createMarker

createMarker(nodeOrCoordinate, contentHtml, options): 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

createTooltip

createTooltip(nodeOrCoordinate, contentHtml, options?): Promise<string>
Creates a tooltip attached to a MappedinNode or a MappedinCoordinate
Parameters
- nodeOrCoordinate: MappedinNode | MappedinCoordinate
  
  Node or Coordinate to attach the tooltip to
- contentHtml: string
- Optional options: TCreateTooltipOptions
Returns Promise<string>

drawPath

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

Deprecated
Use Paths.add instead.

Draw a path based on a list of Nodes

enableImageFlippingForPolygon

enableImageFlippingForPolygon(polygon): Promise<unknown>
Enables image flipping for a specific polygon
Parameters
- polygon: MappedinPolygon
Returns Promise<unknown>

getDirections

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

getNearestNodeByScreenCoordinates

getNearestNodeByScreenCoordinates(x, y, mapIdOrMap?): Promise<MappedinNode>
Gets the nearest node by screen coordinate
Parameters
- x: number
- y: number
- Optional mapIdOrMap: string | MappedinMap
Returns Promise<MappedinNode>

getPolygonsAtCoordinate

getPolygonsAtCoordinate(coordinate, options?): Promise<MappedinPolygon[]>
Get all polygons that intersect with a specific coordinate.
Parameters
- coordinate: MappedinCoordinate
- Optional options: TGetPolygonsAtCoordinateOptions
Returns Promise<MappedinPolygon[]>

getPolygonsAtScreenCoordinate

getPolygonsAtScreenCoordinate(x, y, options?): Promise<MappedinPolygon[]>
Get all polygons that intersect with a specific screen coordinate.
Parameters
- x: number
- y: number
- Optional options: TGetPolygonsAtCoordinateOptions
Returns Promise<MappedinPolygon[]>

getPrimaryLocationForPolygon

getPrimaryLocationForPolygon(polygon): Promise<MappedinLocation>
Finds the primary MappedinLocation associated with a MappedinPolygon. This means a location attached to the polygon that has no parents, or, if there are none of those, a location nearest the top of some hierarchy that does have the polygon attached.
```
// Log the primary location of a clicked polygon
onClick={({ polygons }) => {
    if (polygons.length > 0) {
        for(const polygon of polygons) {
            console.log(await mapView.current?.getPrimaryLocationForPolygon(polygon));
        }
    }
});
```
Parameters
- polygon: MappedinPolygon
  
  The MappedinPolygon you want the primary location of.
Returns Promise<MappedinLocation>
The primary MappedinLocation or null if none found.

labelAllLocations

labelAllLocations(options?): Promise<void>
Label all polygons with locations either loaded via the API or passed in
Parameters
- Optional options: TLabelAllLocationFloatingLabelOptions | TReactNativeFlatLabelAllLocationsLegacy | TReactNativeFlatLabelAllLocations
Returns Promise<void>

Deprecated
Please use FloatingLabels.labelAllLocations or FlatLabels.labelAllLocations instead.

removeAllInteractivePolygons

removeAllInteractivePolygons(): Promise<unknown>
Remove all interactive polygons

Returns Promise<unknown>

removeAllPaths

removeAllPaths(): Promise<unknown>
Returns Promise<unknown>

Deprecated
Use Paths.removeAll instead.

Remove all paths

removeMarker

removeMarker(markerId): Promise<void>
Remove marker by id
Parameters
- markerId: string
Returns Promise<void>

removeTooltip

removeTooltip(tooltipId): Promise<string>
Remove tooltip by id
Parameters
- tooltipId: string
Returns Promise<string>

setMap

setMap(mapIdOrMap): Promise<unknown>
Change Map/Level
Parameters
- mapIdOrMap: string | MappedinMap
Returns Promise<unknown>

setPolygonColor

setPolygonColor(polygon, color): Promise<unknown>
Set Polygon Color
Parameters
- polygon: MappedinPolygon
  
  Polygon
- color: string
  
  Color to use
Returns Promise<unknown>

setState

setState(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>

Class MapViewStore

Hierarchy

Index

Properties

Methods

Properties

BlueDot

Type declaration

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

Returns Promise<undefined>

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

Parameters

Optional options: TEnableBlueDotOptionsBase

Returns Promise<undefined>

Camera

FlatLabels

FloatingLabels

Journey

Type declaration

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

Returns Promise<undefined>

draw: ((directions, options?) => Promise<undefined>)

Parameters

directions: MappedinDirections | MappedinDirections[]

options: TSerializableJourneyOptions = {}

Returns Promise<undefined>

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

Parameters

step: number

Returns Promise<undefined>

setStepByPath: ((path) => Promise<unknown>)

Parameters

path: { id: string; }

id: string

Returns Promise<unknown>

Markers

Type declaration

add: ((nodeOrCoordinate, contentHtml, options) => string)

Parameters

nodeOrCoordinate: MappedinNode | MappedinCoordinate

contentHtml: string

options: TCreateMarkerOptions

Returns string

animate: ((markerId, nodeOrCoordinate, animationOptions) => Promise<void>)

Parameters

markerId: string

nodeOrCoordinate: MappedinNode | MappedinCoordinate

animationOptions: TAnimationOptions

Returns Promise<void>

remove: ((markerId) => Promise<void>)

Parameters

markerId: string

Returns Promise<void>

setPosition: ((markerId, nodeOrCoordinate) => Promise<void>)

Parameters

markerId: string

nodeOrCoordinate: MappedinNode | MappedinCoordinate

Returns Promise<void>

OfflineSearch

Type declaration

addQuery: ((params) => Promise<unknown>)

Parameters

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

object: MappedinLocation | MappedinCategory | Record<string, unknown>

query: string

Optional weight?: number

Returns Promise<unknown>

search: ((query) => Promise<TMappedinOfflineSearchResult[]>)

Parameters

query: string

Returns Promise<TMappedinOfflineSearchResult[]>

suggest: ((query) => Promise<TMappedinOfflineSearchSuggestions>)

Parameters

query: string

Returns Promise<TMappedinOfflineSearchSuggestions>

Paths

Type declaration

add: ((nodes, options?) => Promise<unknown>)

Parameters

nodes: MappedinNode[]

`Optional` options: TEnableBlueDotOptionsBase

path: {
id: string;
}

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

`Optional` weight?: number

`Optional` options: TPathOptions

path: {
id: string;
}

`Optional` currentMap

`Optional` options

`Optional` venueData

`Optional` options: TCreateTooltipCommonOptions

`Optional` options: TCreateTooltipOptions

props: {
accessible?: boolean;
from: MappedinNode | MappedinLocation | MappedinPolygon;
to: MappedinNode | MappedinLocation | MappedinPolygon | MappedinDestinationSet;
}

`Optional` accessible?: boolean

`Optional` mapIdOrMap: string | MappedinMap