@mapmap/core reference

Generated from the published @mapmap/core 0.4.0 type declarations by website/scripts/sdk-reference.mjs. Do not edit by hand: change the JSDoc in the package, or the examples in website/content/sdk-reference/core.examples.md, and regenerate.

Every public export of the WASM core: the guidance session, the navigation state machine, route adapters, ADR tunnel checks and polyline helpers. The package is generated from the Rust core with wasm-bindgen, so many parameters are typed any in the published declarations; the descriptions say what each one takes. The guide is Core (WASM) in SDKs & installation.

npm install @mapmap/core@0.4.0

Other SDK references: @mapmap/maps, @mapmap/points, @mapmap/tile, @mapmap/react-native, @mapmap/voice, MapMapKit, ai.mapmap:core.

67 exports across 2 entry points: 6 classes, 13 functions, 24 interfaces, 24 types.

How to read this page

Each entry gives the declaration as published, the JSDoc description, and a table of parameters or properties with their types. The Default column quotes the default the source states (an @default tag or a "Default ..." sentence in the JSDoc). "required" means the property must be given; "not stated" means the source gives no default, so none is claimed here. Classes, factories and the main entry functions each carry a minimal example; examples marked from the source are the package's own @example.

Contents

• @mapmap/core: 67 exports
• @mapmap/core/web: the same declarations as @mapmap/core.
• @mapmap/core/node: no exports of its own, 62 re-exported from an earlier entry point

@mapmap/core

import { /* … */ } from "@mapmap/core";

Classes (@mapmap/core)

GuidanceSession, NavigationController, NavigationReplay, NavigationSession, NavigationSessionRecording, RouteAdapter

GuidanceSession

Class · also exported from @mapmap/core/node

class GuidanceSession { … }

A turn-by-turn guidance session over one route, the same Ferrostar-backed state machine the mobile SDKs run, driven from JS.

Construct it from a Valhalla route response JSON, then stream location fixes in with GuidanceSession::update_location; each call returns the updated guidance state. Bound to a single route, recalculate by building a new session.

Constructor and methods

• free(): void
• [Symbol.dispose](): void
• advanceToNextStep(): any: Manually advance to the next step (e.g. in a tunnel with no GNSS, or from an agent runtime that steps the route programmatically).
• enableProbe(config: any): void: Enable opt-in aggregate probe collection for this session. Off until called; call once before streaming fixes. config is a plain object mirroring the mobile ProbeConfig plus optional routeRef, territory and vehicleClass: { enabled: true, tripEndSuppressionM, routeRef, territory, vehicleClass, … }. Consent is the caller's responsibility: only enable this for a key whose operator has set probe_opt_in, and, in a browser, only with the user's opt-in consent. See docs/PROBE-SDK-INTEGRATION.md. Only aggregates are ever produced; the collector cannot emit a trajectory.
• finishProbeJson(arrived: boolean, timestamp_ms: number): string | undefined: Close the trip and return the exact JSON body to POST /v1/probe, or undefined when probing was never enabled or there is nothing worth uploading. arrived distinguishes a completed trip from an abandoned one (both apply end suppression).
• constructor(route_response_json: string, config: any): Create a session from a Valhalla route response JSON string (as returned by the hosted /route API or any Valhalla endpoint). config is optional: { stepAdvanceDistanceM, minimumHorizontalAccuracyM, routeDeviationThresholdM, snapCourseToRoute, waypointAdvanceRangeM }, defaulting to the same values as the mobile SDKs.
• updateLocation(lat: number, lon: number, timestamp_ms: number, speed_mps?: number | null, course_deg?: number | null, accuracy_m?: number | null): any: Feed a location fix; returns the updated guidance state as { state: "navigating" | "arrived" | "offRoute", … }. timestampMs is milliseconds since the Unix epoch (Date.now()). accuracyM defaults to 0 (trusted exactly) when omitted; pass the platform's reported accuracy so step advance and deviation gating behave correctly.

Example

import init, { GuidanceSession } from "@mapmap/core";

await init();
// A Valhalla route response, from the hosted /route API or any Valhalla server.
const routeJson = await (await fetch("/route.json")).text();
const session = new GuidanceSession(routeJson, { stepAdvanceDistanceM: 20 });
navigator.geolocation.watchPosition((p) => {
  const update = session.updateLocation(p.coords.latitude, p.coords.longitude, p.timestamp, p.coords.speed, p.coords.heading, p.coords.accuracy);
  console.log(update);
});

