vehicle-path 1.0.4 → 1.0.5

package/dist/hooks/useCanvasInteraction.d.ts

@@ -0,0 +1,31 @@
+import type { Point, Line, Curve } from '../types/core';
+import type { DrawMode } from '../types/ui';
+interface UseCanvasInteractionProps {
+    canvasRef: React.RefObject<HTMLCanvasElement | null>;
+    containerRef: React.RefObject<HTMLDivElement | null>;
+    drawMode: DrawMode;
+    lines: Line[];
+    curves: Curve[];
+    setLines: (lines: Line[]) => void;
+    setCurves: (curves: Curve[]) => void;
+    lineCounterRef: React.MutableRefObject<number>;
+}
+export declare function useCanvasInteraction({ canvasRef, containerRef, drawMode, lines, curves, setLines, setCurves, lineCounterRef }: UseCanvasInteractionProps): {
+    handleMouseDown: (e: React.MouseEvent<HTMLCanvasElement>) => void;
+    handleMouseMove: (e: React.MouseEvent<HTMLCanvasElement>) => void;
+    handleMouseUp: () => void;
+    tempLine: {
+        start: Point;
+        current: Point;
+    } | null;
+    hoveredEndpoint: {
+        lineId: string;
+        endpoint: "start" | "end";
+    } | null;
+    curveStart: {
+        lineId: string;
+        endpoint: "start" | "end";
+    } | null;
+    mousePos: Point;
+};
+export {};

package/dist/hooks/useInitialMovement.d.ts

@@ -0,0 +1,16 @@
+import type { Line } from '../types/core';
+import type { Vehicle } from '../types/vehicle';
+interface UseInitialMovementProps {
+    lines: Line[];
+    wheelbase: number;
+}
+export declare function useInitialMovement({ lines, wheelbase }: UseInitialMovementProps): {
+    vehicles: Vehicle[];
+    initialMovementText: string;
+    movementError: string | null;
+    isDebouncing: boolean;
+    debounceKey: number;
+    setInitialMovementText: import("react").Dispatch<import("react").SetStateAction<string>>;
+    handleAddStartCommand: () => void;
+};
+export {};

package/dist/hooks/useMovementSequence.d.ts

@@ -0,0 +1,17 @@
+import type { Line } from '../types/core';
+import type { Vehicle, GotoCommand } from '../types/vehicle';
+interface UseMovementSequenceProps {
+    lines: Line[];
+    vehicles: Vehicle[];
+}
+export declare function useMovementSequence({ lines, vehicles }: UseMovementSequenceProps): {
+    movementSequenceText: string;
+    gotoCommands: GotoCommand[];
+    vehicleQueues: Map<string, GotoCommand[]>;
+    sequenceError: string | null;
+    isDebouncing: boolean;
+    debounceKey: number;
+    setMovementSequenceText: import("react").Dispatch<import("react").SetStateAction<string>>;
+    handleAddGotoCommand: () => void;
+};
+export {};

package/dist/hooks/useSceneDefinition.d.ts

@@ -0,0 +1,12 @@
+import type { Line, Curve } from '../types/core';
+export declare function useSceneDefinition(): {
+    lines: Line[];
+    curves: Curve[];
+    sceneDefinitionText: string;
+    sceneError: string | null;
+    isDebouncing: boolean;
+    debounceKey: number;
+    setLines: import("react").Dispatch<import("react").SetStateAction<Line[]>>;
+    setCurves: import("react").Dispatch<import("react").SetStateAction<Curve[]>>;
+    setSceneDefinitionText: import("react").Dispatch<import("react").SetStateAction<string>>;
+};

package/dist/hooks/useVehicleEvents.d.ts

