@ingissa/navcore-react-native 1.0.3 → 1.0.7

package/dist/core/src/progress/InstructionEditor.js

@@ -0,0 +1,151 @@
+/**
+ * InstructionEditor — Fluent builder for NavInstruction arrays.
+ *
+ * Create, edit, and annotate navigation instructions for custom routes.
+ * Supports standard turn instructions and exam-specific annotations.
+ *
+ * @example
+ * ```typescript
+ * const editor = new InstructionEditor();
+ * editor
+ *   .addTurn([2.347, 48.859], 'Turn left onto Rue de Rivoli', 42)
+ *   .addExamPoint([2.350, 48.860], 'Check mirrors before changing lane', 50)
+ *   .addCheckpoint([2.355, 48.861], 65);
+ *
+ * editor.attachToCumulative(routeGeometry);
+ * engine.setRoute(routeGeometry, editor.toArray());
+ * ```
+ */
+import { haversineDistance } from '../geo/haversine';
+import { getBearingBetweenPoints } from '../geo/bearing';
+let _idCounter = 0;
+function genId() {
+    return `instr_${Date.now()}_${++_idCounter}`;
+}
+export class InstructionEditor {
+    constructor() {
+        this.instructions = [];
+    }
+    // ── Fluent add methods ──────────────────────────────────────────────────────
+    /** Add a turn instruction at the given route geometry index */
+    addTurn(location, text, geometryIndex, opts) {
+        this.instructions.push({
+            id: genId(), type: 'turn',
+            location, text, instruction: text, geometryIndex,
+            silent: opts?.silent, meta: opts?.meta,
+        });
+        return this;
+    }
+    /** Add an exam-specific point (e.g. "Check mirrors", "Yield here") */
+    addExamPoint(location, text, geometryIndex, opts) {
+        this.instructions.push({
+            id: genId(), type: 'exam_point',
+            location, text, instruction: text, geometryIndex,
+            severity: opts?.severity ?? 'info',
+            silent: opts?.silent,
+            meta: opts?.meta,
+        });
+        return this;
+    }
+    /** Add a silent progress checkpoint (does not trigger voice) */
+    addCheckpoint(location, geometryIndex, meta) {
+        this.instructions.push({
+            id: genId(), type: 'checkpoint',
+            location, text: '', instruction: '', geometryIndex,
+            silent: true, meta,
+        });
+        return this;
+    }
+    /** Add a departure instruction (auto-inserted at index 0) */
+    addDepart(location, text = 'Start navigation') {
+        const instr = {
+            id: genId(), type: 'depart',
+            location, text, instruction: text, geometryIndex: 0,
+        };
+        this.instructions.unshift(instr);
+        return this;
+    }
+    /** Add an arrival instruction */
+    addArrive(location, text = 'You have arrived') {
+        this.instructions.push({
+            id: genId(), type: 'arrive',
+            location, text, instruction: text,
+            geometryIndex: Number.MAX_SAFE_INTEGER,
+        });
+        return this;
+    }
+    // ── Edit operations ─────────────────────────────────────────────────────────
+    /** Update any field of an instruction by id */
+    update(id, patch) {
+        const idx = this.instructions.findIndex(i => i.id === id);
+        if (idx === -1)
+            throw new Error(`[InstructionEditor] Instruction ${id} not found`);
+        this.instructions[idx] = { ...this.instructions[idx], ...patch };
+        return this;
+    }
+    /** Remove an instruction by id */
+    remove(id) {
+        const idx = this.instructions.findIndex(i => i.id === id);
+        if (idx === -1)
+            throw new Error(`[InstructionEditor] Instruction ${id} not found`);
+        this.instructions.splice(idx, 1);
+        return this;
+    }
+    /** Move an instruction to a new position in the list */
+    reorder(id, newIndex) {
+        const idx = this.instructions.findIndex(i => i.id === id);
+        if (idx === -1)
+            throw new Error(`[InstructionEditor] Instruction ${id} not found`);
+        const [item] = this.instructions.splice(idx, 1);
+        this.instructions.splice(Math.max(0, newIndex), 0, item);
+        return this;
+    }
+    /** Sort instructions by geometryIndex ascending */
+    sort() {
+        this.instructions.sort((a, b) => a.geometryIndex - b.geometryIndex);
+        return this;
+    }
+    /** Remove all instructions */
+    clear() {
+        this.instructions = [];
+        return this;
+    }
+    // ── Geometry attachment ─────────────────────────────────────────────────────
+    /**
+     * Compute and attach `cumulativeOffset` and `bearingBefore`/`bearingAfter`
+     * from the route geometry. Call this after loading the route but before
+     * passing instructions to the engine.
+     */
+    attachToCumulative(route) {
+        if (route.length < 2)
+            return this;
+        // Build cumulative distance array
+        const cum = [0];
+        for (let i = 1; i < route.length; i++) {
+            const prev = route[i - 1];
+            const curr = route[i];
+            cum.push(cum[i - 1] + haversineDistance(prev[1], prev[0], curr[1], curr[0]));
+        }
+        for (const instr of this.instructions) {
+            const idx = Math.min(instr.geometryIndex, route.length - 1);
+            instr.cumulativeOffset = cum[idx] ?? 0;
+            if (idx > 0 && idx < route.length - 1) {
+                instr.bearingBefore = getBearingBetweenPoints(route[idx - 1], route[idx]);
+                instr.bearingAfter = getBearingBetweenPoints(route[idx], route[idx + 1]);
+            }
+        }
+        return this;
+    }
+    // ── Import / Export ─────────────────────────────────────────────────────────
+    /** Export as plain NavInstruction[] for use with engine.setRoute() */
+    toArray() {
+        return this.instructions.map(({ id: _id, type: _type, severity: _s, meta: _m, ...rest }) => rest);
+    }
+    /** Export rich instructions with all metadata */
+    toRichArray() {
+        return [...this.instructions];
+    }
+    get size() {
+        return this.instructions.length;
+    }
+}

