vehicle-path 1.0.0

package/dist/utils/VehicleEventEmitter.d.ts

@@ -0,0 +1,79 @@
+import type { GotoCompletionInfo, VehicleState } from '../types/vehicle';
+import type { Point } from '../types/core';
+/**
+ * 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 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;

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

@@ -0,0 +1,8 @@
+export type { CurveData, PathExecutionState, VehicleMovementState } from '../../types/movement';
+export { getPositionFromOffset, getLineLength } from './shared';
+export { checkRearCompletion, handleArrival, type SegmentCompletionContext, type SegmentCompletionResult, type SegmentVehicleState } from './segmentTransition';
+export { updateAxlePosition, calculatePositionOnLine, calculatePositionOnCurve } from './positionUpdate';
+export { calculateFrontAxlePosition, getCumulativeArcLength, arcLengthToSegmentPosition } from './arcLengthTracking';
+export { calculateInitialFrontPosition } from './initialize';
+export { initializeMovingVehicle, createInitialMovementState, initializeAllVehicles, type InitializationResult } from './initialize';
+export { prepareCommandPath, type PreparedPath } from './pathPreparation';

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

@@ -0,0 +1,37 @@
+import type { Vehicle, AxleState } from '../../types/vehicle';
+import type { Line } from '../../types/core';
+import type { VehicleMovementState } from '../../types/movement';
+/**
+ * Calculate initial front axle position from rear position
+ *
+ * @param rLineId - Rear axle line ID
+ * @param rAbsoluteOffset - Rear axle absolute offset on line
+ * @param wheelbase - Distance between front and rear axles
+ * @param line - The line the vehicle is on
+ * @returns Front axle state
+ */
+export declare function calculateInitialFrontPosition(rLineId: string, rAbsoluteOffset: number, wheelbase: number, line: Line): AxleState;
+/**
+ * Initialize Vehicle with runtime state for dual-axle
+ *
+ * @param vehicle - Vehicle to initialize (must have rear and front already populated)
+ * @param _line - The line (kept for compatibility)
+ * @returns Vehicle with state set to idle
+ */
+export declare function initializeMovingVehicle(vehicle: Vehicle, _line: Line): Vehicle;
+/**
+ * Create initial movement state for a vehicle
+ */
+export declare function createInitialMovementState(vehicle: Vehicle): VehicleMovementState;
+export interface InitializationResult {
+    movingVehicles: Vehicle[];
+    stateMap: Map<string, VehicleMovementState>;
+}
+/**
+ * Initialize all vehicles and their movement states
+ *
+ * @param vehicles - Array of vehicles to initialize
+ * @param linesMap - Map of line IDs to Line objects
+ * @returns InitializationResult with moving vehicles and state map
+ */
+export declare function initializeAllVehicles(vehicles: Vehicle[], linesMap: Map<string, Line>): InitializationResult;

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

@@ -0,0 +1,18 @@
+import type { Vehicle, GotoCommand } from '../../types/vehicle';
+import type { SceneContext } from '../../types/movement';
+import { type PathResult } from '../pathFinding';
+import type { CurveData } from '../../types/movement';
+export interface PreparedPath {
+    path: PathResult;
+    curveDataMap: Map<number, CurveData>;
+}
+/**
+ * Prepare path and curve data for a goto command
+ * Returns null if no path found
+ *
+ * @param vehicle - The vehicle to move
+ * @param command - The goto command with target
+ * @param ctx - Scene context with graph, linesMap, curves, and config
+ * @returns PreparedPath with path and curve data, or null if no path found
+ */
+export declare function prepareCommandPath(vehicle: Vehicle, command: GotoCommand, ctx: SceneContext): PreparedPath | null;

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

@@ -0,0 +1,44 @@
+import type { Line, Point } from '../../types/core';
+import type { AxleState } from '../../types/vehicle';
+import type { AxleExecutionState } from '../../types/movement';
+import type { PathResult } from '../pathFinding';
+import type { CurveData } from '../../types/movement';
+/**
+ * Calculate position on line (pure function)
+ *
+ * @param line - The line to calculate position on
+ * @param absoluteOffset - The offset along the line
+ * @returns Position data
+ */
+export declare function calculatePositionOnLine(line: Line, absoluteOffset: number): {
+    position: Point;
+    lineId: string;
+    absoluteOffset: number;
+};
+/**
+ * Calculate position on curve (pure function)
+ *
+ * @param curveData - The curve data with arc-length table
+ * @param segmentDistance - Distance along the curve
+ * @returns Position data
+ */
+export declare function calculatePositionOnCurve(curveData: CurveData, segmentDistance: number): {
+    position: Point;
+};
+/**
+ * Update single axle position and handle segment transitions
+ *
+ * @param axleState - Current axle state
+ * @param axleExecution - Current execution state for this axle
+ * @param path - The path being followed
+ * @param velocity - Distance to move this frame
+ * @param linesMap - Map of line IDs to Line objects
+ * @param curveDataMap - Map of curve indices to curve data
+ * @param maxOffset - Optional max offset for extending beyond path (for front axle)
+ * @returns Updated axle state, execution state, and completion flag
+ */
+export declare function updateAxlePosition(axleState: AxleState, axleExecution: AxleExecutionState, path: PathResult, velocity: number, linesMap: Map<string, Line>, curveDataMap: Map<number, CurveData>, maxOffset?: number): {
+    axleState: AxleState;
+    execution: AxleExecutionState;
+    completed: boolean;
+};

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