@@ -0,0 +1,31 @@
+import { VehicleEventEmitter, type VehicleEventType, type VehicleEventCallback, type VehicleEventMap, type VehiclePositionUpdate } from '../utils/VehicleEventEmitter';
+/**
+ * React context for VehicleEventEmitter
+ */
+export declare const VehicleEventContext: import("react").Context<VehicleEventEmitter | null>;
+/**
+ * Hook to access the VehicleEventEmitter instance from context
+ * @returns VehicleEventEmitter instance
+ * @throws Error if used outside of VehicleEventProvider
+ */
+export declare function useVehicleEventEmitter(): VehicleEventEmitter;
+/**
+ * Hook to create a new VehicleEventEmitter instance (for provider)
+ * @returns VehicleEventEmitter instance (stable reference)
+ */
+export declare function useCreateVehicleEventEmitter(): VehicleEventEmitter;
+/**
+ * Hook to subscribe to a vehicle event with automatic cleanup
+ *
+ * @example
+ * ```typescript
+ * useVehicleEvent('commandComplete', (info) => {
+ *   console.log(`Vehicle ${info.vehicleId} arrived!`)
+ *   if (info.payload) {
+ *     // Handle payload
+ *   }
+ * })
+ * ```
+ */
+export declare function useVehicleEvent<K extends VehicleEventType>(event: K, callback: VehicleEventCallback<K>, deps?: React.DependencyList): void;
+export type { VehicleEventEmitter, VehicleEventType, VehicleEventCallback, VehicleEventMap, VehiclePositionUpdate };

package/dist/hooks/useVehicleMovement.d.ts

@@ -0,0 +1,24 @@
+import type { Line } from '../types/core';
+import type { Vehicle, GotoCommand } from '../types/vehicle';
+import type { TangentMode } from '../types/ui';
+import type { VehicleEventEmitter } from '../utils/VehicleEventEmitter';
+interface UseVehicleMovementProps {
+    vehicles: Vehicle[];
+    lines: Line[];
+    vehicleQueues: Map<string, GotoCommand[]>;
+    velocity: number;
+    wheelbase: number;
+    tangentMode: TangentMode;
+    curves: import('../types/core').Curve[];
+    eventEmitter?: VehicleEventEmitter;
+}
+type PlaybackState = 'stopped' | 'running' | 'paused';
+export declare function useVehicleMovement({ vehicles, lines, vehicleQueues, velocity, wheelbase, tangentMode, curves, eventEmitter }: UseVehicleMovementProps): {
+    movingVehicles: Vehicle[];
+    playbackState: PlaybackState;
+    handleRun: () => void;
+    handlePause: () => void;
+    handleReset: () => void;
+    continueVehicle: (vehicleId: string) => boolean;
+};
+export {};

package/dist/index.d.ts

@@ -0,0 +1,28 @@
+/**
+ * VehiclePath - Vehicle motion simulator library
+ *
+ * A library for simulating dual-axle vehicle movement along paths
+ * composed of lines and Bezier curves.
+ *
+ * @example
+ * ```typescript
+ * import {
+ *   useVehicleMovement,
+ *   VehicleEventEmitter,
+ *   parseSceneDefinition
+ * } from 'vehicle-path'
+ * import type { Point, Line, Vehicle } from 'vehicle-path'
+ * ```
+ */
+export type { Point, Line, BezierCurve, Curve, VehicleState, VehicleStart, Vehicle, AxleState, GotoCommand, GotoCompletionInfo, GotoCompletionCallback, CurveData, PathExecutionState, VehicleMovementState, MovementConfig, SceneDefinition, SceneContext, DrawMode, TangentMode } from './types';
+export { useVehicleMovement } from './hooks/useVehicleMovement';
+export { useVehicleEventEmitter, useCreateVehicleEventEmitter, useVehicleEvent, VehicleEventContext } from './hooks/useVehicleEvents';
+export { useSceneDefinition } from './hooks/useSceneDefinition';
+export { useInitialMovement } from './hooks/useInitialMovement';
+export { useMovementSequence } from './hooks/useMovementSequence';
+export { useCanvasInteraction } from './hooks/useCanvasInteraction';
+export { VehicleEventEmitter, type VehicleEventMap, type VehicleEventType, type VehicleEventCallback, type VehiclePositionUpdate, type Unsubscribe } from './utils/VehicleEventEmitter';
+export { parseSceneDefinition, generateSceneDefinition, parseVehicleStarts, generateVehicleStarts, parseGotoCommands, generateGotoCommands } from './utils/textParser';
+export { buildGraph, findPath, canReachTarget, getReachableCurves, calculateBezierArcLength, resolveOffset, resolveFromLineOffset, resolveToLineOffset, type Graph, type GraphEdge, type PathSegment, type PathResult, type VehiclePosition } from './utils/pathFinding';
+export { initializeMovingVehicle, createInitialMovementState, initializeAllVehicles, calculateInitialFrontPosition, type InitializationResult, updateAxlePosition, calculatePositionOnLine, calculatePositionOnCurve, calculateFrontAxlePosition, getCumulativeArcLength, arcLengthToSegmentPosition, prepareCommandPath, type PreparedPath, checkRearCompletion, handleArrival, type SegmentCompletionContext, type SegmentCompletionResult, type SegmentVehicleState, getPositionFromOffset, getLineLength } from './utils/vehicleMovement';
+export { distance, normalize, getPointOnLine, getPointOnLineByOffset, getPointOnBezier, createBezierCurve, buildArcLengthTable, distanceToT, getArcLength, type ArcLengthEntry, type CurveOffsetOptions } from './utils/math';