package/dist/core/src/progress/InstructionResolver.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Module 7: InstructionResolver
+ * Resolves the next upcoming instruction and determines if it should be triggered.
+ */
+import { type Coordinate } from '../geo/haversine';
+/** Navigation instruction (mirrors @navcore/types NavInstruction) */
+export interface NavInstruction {
+    location: Coordinate;
+    geometryIndex: number;
+    text?: string;
+    instruction?: string;
+    cumulativeOffset?: number;
+    bearingBefore?: number;
+    bearingAfter?: number;
+}
+export interface InstructionResult {
+    nextIdx: number;
+    instruction: NavInstruction | null;
+    wasTriggered: boolean;
+}
+/**
+ * Resolve which instruction is next and whether it should trigger now.
+ */
+export declare function resolveNextInstruction(currentGeometryIdx: number, instructions: NavInstruction[], currentInstrIdx: number, route: Coordinate[], currentCoord: Coordinate, vehicleBearing: number | null, vehicleDistance: number, speed?: number, isCircuit?: boolean): InstructionResult;
+//# sourceMappingURL=InstructionResolver.d.ts.map

package/dist/core/src/progress/InstructionResolver.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"InstructionResolver.d.ts","sourceRoot":"","sources":["../../../../../core/src/progress/InstructionResolver.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,KAAK,UAAU,EAAqB,MAAM,kBAAkB,CAAC;AAItE,qEAAqE;AACrE,MAAM,WAAW,cAAc;IAC7B,QAAQ,EAAE,UAAU,CAAC;IACrB,aAAa,EAAE,MAAM,CAAC;IACtB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB;AAOD,MAAM,WAAW,iBAAiB;IAChC,OAAO,EAAE,MAAM,CAAC;IAChB,WAAW,EAAE,cAAc,GAAG,IAAI,CAAC;IACnC,YAAY,EAAE,OAAO,CAAC;CACvB;AAED;;GAEG;AACH,wBAAgB,sBAAsB,CACpC,kBAAkB,EAAE,MAAM,EAC1B,YAAY,EAAE,cAAc,EAAE,EAC9B,eAAe,EAAE,MAAM,EACvB,KAAK,EAAE,UAAU,EAAE,EACnB,YAAY,EAAE,UAAU,EACxB,cAAc,EAAE,MAAM,GAAG,IAAI,EAC7B,eAAe,EAAE,MAAM,EACvB,KAAK,GAAE,MAAU,EACjB,SAAS,GAAE,OAAe,GACzB,iBAAiB,CAmFnB"}

