@ingissa/navcore-mapbox 1.0.4 → 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/dist/MapboxDirectionsProvider.d.ts

@@ -0,0 +1,68 @@
+/**
+ * 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;
+}
+export 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 {};
+//# sourceMappingURL=MapboxDirectionsProvider.d.ts.map

package/dist/MapboxDirectionsProvider.d.ts.map

@@ -0,0 +1 @@
+{"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

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

@@ -1,49 +1,9 @@
-import { DirectionsOptions, DirectionsProvider, Coordinate, DirectionsResult } from '@ingissa/navcore-core';
-
 /**
- * MapboxDirectionsProvider
+ * @navcore/mapbox — Mapbox GL adapters
  *
- * Implements DirectionsProvider using the Mapbox Directions API.
- * Handles waypoint chunking internally for routes with >25 waypoints.
+ * Provides NavCoreRenderer and DirectionsProvider implementations
+ * for Mapbox GL (via @rnmapbox/maps for React Native, or mapbox-gl for web).
  */
-
-type MapboxProfile = 'driving' | 'driving-traffic' | 'cycling' | 'walking';
-interface MapboxDirectionsConfig {
-    /** Mapbox access token */
-    accessToken: string;
-    /** Routing profile (default: 'driving') */
-    profile?: MapboxProfile;
-    /** API base URL (default: Mapbox production) */
-    baseUrl?: string;
-    /** Max waypoints per API call (default: 25, Mapbox limit) */
-    maxWaypointsPerChunk?: number;
-    /** Optional fetch implementation for tests, React Native, or custom runtimes */
-    fetchFn?: typeof fetch;
-    /** Request timeout in milliseconds. Set to 0 to disable. */
-    timeoutMs?: number;
-}
-type MapboxDirectionsOptions = Omit<DirectionsOptions, 'profile'> & {
-    profile?: MapboxProfile;
-    geometries?: 'geojson';
-    overview?: 'full' | 'simplified' | 'false';
-};
-declare class MapboxDirectionsProvider implements DirectionsProvider {
-    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?: MapboxDirectionsOptions): Promise<DirectionsResult>;
-    /**
-     * Fetch a single route segment from the Mapbox API.
-     */
-    private fetchRoute;
-    /**
-     * Fetch multi-segment route, stitching chunks with OVERLAP_1 strategy.
-     */
-    private fetchChunkedRoute;
-    private fetchWithTimeout;
-}
-
-export { type MapboxDirectionsConfig, type MapboxDirectionsOptions, MapboxDirectionsProvider };
+export { MapboxDirectionsProvider } from './MapboxDirectionsProvider';
+export type { MapboxDirectionsConfig } from './MapboxDirectionsProvider';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"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/dist/index.js