package/dist/types/core.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Core geometry types for the bezier-path system
+ */
+export interface Point {
+    x: number;
+    y: number;
+}
+export interface Line {
+    id: string;
+    start: Point;
+    end: Point;
+}
+export interface BezierCurve {
+    p0: Point;
+    p1: Point;
+    p2: Point;
+    p3: Point;
+}
+export interface Curve {
+    fromLineId: string;
+    toLineId: string;
+    fromOffset?: number;
+    fromIsPercentage?: boolean;
+    toOffset?: number;
+    toIsPercentage?: boolean;
+}

package/dist/types/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Re-export all types from a single entry point
+ *
+ * Usage:
+ *   import type { Point, Line, Vehicle } from '../types'
+ *   // or
+ *   import type { Point } from '../types/core'
+ */
+export type { Point, Line, BezierCurve, Curve } from './core';
+export type { VehicleState, VehicleStart, Vehicle, AxleState, GotoCommand, GotoCompletionInfo, GotoCompletionCallback } from './vehicle';
+export type { CurveData, PathExecutionState, VehicleMovementState, MovementConfig, SceneDefinition, SceneContext } from './movement';
+export type { DrawMode, TangentMode } from './ui';

package/dist/types/movement.d.ts

@@ -0,0 +1,64 @@
+/**
+ * Movement and animation state types
+ */
+import type { Line, Curve, BezierCurve } from './core';
+import type { Vehicle, VehicleStart } from './vehicle';
+import type { TangentMode } from './ui';
+export type { PathResult } from '../utils/pathFinding';
+export type { ArcLengthEntry } from '../utils/math';
+/**
+ * Bezier curve data with arc-length lookup table for animation
+ */
+export interface CurveData {
+    bezier: BezierCurve;
+    arcLengthTable: import('../utils/math').ArcLengthEntry[];
+}
+/**
+ * Execution state for a single axle (Front or Rear)
+ */
+export interface AxleExecutionState {
+    currentSegmentIndex: number;
+    segmentDistance: number;
+}
+/**
+ * State for path execution during animation
+ */
+export interface PathExecutionState {
+    path: import('../utils/pathFinding').PathResult;
+    curveDataMap: Map<number, CurveData>;
+    currentCommandIndex: number;
+    rear: AxleExecutionState;
+    front: AxleExecutionState;
+}
+/**
+ * Movement state container for a vehicle
+ */
+export interface VehicleMovementState {
+    vehicle: Vehicle;
+    execution: PathExecutionState | null;
+}
+/**
+ * Configuration for vehicle movement
+ */
+export interface MovementConfig {
+    wheelbase: number;
+    tangentMode: TangentMode;
+}
+/**
+ * Scene definition (parsed from text input)
+ */
+export interface SceneDefinition {
+    lines: Line[];
+    curves: Curve[];
+    vehicles: VehicleStart[];
+}
+/**
+ * Scene context for path preparation and movement calculations
+ * Bundles commonly-passed together dependencies
+ */
+export interface SceneContext {
+    config: MovementConfig;
+    graph: import('../utils/pathFinding').Graph;
+    linesMap: Map<string, Line>;
+    curves: Curve[];
+}