package/dist/core/src/progress/InstructionResolver.js

@@ -0,0 +1,78 @@
+/**
+ * Module 7: InstructionResolver
+ * Resolves the next upcoming instruction and determines if it should be triggered.
+ */
+import { haversineDistance } from '../geo/haversine';
+import { getBearingBetweenPoints, normalizeAngle } from '../geo/bearing';
+import { BEARING_ALIGNMENT_THRESHOLD } from '../constants';
+// Trigger distance constants
+const BASE_TRIGGER_DISTANCE = 20;
+const MAX_TRIGGER_DISTANCE = 60;
+const SPEED_FACTOR = 3;
+/**
+ * Resolve which instruction is next and whether it should trigger now.
+ */
+export function resolveNextInstruction(currentGeometryIdx, instructions, currentInstrIdx, route, currentCoord, vehicleBearing, vehicleDistance, speed = 0, isCircuit = false) {
+    if (!instructions || instructions.length === 0 || currentInstrIdx >= instructions.length) {
+        return { nextIdx: currentInstrIdx, instruction: null, wasTriggered: false };
+    }
+    let idx = currentInstrIdx;
+    // 1. Monotonic skip-ahead: consume instructions we have physically passed
+    while (idx < instructions.length) {
+        const candidate = instructions[idx];
+        const isWayBehind = currentGeometryIdx > candidate.geometryIndex + 30;
+        const isPastPoint = candidate.cumulativeOffset !== undefined &&
+            vehicleDistance > candidate.cumulativeOffset + 15;
+        if (!isWayBehind && !isPastPoint)
+            break;
+        idx++;
+    }
+    if (idx >= instructions.length) {
+        return { nextIdx: idx, instruction: null, wasTriggered: false };
+    }
+    // 2. Proximity Check
+    const next = instructions[idx];
+    const distance = next.cumulativeOffset !== undefined
+        ? Math.max(0, next.cumulativeOffset - vehicleDistance)
+        : haversineDistance(currentCoord[1], currentCoord[0], next.location[1], next.location[0]);
+    const triggerDistance = Math.min(MAX_TRIGGER_DISTANCE, Math.max(BASE_TRIGGER_DISTANCE, speed * SPEED_FACTOR));
+    const isAhead = currentGeometryIdx <= next.geometryIndex + 2;
+    const isTooFarAhead = next.geometryIndex > currentGeometryIdx + (route.length * 0.15); // Don't trigger if > 15% of route ahead
+    const closeEnough = distance <= triggerDistance;
+    // Circuit logic: gate the arrival instruction (last one) until most of the route is done
+    const isLastInstruction = idx === instructions.length - 1;
+    const circuitGatePassed = (isCircuit && isLastInstruction)
+        ? (currentGeometryIdx > route.length * 0.8)
+        : true;
+    const shouldTrigger = closeEnough && isAhead && !isTooFarAhead && circuitGatePassed;
+    let wasTriggered = false;
+    if (shouldTrigger) {
+        // 3. Bearing gate for significant turns
+        let gatePassed = true;
+        const bearingAfter = next.bearingAfter ??
+            (next.geometryIndex < route.length - 1
+                ? getBearingBetweenPoints(route[next.geometryIndex], route[next.geometryIndex + 1])
+                : null);
+        const bearingBefore = next.bearingBefore ??
+            (next.geometryIndex > 0
+                ? getBearingBetweenPoints(route[next.geometryIndex - 1], route[next.geometryIndex])
+                : null);
+        if (bearingBefore !== null && bearingAfter !== null && vehicleBearing !== null) {
+            const turnAngle = Math.abs(normalizeAngle(bearingAfter - bearingBefore));
+            if (turnAngle > 30) {
+                const bearingDiff = Math.abs(normalizeAngle(vehicleBearing - bearingAfter));
+                if (bearingDiff > BEARING_ALIGNMENT_THRESHOLD) {
+                    gatePassed = false;
+                }
+            }
+        }
+        if (gatePassed) {
+            wasTriggered = true;
+        }
+    }
+    return {
+        nextIdx: idx,
+        instruction: next,
+        wasTriggered,
+    };
+}