NavigationController

Class · also exported from @mapmap/core/node

class NavigationController { … }

JavaScript wrapper for NavigationController. This wrapper is required because NavigationController cannot be directly converted to a JavaScript object and requires serialization/deserialization of its methods' inputs and outputs.

Constructor and methods

• free(): void
• [Symbol.dispose](): void
• advanceToNextStep(state: any): any
• getInitialState(location: any): any
• constructor(route: any, config: any, should_record: any)
• updateUserLocation(location: any, state: any): any

Example

import init, { NavigationController, type Route, type SerializableNavigationControllerConfig, type UserLocation } from "@mapmap/core";

await init();
declare const route: Route;           // from RouteAdapter.parseResponse
declare const here: UserLocation;     // the device's latest fix
const config: SerializableNavigationControllerConfig = {
  waypointAdvance: { WaypointWithinRange: 100 },
  stepAdvanceCondition: { DistanceToEndOfStep: { distance: 10, minimumHorizontalAccuracy: 25 } },
  arrivalStepAdvanceCondition: { DistanceToEndOfStep: { distance: 10, minimumHorizontalAccuracy: 25 } },
  routeDeviationTracking: { StaticThreshold: { minimumHorizontalAccuracy: 25, maxAcceptableDeviation: 50 } },
  snappedLocationCourseFiltering: "SnapToRoute",
};
const controller = new NavigationController(route, config, false);
let state = controller.getInitialState(here);
state = controller.updateUserLocation(here, state);
console.log(state);

NavigationReplay

Class · also exported from @mapmap/core/node

class NavigationReplay { … }

A WebAssembly-compatible wrapper for NavigationReplay that exposes its functionality as a JavaScript object.

This wrapper is required because NavigationReplay cannot be directly converted to a JavaScript object and requires serialization/deserialization of its methods' inputs and outputs.

Constructor and methods

• free(): void
• [Symbol.dispose](): void
• getAllEvents(): any
• getEventByIndex(current_index: any): any
• getInitialRoute(): any
• getInitialTimestamp(): any
• getTotalDuration(): any
• constructor(json: string)

Example

import init, { NavigationReplay } from "@mapmap/core";

await init();
declare const recording: string; // NavigationSessionRecording.getRecordingJson()
const replay = new NavigationReplay(recording);
console.log(replay.getTotalDuration(), replay.getAllEvents());

NavigationSession

Class · also exported from @mapmap/core/node

class NavigationSession { … }

JavaScript wrapper for NavigationSession (simple version). This wrapper provides basic navigation functionality without observers.

Constructor and methods

• free(): void
• [Symbol.dispose](): void
• advanceToNextStep(state: any): any
• getInitialState(location: any): any
• constructor(route: any, config: any)
• updateUserLocation(location: any, state: any): any

Example

import init, { NavigationSession, type Route, type SerializableNavigationControllerConfig, type UserLocation } from "@mapmap/core";

await init();
declare const route: Route;
declare const config: SerializableNavigationControllerConfig; // as in the NavigationController example
declare const here: UserLocation;
const session = new NavigationSession(route, config);
const state = session.updateUserLocation(here, session.getInitialState(here));
console.log(state);

NavigationSessionRecording

Class · also exported from @mapmap/core/node

class NavigationSessionRecording { … }

JavaScript wrapper for NavigationSession with recording capabilities. This version includes a NavigationRecorder observer and provides direct access to recording functionality.

Constructor and methods

• free(): void
• [Symbol.dispose](): void
• advanceToNextStep(state: any): any
• getEvents(): any
• getInitialState(location: any): any
• getRecordingJson(): any
• constructor(route: any, config: any)
• updateUserLocation(location: any, state: any): any

Example

import init, { NavigationSessionRecording, type Route, type SerializableNavigationControllerConfig, type UserLocation } from "@mapmap/core";

await init();
declare const route: Route;
declare const config: SerializableNavigationControllerConfig;
declare const fixes: UserLocation[];
const session = new NavigationSessionRecording(route, config);
let state = session.getInitialState(fixes[0]);
for (const fix of fixes) state = session.updateUserLocation(fix, state);
const recording: string = session.getRecordingJson(); // replay it with NavigationReplay
console.log(recording.length);