package/dist/types/ui.d.ts

@@ -0,0 +1,13 @@
+/**
+ * UI-related types for canvas and controls
+ */
+/**
+ * Drawing mode for canvas interaction
+ */
+export type DrawMode = 'line' | 'curve' | 'drag';
+/**
+ * Tangent calculation mode for bezier curves
+ * - proportional-40: 40% of distance for tangent length
+ * - magic-55: 55.22% of distance (approximates circular arc)
+ */
+export type TangentMode = 'proportional-40' | 'magic-55';

package/dist/types/vehicle.d.ts

@@ -0,0 +1,65 @@
+/**
+ * Vehicle-related types
+ */
+import type { Point } from './core';
+/**
+ * Animation state for a vehicle
+ */
+export type VehicleState = 'idle' | 'moving' | 'waiting';
+/**
+ * Vehicle start position (input from text parsing)
+ */
+export interface VehicleStart {
+    vehicleId: string;
+    lineId: string;
+    offset: number;
+    isPercentage: boolean;
+}
+/**
+ * State for a single axle (Front or Rear)
+ */
+export interface AxleState {
+    lineId: string;
+    position: Point;
+    absoluteOffset: number;
+}
+/**
+ * Vehicle with runtime state (used during animation)
+ */
+export interface Vehicle {
+    id: string;
+    lineId: string;
+    offset: number;
+    isPercentage: boolean;
+    state: VehicleState;
+    rear: AxleState;
+    front: AxleState;
+}
+/**
+ * Command to move a vehicle to a target position
+ */
+export interface GotoCommand {
+    vehicleId: string;
+    targetLineId: string;
+    targetOffset: number;
+    isPercentage: boolean;
+    awaitConfirmation?: boolean;
+    payload?: unknown;
+}
+/**
+ * Information provided when a goto command completes
+ */
+export interface GotoCompletionInfo {
+    vehicleId: string;
+    command: GotoCommand;
+    finalPosition: {
+        lineId: string;
+        absoluteOffset: number;
+        position: Point;
+    };
+    payload?: unknown;
+}
+/**
+ * Callback type for goto command completion
+ */
+export type GotoCompletionCallback = (info: GotoCompletionInfo) => void;

package/dist/utils/VehicleEventEmitter.d.ts

@@ -0,0 +1,94 @@
+import type { GotoCompletionInfo, GotoCommand, VehicleState } from '../types/vehicle';
+import type { Point } from '../types/core';
+/**
+ * Info when a command starts execution
+ */
+export interface CommandStartInfo {
+    vehicleId: string;
+    command: GotoCommand;
+    commandIndex: number;
+    startPosition: {
+        lineId: string;
+        absoluteOffset: number;
+        position: Point;
+    };
+}
+/**
+ * Position update data for a vehicle
+ */
+export interface VehiclePositionUpdate {
+    vehicleId: string;
+    /** Rear axle position */
+    rear: Point;
+    /** Front axle position */
+    front: Point;
+    /** Center point between rear and front axles */
+    center: Point;
+    /** Angle in radians from rear to front (heading direction) */
+    angle: number;
+}
+/**
+ * Event map for vehicle-related events
+ */
+export interface VehicleEventMap {
+    /** Fired when a goto command starts execution */
+    commandStart: CommandStartInfo;
+    /** Fired when a goto command completes (vehicle arrives at destination) */
+    commandComplete: GotoCompletionInfo;
+    /** Fired when vehicle state changes */
+    stateChange: {
+        vehicleId: string;
+        from: VehicleState;
+        to: VehicleState;
+    };
+    /** Fired on each frame when vehicle position updates */
+    positionUpdate: VehiclePositionUpdate;
+}
+export type VehicleEventType = keyof VehicleEventMap;
+export type VehicleEventCallback<K extends VehicleEventType> = (data: VehicleEventMap[K]) => void;
+export type Unsubscribe = () => void;
+/**
+ * Event emitter for vehicle movement events.
+ * Allows multiple subscribers to listen for events like command completion,
+ * state changes, etc.
+ *
+ * @example
+ * ```typescript
+ * const emitter = new VehicleEventEmitter()
+ *
+ * // Subscribe to events
+ * const unsubscribe = emitter.on('commandComplete', (info) => {
+ *   console.log(`Vehicle ${info.vehicleId} arrived with payload:`, info.payload)
+ * })
+ *
+ * // Later, unsubscribe
+ * unsubscribe()
+ * ```
+ */
+export declare class VehicleEventEmitter {
+    private listeners;
+    /**
+     * Subscribe to an event
+     * @param event - The event type to listen for
+     * @param callback - Function to call when event is emitted
+     * @returns Unsubscribe function
+     */
+    on<K extends VehicleEventType>(event: K, callback: VehicleEventCallback<K>): Unsubscribe;
+    /**
+     * Emit an event to all subscribers
+     * @param event - The event type to emit
+     * @param data - The event data
+     */
+    emit<K extends VehicleEventType>(event: K, data: VehicleEventMap[K]): void;
+    /**
+     * Remove all listeners for a specific event, or all events if no event specified
+     * @param event - Optional event type to clear listeners for
+     */
+    off(event?: VehicleEventType): void;
+    /**
+     * Get the number of listeners for a specific event
+     * @param event - The event type
+     * @returns Number of listeners
+     */
+    listenerCount(event: VehicleEventType): number;
+}