package/dist/core/src/progress/ProgressTracker.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Module 6: ProgressTracker
+ * Monotonic route progress tracking with anti-jitter.
+ */
+import { type Coordinate } from '../geo/haversine';
+/**
+ * Validate a progress update: ensures monotonic forward progress with jitter tolerance.
+ *
+ * @returns The new progress index (may be the same as current if update is rejected)
+ */
+export declare function validateProgressUpdate(currentIdx: number, candidateIdx: number, route: Coordinate[], distToRoute: number, maxSnapDistance: number): number;
+//# sourceMappingURL=ProgressTracker.d.ts.map

package/dist/core/src/progress/ProgressTracker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ProgressTracker.d.ts","sourceRoot":"","sources":["../../../../../core/src/progress/ProgressTracker.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,KAAK,UAAU,EAAqB,MAAM,kBAAkB,CAAC;AAEtE;;;;GAIG;AACH,wBAAgB,sBAAsB,CACpC,UAAU,EAAE,MAAM,EAClB,YAAY,EAAE,MAAM,EACpB,KAAK,EAAE,UAAU,EAAE,EACnB,WAAW,EAAE,MAAM,EACnB,eAAe,EAAE,MAAM,GACtB,MAAM,CAYR"}

package/dist/core/src/progress/ProgressTracker.js

@@ -0,0 +1,22 @@
+/**
+ * Module 6: ProgressTracker
+ * Monotonic route progress tracking with anti-jitter.
+ */
+/**
+ * Validate a progress update: ensures monotonic forward progress with jitter tolerance.
+ *
+ * @returns The new progress index (may be the same as current if update is rejected)
+ */
+export function validateProgressUpdate(currentIdx, candidateIdx, route, distToRoute, maxSnapDistance) {
+    // Never go backwards
+    if (candidateIdx < currentIdx)
+        return currentIdx;
+    // Don't jump too far forward in one tick (anti-teleport)
+    const maxJump = 30;
+    if (candidateIdx > currentIdx + maxJump)
+        return currentIdx;
+    // Don't accept if too far from route
+    if (distToRoute > maxSnapDistance)
+        return currentIdx;
+    return candidateIdx;
+}

package/dist/core/src/renderer/MapRendererAdapter.d.ts

@@ -0,0 +1,72 @@
+/**
+ * MapRendererAdapter — Interface for map renderer integrations.
+ *
+ * Implement this interface to connect NavCore's navigation state
+ * to any map library (MapLibre, Leaflet, Google Maps, etc.).
+ *
+ * NavCore itself never depends on a renderer — adapters live
+ * in separate packages and are optionally wired up by the consumer.
+ *
+ * @example
+ * ```typescript
+ * import { MapLibreAdapter } from '@ingissa/navcore-maplibre';
+ *
+ * const adapter = new MapLibreAdapter(mapInstance);
+ * engine.on('stateUpdate', (state) => adapter.updateVehicle(state.snappedCoord, state.bearing, state));
+ * adapter.drawRoute(routeGeometry);
+ * ```
+ */
+import type { Coordinate } from '../geo/haversine';
+import type { NavCoreState } from '../NavCore';
+export interface RouteStyle {
+    /** Line color as CSS color string. Default: '#7c3aed' */
+    color?: string;
+    /** Line width in pixels. Default: 4 */
+    width?: number;
+    /** Line opacity 0–1. Default: 0.9 */
+    opacity?: number;
+    /** Dash array pattern (pixels). Undefined = solid. */
+    dashArray?: number[];
+}
+export interface VehicleStyle {
+    /** Icon size multiplier. Default: 1.0 */
+    scale?: number;
+    /** Custom icon URL (if undefined, adapter uses its default icon) */
+    iconUrl?: string;
+}
+export interface CameraOptions {
+    /** Zoom level (map-library specific). Default: adapter decides. */
+    zoom?: number;
+    /** Pitch/tilt in degrees. Default: 0. */
+    pitch?: number;
+    /** Whether to animate the camera transition. Default: true. */
+    animate?: boolean;
+    /** Animation duration in ms. Default: 300. */
+    animationDurationMs?: number;
+}
+export interface MapRendererAdapter {
+    /**
+     * Update the vehicle marker position and rotation.
+     * Called on every NavCore state update.
+     */
+    updateVehicle(coord: Coordinate, bearing: number, state: NavCoreState, style?: VehicleStyle): void;
+    /**
+     * Draw or update the route polyline on the map.
+     * Replaces any previously drawn route.
+     */
+    drawRoute(coords: Coordinate[], style?: RouteStyle): void;
+    /**
+     * Remove the route polyline and vehicle marker from the map.
+     */
+    clearRoute(): void;
+    /**
+     * Pan (and optionally rotate/tilt) the camera to follow the vehicle.
+     */
+    panCamera(coord: Coordinate, bearing: number, options?: CameraOptions): void;
+    /**
+     * Clean up all map layers, markers, and event listeners created by this adapter.
+     * Call when navigation ends or the component unmounts.
+     */
+    destroy(): void;
+}
+//# sourceMappingURL=MapRendererAdapter.d.ts.map