RouteAdapter

Class · also exported from @mapmap/core/node

class RouteAdapter { … }

JavaScript wrapper for RouteAdapter.

Constructor and methods

• free(): void
• [Symbol.dispose](): void
• generateRequest(user_location: any, waypoints: any): any
• constructor(well_known_route_provider: WellKnownRouteProvider): Creates a new RouteAdapter with a Valhalla HTTP request generator and an OSRM response parser. At the moment, this is the only supported combination.
• parseResponse(response: Uint8Array): any

Example

import init, { RouteAdapter, type UserLocation, type Waypoint } from "@mapmap/core";

await init();
declare const here: UserLocation;
const adapter = new RouteAdapter({ Valhalla: { endpointUrl: "https://valhalla.example.com/route", profile: "auto" } });
const destination: Waypoint = { coordinate: { lat: 51.4545, lng: -2.5879 }, kind: "Break", properties: undefined };
const request = adapter.generateRequest(here, [destination]);
console.log(request);
// Then send the request, and: adapter.parseResponse(new Uint8Array(await response.arrayBuffer()))

Functions (@mapmap/core)

advanceLocationSimulation, buildOfflineRouteRequest, checkTunnel, default, forbiddenCategories, initSync, locationSimulationFromCoordinates, locationSimulationFromPolyline, locationSimulationFromRoute, parseRouteSummary, polylineDecode, polylineEncode, version

advanceLocationSimulation

Function · also exported from @mapmap/core/node

function advanceLocationSimulation(state: any): any;

JavaScript wrapper for advance_location_simulation.

buildOfflineRouteRequest

Function · also exported from @mapmap/core/node

function buildOfflineRouteRequest(locations: any, costing: string, adr_profile: any): string;

Build the Valhalla turn-by-turn request JSON that any Valhalla endpoint (hosted API, self-hosted server, on-device engine) accepts.

locations is an array of { lat, lon } (at least two); costing is a Valhalla costing model ("auto", "truck", "bus", "motor_scooter", "motorcycle", "bicycle", "pedestrian"). An optional ADR profile (truck costing only) is merged into costing_options.truck with the same conflict rules as the hosted gateway and the mobile SDKs, a disagreeing explicit option is an error, never silently overridden.

Example

import init, { buildOfflineRouteRequest } from "@mapmap/core";

await init();
const body = buildOfflineRouteRequest(
  [{ lat: 51.5072, lon: -0.1276 }, { lat: 51.752, lon: -1.2577 }],
  "truck",
  { heightM: 4.2, hazmat: true, tunnelCode: "C/D" },
);
const response = await fetch("https://valhalla.example.com/route", { method: "POST", body, headers: { "content-type": "application/json" } });
console.log(response.status);

checkTunnel

Function · also exported from @mapmap/core/node

function checkTunnel(profile: any, category: string): any;

Decide whether the vehicle described by profile may pass through a tunnel of ADR category ("A"–"E"), under the conservative worst-case ADR 8.6.4 reading.

profile is a plain object; all fields optional: { heightM, widthM, lengthM, grossWeightT, axleLoadT, axleCount, hazmat, tunnelCode }.

Returns { status: "allowed" } or { status: "blocked", reason }.

Example

import init, { checkTunnel, forbiddenCategories } from "@mapmap/core";

await init();
const lorry = { heightM: 4.1, grossWeightT: 26, hazmat: true, tunnelCode: "D/E" };
console.log(checkTunnel(lorry, "D")); // { status: "blocked", reason }
console.log(forbiddenCategories(lorry));

default

Function · the default export

function init(module_or_path?: {
    module_or_path: InitInput | Promise<InitInput>;
} | InitInput | Promise<InitInput>): Promise<InitOutput>;

If module_or_path is {RequestInfo} or {URL}, makes a request and for everything else, calls WebAssembly.instantiate directly.

Options and types: InitInput.

Example

import init, { version } from "@mapmap/core";

// Browser and worker builds: load the WASM once, before any other call.
await init();
console.log(version());

forbiddenCategories

Function · also exported from @mapmap/core/node

function forbiddenCategories(profile: any): string[];