@@ -0,0 +1,39 @@
+import type { Line } from '../../types/core';
+import type { GotoCommand, GotoCompletionCallback } from '../../types/vehicle';
+import type { MovementConfig, SceneContext } from '../../types/movement';
+import type { Vehicle } from '../../types/vehicle';
+import type { PathResult } from '../pathFinding';
+import type { CurveData, PathExecutionState, VehicleMovementState } from '../../types/movement';
+interface SegmentCompletionContext {
+    linesMap: Map<string, Line>;
+    config: MovementConfig;
+    vehicleQueues: Map<string, GotoCommand[]>;
+    curves: import('../../types/core').Curve[];
+    graphRef: {
+        current: ReturnType<typeof import('../pathFinding').buildGraph> | null;
+    };
+    prepareCommandPath: (vehicle: Vehicle, command: GotoCommand, ctx: SceneContext) => {
+        path: PathResult;
+        curveDataMap: Map<number, CurveData>;
+    } | null;
+    onCommandComplete?: GotoCompletionCallback;
+}
+export interface SegmentCompletionResult {
+    handled: boolean;
+    vehicle: Vehicle;
+    /** New execution state (null if completed or unchanged) */
+    newExecution?: PathExecutionState | null;
+    /** True if vehicle is waiting for confirmation to continue */
+    isWaiting?: boolean;
+}
+/**
+ * Handle arrival at destination - all segments completed (pure function)
+ * Checks for next command in queue and starts it, or marks vehicle as arrived
+ */
+export declare function handleArrival(state: VehicleMovementState, overflow: number, ctx: SegmentCompletionContext): SegmentCompletionResult;
+/**
+ * Check if rear axle has completed all segments
+ * Note: This is called from the animation loop which uses updateAxlePosition for movement
+ */
+export declare function checkRearCompletion(state: VehicleMovementState, ctx: SegmentCompletionContext): SegmentCompletionResult;
+export type { SegmentCompletionContext, VehicleMovementState as SegmentVehicleState };

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

@@ -0,0 +1,10 @@
+import type { Line, Point } from '../../types/core';
+/**
+ * Get position on line from absolute offset
+ * This is a pure function that converts absolute offset to Point coordinates
+ */
+export declare function getPositionFromOffset(line: Line, absoluteOffset: number): Point;
+/**
+ * Calculate line length
+ */
+export declare function getLineLength(line: Line): number;

package/dist/vehicle-path.cjs