package/dist/core/src/renderer/MapRendererAdapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MapRendererAdapter.d.ts","sourceRoot":"","sources":["../../../../../core/src/renderer/MapRendererAdapter.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AACnD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAI/C,MAAM,WAAW,UAAU;IACzB,yDAAyD;IACzD,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,uCAAuC;IACvC,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,qCAAqC;IACrC,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,sDAAsD;IACtD,SAAS,CAAC,EAAE,MAAM,EAAE,CAAC;CACtB;AAED,MAAM,WAAW,YAAY;IAC3B,yCAAyC;IACzC,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,oEAAoE;IACpE,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,aAAa;IAC5B,mEAAmE;IACnE,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,yCAAyC;IACzC,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,+DAA+D;IAC/D,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,8CAA8C;IAC9C,mBAAmB,CAAC,EAAE,MAAM,CAAC;CAC9B;AAID,MAAM,WAAW,kBAAkB;IACjC;;;OAGG;IACH,aAAa,CACX,KAAK,EAAE,UAAU,EACjB,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,YAAY,EACnB,KAAK,CAAC,EAAE,YAAY,GACnB,IAAI,CAAC;IAER;;;OAGG;IACH,SAAS,CAAC,MAAM,EAAE,UAAU,EAAE,EAAE,KAAK,CAAC,EAAE,UAAU,GAAG,IAAI,CAAC;IAE1D;;OAEG;IACH,UAAU,IAAI,IAAI,CAAC;IAEnB;;OAEG;IACH,SAAS,CAAC,KAAK,EAAE,UAAU,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,aAAa,GAAG,IAAI,CAAC;IAE7E;;;OAGG;IACH,OAAO,IAAI,IAAI,CAAC;CACjB"}

package/dist/core/src/renderer/MapRendererAdapter.js

@@ -0,0 +1,19 @@
+/**
+ * MapRendererAdapter — Interface for map renderer integrations.
+ *
+ * Implement this interface to connect NavCore's navigation state
+ * to any map library (MapLibre, Leaflet, Google Maps, etc.).
+ *
+ * NavCore itself never depends on a renderer — adapters live
+ * in separate packages and are optionally wired up by the consumer.
+ *
+ * @example
+ * ```typescript
+ * import { MapLibreAdapter } from '@ingissa/navcore-maplibre';
+ *
+ * const adapter = new MapLibreAdapter(mapInstance);
+ * engine.on('stateUpdate', (state) => adapter.updateVehicle(state.snappedCoord, state.bearing, state));
+ * adapter.drawRoute(routeGeometry);
+ * ```
+ */
+export {};

package/dist/core/src/route-builder/CustomRouteBuilder.d.ts