package/dist/utils/canvasHelpers.d.ts

@@ -0,0 +1,9 @@
+import type { Point, Line } from '../types/core';
+import type { TangentMode } from '../types/ui';
+export declare function setupCanvas(canvas: HTMLCanvasElement, container: HTMLDivElement): void;
+export declare function getMousePos(e: React.MouseEvent<HTMLCanvasElement>, canvas: HTMLCanvasElement | null, container: HTMLDivElement | null): Point;
+export declare function findEndpointAtPoint(pos: Point, lines: Line[], threshold?: number): {
+    lineId: string;
+    endpoint: 'start' | 'end';
+} | null;
+export declare function parseTangentMode(smoothness: string): TangentMode;

package/dist/utils/canvasRenderer.d.ts

@@ -0,0 +1,13 @@
+import type { Point, Line, BezierCurve } from '../types/core';
+import type { TangentMode } from '../types/ui';
+import type { Vehicle } from '../types/vehicle';
+import { type CurveOffsetOptions } from './math';
+export declare function drawLine(ctx: CanvasRenderingContext2D, line: Line, hoveredEndpoint: {
+    lineId: string;
+    endpoint: 'start' | 'end';
+} | null): void;
+export declare function drawTempLine(ctx: CanvasRenderingContext2D, start: Point, end: Point): void;
+export declare function drawCurve(ctx: CanvasRenderingContext2D, fromLine: Line, toLine: Line, wheelbase: number, tangentMode: TangentMode, offsetOptions?: CurveOffsetOptions): void;
+export declare function drawBezierCurve(ctx: CanvasRenderingContext2D, bezier: BezierCurve): void;
+export declare function drawTempCurveLine(ctx: CanvasRenderingContext2D, start: Point, end: Point): void;
+export declare function drawVehicle(ctx: CanvasRenderingContext2D, vehicle: Vehicle): void;

package/dist/utils/math.d.ts