All tunnel categories the vehicle is forbidden from, ascending (e.g. ["C", "D", "E"] for code C). Empty when unrestricted.

initSync

Function

function initSync(module: {
    module: SyncInitInput;
} | SyncInitInput): InitOutput;

Instantiates the given module, which can either be bytes or a precompiled WebAssembly.Module.

Options and types: SyncInitInput.

Example

import { initSync, version } from "@mapmap/core";

// When you already hold the WASM bytes (for example in a worker that was sent them).
declare const wasmBytes: ArrayBuffer;
initSync({ module: wasmBytes });
console.log(version());

locationSimulationFromCoordinates

Function · also exported from @mapmap/core/node

function locationSimulationFromCoordinates(coordinates: any, resample_distance: number | null | undefined, bias: LocationBias): any;

JavaScript wrapper for location_simulation_from_coordinates.

Options and types: LocationBias.

locationSimulationFromPolyline

Function · also exported from @mapmap/core/node

function locationSimulationFromPolyline(polyline: string, precision: number, resample_distance: number | null | undefined, bias: LocationBias): any;

JavaScript wrapper for location_simulation_from_polyline.

Options and types: LocationBias.

locationSimulationFromRoute

Function · also exported from @mapmap/core/node

function locationSimulationFromRoute(route: any, resample_distance: number | null | undefined, bias: LocationBias): any;

JavaScript wrapper for location_simulation_from_route.

Options and types: LocationBias.

parseRouteSummary

Function · also exported from @mapmap/core/node

function parseRouteSummary(route_response_json: string): any;

Parse a Valhalla route response JSON into an SI summary: { distanceM, durationS, hasToll, hasHighway, hasFerry }.

A Valhalla error body ({"error_code": …}) and malformed JSON both raise with the backend's message.

Example

import init, { parseRouteSummary } from "@mapmap/core";

await init();
const routeJson = await (await fetch("/route.json")).text();
const { distanceM, durationS, hasToll } = parseRouteSummary(routeJson);
console.log(distanceM, durationS, hasToll);

polylineDecode

Function · also exported from @mapmap/core/node

function polylineDecode(encoded: string, precision: number): Float64Array;

Decode an encoded polyline into a flat Float64Array of [lat0, lon0, lat1, lon1, …] pairs. precision is 5 for OSRM polyline, 6 for Valhalla/OSRM polyline6.

polylineEncode

Function · also exported from @mapmap/core/node

function polylineEncode(coordinates: Float64Array, precision: number): string;

Encode a flat Float64Array of [lat0, lon0, lat1, lon1, …] pairs as a polyline string at the given precision (5 or 6).

version

Function · also exported from @mapmap/core/node

function version(): string;

The crate version of the underlying navigation core package.

Interfaces (@mapmap/core)

BoundingBox, Congestion, CourseOverGround, GeographicCoordinate, Incident, InitOutput, LaneInfo, LocationSimulationState, NavigationRecordingEvent, OsrmWaypointProperties, Route, RouteStep, SerializableNavigationControllerConfig, SerializableNavState, Speed, SpokenInstruction, TripProgress, TripSummary, UserLocation, ValhallaLocationSearchFilter, ValhallaWaypointProperties, VisualInstruction, VisualInstructionContent, Waypoint

BoundingBox

Interface · also exported from @mapmap/core/node

interface BoundingBox

A geographic bounding box defined by its corners.

Congestion

Interface · also exported from @mapmap/core/node

interface Congestion

Details about congestion for an incident.

CourseOverGround

Interface · also exported from @mapmap/core/node

interface CourseOverGround

The direction in which the user/device is observed to be traveling.

GeographicCoordinate

Interface · also exported from @mapmap/core/node

interface GeographicCoordinate

A geographic coordinate in WGS84.

Incident

Interface · also exported from @mapmap/core/node

interface Incident

An incident affecting the free flow of traffic, such as constructions, accidents, and congestion.

InitOutput

Interface

interface InitOutput

LaneInfo

Interface · also exported from @mapmap/core/node

interface LaneInfo

The content of a visual instruction.

LocationSimulationState

Interface · also exported from @mapmap/core/node

interface LocationSimulationState

The current state of the simulation.

NavigationRecordingEvent

Interface · also exported from @mapmap/core/node