@@ -0,0 +1,83 @@
+/**
+ * Module 10: CustomRouteBuilder
+ * Build custom routes with unlimited waypoints, chunking, and GPX/GeoJSON.
+ */
+import type { Coordinate } from '../geo/haversine';
+export interface WaypointOptions {
+    silent?: boolean;
+    name?: string;
+}
+export interface BuildOptions {
+    connectionMode?: 'ROUTED' | 'STRAIGHT';
+    chunkStrategy?: 'OVERLAP_1' | 'OVERLAP_2';
+    maxWaypointsPerChunk?: number;
+}
+export interface CustomWaypoint {
+    id: string;
+    coord: Coordinate;
+    options?: WaypointOptions;
+}
+/**
+ * CustomRouteBuilder — builds exam routes from waypoints.
+ *
+ * Pass a DirectionsProvider to `build()` for routed connections.
+ * Without a provider, `build()` returns straight-line geometry.
+ */
+export declare class CustomRouteBuilder {
+    private waypoints;
+    /** Add a waypoint at the end. Returns the generated ID. */
+    addWaypoint(coord: Coordinate, options?: WaypointOptions): string;
+    /** Insert a waypoint after an existing one. Returns the new ID. */
+    insertWaypoint(coord: Coordinate, afterId: string): string;
+    /** Remove a waypoint by ID */
+    removeWaypoint(id: string): void;
+    /** Move a waypoint to a new coordinate */
+    moveWaypoint(id: string, newCoord: Coordinate): void;
+    /** Get all current waypoints */
+    getWaypoints(): ReadonlyArray<CustomWaypoint>;
+    /** Get the number of waypoints */
+    get size(): number;
+    /**
+     * Chunk waypoints for a provider with max waypoint limits.
+     * OVERLAP_1: adjacent chunks share 1 waypoint (last of prev = first of next)
+     * OVERLAP_2: adjacent chunks share 2 waypoints
+     */
+    chunk(strategy?: 'OVERLAP_1' | 'OVERLAP_2', maxPerChunk?: number): Coordinate[][];
+    /**
+     * Build straight-line geometry (no provider needed).
+     * For routed geometry, pass chunks to a DirectionsProvider externally.
+     */
+    buildStraightLine(): {
+        geometry: Coordinate[];
+        waypoints: CustomWaypoint[];
+    };
+    /** Import waypoints from a GPX string */
+    fromGPX(gpx: string): void;
+    /** Export the current waypoints as a GPX string */
+    toGPX(): string;
+    /** Import waypoints from GeoJSON */
+    fromGeoJSON(geojson: {
+        type: string;
+        features?: Array<{
+            geometry: {
+                type: string;
+                coordinates: unknown;
+            };
+        }>;
+    }): void;
+    /** Export the current route as GeoJSON FeatureCollection */
+    toGeoJSON(): {
+        type: 'FeatureCollection';
+        features: Array<{
+            type: 'Feature';
+            geometry: {
+                type: string;
+                coordinates: Coordinate | Coordinate[];
+            };
+            properties: Record<string, unknown>;
+        }>;
+    };
+    /** Clear all waypoints */
+    clear(): void;
+}
+//# sourceMappingURL=CustomRouteBuilder.d.ts.map