@@ -0,0 +1,35 @@
+import type { Point, Line, BezierCurve } from '../types/core';
+import type { TangentMode } from '../types/ui';
+import type { MovementConfig } from '../types/movement';
+export declare function distance(p1: Point, p2: Point): number;
+export declare function normalize(p1: Point, p2: Point): Point;
+export declare function calculateTangentLength(mode: TangentMode, distance: number): number;
+export interface CurveOffsetOptions {
+    fromOffset?: number;
+    fromIsPercentage?: boolean;
+    toOffset?: number;
+    toIsPercentage?: boolean;
+}
+export declare function createBezierCurve(line: Line, nextLine: Line, config: MovementConfig, willFlip?: boolean, offsetOptions?: CurveOffsetOptions): BezierCurve;
+export declare function getPointOnLine(line: Line, t: number): Point;
+export declare function getPointOnLineByOffset(line: Line, offset: number, isPercentage: boolean): Point;
+export declare function getPointOnBezier(bezier: BezierCurve, t: number): Point;
+export declare function isPointNearPoint(p1: Point, p2: Point, threshold?: number): boolean;
+export interface ArcLengthEntry {
+    t: number;
+    distance: number;
+}
+/**
+ * Build a lookup table for arc-length parameterization.
+ * Maps t values to cumulative distances along the curve.
+ */
+export declare function buildArcLengthTable(bezier: BezierCurve, samples?: number): ArcLengthEntry[];
+/**
+ * Convert a distance along the curve to the corresponding t parameter.
+ * Uses linear interpolation between table entries for smooth results.
+ */
+export declare function distanceToT(table: ArcLengthEntry[], targetDistance: number): number;
+/**
+ * Get the total arc length from a pre-built table
+ */
+export declare function getArcLength(table: ArcLengthEntry[]): number;

package/dist/utils/pathFinding.d.ts

@@ -0,0 +1,75 @@
+import type { Line, Curve, BezierCurve } from '../types/core';
+import type { MovementConfig } from '../types/movement';
+export interface GraphEdge {
+    curveIndex: number;
+    fromLineId: string;
+    toLineId: string;
+    fromOffset: number;
+    toOffset: number;
+    curveLength: number;
+}
+export interface Graph {
+    adjacency: Map<string, GraphEdge[]>;
+    lines: Map<string, Line>;
+    lineLengths: Map<string, number>;
+}
+export interface PathSegment {
+    type: 'line' | 'curve';
+    lineId?: string;
+    curveIndex?: number;
+    startOffset: number;
+    endOffset: number;
+    length: number;
+}
+export interface PathResult {
+    segments: PathSegment[];
+    totalDistance: number;
+}
+export interface VehiclePosition {
+    lineId: string;
+    offset: number;
+}
+/**
+ * Menghitung arc length dari bezier curve menggunakan numerical integration
+ */
+export declare function calculateBezierArcLength(bezier: BezierCurve, segments?: number): number;
+/**
+ * Menghitung absolute offset dari offset yang mungkin percentage
+ * (Legacy function - use resolveFromLineOffset/resolveToLineOffset for curve offsets)
+ */
+export declare function resolveOffset(line: Line, offset: number | undefined, isPercentage: boolean | undefined, defaultPercentage: number): number;
+/**
+ * Resolve offset untuk FROM line (garis asal kurva)
+ * - 0% → wheelbase (bukan 0, untuk memberi ruang vehicle)
+ * - 100% → lineLength (ujung garis)
+ *
+ * Effective range: [wheelbase, lineLength]
+ */
+export declare function resolveFromLineOffset(line: Line, offset: number | undefined, isPercentage: boolean | undefined, defaultPercentage: number, wheelbase: number): number;
+/**
+ * Resolve offset untuk TO line (garis tujuan kurva)
+ * - 0% → 0 (awal garis)
+ * - 100% → lineLength - wheelbase (untuk memberi ruang vehicle)
+ *
+ * Effective range: [0, lineLength - wheelbase]
+ */
+export declare function resolveToLineOffset(line: Line, offset: number | undefined, isPercentage: boolean | undefined, defaultPercentage: number, wheelbase: number): number;
+/**
+ * Membangun graph dari lines dan curves
+ */
+export declare function buildGraph(lines: Line[], curves: Curve[], config: MovementConfig): Graph;
+/**
+ * Mencari path terpendek dari posisi vehicle ke target
+ *
+ * @returns PathResult jika path ditemukan, null jika tidak ada path valid
+ */
+export declare function findPath(graph: Graph, vehiclePos: VehiclePosition, targetLineId: string, targetOffset: number, // Absolute offset
+targetIsPercentage?: boolean): PathResult | null;
+/**
+ * Mengecek apakah path valid dari posisi vehicle ke target
+ */
+export declare function canReachTarget(graph: Graph, vehiclePos: VehiclePosition, targetLineId: string, targetOffset: number, targetIsPercentage?: boolean): boolean;
+/**
+ * Mendapatkan semua kurva yang bisa diambil dari posisi tertentu pada line
+ */
+export declare function getReachableCurves(graph: Graph, lineId: string, currentOffset: number): GraphEdge[];