interface NavigationRecordingEvent

An event that occurs during navigation.

This is used for the optional session recording / telemetry.

OsrmWaypointProperties

Interface · also exported from @mapmap/core/node

interface OsrmWaypointProperties

Waypoint properties parsed from an OSRM-compatible server response.

NOTE: Some servers (such as Valhalla) may support additional parameters at request time which are not echoed back in the response time. This is unfortunate; PRs upstream would likely be welcomed! Similarly, if your server is OSRM-compatible and returns additional attributes, feel free to open a PR to include these as optional properties.

Route

Interface · also exported from @mapmap/core/node

interface Route

Information describing the series of steps needed to travel between two or more points.

NOTE: This type is unstable and is still under active development and should be considered unstable.

RouteStep

Interface · also exported from @mapmap/core/node

interface RouteStep

A maneuver (such as a turn or merge) followed by travel of a certain distance until reaching the next step.

SerializableNavigationControllerConfig

Interface · also exported from @mapmap/core/node

interface SerializableNavigationControllerConfig

SerializableNavState

Interface · also exported from @mapmap/core/node

interface SerializableNavState

Speed

Interface · also exported from @mapmap/core/node

interface Speed

The speed of the user from the location provider.

SpokenInstruction

Interface · also exported from @mapmap/core/node

interface SpokenInstruction

An instruction that can be synthesized using a TTS engine to announce an upcoming maneuver.

Note that these do not have any locale information attached.

TripProgress

Interface · also exported from @mapmap/core/node

interface TripProgress

High-level state describing progress through a route.

TripSummary

Interface · also exported from @mapmap/core/node

interface TripSummary

Information pertaining to the user's full navigation trip. This includes simple stats like total duration and distance.

UserLocation

Interface · also exported from @mapmap/core/node

interface UserLocation

The location of the user that is navigating.

In addition to coordinates, this includes estimated accuracy and course information, which can influence navigation logic and UI.

NOTE: Heading is absent on purpose. Heading updates are not related to a change in the user's location.

ValhallaLocationSearchFilter

Interface · also exported from @mapmap/core/node

interface ValhallaLocationSearchFilter

A set of optional filters to exclude candidate edges based on their attributes.

ValhallaWaypointProperties

Interface · also exported from @mapmap/core/node

interface ValhallaWaypointProperties

Waypoint properties supported by Valhalla servers.

Our docstrings are short here, since Valhalla is the final authority. Refer to https://valhalla.github.io/valhalla/api/turn-by-turn/api-reference/#locations for more details, including default values. Other Valhalla-based APIs such as Stadia Maps or Mapbox may have slightly different defaults. Refer to your vendor's documentation when in doubt.

NOTE: Waypoint properties will NOT currently be echoed back in OSRM format, so these are sent to the server one time.

VisualInstruction

Interface · also exported from @mapmap/core/node

interface VisualInstruction

An instruction for visual display (usually as banners) at a specific point along a RouteStep.

VisualInstructionContent

Interface · also exported from @mapmap/core/node

interface VisualInstructionContent

The content of a visual instruction.

Waypoint

Interface · also exported from @mapmap/core/node

interface Waypoint

A waypoint along a route.

Within the context of Ferrostar, a route request consists of exactly one UserLocation and at least one Waypoint. The route starts from the user's location (which may contain other useful information like their current course for the crate::routing_adapters::RouteRequestGenerator to use) and proceeds through one or more waypoints.

Waypoints are used during route calculation, are tracked throughout the lifecycle of a trip, and are used for recalculating when the user deviates from the expected route.

Note that support for properties beyond basic geographic coordinates varies by routing engine.

Types (@mapmap/core)

BlockedLane, CourseFiltering, DeviationCalculationPolicy, DeviationKind, DrivingSide, GraphHopperVoiceUnits, Impact, IncidentType, InitInput, LocationBias, ManeuverModifier, ManeuverType, NavigationRecordingEventData, RouteDeviation, RouteDeviationTracking, SerializableStepAdvanceCondition, SimulationError, SyncInitInput, TripState, ValhallaRoadClass, ValhallaWaypointPreferredSide, WaypointAdvanceMode, WaypointKind, WellKnownRouteProvider

BlockedLane

Type · also exported from @mapmap/core/node