package/dist/core/src/route-builder/CustomRouteBuilder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CustomRouteBuilder.d.ts","sourceRoot":"","sources":["../../../../../core/src/route-builder/CustomRouteBuilder.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAEnD,MAAM,WAAW,eAAe;IAC9B,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAED,MAAM,WAAW,YAAY;IAC3B,cAAc,CAAC,EAAE,QAAQ,GAAG,UAAU,CAAC;IACvC,aAAa,CAAC,EAAE,WAAW,GAAG,WAAW,CAAC;IAC1C,oBAAoB,CAAC,EAAE,MAAM,CAAC;CAC/B;AAED,MAAM,WAAW,cAAc;IAC7B,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAE,UAAU,CAAC;IAClB,OAAO,CAAC,EAAE,eAAe,CAAC;CAC3B;AAOD;;;;;GAKG;AACH,qBAAa,kBAAkB;IAC7B,OAAO,CAAC,SAAS,CAAwB;IAEzC,2DAA2D;IAC3D,WAAW,CAAC,KAAK,EAAE,UAAU,EAAE,OAAO,CAAC,EAAE,eAAe,GAAG,MAAM;IAMjE,mEAAmE;IACnE,cAAc,CAAC,KAAK,EAAE,UAAU,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM;IAS1D,8BAA8B;IAC9B,cAAc,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI;IAMhC,0CAA0C;IAC1C,YAAY,CAAC,EAAE,EAAE,MAAM,EAAE,QAAQ,EAAE,UAAU,GAAG,IAAI;IAMpD,gCAAgC;IAChC,YAAY,IAAI,aAAa,CAAC,cAAc,CAAC;IAI7C,kCAAkC;IAClC,IAAI,IAAI,IAAI,MAAM,CAEjB;IAED;;;;OAIG;IACH,KAAK,CACH,QAAQ,GAAE,WAAW,GAAG,WAAyB,EACjD,WAAW,GAAE,MAAW,GACvB,UAAU,EAAE,EAAE;IAiBjB;;;OAGG;IACH,iBAAiB,IAAI;QAAE,QAAQ,EAAE,UAAU,EAAE,CAAC;QAAC,SAAS,EAAE,cAAc,EAAE,CAAA;KAAE;IAO5E,yCAAyC;IACzC,OAAO,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI;IAgB1B,mDAAmD;IACnD,KAAK,IAAI,MAAM;IAaf,oCAAoC;IACpC,WAAW,CAAC,OAAO,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,EAAE,KAAK,CAAC;YAAE,QAAQ,EAAE;gBAAE,IAAI,EAAE,MAAM,CAAC;gBAAC,WAAW,EAAE,OAAO,CAAA;aAAE,CAAA;SAAE,CAAC,CAAA;KAAE,GAAG,IAAI;IAkBpH,4DAA4D;IAC5D,SAAS,IAAI;QAAE,IAAI,EAAE,mBAAmB,CAAC;QAAC,QAAQ,EAAE,KAAK,CAAC;YAAE,IAAI,EAAE,SAAS,CAAC;YAAC,QAAQ,EAAE;gBAAE,IAAI,EAAE,MAAM,CAAC;gBAAC,WAAW,EAAE,UAAU,GAAG,UAAU,EAAE,CAAA;aAAE,CAAC;YAAC,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;SAAE,CAAC,CAAA;KAAE;IA8BzL,0BAA0B;IAC1B,KAAK,IAAI,IAAI;CAGd"}

package/dist/core/src/route-builder/CustomRouteBuilder.js