package/dist/utils/textParser.d.ts

@@ -0,0 +1,22 @@
+import type { VehicleStart, GotoCommand } from '../types/vehicle';
+import type { SceneDefinition } from '../types/movement';
+export declare function parseSceneDefinition(text: string): SceneDefinition;
+export declare function generateSceneDefinition(scene: SceneDefinition): string;
+/**
+ * Parse vehicle start positions from initial movement text
+ * Format: v1 start line001 10 or v2 start line002 20%
+ */
+export declare function parseVehicleStarts(text: string): VehicleStart[];
+/**
+ * Generate initial movement text from vehicle starts
+ */
+export declare function generateVehicleStarts(vehicles: VehicleStart[]): string;
+/**
+ * Parse goto commands from movement sequence text
+ * Format: v1 goto line001 100% [--wait] [--payload {...}]
+ */
+export declare function parseGotoCommands(text: string): GotoCommand[];
+/**
+ * Generate movement sequence text from goto commands
+ */
+export declare function generateGotoCommands(commands: GotoCommand[]): string;

package/dist/utils/vehicleHelpers.d.ts

@@ -0,0 +1,14 @@
+import type { Line } from '../types/core';
+import type { Vehicle, VehicleStart, GotoCommand } from '../types/vehicle';
+export declare function validateAndCreateVehicles(vehicleStarts: VehicleStart[], lines: Line[], wheelbase?: number): {
+    vehicles: Vehicle[];
+    errors: string[];
+};
+export declare function getNextStartVehicleId(existingVehicles: VehicleStart[]): string;
+export interface GotoValidationResult {
+    commands: GotoCommand[];
+    errors: string[];
+    vehicleQueues: Map<string, GotoCommand[]>;
+}
+export declare function validateGotoCommands(commands: GotoCommand[], vehicles: Vehicle[], lines: Line[]): GotoValidationResult;
+export declare function getNextGotoVehicleId(existingCommands: GotoCommand[], vehicles: Vehicle[]): string | null;

package/dist/utils/vehicleMovement/arcLengthTracking.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Arc-length tracking utilities for dual-axle vehicle movement
+ *
+ * Enables calculating front axle position from rear axle position
+ * by maintaining wheelbase distance in arc-length terms.
+ */
+import type { PathResult } from '../pathFinding';
+/**
+ * Calculate cumulative arc-length from start of path
+ *
+ * @param path - The path being followed
+ * @param segmentIndex - Current segment index
+ * @param segmentDistance - Distance along current segment
+ * @returns Total arc-length from path start
+ */
+export declare function getCumulativeArcLength(path: PathResult, segmentIndex: number, segmentDistance: number): number;
+/**
+ * Convert arc-length to segment position
+ *
+ * @param path - The path being followed
+ * @param targetArcLength - Target cumulative arc-length
+ * @returns Segment position or null if exceeds path length
+ */
+export declare function arcLengthToSegmentPosition(path: PathResult, targetArcLength: number): {
+    segmentIndex: number;
+    segmentDistance: number;
+} | null;
+/**
+ * Calculate front axle position from rear position + wheelbase
+ *
+ * @param path - The path being followed
+ * @param rearSegmentIndex - Rear axle segment index
+ * @param rearSegmentDistance - Rear axle distance in segment
+ * @param wheelbase - Distance between front and rear axles
+ * @returns Front axle position or null if exceeds path
+ */
+export declare function calculateFrontAxlePosition(path: PathResult, rearSegmentIndex: number, rearSegmentDistance: number, wheelbase: number): {
+    segmentIndex: number;
+    segmentDistance: number;
+} | null;