@@ -0,0 +1,14 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const f=require("react");function R(e,t){const n=t.x-e.x,s=t.y-e.y;return Math.sqrt(n*n+s*s)}function K(e,t){const n=t.x-e.x,s=t.y-e.y,r=Math.sqrt(n*n+s*s);return r===0?{x:0,y:0}:{x:n/r,y:s/r}}function we(e,t){return t*(e==="proportional-40"?.4:.5522)}function ne(e,t,n,s=!1,r){const{wheelbase:c,tangentMode:o}=n;let i;r?.fromOffset!==void 0?i=H(e,r.fromOffset,r.fromIsPercentage??!1):i=e.end;let l;r?.toOffset!==void 0?l=H(t,r.toOffset,r.toIsPercentage??!1):l=t.start;const a=K(e.start,e.end),u=s?{x:i.x-a.x*c,y:i.y-a.y*c}:i,m=K(e.start,e.end),g=K(t.start,t.end),I=R(u,l),p=we(o,I),d=s?{x:u.x-m.x*p,y:u.y-m.y*p}:{x:u.x+m.x*p,y:u.y+m.y*p},v={x:l.x-g.x*p,y:l.y-g.y*p};return{p0:u,p1:d,p2:v,p3:l}}function le(e,t){return{x:e.start.x+(e.end.x-e.start.x)*t,y:e.start.y+(e.end.y-e.start.y)*t}}function H(e,t,n){const s=R(e.start,e.end);let r;return n?r=t/100:r=s>0?t/s:0,r=Math.max(0,Math.min(1,r)),le(e,r)}function Y(e,t){const{p0:n,p1:s,p2:r,p3:c}=e,o=1-t,i=o*o,l=i*o,a=t*t,u=a*t;return{x:l*n.x+3*i*t*s.x+3*o*a*r.x+u*c.x,y:l*n.y+3*i*t*s.y+3*o*a*r.y+u*c.y}}function de(e,t=100){const n=[{t:0,distance:0}];let s=e.p0,r=0;for(let c=1;c<=t;c++){const o=c/t,i=Y(e,o);r+=R(s,i),n.push({t:o,distance:r}),s=i}return n}function me(e,t){if(t<=0)return 0;const n=e[e.length-1].distance;if(t>=n)return 1;let s=0,r=e.length-1;for(;s<r-1;){const u=Math.floor((s+r)/2);e[u].distance<t?s=u:r=u}const c=e[s].distance,o=e[r].distance,i=e[s].t,l=e[r].t;if(o===c)return i;const a=(t-c)/(o-c);return i+a*(l-i)}function Te(e){return e[e.length-1].distance}function ge(e,t=100){let n=0,s=e.p0;for(let r=1;r<=t;r++){const c=r/t,o=Y(e,c);n+=R(s,o),s=o}return n}function Ee(e,t,n,s){const r=R(e.start,e.end);return t===void 0?s/100*r:n?t/100*r:t}function se(e,t,n,s,r){const c=R(e.start,e.end),o=c-r;if(o<=0)return c;let i;if(t===void 0)i=s;else if(n)i=t;else return Math.max(r,Math.min(t,c));return r+i/100*o}function re(e,t,n,s,r){const o=R(e.start,e.end)-r;if(o<=0)return 0;let i;if(t===void 0)i=s;else if(n)i=t;else return Math.max(0,Math.min(t,o));return i/100*o}function he(e,t,n){const s=new Map,r=new Map,c=new Map;for(const o of e)r.set(o.id,o),c.set(o.id,R(o.start,o.end)),s.set(o.id,[]);for(let o=0;o<t.length;o++){const i=t[o],l=r.get(i.fromLineId),a=r.get(i.toLineId);if(!l||!a)continue;const u=se(l,i.fromOffset,i.fromIsPercentage,100,n.wheelbase),m=re(a,i.toOffset,i.toIsPercentage,0,n.wheelbase),g=ne(l,a,n,!1,{fromOffset:u,fromIsPercentage:!1,toOffset:m,toIsPercentage:!1}),I=ge(g),p={curveIndex:o,fromLineId:i.fromLineId,toLineId:i.toLineId,fromOffset:u,toOffset:m,curveLength:I};s.get(i.fromLineId).push(p)}return{adjacency:s,lines:r,lineLengths:c}}function oe(e,t,n,s,r=!1){const{adjacency:c,lines:o,lineLengths:i}=e;if(!o.get(n))return null;const a=i.get(n),u=r?s/100*a:s,m=[],g=new Map,I=(d,v)=>`${d}:${Math.round(v)}`;if(t.lineId===n&&u>=t.offset){const d=u-t.offset;return{segments:[{type:"line",lineId:t.lineId,startOffset:t.offset,endOffset:u,length:d}],totalDistance:d}}const p=c.get(t.lineId)||[];for(const d of p){if(d.fromOffset<t.offset)continue;const v=d.fromOffset-t.offset,O=v+d.curveLength,L={type:"line",lineId:t.lineId,startOffset:t.offset,endOffset:d.fromOffset,length:v},h={type:"curve",curveIndex:d.curveIndex,startOffset:0,endOffset:d.curveLength,length:d.curveLength};m.push({lineId:d.toLineId,entryOffset:d.toOffset,totalDistance:O,path:[L,h]})}for(m.sort((d,v)=>d.totalDistance-v.totalDistance);m.length>0;){const d=m.shift(),v=I(d.lineId,d.entryOffset),O=g.get(v);if(O!==void 0&&O<=d.totalDistance)continue;if(g.set(v,d.totalDistance),d.lineId===n){const h=Math.abs(u-d.entryOffset);if(u>=d.entryOffset){const x={type:"line",lineId:n,startOffset:d.entryOffset,endOffset:u,length:h};return{segments:[...d.path,x],totalDistance:d.totalDistance+h}}}const L=c.get(d.lineId)||[];for(const h of L){if(h.fromOffset<d.entryOffset)continue;const x=h.fromOffset-d.entryOffset,M=d.totalDistance+x+h.curveLength,C=I(h.toLineId,h.toOffset),V=g.get(C);if(V!==void 0&&V<=M)continue;const D={type:"line",lineId:d.lineId,startOffset:d.entryOffset,endOffset:h.fromOffset,length:x},y={type:"curve",curveIndex:h.curveIndex,startOffset:0,endOffset:h.curveLength,length:h.curveLength};m.push({lineId:h.toLineId,entryOffset:h.toOffset,totalDistance:M,path:[...d.path,D,y]})}m.sort((h,x)=>h.totalDistance-x.totalDistance)}return null}function Ve(e,t,n,s,r=!1){return oe(e,t,n,s,r)!==null}function $e(e,t,n){return(e.adjacency.get(t)||[]).filter(r=>r.fromOffset>=n)}function ie(e,t){const n=Math.sqrt(Math.pow(e.end.x-e.start.x,2)+Math.pow(e.end.y-e.start.y,2)),s=n>0?t/n:0;return{x:e.start.x+(e.end.x-e.start.x)*Math.min(1,Math.max(0,s)),y:e.start.y+(e.end.y-e.start.y)*Math.min(1,Math.max(0,s))}}function pe(e){return Math.sqrt(Math.pow(e.end.x-e.start.x,2)+Math.pow(e.end.y-e.start.y,2))}function ve(e,t,n){let s=0;for(let r=0;r<t;r++)s+=e.segments[r].length;return s+=n,s}function Ie(e,t){let n=0;for(let s=0;s<e.segments.length;s++){const r=e.segments[s],c=n+r.length;if(t<c)return{segmentIndex:s,segmentDistance:t-n};if(t===c)return s+1<e.segments.length?{segmentIndex:s+1,segmentDistance:0}:{segmentIndex:s,segmentDistance:r.length};n+=r.length}return null}function X(e,t,n,s){const c=ve(e,t,n)+s;return Ie(e,c)}function ce(e,t,n){const s=e.execution,r=n.vehicleQueues.get(e.vehicle.id),c=r?.[s.currentCommandIndex];if(c&&n.onCommandComplete&&n.onCommandComplete({vehicleId:e.vehicle.id,command:c,finalPosition:{lineId:e.vehicle.rear.lineId,absoluteOffset:e.vehicle.rear.absoluteOffset,position:e.vehicle.rear.position},payload:c.payload}),c?.awaitConfirmation)return{handled:!0,vehicle:{...e.vehicle,state:"waiting"},newExecution:s,isWaiting:!0};const o=s.currentCommandIndex+1;if(r&&o<r.length){const l=r[o],a=n.graphRef.current;if(a){const u={graph:a,linesMap:n.linesMap,curves:n.curves,config:n.config},m=n.prepareCommandPath(e.vehicle,l,u);if(m){const g=X(m.path,0,t,n.config.wheelbase),I={path:m.path,curveDataMap:m.curveDataMap,currentCommandIndex:o,rear:{currentSegmentIndex:0,segmentDistance:t},front:g?{currentSegmentIndex:g.segmentIndex,segmentDistance:g.segmentDistance}:{currentSegmentIndex:0,segmentDistance:t}};return{handled:!0,vehicle:{...e.vehicle,state:"moving"},newExecution:I}}}}return{handled:!0,vehicle:{...e.vehicle,state:"idle"},newExecution:null}}function be(e,t){const n=e.execution;return n?n.rear.currentSegmentIndex>=n.path.segments.length?ce(e,n.rear.segmentDistance,t):{handled:!1,vehicle:e.vehicle}:{handled:!1,vehicle:e.vehicle}}function k(e,t){return{position:ie(e,t),lineId:e.id,absoluteOffset:t}}function U(e,t){const n=me(e.arcLengthTable,t);return{position:Y(e.bezier,n)}}function Z(e,t,n,s,r,c,o){const i=n.segments[t.currentSegmentIndex],l=t.segmentDistance+s;if(l>=i.length){const u=l-i.length,m=t.currentSegmentIndex+1;if(m>=n.segments.length){if(o!==void 0&&i.type==="line"){const d=r.get(i.lineId),v=i.startOffset+l;if(v<=o){const L=k(d,v);return{axleState:{...e,...L},execution:{...t,segmentDistance:l},completed:!1}}const O=k(d,o);return{axleState:{...e,...O},execution:{...t,segmentDistance:o-i.startOffset},completed:!0}}const p=i.type==="line"?k(r.get(i.lineId),i.endOffset):U(c.get(i.curveIndex),i.length);return{axleState:{...e,...p},execution:{...t,segmentDistance:i.length},completed:!0}}const g=n.segments[m],I=g.type==="line"?k(r.get(g.lineId),g.startOffset+u):U(c.get(g.curveIndex),u);return{axleState:{...e,...I},execution:{currentSegmentIndex:m,segmentDistance:u},completed:!1}}const a=i.type==="line"?k(r.get(i.lineId),i.startOffset+l):U(c.get(i.curveIndex),l);return{axleState:{...e,...a},execution:{...t,segmentDistance:l},completed:!1}}function xe(e,t,n,s){const r=Math.sqrt(Math.pow(s.end.x-s.start.x,2)+Math.pow(s.end.y-s.start.y,2));let c=t+n;c=Math.min(c,r);const o=ie(s,c);return{lineId:e,position:o,absoluteOffset:c}}function ye(e,t){return{...e,state:"idle"}}function Se(e){return{vehicle:e,execution:null}}function ee(e,t){const n=[],s=new Map;for(const r of e){if(!t.get(r.lineId))continue;const o=ye(r);n.push(o);const i=Se(o);s.set(r.id,i)}return{movingVehicles:n,stateMap:s}}function Re(e,t,n,s){const r=new Map;for(const c of e.segments)if(c.type==="curve"&&c.curveIndex!==void 0){const o=t[c.curveIndex];if(o){const i=n.get(o.fromLineId),l=n.get(o.toLineId);if(i&&l){const a=se(i,o.fromOffset,o.fromIsPercentage,100,s.wheelbase),u=re(l,o.toOffset,o.toIsPercentage,0,s.wheelbase),m=ne(i,l,s,!1,{fromOffset:a,fromIsPercentage:!1,toOffset:u,toIsPercentage:!1}),g=de(m);r.set(c.curveIndex,{bezier:m,arcLengthTable:g})}}}return r}function W(e,t,n){const{graph:s,linesMap:r,curves:c,config:o}=n,i=r.get(t.targetLineId);if(!i)return null;const a=pe(i)-o.wheelbase;if(a<=0)return null;const u=t.isPercentage?t.targetOffset/100*a:Math.min(t.targetOffset,a),m=oe(s,{lineId:e.lineId,offset:e.rear.absoluteOffset},t.targetLineId,u,!1);if(!m)return null;const g=Re(m,c,r,o);return{path:m,curveDataMap:g}}function Ae({vehicles:e,lines:t,vehicleQueues:n,velocity:s,wheelbase:r,tangentMode:c,curves:o,eventEmitter:i}){const[l,a]=f.useState("stopped"),[u,m]=f.useState([]),g=f.useMemo(()=>({wheelbase:r,tangentMode:c}),[r,c]),I=f.useMemo(()=>new Map(t.map(y=>[y.id,y])),[t]),p=f.useRef(null),d=f.useRef(new Map);f.useEffect(()=>{const{movingVehicles:y,stateMap:S}=ee(e,I);d.current=S;const P=setTimeout(()=>{m(y)},0);return()=>clearTimeout(P)},[e,I]);const v=f.useRef(null);f.useEffect(()=>{t.length>0&&(v.current=he(t,o,g))},[t,o,g]);const O=f.useRef(!1),L=f.useRef(()=>{}),h=f.useRef(0),x=f.useRef(new Set);f.useEffect(()=>{L.current=()=>{const y=s;let S=!1;for(const[,P]of d.current)P.vehicle.state==="moving"&&(S=!0);if(!S){O.current=!1,h.current=0;return}m(P=>P.map($=>{const w=d.current.get($.id);if(!w||$.state!=="moving"||!w.execution)return $;const T=w.execution;let A;if(T.front.currentSegmentIndex<T.path.segments.length){const F=T.path.segments[T.front.currentSegmentIndex];if(F.type==="line"){const E=I.get(F.lineId);E&&(A=Math.sqrt(Math.pow(E.end.x-E.start.x,2)+Math.pow(E.end.y-E.start.y,2)))}}const q=Z($.rear,T.rear,T.path,y,I,T.curveDataMap),b=Z($.front,T.front,T.path,y,I,T.curveDataMap,A);if(q.completed){const F={linesMap:I,config:g,vehicleQueues:n,curves:o,graphRef:v,prepareCommandPath:W,onCommandComplete:i?j=>i.emit("commandComplete",j):void 0},E={...$,rear:q.axleState,front:b.axleState};w.vehicle=E,w.execution.rear=q.execution,w.execution.front=b.execution;const ae=q.execution.segmentDistance,z=ce(w,ae,F);if(w.vehicle=z.vehicle,z.newExecution!==void 0&&(w.execution=z.newExecution),i){const j=z.vehicle.rear.position,G=z.vehicle.front.position;i.emit("positionUpdate",{vehicleId:z.vehicle.id,rear:j,front:G,center:{x:(j.x+G.x)/2,y:(j.y+G.y)/2},angle:Math.atan2(G.y-j.y,G.x-j.x)})}return z.vehicle}const N={...$,rear:q.axleState,front:b.axleState};if(w.vehicle=N,w.execution.rear=q.execution,w.execution.front=b.execution,i){const F=N.rear.position,E=N.front.position;i.emit("positionUpdate",{vehicleId:N.id,rear:F,front:E,center:{x:(F.x+E.x)/2,y:(F.y+E.y)/2},angle:Math.atan2(E.y-F.y,E.x-F.x)})}return N})),O.current&&(p.current=requestAnimationFrame(()=>L.current()))}},[s,I,o,g,n,i]),f.useEffect(()=>(l==="running"?(O.current=!0,p.current=requestAnimationFrame(()=>L.current())):O.current=!1,()=>{p.current&&cancelAnimationFrame(p.current)}),[l]);const M=f.useCallback(()=>{if(l==="running")return;const y=v.current;y&&(h.current=0,x.current.clear(),m(S=>S.map(P=>{const $=n.get(P.id);if(!$||$.length===0)return P;const w=$[0],A=W(P,w,{graph:y,linesMap:I,curves:o,config:g});if(!A)return console.warn(`No path found for vehicle ${P.id}`),P;const q=d.current.get(P.id);if(q){const b=X(A.path,0,0,r);q.execution={path:A.path,curveDataMap:A.curveDataMap,currentCommandIndex:0,rear:{currentSegmentIndex:0,segmentDistance:0},front:b?{currentSegmentIndex:b.segmentIndex,segmentDistance:b.segmentDistance}:{currentSegmentIndex:0,segmentDistance:0}},q.vehicle={...P,state:"moving"}}return{...P,state:"moving"}})),a("running"))},[l,I,o,n,g,r]),C=f.useCallback(()=>{p.current&&(cancelAnimationFrame(p.current),p.current=null),a("paused")},[]),V=f.useCallback(()=>{p.current&&(cancelAnimationFrame(p.current),p.current=null);const{movingVehicles:y,stateMap:S}=ee(e,I);d.current=S,m(y),a("stopped")},[e,I]),D=f.useCallback(y=>{const S=d.current.get(y);if(!S||S.vehicle.state!=="waiting")return!1;const P=n.get(y),$=S.execution;if(!$)return!1;const w=$.currentCommandIndex+1;if(P&&w<P.length){const T=v.current;if(T){const A=P[w],q={graph:T,linesMap:I,curves:o,config:g},b=W(S.vehicle,A,q);if(b){const N=X(b.path,0,0,r);return S.execution={path:b.path,curveDataMap:b.curveDataMap,currentCommandIndex:w,rear:{currentSegmentIndex:0,segmentDistance:0},front:N?{currentSegmentIndex:N.segmentIndex,segmentDistance:N.segmentDistance}:{currentSegmentIndex:0,segmentDistance:0}},S.vehicle={...S.vehicle,state:"moving"},m(F=>F.map(E=>E.id===y?S.vehicle:E)),l!=="running"&&a("running"),!0}}}return S.vehicle={...S.vehicle,state:"idle"},S.execution=null,m(T=>T.map(A=>A.id===y?S.vehicle:A)),!0},[n,I,o,g,r,l]);return{movingVehicles:u,playbackState:l,handleRun:M,handlePause:C,handleReset:V,continueVehicle:D}}class Le{listeners=new Map;on(t,n){return this.listeners.has(t)||this.listeners.set(t,new Set),this.listeners.get(t).add(n),()=>{this.listeners.get(t)?.delete(n)}}emit(t,n){this.listeners.get(t)?.forEach(s=>{try{s(n)}catch(r){console.error(`Error in event listener for "${t}":`,r)}})}off(t){t?this.listeners.delete(t):this.listeners.clear()}listenerCount(t){return this.listeners.get(t)?.size??0}}const Me=f.createContext(null);function Oe(){const e=f.useContext(Me);if(!e)throw new Error("useVehicleEventEmitter must be used within a VehicleEventProvider");return e}function qe(){return f.useMemo(()=>new Le,[])}function Fe(e,t,n=[]){const s=Oe();f.useEffect(()=>s.on(e,t),[s,e,...n])}function te(e){const t=[],n=[],s=[],r=e.trim().split(`
+`);for(const c of r){const o=c.trim();if(!o||o.startsWith("#"))continue;const i=o.match(/^(\w+)\s*:\s*\((\d+),\s*(\d+)\)\s*->\s*\((\d+),\s*(\d+)\)/);if(i){t.push({id:i[1],start:{x:parseInt(i[2]),y:parseInt(i[3])},end:{x:parseInt(i[4]),y:parseInt(i[5])}});continue}const l=o.match(/^(\w+)(?:\s+(\d+(?:\.\d+)?)(%?))??\s*->\s*(\w+)(?:\s+(\d+(?:\.\d+)?)(%?))?/);if(l){const u={fromLineId:l[1],toLineId:l[4]};l[2]&&(u.fromOffset=parseFloat(l[2]),u.fromIsPercentage=l[3]==="%"),l[5]&&(u.toOffset=parseFloat(l[5]),u.toIsPercentage=l[6]==="%"),n.push(u);continue}const a=o.match(/^(\w+)\s+start\s+(\w+)\s+(\d+(?:\.\d+)?)(%?)/);if(a){const u=parseFloat(a[3]),m=a[4]==="%";s.push({vehicleId:a[1],lineId:a[2],offset:u,isPercentage:m});continue}}return{lines:t,curves:n,vehicles:s}}function Ce(e){const t=[];return e.lines.forEach(n=>{t.push(`${n.id} : (${Math.round(n.start.x)}, ${Math.round(n.start.y)}) -> (${Math.round(n.end.x)}, ${Math.round(n.end.y)})`)}),e.lines.length>0&&e.curves.length>0&&t.push(""),e.curves.forEach(n=>{let s=`${n.fromLineId}`;n.fromOffset!==void 0&&(s+=` ${n.fromOffset}${n.fromIsPercentage?"%":""}`),s+=" -> ",s+=`${n.toLineId}`,n.toOffset!==void 0&&(s+=` ${n.toOffset}${n.toIsPercentage?"%":""}`),t.push(s)}),(e.lines.length>0||e.curves.length>0)&&e.vehicles.length>0&&t.push(""),e.vehicles.forEach(n=>{const s=n.isPercentage?`${n.offset}%`:`${n.offset}`;t.push(`${n.vehicleId} start ${n.lineId} ${s}`)}),t.join(`
+`)}function B(e){const t=[],n=e.trim().split(`
+`);for(const s of n){const r=s.trim();if(!r||r.startsWith("#"))continue;const c=r.match(/^(\w+)\s+start\s+(\w+)\s+(\d+(?:\.\d+)?)(%?)/);c&&t.push({vehicleId:c[1],lineId:c[2],offset:parseFloat(c[3]),isPercentage:c[4]==="%"})}return t}function De(e){return e.map(t=>{const n=t.isPercentage?`${t.offset}%`:`${t.offset}`;return`${t.vehicleId} start ${t.lineId} ${n}`}).join(`
+`)}function Q(e){const t=[],n=e.trim().split(`
+`);for(const s of n){const r=s.trim();if(!r||r.startsWith("#"))continue;const c=r.match(/^(\w+)\s+goto\s+(\w+)\s+(\d+(?:\.\d+)?)(%?)/);if(c){const o=r.slice(c[0].length),i=o.includes("--wait");let l;const a=o.match(/--payload\s+(\{.*\})/);if(a)try{l=JSON.parse(a[1])}catch{console.warn(`Invalid JSON payload in goto command: ${a[1]}`)}t.push({vehicleId:c[1],targetLineId:c[2],targetOffset:parseFloat(c[3]),isPercentage:c[4]==="%",awaitConfirmation:i,payload:l})}}return t}function Pe(e){return e.map(t=>{const n=t.isPercentage?`${t.targetOffset}%`:`${t.targetOffset}`,s=t.awaitConfirmation?" --wait":"",r=t.payload!==void 0?` --payload ${JSON.stringify(t.payload)}`:"";return`${t.vehicleId} goto ${t.targetLineId} ${n}${s}${r}`}).join(`
+`)}function Ne(){const[e,t]=f.useState([]),[n,s]=f.useState([]),[r,c]=f.useState(""),[o,i]=f.useState(null),[l,a]=f.useState(!1),[u,m]=f.useState(0),g=f.useRef(!1),I=f.useRef("");return f.useEffect(()=>{I.current=r},[r]),f.useEffect(()=>{if(g.current)return;const p=te(I.current),d=Ce({lines:e,curves:n,vehicles:p.vehicles});d!==I.current&&(g.current=!0,c(d),setTimeout(()=>{g.current=!1},50))},[e,n]),f.useEffect(()=>{if(g.current)return;const p=setTimeout(()=>{a(!0),m(v=>v+1)},0),d=setTimeout(()=>{try{const v=te(r);a(!1);const O=JSON.stringify(v.lines)!==JSON.stringify(e),L=JSON.stringify(v.curves)!==JSON.stringify(n);(O||L)&&(g.current=!0,O&&t(v.lines),L&&s(v.curves),setTimeout(()=>{g.current=!1},100)),i(null)}catch(v){a(!1),i(v instanceof Error?v.message:"Invalid scene definition")}},2e3);return()=>{clearTimeout(p),clearTimeout(d)}},[r,e,n]),{lines:e,curves:n,sceneDefinitionText:r,sceneError:o,isDebouncing:l,debounceKey:u,setLines:t,setCurves:s,setSceneDefinitionText:c}}function J(e,t,n=0){const s=[],r=[],c=new Set;for(const o of e){if(c.has(o.vehicleId)){r.push(`Duplicate vehicle ID: ${o.vehicleId}`);continue}c.add(o.vehicleId);const i=t.find(p=>p.id===o.lineId);if(!i){r.push(`Vehicle ${o.vehicleId}: Line "${o.lineId}" not found`);continue}const l=R(i.start,i.end),a=Math.max(0,l-n);let u;if(o.isPercentage){if(o.offset<0||o.offset>100){r.push(`Vehicle ${o.vehicleId}: Offset ${o.offset}% must be between 0% and 100%`);continue}u=o.offset/100*a}else{if(o.offset<0||o.offset>l){r.push(`Vehicle ${o.vehicleId}: Offset ${o.offset} exceeds line length ${l.toFixed(2)}`);continue}u=Math.min(o.offset,a)}const m=H(i,u,!1),g={lineId:o.lineId,position:m,absoluteOffset:u},I=xe(o.lineId,u,n,i);s.push({id:o.vehicleId,lineId:o.lineId,offset:o.offset,isPercentage:o.isPercentage,state:"idle",rear:g,front:I})}return{vehicles:s,errors:r}}function ze(e){const t=e.map(s=>{const r=s.vehicleId.match(/^v(\d+)$/);return r?parseInt(r[1]):0}).filter(s=>s>0);return`v${(t.length>0?Math.max(...t):0)+1}`}function _(e,t,n){const s=[],r=[],c=new Map,o=new Set(t.map(a=>a.id)),i=new Set(n.map(a=>a.id)),l=new Map(n.map(a=>{const u=a.end.x-a.start.x,m=a.end.y-a.start.y;return[a.id,Math.sqrt(u*u+m*m)]}));for(const a of e){if(!o.has(a.vehicleId)){s.push(`Vehicle "${a.vehicleId}" does not exist`);continue}if(!i.has(a.targetLineId)){s.push(`Line "${a.targetLineId}" does not exist`);continue}const u=l.get(a.targetLineId),m=a.isPercentage?a.targetOffset/100*u:a.targetOffset;if(m<0||m>u){s.push(`Offset ${a.targetOffset}${a.isPercentage?"%":""} is out of bounds for ${a.targetLineId}`);continue}r.push(a);const g=c.get(a.vehicleId)||[];g.push(a),c.set(a.vehicleId,g)}return{commands:r,errors:s,vehicleQueues:c}}function je(e,t){if(t.length===0)return null;if(e.length===0)return t[0].id;const n=new Map;for(const s of t)n.set(s.id,0);for(const s of e){const r=n.get(s.vehicleId)||0;n.set(s.vehicleId,r+1)}return t[0].id}function ke({lines:e,wheelbase:t}){const[n,s]=f.useState([]),[r,c]=f.useState(""),[o,i]=f.useState(null),[l,a]=f.useState(!1),[u,m]=f.useState(0),g=f.useRef(!1),I=f.useRef(e),p=f.useRef(e),d=f.useRef(t),v=f.useRef(t);f.useEffect(()=>{I.current=e},[e]),f.useEffect(()=>{d.current=t},[t]),f.useEffect(()=>{if(g.current)return;const L=setTimeout(()=>{a(!0),m(x=>x+1)},0),h=setTimeout(()=>{try{const x=B(r),{vehicles:M,errors:C}=J(x,I.current,d.current);a(!1),C.length>0?(i(C.join(`
+`)),s(M)):(i(null),s(M))}catch(x){a(!1),i(x instanceof Error?x.message:"Invalid initial movement"),s([])}},2e3);return()=>{clearTimeout(L),clearTimeout(h)}},[r]),f.useEffect(()=>{if(!(JSON.stringify(p.current)!==JSON.stringify(e))||(p.current=e,g.current||!r.trim()))return;const h=setTimeout(()=>{try{const x=B(r),{vehicles:M,errors:C}=J(x,e,d.current);C.length>0?(i(C.join(`
+`)),s(M)):(i(null),s(M))}catch(x){i(x instanceof Error?x.message:"Invalid initial movement"),s([])}},0);return()=>clearTimeout(h)},[e,r]),f.useEffect(()=>{if(v.current===t||(v.current=t,g.current||!r.trim()))return;const L=setTimeout(()=>{try{const h=B(r),{vehicles:x,errors:M}=J(h,I.current,t);M.length>0?(i(M.join(`
+`)),s(x)):(i(null),s(x))}catch(h){i(h instanceof Error?h.message:"Invalid initial movement"),s([])}},0);return()=>clearTimeout(L)},[t,r]);const O=f.useCallback(()=>{const L=B(r),h=ze(L),x=e.length>0?e[0]:null;if(!x){i("No lines available. Please create at least one line first.");return}const M={vehicleId:h,lineId:x.id,offset:0,isPercentage:!1},C=[...L,M],V=De(C),{vehicles:D,errors:y}=J(C,e,t);g.current=!0,c(V),y.length>0?i(y.join(`
+`)):i(null),s(D),setTimeout(()=>{g.current=!1},50)},[r,e,t]);return{vehicles:n,initialMovementText:r,movementError:o,isDebouncing:l,debounceKey:u,setInitialMovementText:c,handleAddStartCommand:O}}function Ge({lines:e,vehicles:t}){const[n,s]=f.useState(""),[r,c]=f.useState([]),[o,i]=f.useState(new Map),[l,a]=f.useState(null),[u,m]=f.useState(!1),[g,I]=f.useState(0),p=f.useRef(!1),d=f.useRef(t),v=f.useRef(e);f.useEffect(()=>{d.current=t,v.current=e},[t,e]),f.useEffect(()=>{if(p.current)return;const L=setTimeout(()=>{m(!0),I(x=>x+1)},0),h=setTimeout(()=>{try{const x=Q(n),{commands:M,errors:C,vehicleQueues:V}=_(x,d.current,v.current);m(!1),C.length>0?a(C.join(`
+`)):a(null),c(M),i(V)}catch(x){m(!1),a(x instanceof Error?x.message:"Invalid movement sequence"),c([]),i(new Map)}},2e3);return()=>{clearTimeout(L),clearTimeout(h)}},[n]),f.useEffect(()=>{if(p.current||!n.trim())return;const L=setTimeout(()=>{try{const h=Q(n),{commands:x,errors:M,vehicleQueues:C}=_(h,t,e);M.length>0?a(M.join(`
+`)):a(null),c(x),i(C)}catch(h){a(h instanceof Error?h.message:"Invalid movement sequence"),c([]),i(new Map)}},0);return()=>clearTimeout(L)},[t,e,n]);const O=f.useCallback(()=>{if(t.length===0){a("No vehicles available. Please create at least one vehicle first.");return}if(e.length===0){a("No lines available. Please create at least one line first.");return}const L=Q(n),h=je(L,t);if(!h){a("No vehicles available.");return}const x=e[0],M={vehicleId:h,targetLineId:x.id,targetOffset:100,isPercentage:!0},C=[...L,M],V=Pe(C),{commands:D,errors:y,vehicleQueues:S}=_(C,t,e);p.current=!0,s(V),y.length>0?a(y.join(`
+`)):a(null),c(D),i(S),setTimeout(()=>{p.current=!1},50)},[n,t,e]);return{movementSequenceText:n,gotoCommands:r,vehicleQueues:o,sequenceError:l,isDebouncing:u,debounceKey:g,setMovementSequenceText:s,handleAddGotoCommand:O}}function ue(e,t,n){if(!t||!n)return{x:0,y:0};const s=t.getBoundingClientRect();return{x:e.clientX-s.left,y:e.clientY-s.top}}function fe(e,t,n=10){for(const s of t){if(R(e,s.start)<n)return{lineId:s.id,endpoint:"start"};if(R(e,s.end)<n)return{lineId:s.id,endpoint:"end"}}return null}function Be({canvasRef:e,containerRef:t,drawMode:n,lines:s,curves:r,setLines:c,setCurves:o,lineCounterRef:i}){const[l,a]=f.useState(!1),[u,m]=f.useState(null),[g,I]=f.useState(null),[p,d]=f.useState(null),[v,O]=f.useState(null),[L,h]=f.useState({x:0,y:0});return{handleMouseDown:V=>{const D=ue(V,e.current,t.current),y=fe(D,s);if(n==="line")y||(a(!0),m({start:D,current:D}));else if(n==="drag")y&&d(y);else if(n==="curve")if(y)if(!v)O(y);else{if(v.lineId!==y.lineId){const S={fromLineId:v.lineId,toLineId:y.lineId};o([...r,S])}O(null)}else v&&O(null)},handleMouseMove:V=>{const D=ue(V,e.current,t.current);if(h(D),l&&u)m({...u,current:D});else if(p){const y=s.map(S=>S.id===p.lineId?p.endpoint==="start"?{...S,start:D}:{...S,end:D}:S);c(y)}else{const y=fe(D,s);I(y)}},handleMouseUp:()=>{if(l&&u){if(R(u.start,u.current)>20){const D={id:`line${String(i.current).padStart(3,"0")}`,start:u.start,end:u.current};i.current++,c([...s,D])}m(null),a(!1)}else p&&d(null)},tempLine:u,hoveredEndpoint:g,curveStart:v,mousePos:L}}exports.VehicleEventContext=Me;exports.VehicleEventEmitter=Le;exports.arcLengthToSegmentPosition=Ie;exports.buildArcLengthTable=de;exports.buildGraph=he;exports.calculateBezierArcLength=ge;exports.calculateFrontAxlePosition=X;exports.calculateInitialFrontPosition=xe;exports.calculatePositionOnCurve=U;exports.calculatePositionOnLine=k;exports.canReachTarget=Ve;exports.checkRearCompletion=be;exports.createBezierCurve=ne;exports.createInitialMovementState=Se;exports.distance=R;exports.distanceToT=me;exports.findPath=oe;exports.generateGotoCommands=Pe;exports.generateSceneDefinition=Ce;exports.generateVehicleStarts=De;exports.getArcLength=Te;exports.getCumulativeArcLength=ve;exports.getLineLength=pe;exports.getPointOnBezier=Y;exports.getPointOnLine=le;exports.getPointOnLineByOffset=H;exports.getPositionFromOffset=ie;exports.getReachableCurves=$e;exports.handleArrival=ce;exports.initializeAllVehicles=ee;exports.initializeMovingVehicle=ye;exports.normalize=K;exports.parseGotoCommands=Q;exports.parseSceneDefinition=te;exports.parseVehicleStarts=B;exports.prepareCommandPath=W;exports.resolveFromLineOffset=se;exports.resolveOffset=Ee;exports.resolveToLineOffset=re;exports.updateAxlePosition=Z;exports.useCanvasInteraction=Be;exports.useCreateVehicleEventEmitter=qe;exports.useInitialMovement=ke;exports.useMovementSequence=Ge;exports.useSceneDefinition=Ne;exports.useVehicleEvent=Fe;exports.useVehicleEventEmitter=Oe;exports.useVehicleMovement=Ae;