type BlockedLane = "left" | "left center" | "left turn lane" | "center" | "right" | "right center" | "right turn lane" | "hov";

The lane type blocked by the incident.

CourseFiltering

Type · also exported from @mapmap/core/node

type CourseFiltering = "SnapToRoute" | "Raw";

Controls filtering/post-processing of user course by the NavigationController.

DeviationCalculationPolicy

Type · also exported from @mapmap/core/node

type DeviationCalculationPolicy = "Always" | "WhileOnRoute" | "WhileOnCurrentStep";

Controls when a deviation-aware step-advance condition is allowed to evaluate, based on the user's current RouteDeviation status.

DeviationKind

Type · also exported from @mapmap/core/node

type DeviationKind = {
    OffStepOnRoute: {
        deviationFromStepLine: number;
    };
} | {
    CompletelyOffRoute: {
        deviationFromRouteLine: number;
    };
};

The kind of deviation from the expected route.

DrivingSide

Type · also exported from @mapmap/core/node

type DrivingSide = "left" | "right";

Which side of the road traffic drives on.

This is needed by consumers like Android Auto to determine whether a roundabout should be rendered as clockwise (right-hand traffic) or counterclockwise (left-hand traffic).

GraphHopperVoiceUnits

Type · also exported from @mapmap/core/node

type GraphHopperVoiceUnits = "metric" | "imperial";

Impact

Type · also exported from @mapmap/core/node

type Impact = "unknown" | "critical" | "major" | "minor" | "low";

The impact of the incident that has occurred.

IncidentType

Type · also exported from @mapmap/core/node

type IncidentType = "accident" | "congestion" | "construction" | "disabled_vehicle" | "lane_restriction" | "mass_transit" | "miscellaneous" | "other_news" | "planned_event" | "road_closure" | "road_hazard" | "weather";

The type of incident that has occurred.

InitInput

Type

type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembly.Module;

LocationBias

Type · also exported from @mapmap/core/node

type LocationBias = {
    Left: number;
} | {
    Right: number;
} | {
    Random: number;
} | "None";

Controls how simulated locations deviate from the actual route line. This simulates real-world GPS behavior where readings often have systematic bias.

ManeuverModifier

Type · also exported from @mapmap/core/node

type ManeuverModifier = "uturn" | "sharp right" | "right" | "slight right" | "straight" | "slight left" | "left" | "sharp left";

Additional information to further specify a ManeuverType.

ManeuverType

Type · also exported from @mapmap/core/node

type ManeuverType = "turn" | "new name" | "depart" | "arrive" | "merge" | "on ramp" | "off ramp" | "fork" | "end of road" | "continue" | "roundabout" | "rotary" | "roundabout turn" | "notification" | "exit roundabout" | "exit rotary";

The broad class of maneuver to perform.

This is usually combined with ManeuverModifier in VisualInstructionContent.

NavigationRecordingEventData

Type · also exported from @mapmap/core/node

type NavigationRecordingEventData = {
    StateUpdate: {
        trip_state: TripState;
        step_advance_condition: SerializableStepAdvanceCondition;
    };
} | {
    RouteUpdate: {
        route: Route;
    };
};

The event type.

For full replayability, we record things like rerouting, and not just location updates.

RouteDeviation

Type · also exported from @mapmap/core/node

type RouteDeviation = "NoDeviation" | {
    Deviation: {
        kind: DeviationKind;
    };
};

Status information that describes whether the user is proceeding according to the route or not.

Note that the name is intentionally a bit generic to allow for expansion of other states. For example, we could conceivably add a "wrong way" status in the future.

RouteDeviationTracking

Type · also exported from @mapmap/core/node

type RouteDeviationTracking = "None" | {
    StaticThreshold: {
        minimumHorizontalAccuracy: number;
        maxAcceptableDeviation: number;
    };
};

Determines if the user has deviated from the expected route.

SerializableStepAdvanceCondition

Type · also exported from @mapmap/core/node

