@ingissa/navcore-mapbox 1.0.3 → 1.0.8

package/LICENSE

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

package/package.json

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

package/src/MapboxDirectionsProvider.ts

@@ -0,0 +1,198 @@
+/**
+ * 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

@@ -0,0 +1,9 @@
+/**
+ * @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';