@ingissa/navcore-mapbox 1.0.3 → 1.0.4

package/dist/index.d.mts

@@ -0,0 +1,49 @@
+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.d.ts

@@ -1,9 +1,49 @@
+import { DirectionsOptions, DirectionsProvider, Coordinate, DirectionsResult } from '@ingissa/navcore-core';
+
 /**
- * @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 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.js

@@ -1,7 +1,146 @@
-/**
- * @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 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;

package/dist/index.mjs

@@ -0,0 +1,144 @@
+// 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 };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@ingissa/navcore-mapbox",
-  "version": "1.0.3",
-  "description": "Mapbox GL adapter for NavCore — renderer and directions provider.",
+  "version": "1.0.4",
+  "description": "Mapbox GL adapter for NavCore - renderer and directions provider.",
   "author": "Ingissa <8abnav@gmail.com>",
   "license": "Commercial",
   "homepage": "https://navcore-web.vercel.app/",
@@ -17,28 +17,33 @@
   "types": "dist/index.d.ts",
   "exports": {
     ".": {
+      "types": "./dist/index.d.ts",
       "import": "./dist/index.mjs",
-      "require": "./dist/index.js",
-      "types": "./dist/index.d.ts"
+      "require": "./dist/index.js"
     }
   },
-  "files": ["dist"],
+  "files": [
+    "dist"
+  ],
   "sideEffects": false,
   "publishConfig": {
     "access": "public"
   },
-  "engines": { "node": ">=18" },
+  "engines": {
+    "node": ">=18"
+  },
   "scripts": {
-    "build": "tsc -p tsconfig.build.json",
+    "build": "tsup",
     "lint": "tsc --noEmit",
     "prepublishOnly": "npm run build"
   },
   "peerDependencies": {
-    "@ingissa/navcore-core": "^1.0.3",
+    "@ingissa/navcore-core": "^1.0.4",
     "@rnmapbox/maps": ">=10.0.0"
   },
   "peerDependenciesMeta": {
-    "@rnmapbox/maps": { "optional": true }
-  },
-  "dependencies": {}
+    "@rnmapbox/maps": {
+      "optional": true
+    }
+  }
 }

package/dist/MapboxDirectionsProvider.d.ts

@@ -1,68 +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;
-}
-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

@@ -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"}