type SerializableStepAdvanceCondition = "Manual" | {
    DistanceToEndOfStep: {
        distance: number;
        minimumHorizontalAccuracy: number;
    };
} | {
    DistanceFromStep: {
        distance: number;
        minimumHorizontalAccuracy: number;
        calculationPolicy: DeviationCalculationPolicy;
    };
} | {
    DistanceEntryExit: {
        distanceToEndOfStep: number;
        distanceAfterEndStep: number;
        minimumHorizontalAccuracy: number;
        hasReachedEndOfCurrentStep: boolean;
    };
} | {
    DistanceEntryAndSnappedExit: {
        distanceToEndOfStep: number;
        distanceAfterEndStep: number;
        minimumHorizontalAccuracy: number;
        hasReachedEndOfCurrentStep: boolean;
    };
} | {
    OrAdvanceConditions: {
        conditions: SerializableStepAdvanceCondition[];
    };
} | {
    AndAdvanceConditions: {
        conditions: SerializableStepAdvanceCondition[];
    };
};

SimulationError

Type · also exported from @mapmap/core/node

type SimulationError = {
    PolylineError: {
        error: string;
    };
} | "NotEnoughPoints";

SyncInitInput

Type

type SyncInitInput = BufferSource | WebAssembly.Module;

TripState

Type · also exported from @mapmap/core/node

type TripState = {
    Idle: {
        user_location: UserLocation | undefined;
    };
} | {
    Navigating: {
        currentStepGeometryIndex: number | undefined;
        userLocation: UserLocation;
        snappedUserLocation: UserLocation;
        remainingSteps: RouteStep[];
        remainingWaypoints: Waypoint[];
        progress: TripProgress;
        summary: TripSummary;
        deviation: RouteDeviation;
        visualInstruction: VisualInstruction | undefined;
        spokenInstruction: SpokenInstruction | undefined;
        annotationJson: string | undefined;
    };
} | {
    Complete: {
        user_location: UserLocation;
        summary: TripSummary;
    };
};

The state of a navigation session.

This is produced by NavigationController methods including get_initial_state and update_user_location.

ValhallaRoadClass

Type · also exported from @mapmap/core/node

type ValhallaRoadClass = "motorway" | "trunk" | "primary" | "secondary" | "tertiary" | "unclassified" | "residential" | "service_other";

A road class in the Valhalla taxonomy.

These are ordered from highest (fastest travel speed) to lowest.

ValhallaWaypointPreferredSide

Type · also exported from @mapmap/core/node

type ValhallaWaypointPreferredSide = "same" | "opposite" | "either";

Specifies a preferred side for departing from / arriving at a location.

Examples:

• Germany drives on the right side of the road. A value of same will only allow leaving or arriving at a location such that it is on your right.
• Australia drives on the left side of the road. Passing a value of same will only allow leaving or arriving at a location such that it is on your left.

WaypointAdvanceMode

Type · also exported from @mapmap/core/node

type WaypointAdvanceMode = {
    WaypointWithinRange: number;
} | {
    WaypointAlongAdvancingStep: number;
};

Controls when a waypoint should be marked as complete.

While a route may consist of thousands of points, waypoints are special. A simple trip will have only one waypoint: the final destination. A more complex trip may have several intermediate stops. Just as the navigation state keeps track of which steps remain in the route, it also tracks which waypoints are still remaining.

Tracking waypoints enables Ferrostar to reroute users when they stray off the route line. The waypoint advance mode specifies how the framework decides that a waypoint has been visited (and is removed from the list).

NOTE: Advancing to the next step and advancing to the next waypoint are separate processes. This will not normally cause any issues, but keep in mind that manually advancing to the next step does not necessarily imply that the waypoint will be marked as complete!

WaypointKind

Type · also exported from @mapmap/core/node

type WaypointKind = "Break" | "Via";

Describes characteristics of the waypoint for routing purposes.

WellKnownRouteProvider

Type · also exported from @mapmap/core/node

type WellKnownRouteProvider = {
    Valhalla: {
        endpointUrl: string;
        profile: string;
        optionsJson?: string | undefined;
    };
} | {
    GraphHopper: {
        endpointUrl: string;
        profile: string;
        locale: string;
        voiceUnits: GraphHopperVoiceUnits;
        optionsJson?: string | undefined;
    };
};

Configurations for built-in route providers.

@mapmap/core/node

import { /* … */ } from "@mapmap/core/node";

Every export of this entry point is documented above, under @mapmap/core: 62 names, that is all of them except default, InitInput, InitOutput, initSync, SyncInitInput.