@@ -0,0 +1,160 @@
+/**
+ * Module 10: CustomRouteBuilder
+ * Build custom routes with unlimited waypoints, chunking, and GPX/GeoJSON.
+ */
+let _counter = 0;
+function generateId() {
+    return `wp_${Date.now()}_${++_counter}`;
+}
+/**
+ * CustomRouteBuilder — builds exam routes from waypoints.
+ *
+ * Pass a DirectionsProvider to `build()` for routed connections.
+ * Without a provider, `build()` returns straight-line geometry.
+ */
+export class CustomRouteBuilder {
+    constructor() {
+        this.waypoints = [];
+    }
+    /** Add a waypoint at the end. Returns the generated ID. */
+    addWaypoint(coord, options) {
+        const id = generateId();
+        this.waypoints.push({ id, coord, options });
+        return id;
+    }
+    /** Insert a waypoint after an existing one. Returns the new ID. */
+    insertWaypoint(coord, afterId) {
+        const idx = this.waypoints.findIndex(w => w.id === afterId);
+        if (idx === -1)
+            throw new Error(`Waypoint ${afterId} not found`);
+        const id = generateId();
+        this.waypoints.splice(idx + 1, 0, { id, coord, options: undefined });
+        return id;
+    }
+    /** Remove a waypoint by ID */
+    removeWaypoint(id) {
+        const idx = this.waypoints.findIndex(w => w.id === id);
+        if (idx === -1)
+            throw new Error(`Waypoint ${id} not found`);
+        this.waypoints.splice(idx, 1);
+    }
+    /** Move a waypoint to a new coordinate */
+    moveWaypoint(id, newCoord) {
+        const wp = this.waypoints.find(w => w.id === id);
+        if (!wp)
+            throw new Error(`Waypoint ${id} not found`);
+        wp.coord = newCoord;
+    }
+    /** Get all current waypoints */
+    getWaypoints() {
+        return this.waypoints;
+    }
+    /** Get the number of waypoints */
+    get size() {
+        return this.waypoints.length;
+    }
+    /**
+     * Chunk waypoints for a provider with max waypoint limits.
+     * OVERLAP_1: adjacent chunks share 1 waypoint (last of prev = first of next)
+     * OVERLAP_2: adjacent chunks share 2 waypoints
+     */
+    chunk(strategy = 'OVERLAP_1', maxPerChunk = 25) {
+        const coords = this.waypoints.map(w => w.coord);
+        if (coords.length <= maxPerChunk)
+            return [coords];
+        const overlap = strategy === 'OVERLAP_2' ? 2 : 1;
+        const step = maxPerChunk - overlap;
+        const chunks = [];
+        for (let i = 0; i < coords.length; i += step) {
+            const chunk = coords.slice(i, i + maxPerChunk);
+            chunks.push(chunk);
+            if (i + maxPerChunk >= coords.length)
+                break;
+        }
+        return chunks;
+    }
+    /**
+     * Build straight-line geometry (no provider needed).
+     * For routed geometry, pass chunks to a DirectionsProvider externally.
+     */
+    buildStraightLine() {
+        return {
+            geometry: this.waypoints.map(w => w.coord),
+            waypoints: [...this.waypoints],
+        };
+    }
+    /** Import waypoints from a GPX string */
+    fromGPX(gpx) {
+        this.waypoints = [];
+        // Minimal GPX parser — extract <trkpt> and <wpt> elements
+        const pointRegex = /<(?:trkpt|wpt|rtept)\s+lat="([^"]+)"\s+lon="([^"]+)"/g;
+        let match;
+        while ((match = pointRegex.exec(gpx)) !== null) {
+            const lat = parseFloat(match[1]);
+            const lon = parseFloat(match[2]);
+            if (isFinite(lat) && isFinite(lon)) {
+                this.addWaypoint([lon, lat]);
+            }
+        }
+    }
+    /** Export the current waypoints as a GPX string */
+    toGPX() {
+        const points = this.waypoints.map(w => `    <wpt lat="${w.coord[1]}" lon="${w.coord[0]}">` +
+            (w.options?.name ? `\n      <name>${w.options.name}</name>` : '') +
+            `\n    </wpt>`).join('\n');
+        return `<?xml version="1.0" encoding="UTF-8"?>
+<gpx version="1.1" creator="NavCore SDK">
+${points}
+</gpx>`;
+    }
+    /** Import waypoints from GeoJSON */
+    fromGeoJSON(geojson) {
+        this.waypoints = [];
+        if (geojson.type === 'FeatureCollection' && geojson.features) {
+            for (const feature of geojson.features) {
+                if (feature.geometry.type === 'Point') {
+                    const coord = feature.geometry.coordinates;
+                    this.addWaypoint(coord);
+                }
+                else if (feature.geometry.type === 'LineString') {
+                    const coords = feature.geometry.coordinates;
+                    for (const coord of coords) {
+                        this.addWaypoint(coord);
+                    }
+                }
+            }
+        }
+    }
+    /** Export the current route as GeoJSON FeatureCollection */
+    toGeoJSON() {
+        const pointFeatures = this.waypoints.map((w, i) => ({
+            type: 'Feature',
+            geometry: {
+                type: 'Point',
+                coordinates: w.coord,
+            },
+            properties: {
+                id: w.id,
+                order: i,
+                name: w.options?.name ?? null,
+                silent: w.options?.silent ?? false,
+            },
+        }));
+        const lineFeature = {
+            type: 'Feature',
+            geometry: {
+                type: 'LineString',
+                coordinates: this.waypoints.map(w => w.coord),
+            },
+            properties: { type: 'route' },
+        };
+        return {
+            type: 'FeatureCollection',
+            features: [...pointFeatures, lineFeature],
+        };
+    }
+    /** Clear all waypoints */
+    clear() {
+        this.waypoints = [];
+    }
+}