@ingissa/navcore-mapbox 1.0.8 → 1.0.10

package/LICENSE

@@ -1,3 +1,3 @@
-Copyright (c) 2026 Abdelnasser Aitabi. All rights reserved.
-
-No license is granted except by separate written agreement.
+Copyright (c) 2026 Abdelnasser Aitabi. All rights reserved.
+
+No license is granted except by separate written agreement.

package/README.md

@@ -0,0 +1,102 @@
+# @ingissa/navcore-mapbox
+
+[Official Website](https://navcore-web.vercel.app/)
+
+> Mapbox Directions provider adapter for the NavCore navigation engine.
+
+[![npm version](https://img.shields.io/npm/v/@ingissa/navcore-mapbox)](https://www.npmjs.com/package/@ingissa/navcore-mapbox)
+![License](https://img.shields.io/badge/license-Proprietary-red)
+[![TypeScript](https://img.shields.io/badge/TypeScript-strict-blue)](https://www.typescriptlang.org/)
+
+---
+
+## Overview
+
+`@ingissa/navcore-mapbox` provides `MapboxDirectionsProvider`, an implementation of NavCore's `DirectionsProvider` interface targeting the Mapbox Directions API.
+
+### Key Capabilities
+- **Direct NavCore integration**: Directly compatible with `createNavigationSession` and `createRoutePlan`.
+- **Automatic waypoint chunking**: Transparently splits routes with more than 25 waypoints into chunks, querying each chunk and stitching geometry with the `OVERLAP_1` strategy.
+- **Configurable routing profiles**: Supports `driving`, `driving-traffic`, `cycling`, and `walking`.
+
+> [!NOTE]
+> `@ingissa/navcore-mapbox` is a routing directions provider only. It does not export a map renderer. For map rendering in React Native, use `@rnmapbox/maps` or `react-native-maps` directly in your application components by consuming state from `useNavSelector()`.
+
+---
+
+## Installation
+
+```bash
+npm install @ingissa/navcore-mapbox @ingissa/navcore-core
+```
+
+### Peer Dependencies
+- `@ingissa/navcore-core`: `^1.0.9` (required)
+- `@rnmapbox/maps`: `>=10.0.0` (optional, for React Native applications)
+
+---
+
+## Quickstart
+
+```typescript
+import { createNavigationSession } from '@ingissa/navcore-core';
+import { MapboxDirectionsProvider } from '@ingissa/navcore-mapbox';
+
+// Initialize Mapbox provider with your access token
+const provider = new MapboxDirectionsProvider({
+  accessToken: 'pk.eyJ1...',
+  profile: 'driving-traffic', // 'driving' | 'driving-traffic' | 'cycling' | 'walking'
+  maxWaypointsPerChunk: 25,   // Default: 25 (Mapbox API limit)
+});
+
+// Pass to a NavigationSession
+const nav = createNavigationSession({
+  provider,
+  providerName: 'mapbox',
+  engineOptions: { isDev: true },
+});
+
+// Fetch route and start navigation
+const plan = await nav.navigate({
+  origin: [2.3522, 48.8566],
+  destination: [2.3009, 48.8741],
+});
+
+console.log(`Route loaded: ${plan.distanceM}m, duration: ${plan.durationS}s`);
+```
+
+---
+
+## Standalone Usage
+
+```typescript
+import { MapboxDirectionsProvider } from '@ingissa/navcore-mapbox';
+
+const provider = new MapboxDirectionsProvider({
+  accessToken: process.env.MAPBOX_TOKEN!,
+});
+
+const result = await provider.getRoute([
+  [2.3522, 48.8566],
+  [2.3300, 48.8650],
+  [2.3009, 48.8741],
+]);
+
+console.log('Coordinates:', result.geometry.length);
+console.log('Distance in metres:', result.distance);
+console.log('Duration in seconds:', result.duration);
+```
+
+---
+
+## Documentation
+
+- [Directions Providers Guide](../../docs/directions-providers.md)
+- [API Reference](../../docs/api-reference/navcore-mapbox.md)
+- [Official Website](https://navcore-web.vercel.app/)
+
+---
+
+## Licensing
+
+Proprietary software. Copyright (c) 2026 Abdelnasser Aitabi. All rights reserved. No license is granted except by separate written agreement.

package/dist/{MapboxDirectionsProvider.d.ts → index.d.mts}

@@ -5,7 +5,7 @@
  * Handles waypoint chunking internally for routes with >25 waypoints.
  */
 type Coordinate = [number, number];
-export interface MapboxDirectionsConfig {
+interface MapboxDirectionsConfig {
     /** Mapbox access token */
     accessToken: string;
     /** Routing profile (default: 'driving') */
@@ -47,7 +47,7 @@ interface RouteOptions {
     overview?: string;
     language?: string;
 }
-export declare class MapboxDirectionsProvider {
+declare class MapboxDirectionsProvider {
     private readonly config;
     constructor(config: MapboxDirectionsConfig);
     /**
@@ -64,5 +64,5 @@ export declare class MapboxDirectionsProvider {
      */
     private fetchChunkedRoute;
 }
-export {};
-//# sourceMappingURL=MapboxDirectionsProvider.d.ts.map
+
+export { type MapboxDirectionsConfig, MapboxDirectionsProvider };

package/dist/index.d.ts

@@ -1,9 +1,68 @@
 /**
- * @navcore/mapbox — Mapbox GL adapters
+ * MapboxDirectionsProvider
  *
- * Provides NavCoreRenderer and DirectionsProvider implementations
- * for Mapbox GL (via @rnmapbox/maps for React Native, or mapbox-gl for web).
+ * Implements DirectionsProvider using the Mapbox Directions API.
+ * Handles waypoint chunking internally for routes with >25 waypoints.
  */
-export { MapboxDirectionsProvider } from './MapboxDirectionsProvider';
-export type { MapboxDirectionsConfig } from './MapboxDirectionsProvider';
-//# sourceMappingURL=index.d.ts.map
+type Coordinate = [number, number];
+interface MapboxDirectionsConfig {
+    /** Mapbox access token */
+    accessToken: string;
+    /** Routing profile (default: 'driving') */
+    profile?: 'driving' | 'driving-traffic' | 'cycling' | 'walking';
+    /** API base URL (default: Mapbox production) */
+    baseUrl?: string;
+    /** Max waypoints per API call (default: 25, Mapbox limit) */
+    maxWaypointsPerChunk?: number;
+}
+interface RouteResult {
+    geometry: Coordinate[];
+    distance: number;
+    duration: number;
+    legs: Array<{
+        distance: number;
+        duration: number;
+        steps?: Array<{
+            distance: number;
+            duration: number;
+            geometry: Coordinate[];
+            maneuver: {
+                type: string;
+                modifier?: string;
+                location: Coordinate;
+                bearing_before: number;
+                bearing_after: number;
+                instruction?: string;
+            };
+            name?: string;
+        }>;
+    }>;
+    raw?: unknown;
+}
+interface RouteOptions {
+    profile?: string;
+    alternatives?: boolean;
+    steps?: boolean;
+    geometries?: string;
+    overview?: string;
+    language?: string;
+}
+declare class MapboxDirectionsProvider {
+    private readonly config;
+    constructor(config: MapboxDirectionsConfig);
+    /**
+     * Get a route through the given waypoints.
+     * Automatically chunks if waypoints exceed the Mapbox limit.
+     */
+    getRoute(waypoints: Coordinate[], options?: RouteOptions): Promise<RouteResult>;
+    /**
+     * Fetch a single route segment from the Mapbox API.
+     */
+    private fetchRoute;
+    /**
+     * Fetch multi-segment route, stitching chunks with OVERLAP_1 strategy.
+     */
+    private fetchChunkedRoute;
+}
+
+export { type MapboxDirectionsConfig, MapboxDirectionsProvider };

package/dist/index.js

@@ -1,7 +1,121 @@
-/**
- * @navcore/mapbox — Mapbox GL adapters
- *
- * Provides NavCoreRenderer and DirectionsProvider implementations
- * for Mapbox GL (via @rnmapbox/maps for React Native, or mapbox-gl for web).
- */
-export { MapboxDirectionsProvider } from './MapboxDirectionsProvider';
+'use strict';
+
+// src/MapboxDirectionsProvider.ts
+var DEFAULT_BASE_URL = "https://api.mapbox.com/directions/v5/mapbox";
+var MAX_WAYPOINTS = 25;
+var MapboxDirectionsProvider = class {
+  constructor(config) {
+    this.config = {
+      accessToken: config.accessToken,
+      profile: config.profile ?? "driving",
+      baseUrl: config.baseUrl ?? DEFAULT_BASE_URL,
+      maxWaypointsPerChunk: config.maxWaypointsPerChunk ?? MAX_WAYPOINTS
+    };
+  }
+  /**
+   * Get a route through the given waypoints.
+   * Automatically chunks if waypoints exceed the Mapbox limit.
+   */
+  async getRoute(waypoints, options) {
+    if (waypoints.length < 2) {
+      throw new Error("At least 2 waypoints are required");
+    }
+    if (waypoints.length <= this.config.maxWaypointsPerChunk) {
+      return this.fetchRoute(waypoints, options);
+    }
+    return this.fetchChunkedRoute(waypoints, options);
+  }
+  /**
+   * Fetch a single route segment from the Mapbox API.
+   */
+  async fetchRoute(waypoints, options) {
+    const profile = options?.profile ?? this.config.profile;
+    const coords = waypoints.map((w) => `${w[0]},${w[1]}`).join(";");
+    const params = new URLSearchParams({
+      access_token: this.config.accessToken,
+      geometries: options?.geometries ?? "geojson",
+      overview: options?.overview ?? "full",
+      steps: String(options?.steps ?? true),
+      alternatives: String(options?.alternatives ?? false)
+    });
+    if (options?.language) {
+      params.set("language", options.language);
+    }
+    const url = `${this.config.baseUrl}/${profile}/${coords}?${params}`;
+    const response = await fetch(url);
+    if (!response.ok) {
+      throw new Error(`Mapbox API error: ${response.status} ${response.statusText}`);
+    }
+    const data = await response.json();
+    if (!data.routes || data.routes.length === 0) {
+      throw new Error("No route found");
+    }
+    const route = data.routes[0];
+    return {
+      geometry: route.geometry.coordinates,
+      distance: route.distance,
+      duration: route.duration,
+      legs: route.legs.map((leg) => ({
+        distance: leg.distance,
+        duration: leg.duration,
+        steps: leg.steps?.map((step) => ({
+          distance: step.distance,
+          duration: step.duration,
+          geometry: step.geometry?.coordinates ?? [],
+          maneuver: {
+            type: step.maneuver?.type ?? "unknown",
+            modifier: step.maneuver?.modifier,
+            location: step.maneuver?.location ?? [0, 0],
+            bearing_before: step.maneuver?.bearing_before ?? 0,
+            bearing_after: step.maneuver?.bearing_after ?? 0,
+            instruction: step.maneuver?.instruction
+          },
+          name: step.name
+        }))
+      })),
+      raw: data
+    };
+  }
+  /**
+   * Fetch multi-segment route, stitching chunks with OVERLAP_1 strategy.
+   */
+  async fetchChunkedRoute(waypoints, options) {
+    const chunkSize = this.config.maxWaypointsPerChunk;
+    const step = chunkSize - 1;
+    const chunks = [];
+    for (let i = 0; i < waypoints.length; i += step) {
+      const chunk = waypoints.slice(i, i + chunkSize);
+      if (chunk.length < 2) break;
+      chunks.push(chunk);
+      if (i + chunkSize >= waypoints.length) break;
+    }
+    const results = await Promise.all(
+      chunks.map((chunk) => this.fetchRoute(chunk, options))
+    );
+    const stitchedGeometry = [];
+    let totalDistance = 0;
+    let totalDuration = 0;
+    const allLegs = [];
+    for (let i = 0; i < results.length; i++) {
+      const result = results[i];
+      const geom = result.geometry;
+      if (i === 0) {
+        stitchedGeometry.push(...geom);
+      } else {
+        stitchedGeometry.push(...geom.slice(1));
+      }
+      totalDistance += result.distance;
+      totalDuration += result.duration;
+      allLegs.push(...result.legs);
+    }
+    return {
+      geometry: stitchedGeometry,
+      distance: totalDistance,
+      duration: totalDuration,
+      legs: allLegs,
+      raw: results.map((r) => r.raw)
+    };
+  }
+};
+
+exports.MapboxDirectionsProvider = MapboxDirectionsProvider;

package/dist/index.mjs

@@ -0,0 +1,119 @@
+// src/MapboxDirectionsProvider.ts
+var DEFAULT_BASE_URL = "https://api.mapbox.com/directions/v5/mapbox";
+var MAX_WAYPOINTS = 25;
+var MapboxDirectionsProvider = class {
+  constructor(config) {
+    this.config = {
+      accessToken: config.accessToken,
+      profile: config.profile ?? "driving",
+      baseUrl: config.baseUrl ?? DEFAULT_BASE_URL,
+      maxWaypointsPerChunk: config.maxWaypointsPerChunk ?? MAX_WAYPOINTS
+    };
+  }
+  /**
+   * Get a route through the given waypoints.
+   * Automatically chunks if waypoints exceed the Mapbox limit.
+   */
+  async getRoute(waypoints, options) {
+    if (waypoints.length < 2) {
+      throw new Error("At least 2 waypoints are required");
+    }
+    if (waypoints.length <= this.config.maxWaypointsPerChunk) {
+      return this.fetchRoute(waypoints, options);
+    }
+    return this.fetchChunkedRoute(waypoints, options);
+  }
+  /**
+   * Fetch a single route segment from the Mapbox API.
+   */
+  async fetchRoute(waypoints, options) {
+    const profile = options?.profile ?? this.config.profile;
+    const coords = waypoints.map((w) => `${w[0]},${w[1]}`).join(";");
+    const params = new URLSearchParams({
+      access_token: this.config.accessToken,
+      geometries: options?.geometries ?? "geojson",
+      overview: options?.overview ?? "full",
+      steps: String(options?.steps ?? true),
+      alternatives: String(options?.alternatives ?? false)
+    });
+    if (options?.language) {
+      params.set("language", options.language);
+    }
+    const url = `${this.config.baseUrl}/${profile}/${coords}?${params}`;
+    const response = await fetch(url);
+    if (!response.ok) {
+      throw new Error(`Mapbox API error: ${response.status} ${response.statusText}`);
+    }
+    const data = await response.json();
+    if (!data.routes || data.routes.length === 0) {
+      throw new Error("No route found");
+    }
+    const route = data.routes[0];
+    return {
+      geometry: route.geometry.coordinates,
+      distance: route.distance,
+      duration: route.duration,
+      legs: route.legs.map((leg) => ({
+        distance: leg.distance,
+        duration: leg.duration,
+        steps: leg.steps?.map((step) => ({
+          distance: step.distance,
+          duration: step.duration,
+          geometry: step.geometry?.coordinates ?? [],
+          maneuver: {
+            type: step.maneuver?.type ?? "unknown",
+            modifier: step.maneuver?.modifier,
+            location: step.maneuver?.location ?? [0, 0],
+            bearing_before: step.maneuver?.bearing_before ?? 0,
+            bearing_after: step.maneuver?.bearing_after ?? 0,
+            instruction: step.maneuver?.instruction
+          },
+          name: step.name
+        }))
+      })),
+      raw: data
+    };
+  }
+  /**
+   * Fetch multi-segment route, stitching chunks with OVERLAP_1 strategy.
+   */
+  async fetchChunkedRoute(waypoints, options) {
+    const chunkSize = this.config.maxWaypointsPerChunk;
+    const step = chunkSize - 1;
+    const chunks = [];
+    for (let i = 0; i < waypoints.length; i += step) {
+      const chunk = waypoints.slice(i, i + chunkSize);
+      if (chunk.length < 2) break;
+      chunks.push(chunk);
+      if (i + chunkSize >= waypoints.length) break;
+    }
+    const results = await Promise.all(
+      chunks.map((chunk) => this.fetchRoute(chunk, options))
+    );
+    const stitchedGeometry = [];
+    let totalDistance = 0;
+    let totalDuration = 0;
+    const allLegs = [];
+    for (let i = 0; i < results.length; i++) {
+      const result = results[i];
+      const geom = result.geometry;
+      if (i === 0) {
+        stitchedGeometry.push(...geom);
+      } else {
+        stitchedGeometry.push(...geom.slice(1));
+      }
+      totalDistance += result.distance;
+      totalDuration += result.duration;
+      allLegs.push(...result.legs);
+    }
+    return {
+      geometry: stitchedGeometry,
+      distance: totalDistance,
+      duration: totalDuration,
+      legs: allLegs,
+      raw: results.map((r) => r.raw)
+    };
+  }
+};
+
+export { MapboxDirectionsProvider };

package/package.json

@@ -1,52 +1,44 @@
-{
-  "name": "@ingissa/navcore-mapbox",
-  "version": "1.0.8",
-  "description": "Mapbox GL adapter for NavCore — renderer and directions provider.",
-  "author": "Ingissa <8abnav@gmail.com>",
-  "license": "SEE LICENSE IN LICENSE",
-  "homepage": "https://navcore.dev",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/ingissa/navcore-sdk.git"
-  },
-  "bugs": {
-    "url": "https://github.com/ingissa/navcore-sdk/issues"
-  },
-  "main": "dist/index.js",
-  "module": "dist/index.mjs",
-  "types": "dist/index.d.ts",
-  "exports": {
-    ".": {
-      "import": "./dist/index.mjs",
-      "require": "./dist/index.js",
-      "types": "./dist/index.d.ts"
-    }
-  },
-  "files": [
-    "dist",
-    "src",
-    "LICENSE"
-  ],
-  "sideEffects": false,
-  "publishConfig": {
-    "access": "public"
-  },
-  "engines": {
-    "node": ">=16"
-  },
-  "scripts": {
-    "build": "tsc -p tsconfig.build.json",
-    "lint": "tsc --noEmit",
-    "prepublishOnly": "npm run build"
-  },
-  "peerDependencies": {
-    "@ingissa/navcore-core": "^1.0.8",
-    "@rnmapbox/maps": ">=10.0.0"
-  },
-  "peerDependenciesMeta": {
-    "@rnmapbox/maps": {
-      "optional": true
-    }
-  },
-  "dependencies": {}
-}
+{
+  "name": "@ingissa/navcore-mapbox",
+  "version": "1.0.10",
+  "description": "Mapbox GL adapter for NavCore — renderer and directions provider.",
+  "author": "Ingissa <8abnav@gmail.com>",
+  "license": "SEE LICENSE IN LICENSE",
+  "homepage": "https://navcore-web.vercel.app/",
+  "main": "dist/index.js",
+  "module": "dist/index.mjs",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "LICENSE"
+  ],
+  "sideEffects": false,
+  "publishConfig": {
+    "access": "public"
+  },
+  "engines": {
+    "node": ">=16"
+  },
+  "scripts": {
+    "build": "tsup",
+    "lint": "tsc --noEmit",
+    "prepublishOnly": "npm run build --prefix ../.. && node ../../scripts/check-release.mjs"
+  },
+  "peerDependencies": {
+    "@ingissa/navcore-core": "^1.0.10",
+    "@rnmapbox/maps": ">=10.0.0"
+  },
+  "peerDependenciesMeta": {
+    "@rnmapbox/maps": {
+      "optional": true
+    }
+  },
+  "dependencies": {}
+}

package/dist/MapboxDirectionsProvider.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"MapboxDirectionsProvider.d.ts","sourceRoot":"","sources":["../src/MapboxDirectionsProvider.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,KAAK,UAAU,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;AAEnC,MAAM,WAAW,sBAAsB;IACrC,0BAA0B;IAC1B,WAAW,EAAE,MAAM,CAAC;IACpB,2CAA2C;IAC3C,OAAO,CAAC,EAAE,SAAS,GAAG,iBAAiB,GAAG,SAAS,GAAG,SAAS,CAAC;IAChE,gDAAgD;IAChD,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,6DAA6D;IAC7D,oBAAoB,CAAC,EAAE,MAAM,CAAC;CAC/B;AAED,UAAU,WAAW;IACnB,QAAQ,EAAE,UAAU,EAAE,CAAC;IACvB,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,EAAE,KAAK,CAAC;QACV,QAAQ,EAAE,MAAM,CAAC;QACjB,QAAQ,EAAE,MAAM,CAAC;QACjB,KAAK,CAAC,EAAE,KAAK,CAAC;YACZ,QAAQ,EAAE,MAAM,CAAC;YACjB,QAAQ,EAAE,MAAM,CAAC;YACjB,QAAQ,EAAE,UAAU,EAAE,CAAC;YACvB,QAAQ,EAAE;gBACR,IAAI,EAAE,MAAM,CAAC;gBACb,QAAQ,CAAC,EAAE,MAAM,CAAC;gBAClB,QAAQ,EAAE,UAAU,CAAC;gBACrB,cAAc,EAAE,MAAM,CAAC;gBACvB,aAAa,EAAE,MAAM,CAAC;gBACtB,WAAW,CAAC,EAAE,MAAM,CAAC;aACtB,CAAC;YACF,IAAI,CAAC,EAAE,MAAM,CAAC;SACf,CAAC,CAAC;KACJ,CAAC,CAAC;IACH,GAAG,CAAC,EAAE,OAAO,CAAC;CACf;AAED,UAAU,YAAY;IACpB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAKD,qBAAa,wBAAwB;IACnC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAmC;gBAE9C,MAAM,EAAE,sBAAsB;IAS1C;;;OAGG;IACG,QAAQ,CAAC,SAAS,EAAE,UAAU,EAAE,EAAE,OAAO,CAAC,EAAE,YAAY,GAAG,OAAO,CAAC,WAAW,CAAC;IAcrF;;OAEG;YACW,UAAU;IAyDxB;;OAEG;YACW,iBAAiB;CA+ChC"}

package/dist/MapboxDirectionsProvider.js

@@ -1,128 +0,0 @@
-/**
- * MapboxDirectionsProvider
- *
- * Implements DirectionsProvider using the Mapbox Directions API.
- * Handles waypoint chunking internally for routes with >25 waypoints.
- */
-const DEFAULT_BASE_URL = 'https://api.mapbox.com/directions/v5/mapbox';
-const MAX_WAYPOINTS = 25;
-export class MapboxDirectionsProvider {
-    constructor(config) {
-        this.config = {
-            accessToken: config.accessToken,
-            profile: config.profile ?? 'driving',
-            baseUrl: config.baseUrl ?? DEFAULT_BASE_URL,
-            maxWaypointsPerChunk: config.maxWaypointsPerChunk ?? MAX_WAYPOINTS,
-        };
-    }
-    /**
-     * Get a route through the given waypoints.
-     * Automatically chunks if waypoints exceed the Mapbox limit.
-     */
-    async getRoute(waypoints, options) {
-        if (waypoints.length < 2) {
-            throw new Error('At least 2 waypoints are required');
-        }
-        // If within limit, single request
-        if (waypoints.length <= this.config.maxWaypointsPerChunk) {
-            return this.fetchRoute(waypoints, options);
-        }
-        // Otherwise chunk with OVERLAP_1 strategy
-        return this.fetchChunkedRoute(waypoints, options);
-    }
-    /**
-     * Fetch a single route segment from the Mapbox API.
-     */
-    async fetchRoute(waypoints, options) {
-        const profile = options?.profile ?? this.config.profile;
-        const coords = waypoints.map(w => `${w[0]},${w[1]}`).join(';');
-        const params = new URLSearchParams({
-            access_token: this.config.accessToken,
-            geometries: options?.geometries ?? 'geojson',
-            overview: options?.overview ?? 'full',
-            steps: String(options?.steps ?? true),
-            alternatives: String(options?.alternatives ?? false),
-        });
-        if (options?.language) {
-            params.set('language', options.language);
-        }
-        const url = `${this.config.baseUrl}/${profile}/${coords}?${params}`;
-        const response = await fetch(url);
-        if (!response.ok) {
-            throw new Error(`Mapbox API error: ${response.status} ${response.statusText}`);
-        }
-        const data = await response.json();
-        if (!data.routes || data.routes.length === 0) {
-            throw new Error('No route found');
-        }
-        const route = data.routes[0];
-        return {
-            geometry: route.geometry.coordinates,
-            distance: route.distance,
-            duration: route.duration,
-            legs: route.legs.map((leg) => ({
-                distance: leg.distance,
-                duration: leg.duration,
-                steps: leg.steps?.map((step) => ({
-                    distance: step.distance,
-                    duration: step.duration,
-                    geometry: step.geometry?.coordinates ?? [],
-                    maneuver: {
-                        type: step.maneuver?.type ?? 'unknown',
-                        modifier: step.maneuver?.modifier,
-                        location: step.maneuver?.location ?? [0, 0],
-                        bearing_before: step.maneuver?.bearing_before ?? 0,
-                        bearing_after: step.maneuver?.bearing_after ?? 0,
-                        instruction: step.maneuver?.instruction,
-                    },
-                    name: step.name,
-                })),
-            })),
-            raw: data,
-        };
-    }
-    /**
-     * Fetch multi-segment route, stitching chunks with OVERLAP_1 strategy.
-     */
-    async fetchChunkedRoute(waypoints, options) {
-        const chunkSize = this.config.maxWaypointsPerChunk;
-        const step = chunkSize - 1; // OVERLAP_1
-        const chunks = [];
-        for (let i = 0; i < waypoints.length; i += step) {
-            const chunk = waypoints.slice(i, i + chunkSize);
-            if (chunk.length < 2)
-                break;
-            chunks.push(chunk);
-            if (i + chunkSize >= waypoints.length)
-                break;
-        }
-        // Fetch all chunks in parallel
-        const results = await Promise.all(chunks.map(chunk => this.fetchRoute(chunk, options)));
-        // Stitch geometries — drop first point of subsequent chunks (it's the overlap)
-        const stitchedGeometry = [];
-        let totalDistance = 0;
-        let totalDuration = 0;
-        const allLegs = [];
-        for (let i = 0; i < results.length; i++) {
-            const result = results[i];
-            const geom = result.geometry;
-            if (i === 0) {
-                stitchedGeometry.push(...geom);
-            }
-            else {
-                // Skip first point (overlap with previous chunk's last point)
-                stitchedGeometry.push(...geom.slice(1));
-            }
-            totalDistance += result.distance;
-            totalDuration += result.duration;
-            allLegs.push(...result.legs);
-        }
-        return {
-            geometry: stitchedGeometry,
-            distance: totalDistance,
-            duration: totalDuration,
-            legs: allLegs,
-            raw: results.map(r => r.raw),
-        };
-    }
-}

package/dist/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,wBAAwB,EAAE,MAAM,4BAA4B,CAAC;AACtE,YAAY,EAAE,sBAAsB,EAAE,MAAM,4BAA4B,CAAC"}

package/src/MapboxDirectionsProvider.ts

@@ -1,198 +0,0 @@
-/**
- * MapboxDirectionsProvider
- *
- * Implements DirectionsProvider using the Mapbox Directions API.
- * Handles waypoint chunking internally for routes with >25 waypoints.
- */
-
-type Coordinate = [number, number];
-
-export interface MapboxDirectionsConfig {
-  /** Mapbox access token */
-  accessToken: string;
-  /** Routing profile (default: 'driving') */
-  profile?: 'driving' | 'driving-traffic' | 'cycling' | 'walking';
-  /** API base URL (default: Mapbox production) */
-  baseUrl?: string;
-  /** Max waypoints per API call (default: 25, Mapbox limit) */
-  maxWaypointsPerChunk?: number;
-}
-
-interface RouteResult {
-  geometry: Coordinate[];
-  distance: number;
-  duration: number;
-  legs: Array<{
-    distance: number;
-    duration: number;
-    steps?: Array<{
-      distance: number;
-      duration: number;
-      geometry: Coordinate[];
-      maneuver: {
-        type: string;
-        modifier?: string;
-        location: Coordinate;
-        bearing_before: number;
-        bearing_after: number;
-        instruction?: string;
-      };
-      name?: string;
-    }>;
-  }>;
-  raw?: unknown;
-}
-
-interface RouteOptions {
-  profile?: string;
-  alternatives?: boolean;
-  steps?: boolean;
-  geometries?: string;
-  overview?: string;
-  language?: string;
-}
-
-const DEFAULT_BASE_URL = 'https://api.mapbox.com/directions/v5/mapbox';
-const MAX_WAYPOINTS = 25;
-
-export class MapboxDirectionsProvider {
-  private readonly config: Required<MapboxDirectionsConfig>;
-
-  constructor(config: MapboxDirectionsConfig) {
-    this.config = {
-      accessToken: config.accessToken,
-      profile: config.profile ?? 'driving',
-      baseUrl: config.baseUrl ?? DEFAULT_BASE_URL,
-      maxWaypointsPerChunk: config.maxWaypointsPerChunk ?? MAX_WAYPOINTS,
-    };
-  }
-
-  /**
-   * Get a route through the given waypoints.
-   * Automatically chunks if waypoints exceed the Mapbox limit.
-   */
-  async getRoute(waypoints: Coordinate[], options?: RouteOptions): Promise<RouteResult> {
-    if (waypoints.length < 2) {
-      throw new Error('At least 2 waypoints are required');
-    }
-
-    // If within limit, single request
-    if (waypoints.length <= this.config.maxWaypointsPerChunk) {
-      return this.fetchRoute(waypoints, options);
-    }
-
-    // Otherwise chunk with OVERLAP_1 strategy
-    return this.fetchChunkedRoute(waypoints, options);
-  }
-
-  /**
-   * Fetch a single route segment from the Mapbox API.
-   */
-  private async fetchRoute(waypoints: Coordinate[], options?: RouteOptions): Promise<RouteResult> {
-    const profile = options?.profile ?? this.config.profile;
-    const coords = waypoints.map(w => `${w[0]},${w[1]}`).join(';');
-
-    const params = new URLSearchParams({
-      access_token: this.config.accessToken,
-      geometries: options?.geometries ?? 'geojson',
-      overview: options?.overview ?? 'full',
-      steps: String(options?.steps ?? true),
-      alternatives: String(options?.alternatives ?? false),
-    });
-
-    if (options?.language) {
-      params.set('language', options.language);
-    }
-
-    const url = `${this.config.baseUrl}/${profile}/${coords}?${params}`;
-    const response = await fetch(url);
-
-    if (!response.ok) {
-      throw new Error(`Mapbox API error: ${response.status} ${response.statusText}`);
-    }
-
-    const data = await response.json();
-
-    if (!data.routes || data.routes.length === 0) {
-      throw new Error('No route found');
-    }
-
-    const route = data.routes[0];
-
-    return {
-      geometry: route.geometry.coordinates as Coordinate[],
-      distance: route.distance,
-      duration: route.duration,
-      legs: route.legs.map((leg: { distance: number; duration: number; steps?: unknown[] }) => ({
-        distance: leg.distance,
-        duration: leg.duration,
-        steps: leg.steps?.map((step: any) => ({
-          distance: step.distance,
-          duration: step.duration,
-          geometry: step.geometry?.coordinates ?? [],
-          maneuver: {
-            type: step.maneuver?.type ?? 'unknown',
-            modifier: step.maneuver?.modifier,
-            location: step.maneuver?.location ?? [0, 0],
-            bearing_before: step.maneuver?.bearing_before ?? 0,
-            bearing_after: step.maneuver?.bearing_after ?? 0,
-            instruction: step.maneuver?.instruction,
-          },
-          name: step.name,
-        })),
-      })),
-      raw: data,
-    };
-  }
-
-  /**
-   * Fetch multi-segment route, stitching chunks with OVERLAP_1 strategy.
-   */
-  private async fetchChunkedRoute(waypoints: Coordinate[], options?: RouteOptions): Promise<RouteResult> {
-    const chunkSize = this.config.maxWaypointsPerChunk;
-    const step = chunkSize - 1; // OVERLAP_1
-    const chunks: Coordinate[][] = [];
-
-    for (let i = 0; i < waypoints.length; i += step) {
-      const chunk = waypoints.slice(i, i + chunkSize);
-      if (chunk.length < 2) break;
-      chunks.push(chunk);
-      if (i + chunkSize >= waypoints.length) break;
-    }
-
-    // Fetch all chunks in parallel
-    const results = await Promise.all(
-      chunks.map(chunk => this.fetchRoute(chunk, options))
-    );
-
-    // Stitch geometries — drop first point of subsequent chunks (it's the overlap)
-    const stitchedGeometry: Coordinate[] = [];
-    let totalDistance = 0;
-    let totalDuration = 0;
-    const allLegs: RouteResult['legs'] = [];
-
-    for (let i = 0; i < results.length; i++) {
-      const result = results[i]!;
-      const geom = result.geometry;
-
-      if (i === 0) {
-        stitchedGeometry.push(...geom);
-      } else {
-        // Skip first point (overlap with previous chunk's last point)
-        stitchedGeometry.push(...geom.slice(1));
-      }
-
-      totalDistance += result.distance;
-      totalDuration += result.duration;
-      allLegs.push(...result.legs);
-    }
-
-    return {
-      geometry: stitchedGeometry,
-      distance: totalDistance,
-      duration: totalDuration,
-      legs: allLegs,
-      raw: results.map(r => r.raw),
-    };
-  }
-}

package/src/index.ts

@@ -1,9 +0,0 @@
-/**
- * @navcore/mapbox — Mapbox GL adapters
- *
- * Provides NavCoreRenderer and DirectionsProvider implementations
- * for Mapbox GL (via @rnmapbox/maps for React Native, or mapbox-gl for web).
- */
-
-export { MapboxDirectionsProvider } from './MapboxDirectionsProvider';
-export type { MapboxDirectionsConfig } from './MapboxDirectionsProvider';