@@ -1,146 +1,7 @@
-'use strict';
-
-// src/MapboxDirectionsProvider.ts
-var DEFAULT_BASE_URL = "https://api.mapbox.com/directions/v5/mapbox";
-var MAX_WAYPOINTS = 25;
-var DEFAULT_TIMEOUT_MS = 15e3;
-var MapboxDirectionsProvider = class {
-  constructor(config) {
-    const fetchFn = config.fetchFn ?? globalThis.fetch?.bind(globalThis);
-    if (!fetchFn) {
-      throw new Error("[Mapbox] fetch is not available. Pass config.fetchFn in this runtime.");
-    }
-    this.config = {
-      accessToken: config.accessToken,
-      profile: config.profile ?? "driving",
-      baseUrl: config.baseUrl ?? DEFAULT_BASE_URL,
-      maxWaypointsPerChunk: config.maxWaypointsPerChunk ?? MAX_WAYPOINTS,
-      fetchFn,
-      timeoutMs: config.timeoutMs ?? DEFAULT_TIMEOUT_MS
-    };
-  }
-  /**
-   * 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 this.fetchWithTimeout(url);
-    if (!response.ok) {
-      const text = await response.text();
-      throw new Error(`[Mapbox] HTTP ${response.status}: ${text || 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],
-            bearingBefore: step.maneuver?.bearing_before ?? 0,
-            bearingAfter: 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)
-    };
-  }
-  async fetchWithTimeout(url, init) {
-    if (this.config.timeoutMs <= 0 || typeof AbortController === "undefined") {
-      return this.config.fetchFn(url, init);
-    }
-    const controller = new AbortController();
-    const timeout = setTimeout(() => controller.abort(), this.config.timeoutMs);
-    try {
-      return await this.config.fetchFn(url, { ...init, signal: controller.signal });
-    } catch (error) {
-      if (error.name === "AbortError") {
-        throw new Error(`[Mapbox] Request timed out after ${this.config.timeoutMs}ms`);
-      }
-      throw error;
-    } finally {
-      clearTimeout(timeout);
-    }
-  }
-};
-
-exports.MapboxDirectionsProvider = MapboxDirectionsProvider;
+/**
+ * @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';

package/package.json

@@ -1,49 +1,52 @@
 {
   "name": "@ingissa/navcore-mapbox",
-  "version": "1.0.4",
-  "description": "Mapbox GL adapter for NavCore - renderer and directions provider.",
+  "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",
   "types": "dist/index.d.ts",
   "exports": {
     ".": {
-      "types": "./dist/index.d.ts",
       "import": "./dist/index.mjs",
-      "require": "./dist/index.js"
+      "require": "./dist/index.js",
+      "types": "./dist/index.d.ts"
     }
   },
   "files": [
-    "dist"
+    "dist",
+    "src",
+    "LICENSE"
   ],
   "sideEffects": false,
   "publishConfig": {
     "access": "public"
   },
   "engines": {
-    "node": ">=18"
+    "node": ">=16"
   },
   "scripts": {
-    "build": "tsup",
+    "build": "tsc -p tsconfig.build.json",
     "lint": "tsc --noEmit",
     "prepublishOnly": "npm run build"
   },
   "peerDependencies": {
-    "@ingissa/navcore-core": "^1.0.4",
+    "@ingissa/navcore-core": "^1.0.8",
     "@rnmapbox/maps": ">=10.0.0"
   },
   "peerDependenciesMeta": {
     "@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';

package/dist/index.d.mts

@@ -1,49 +0,0 @@
-import { DirectionsOptions, DirectionsProvider, Coordinate, DirectionsResult } from '@ingissa/navcore-core';
-
-/**
- * MapboxDirectionsProvider
- *
- * Implements DirectionsProvider using the Mapbox Directions API.
- * Handles waypoint chunking internally for routes with >25 waypoints.
- */
-
-type MapboxProfile = 'driving' | 'driving-traffic' | 'cycling' | 'walking';
-interface MapboxDirectionsConfig {
-    /** Mapbox access token */
-    accessToken: string;
-    /** Routing profile (default: 'driving') */
-    profile?: MapboxProfile;
-    /** API base URL (default: Mapbox production) */
-    baseUrl?: string;
-    /** Max waypoints per API call (default: 25, Mapbox limit) */
-    maxWaypointsPerChunk?: number;
-    /** Optional fetch implementation for tests, React Native, or custom runtimes */
-    fetchFn?: typeof fetch;
-    /** Request timeout in milliseconds. Set to 0 to disable. */
-    timeoutMs?: number;
-}
-type MapboxDirectionsOptions = Omit<DirectionsOptions, 'profile'> & {
-    profile?: MapboxProfile;
-    geometries?: 'geojson';
-    overview?: 'full' | 'simplified' | 'false';
-};
-declare class MapboxDirectionsProvider implements DirectionsProvider {
-    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?: MapboxDirectionsOptions): Promise<DirectionsResult>;
-    /**
-     * Fetch a single route segment from the Mapbox API.
-     */
-    private fetchRoute;
-    /**
-     * Fetch multi-segment route, stitching chunks with OVERLAP_1 strategy.
-     */
-    private fetchChunkedRoute;
-    private fetchWithTimeout;
-}
-
-export { type MapboxDirectionsConfig, type MapboxDirectionsOptions, MapboxDirectionsProvider };

package/dist/index.mjs

@@ -1,144 +0,0 @@
-// src/MapboxDirectionsProvider.ts
-var DEFAULT_BASE_URL = "https://api.mapbox.com/directions/v5/mapbox";
-var MAX_WAYPOINTS = 25;
-var DEFAULT_TIMEOUT_MS = 15e3;
-var MapboxDirectionsProvider = class {
-  constructor(config) {
-    const fetchFn = config.fetchFn ?? globalThis.fetch?.bind(globalThis);
-    if (!fetchFn) {
-      throw new Error("[Mapbox] fetch is not available. Pass config.fetchFn in this runtime.");
-    }
-    this.config = {
-      accessToken: config.accessToken,
-      profile: config.profile ?? "driving",
-      baseUrl: config.baseUrl ?? DEFAULT_BASE_URL,
-      maxWaypointsPerChunk: config.maxWaypointsPerChunk ?? MAX_WAYPOINTS,
-      fetchFn,
-      timeoutMs: config.timeoutMs ?? DEFAULT_TIMEOUT_MS
-    };
-  }
-  /**
-   * 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 this.fetchWithTimeout(url);
-    if (!response.ok) {
-      const text = await response.text();
-      throw new Error(`[Mapbox] HTTP ${response.status}: ${text || 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],
-            bearingBefore: step.maneuver?.bearing_before ?? 0,
-            bearingAfter: 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)
-    };
-  }
-  async fetchWithTimeout(url, init) {
-    if (this.config.timeoutMs <= 0 || typeof AbortController === "undefined") {
-      return this.config.fetchFn(url, init);
-    }
-    const controller = new AbortController();
-    const timeout = setTimeout(() => controller.abort(), this.config.timeoutMs);
-    try {
-      return await this.config.fetchFn(url, { ...init, signal: controller.signal });
-    } catch (error) {
-      if (error.name === "AbortError") {
-        throw new Error(`[Mapbox] Request timed out after ${this.config.timeoutMs}ms`);
-      }
-      throw error;
-    } finally {
-      clearTimeout(timeout);
-    }
-  }
-};
-
-export { MapboxDirectionsProvider };