vehicle-path2 1.0.0

package/dist/core.js

@@ -0,0 +1,551 @@
+function v(e, t) {
+  const o = t.x - e.x, n = t.y - e.y;
+  return Math.sqrt(o * o + n * n);
+}
+function M(e, t) {
+  const o = t.x - e.x, n = t.y - e.y, s = Math.sqrt(o * o + n * n);
+  return s === 0 ? { x: 0, y: 0 } : { x: o / s, y: n / s };
+}
+function F(e, t) {
+  return t * (e === "proportional-40" ? 0.4 : 0.5522);
+}
+function T(e, t, o, n = !1, s) {
+  const { wheelbase: c, tangentMode: i } = o;
+  let r;
+  s?.fromOffset !== void 0 ? r = S(e, s.fromOffset, s.fromIsPercentage ?? !1) : r = e.end;
+  let l;
+  s?.toOffset !== void 0 ? l = S(t, s.toOffset, s.toIsPercentage ?? !1) : l = t.start;
+  const d = M(e.start, e.end), a = n ? {
+    // Transition with flip: kurva dimulai dari P (baseP0 - wheelbase in line direction)
+    x: r.x - d.x * c,
+    y: r.y - d.y * c
+  } : r, u = M(e.start, e.end), g = M(t.start, t.end), p = v(a, l), I = F(i, p), f = n ? { x: a.x - u.x * I, y: a.y - u.y * I } : { x: a.x + u.x * I, y: a.y + u.y * I }, m = {
+    x: l.x - g.x * I,
+    y: l.y - g.y * I
+  };
+  return { p0: a, p1: f, p2: m, p3: l };
+}
+function K(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 S(e, t, o) {
+  const n = v(e.start, e.end);
+  let s;
+  return o ? s = t / 100 : s = n > 0 ? t / n : 0, s = Math.max(0, Math.min(1, s)), K(e, s);
+}
+function D(e, t) {
+  const { p0: o, p1: n, p2: s, p3: c } = e, i = 1 - t, r = i * i, l = r * i, d = t * t, a = d * t;
+  return {
+    x: l * o.x + 3 * r * t * n.x + 3 * i * d * s.x + a * c.x,
+    y: l * o.y + 3 * r * t * n.y + 3 * i * d * s.y + a * c.y
+  };
+}
+function J(e, t, o = 10) {
+  return v(e, t) <= o;
+}
+function j(e, t = 100) {
+  const o = [{ t: 0, distance: 0 }];
+  let n = e.p0, s = 0;
+  for (let c = 1; c <= t; c++) {
+    const i = c / t, r = D(e, i);
+    s += v(n, r), o.push({ t: i, distance: s }), n = r;
+  }
+  return o;
+}
+function $(e, t) {
+  if (t <= 0) return 0;
+  const o = e[e.length - 1].distance;
+  if (t >= o) return 1;
+  let n = 0, s = e.length - 1;
+  for (; n < s - 1; ) {
+    const a = Math.floor((n + s) / 2);
+    e[a].distance < t ? n = a : s = a;
+  }
+  const c = e[n].distance, i = e[s].distance, r = e[n].t, l = e[s].t;
+  if (i === c) return r;
+  const d = (t - c) / (i - c);
+  return r + d * (l - r);
+}
+function U(e) {
+  return e[e.length - 1].distance;
+}
+function k(e, t = 100) {
+  let o = 0, n = e.p0;
+  for (let s = 1; s <= t; s++) {
+    const c = s / t, i = D(e, c);
+    o += v(n, i), n = i;
+  }
+  return o;
+}
+function b(e, t, o, n, s) {
+  const c = v(e.start, e.end), i = c - s;
+  if (i <= 0)
+    return c;
+  let r;
+  if (t === void 0)
+    r = n;
+  else if (o)
+    r = t;
+  else
+    return Math.max(s, Math.min(t, c));
+  return s + r / 100 * i;
+}
+function A(e, t, o, n, s) {
+  const i = v(e.start, e.end) - s;
+  if (i <= 0)
+    return 0;
+  let r;
+  if (t === void 0)
+    r = n;
+  else if (o)
+    r = t;
+  else
+    return Math.max(0, Math.min(t, i));
+  return r / 100 * i;
+}
+function X(e, t, o) {
+  const n = /* @__PURE__ */ new Map(), s = /* @__PURE__ */ new Map(), c = /* @__PURE__ */ new Map();
+  for (const i of e)
+    s.set(i.id, i), c.set(i.id, v(i.start, i.end)), n.set(i.id, []);
+  for (let i = 0; i < t.length; i++) {
+    const r = t[i], l = s.get(r.fromLineId), d = s.get(r.toLineId);
+    if (!l || !d) continue;
+    const a = b(l, r.fromOffset, r.fromIsPercentage, 100, o.wheelbase), u = A(d, r.toOffset, r.toIsPercentage, 0, o.wheelbase), g = T(
+      l,
+      d,
+      o,
+      !1,
+      // willFlip is always false now
+      {
+        fromOffset: a,
+        fromIsPercentage: !1,
+        // Already resolved to absolute
+        toOffset: u,
+        toIsPercentage: !1
+        // Already resolved to absolute
+      }
+    ), p = k(g), I = {
+      curveIndex: i,
+      fromLineId: r.fromLineId,
+      toLineId: r.toLineId,
+      fromOffset: a,
+      toOffset: u,
+      curveLength: p
+    };
+    n.get(r.fromLineId).push(I);
+  }
+  return { adjacency: n, lines: s, lineLengths: c };
+}
+function G(e, t, o, n, s = !1) {
+  const { adjacency: c, lines: i, lineLengths: r } = e;
+  if (!i.get(o)) return null;
+  const d = r.get(o), a = s ? n / 100 * d : n, u = [], g = /* @__PURE__ */ new Map(), p = (f, m) => `${f}:${Math.round(m)}`;
+  if (t.lineId === o && a >= t.offset) {
+    const f = a - t.offset;
+    return {
+      segments: [{
+        type: "line",
+        lineId: t.lineId,
+        startOffset: t.offset,
+        endOffset: a,
+        length: f
+      }],
+      totalDistance: f
+    };
+  }
+  const I = c.get(t.lineId) || [];
+  for (const f of I) {
+    if (f.fromOffset < t.offset) continue;
+    const m = f.fromOffset - t.offset, y = m + f.curveLength, L = {
+      type: "line",
+      lineId: t.lineId,
+      startOffset: t.offset,
+      endOffset: f.fromOffset,
+      length: m
+    }, h = {
+      type: "curve",
+      curveIndex: f.curveIndex,
+      startOffset: 0,
+      endOffset: f.curveLength,
+      length: f.curveLength
+    };
+    u.push({
+      lineId: f.toLineId,
+      entryOffset: f.toOffset,
+      totalDistance: y,
+      path: [L, h]
+    });
+  }
+  for (u.sort((f, m) => f.totalDistance - m.totalDistance); u.length > 0; ) {
+    const f = u.shift(), m = p(f.lineId, f.entryOffset), y = g.get(m);
+    if (y !== void 0 && y <= f.totalDistance)
+      continue;
+    if (g.set(m, f.totalDistance), f.lineId === o) {
+      const h = Math.abs(a - f.entryOffset);
+      if (a >= f.entryOffset) {
+        const x = {
+          type: "line",
+          lineId: o,
+          startOffset: f.entryOffset,
+          endOffset: a,
+          length: h
+        };
+        return {
+          segments: [...f.path, x],
+          totalDistance: f.totalDistance + h
+        };
+      }
+    }
+    const L = c.get(f.lineId) || [];
+    for (const h of L) {
+      if (h.fromOffset < f.entryOffset) continue;
+      const x = h.fromOffset - f.entryOffset, P = f.totalDistance + x + h.curveLength, q = p(h.toLineId, h.toOffset), C = g.get(q);
+      if (C !== void 0 && C <= P)
+        continue;
+      const z = {
+        type: "line",
+        lineId: f.lineId,
+        startOffset: f.entryOffset,
+        endOffset: h.fromOffset,
+        length: x
+      }, B = {
+        type: "curve",
+        curveIndex: h.curveIndex,
+        startOffset: 0,
+        endOffset: h.curveLength,
+        length: h.curveLength
+      };
+      u.push({
+        lineId: h.toLineId,
+        entryOffset: h.toOffset,
+        totalDistance: P,
+        path: [...f.path, z, B]
+      });
+    }
+    u.sort((h, x) => h.totalDistance - x.totalDistance);
+  }
+  return null;
+}
+function V(e, t) {
+  const o = Math.sqrt(
+    Math.pow(e.end.x - e.start.x, 2) + Math.pow(e.end.y - e.start.y, 2)
+  ), n = o > 0 ? t / o : 0;
+  return {
+    x: e.start.x + (e.end.x - e.start.x) * Math.min(1, Math.max(0, n)),
+    y: e.start.y + (e.end.y - e.start.y) * Math.min(1, Math.max(0, n))
+  };
+}
+function N(e) {
+  return Math.sqrt(
+    Math.pow(e.end.x - e.start.x, 2) + Math.pow(e.end.y - e.start.y, 2)
+  );
+}
+function Q(e, t, o) {
+  let n = 0;
+  for (let s = 0; s < t; s++)
+    n += e.segments[s].length;
+  return n += o, n;
+}
+function R(e, t) {
+  let o = 0;
+  for (let n = 0; n < e.segments.length; n++) {
+    const s = e.segments[n], c = o + s.length;
+    if (t < c)
+      return {
+        segmentIndex: n,
+        segmentDistance: t - o
+      };
+    if (t === c)
+      return n + 1 < e.segments.length ? {
+        segmentIndex: n + 1,
+        segmentDistance: 0
+      } : {
+        segmentIndex: n,
+        segmentDistance: s.length
+      };
+    o += s.length;
+  }
+  return null;
+}
+function W(e, t, o, n) {
+  const c = Q(
+    e,
+    t,
+    o
+  ) + n;
+  return R(e, c);
+}
+function Y(e, t, o, n) {
+  const s = Math.sqrt(
+    Math.pow(n.end.x - n.start.x, 2) + Math.pow(n.end.y - n.start.y, 2)
+  );
+  let c = t + o;
+  c = Math.min(c, s);
+  const i = V(n, c);
+  return {
+    lineId: e,
+    position: i,
+    absoluteOffset: c
+  };
+}
+function _(e, t) {
+  return {
+    ...e,
+    state: "idle"
+  };
+}
+function E(e) {
+  return {
+    vehicle: e,
+    execution: null
+  };
+}
+function Z(e, t) {
+  const o = [], n = /* @__PURE__ */ new Map();
+  for (const s of e) {
+    if (!t.get(s.lineId)) continue;
+    const i = _(s);
+    o.push(i);
+    const r = E(i);
+    n.set(s.id, r);
+  }
+  return { movingVehicles: o, stateMap: n };
+}
+function O(e, t) {
+  return { position: V(e, t), lineId: e.id, absoluteOffset: t };
+}
+function w(e, t) {
+  const o = $(e.arcLengthTable, t);
+  return { position: D(e.bezier, o) };
+}
+function ee(e, t, o, n, s, c, i) {
+  const r = o.segments[t.currentSegmentIndex], l = t.segmentDistance + n;
+  if (l >= r.length) {
+    const a = l - r.length, u = t.currentSegmentIndex + 1;
+    if (u >= o.segments.length) {
+      if (i !== void 0 && r.type === "line") {
+        const f = s.get(r.lineId), m = r.startOffset + l;
+        if (m <= i) {
+          const L = O(f, m);
+          return {
+            axleState: { ...e, ...L },
+            execution: { ...t, segmentDistance: l },
+            completed: !1
+          };
+        }
+        const y = O(f, i);
+        return {
+          axleState: { ...e, ...y },
+          execution: { ...t, segmentDistance: i - r.startOffset },
+          completed: !0
+        };
+      }
+      const I = r.type === "line" ? O(
+        s.get(r.lineId),
+        r.endOffset
+      ) : w(
+        c.get(r.curveIndex),
+        r.length
+      );
+      return {
+        axleState: { ...e, ...I },
+        execution: { ...t, segmentDistance: r.length },
+        completed: !0
+      };
+    }
+    const g = o.segments[u], p = g.type === "line" ? O(
+      s.get(g.lineId),
+      g.startOffset + a
+    ) : w(
+      c.get(g.curveIndex),
+      a
+    );
+    return {
+      axleState: { ...e, ...p },
+      execution: {
+        currentSegmentIndex: u,
+        segmentDistance: a
+      },
+      completed: !1
+    };
+  }
+  const d = r.type === "line" ? O(
+    s.get(r.lineId),
+    r.startOffset + l
+  ) : w(
+    c.get(r.curveIndex),
+    l
+  );
+  return {
+    axleState: { ...e, ...d },
+    execution: { ...t, segmentDistance: l },
+    completed: !1
+  };
+}
+function H(e, t, o, n) {
+  const s = /* @__PURE__ */ new Map();
+  for (const c of e.segments)
+    if (c.type === "curve" && c.curveIndex !== void 0) {
+      const i = t[c.curveIndex];
+      if (i) {
+        const r = o.get(i.fromLineId), l = o.get(i.toLineId);
+        if (r && l) {
+          const d = b(
+            r,
+            i.fromOffset,
+            i.fromIsPercentage,
+            100,
+            n.wheelbase
+          ), a = A(
+            l,
+            i.toOffset,
+            i.toIsPercentage,
+            0,
+            n.wheelbase
+          ), u = T(
+            r,
+            l,
+            n,
+            !1,
+            // willFlip is always false now
+            {
+              fromOffset: d,
+              fromIsPercentage: !1,
+              // Already resolved to absolute
+              toOffset: a,
+              toIsPercentage: !1
+              // Already resolved to absolute
+            }
+          ), g = j(u);
+          s.set(c.curveIndex, { bezier: u, arcLengthTable: g });
+        }
+      }
+    }
+  return s;
+}
+function te(e, t, o) {
+  const { graph: n, linesMap: s, curves: c, config: i } = o, r = s.get(t.targetLineId);
+  if (!r) return null;
+  const d = N(r) - i.wheelbase;
+  if (d <= 0) return null;
+  const a = t.isPercentage ? t.targetOffset / 100 * d : Math.min(t.targetOffset, d), u = G(
+    n,
+    { lineId: e.rear.lineId, offset: e.rear.absoluteOffset },
+    t.targetLineId,
+    a,
+    !1
+  );
+  if (!u) return null;
+  const g = H(u, c, s, i);
+  return { path: u, curveDataMap: g };
+}
+function ne(e, t) {
+  const o = e.execution, n = t.vehicleQueues.get(e.vehicle.id), s = n?.[o.currentCommandIndex];
+  if (s && t.onCommandComplete && t.onCommandComplete({
+    vehicleId: e.vehicle.id,
+    command: s,
+    finalPosition: {
+      lineId: e.vehicle.rear.lineId,
+      absoluteOffset: e.vehicle.rear.absoluteOffset,
+      position: e.vehicle.rear.position
+    },
+    payload: s.payload
+  }), s?.awaitConfirmation)
+    return {
+      handled: !0,
+      vehicle: { ...e.vehicle, state: "waiting" },
+      newExecution: o,
+      // Keep execution state for resume
+      isWaiting: !0
+    };
+  const c = o.currentCommandIndex + 1;
+  if (n && c < n.length) {
+    const r = n[c], l = t.graphRef.current;
+    if (l) {
+      const d = {
+        graph: l,
+        linesMap: t.linesMap,
+        curves: t.curves,
+        config: t.config
+      }, a = t.prepareCommandPath(
+        e.vehicle,
+        r,
+        d
+      );
+      if (a) {
+        const u = W(
+          a.path,
+          0,
+          0,
+          t.config.wheelbase
+        );
+        t.onCommandStart && t.onCommandStart({
+          vehicleId: e.vehicle.id,
+          command: r,
+          commandIndex: c,
+          startPosition: {
+            lineId: e.vehicle.rear.lineId,
+            absoluteOffset: e.vehicle.rear.absoluteOffset,
+            position: e.vehicle.rear.position
+          }
+        });
+        const g = {
+          path: a.path,
+          curveDataMap: a.curveDataMap,
+          currentCommandIndex: c,
+          rear: {
+            currentSegmentIndex: 0,
+            segmentDistance: 0
+          },
+          front: u ? {
+            currentSegmentIndex: u.segmentIndex,
+            segmentDistance: u.segmentDistance
+          } : {
+            currentSegmentIndex: 0,
+            segmentDistance: 0
+          }
+        };
+        return { handled: !0, vehicle: { ...e.vehicle, state: "moving" }, newExecution: g };
+      }
+    }
+  }
+  return { handled: !0, vehicle: {
+    ...e.vehicle,
+    state: "idle"
+  }, newExecution: null };
+}
+export {
+  R as arcLengthToSegmentPosition,
+  j as buildArcLengthTable,
+  X as buildGraph,
+  k as calculateBezierArcLength,
+  W as calculateFrontAxlePosition,
+  Y as calculateInitialFrontPosition,
+  w as calculatePositionOnCurve,
+  O as calculatePositionOnLine,
+  F as calculateTangentLength,
+  T as createBezierCurve,
+  E as createInitialMovementState,
+  v as distance,
+  $ as distanceToT,
+  G as findPath,
+  U as getArcLength,
+  Q as getCumulativeArcLength,
+  N as getLineLength,
+  D as getPointOnBezier,
+  K as getPointOnLine,
+  S as getPointOnLineByOffset,
+  V as getPositionFromOffset,
+  ne as handleArrival,
+  Z as initializeAllVehicles,
+  _ as initializeMovingVehicle,
+  J as isPointNearPoint,
+  M as normalize,
+  te as prepareCommandPath,
+  b as resolveFromLineOffset,
+  A as resolveToLineOffset,
+  ee as updateAxlePosition
+};

package/dist/index.d.ts

@@ -0,0 +1,45 @@
+/**
+ * VehiclePath - Vehicle motion simulator library
+ *
+ * A library for simulating dual-axle vehicle movement along paths
+ * composed of lines and Bezier curves.
+ *
+ * @example
+ * ```typescript
+ * import { useVehicleSimulation } from 'vehicle-path'
+ *
+ * const sim = useVehicleSimulation({ wheelbase: 30 })
+ * sim.addLine({ id: 'line1', start: [0, 0], end: [400, 0] })
+ * sim.addVehicles({ id: 'v1', lineId: 'line1', position: 0 })
+ * sim.goto('v1', 'line1', 1.0)
+ * sim.prepare()
+ * sim.tick(5)
+ * ```
+ */
+export type { Point, Line, BezierCurve, Curve } from './core/types/geometry';
+export type { VehicleState, VehicleStart, Vehicle, AxleState, GotoCommand, GotoCompletionInfo, GotoCompletionCallback } from './core/types/vehicle';
+export type { CurveData, PathExecutionState, VehicleMovementState, MovementConfig, SceneContext } from './core/types/movement';
+export type { TangentMode } from './core/types/config';
+export type { CoordinateInput, SceneLineInput, SceneConnectionInput, SceneConfig, VehicleInput, VehicleUpdateInput, ConnectionUpdateInput, GotoInput, GotoCommandInput, MovementCommandInput, SimulationConfig } from './core/types/api';
+export { buildGraph, findPath, calculateBezierArcLength, resolveFromLineOffset, resolveToLineOffset, type Graph, type GraphEdge, type PathSegment, type PathResult, type VehiclePosition } from './core/algorithms/pathFinding';
+export { initializeMovingVehicle, createInitialMovementState, initializeAllVehicles, calculateInitialFrontPosition, type InitializationResult, updateAxlePosition, calculatePositionOnLine, calculatePositionOnCurve, calculateFrontAxlePosition, getCumulativeArcLength, arcLengthToSegmentPosition, prepareCommandPath, type PreparedPath, handleArrival, type SegmentCompletionContext, type SegmentCompletionResult, type SegmentVehicleState, getPositionFromOffset, getLineLength } from './core/algorithms/vehicleMovement';
+export { distance, normalize, getPointOnLine, getPointOnLineByOffset, getPointOnBezier, createBezierCurve, buildArcLengthTable, distanceToT, getArcLength, type ArcLengthEntry, type CurveOffsetOptions } from './core/algorithms/math';
+export { VehicleEventEmitter, type VehicleEventMap, type VehicleEventType, type VehicleEventCallback, type VehiclePositionUpdate, type Unsubscribe, type CommandStartInfo } from './utils/event-emitter';
+export { parseSceneDSL, parseVehiclesDSL, parseMovementDSL, parseAllDSL, generateSceneDSL, generateVehiclesDSL, generateMovementDSL, type ParseResult, type MovementCommand } from './utils/dsl-parser';
+export { createAnimationLoop, useAnimationLoop, type AnimationLoopOptions, type AnimationLoopControls } from './utils/animation-loop';
+export { validateAndCreateVehicles, getNextStartVehicleId, getNextGotoVehicleId } from './utils/vehicle-helpers';
+export { useVehicleSimulation, type UseVehicleSimulationProps, type UseVehicleSimulationResult, type SimulationWarning, type SimulationResult } from './react/hooks/useVehicleSimulation';
+export { useScene, type UseSceneResult } from './react/hooks/useScene';
+export { useVehicles, type UseVehiclesResult, type UseVehiclesProps } from './react/hooks/useVehicles';
+export { useMovementQueue, type UseMovementQueueResult, type UseMovementQueueProps } from './react/hooks/useMovementQueue';
+export { useAnimation, type UseAnimationProps } from './react/hooks/useAnimation';
+/** @deprecated Use useMovementQueue instead */
+export { useMovementQueue as useMovement } from './react/hooks/useMovementQueue';
+export type { UseMovementQueueResult as UseMovementResult } from './react/hooks/useMovementQueue';
+export type { UseMovementQueueProps as UseMovementProps } from './react/hooks/useMovementQueue';
+/** @deprecated Use useAnimation instead */
+export { useAnimation as useVehicleMovement } from './react/hooks/useAnimation';
+export { useSceneDefinition } from './react/dsl-hooks/useSceneDefinition';
+export { useInitialMovement } from './react/dsl-hooks/useInitialMovement';
+export { useMovementSequence } from './react/dsl-hooks/useMovementSequence';
+export { useVehicleEventEmitter, useCreateVehicleEventEmitter, useVehicleEvent, VehicleEventContext, VehicleEventProvider, type VehicleEventProviderProps } from './react/providers/useVehicleEvents';

package/dist/react/dsl-hooks/useInitialMovement.d.ts

@@ -0,0 +1,24 @@
+import type { Line } from '../../core/types/geometry';
+interface UseInitialMovementProps {
+    lines: Line[];
+    wheelbase: number;
+}
+/**
+ * DSL wrapper for useVehicles hook.
+ *
+ * This hook provides text-based vehicle initialization that internally uses
+ * the programmatic useVehicles API as the single source of truth.
+ *
+ * @deprecated Use `useVehicleSimulation.loadFromDSL()` instead. This hook will be removed in a future version.
+ * The new unified hook provides a simpler API for loading DSL definitions that includes
+ * scene, vehicles, and movements in a single call.
+ */
+export declare function useInitialMovement({ lines, wheelbase }: UseInitialMovementProps): {
+    vehicles: import("../..").Vehicle[];
+    initialMovementText: string;
+    movementError: string | null;
+    isDebouncing: boolean;
+    debounceKey: number;
+    setInitialMovementText: (text: string) => void;
+};
+export {};

package/dist/react/dsl-hooks/useMovementSequence.d.ts

@@ -0,0 +1,27 @@
+import type { Line } from '../../core/types/geometry';
+import type { Vehicle } from '../../core/types/vehicle';
+import { type MovementCommand } from '../../utils/dsl-parser';
+interface UseMovementSequenceProps {
+    lines: Line[];
+    vehicles: Vehicle[];
+}
+/**
+ * DSL wrapper for useMovementQueue hook.
+ *
+ * This hook provides text-based movement commands that internally uses
+ * the programmatic useMovementQueue API as the single source of truth.
+ *
+ * @deprecated Use `useVehicleSimulation.loadFromDSL()` instead. This hook will be removed in a future version.
+ * The new unified hook provides a simpler API for loading DSL definitions that includes
+ * scene, vehicles, and movements in a single call.
+ */
+export declare function useMovementSequence({ lines, vehicles }: UseMovementSequenceProps): {
+    movementSequenceText: string;
+    gotoCommands: MovementCommand[];
+    vehicleQueues: Map<string, import("../..").GotoCommand[]>;
+    sequenceError: string | null;
+    isDebouncing: boolean;
+    debounceKey: number;
+    setMovementSequenceText: (text: string) => void;
+};
+export {};

package/dist/react/dsl-hooks/useSceneDefinition.d.ts

@@ -0,0 +1,22 @@
+import type { Line, Curve } from '../../core/types/geometry';
+/**
+ * DSL wrapper for useScene hook.
+ *
+ * This hook provides text-based scene definition that internally uses
+ * the programmatic useScene API as the single source of truth.
+ *
+ * @deprecated Use `useVehicleSimulation.loadFromDSL()` instead. This hook will be removed in a future version.
+ * The new unified hook provides a simpler API for loading DSL definitions that includes
+ * scene, vehicles, and movements in a single call.
+ */
+export declare function useSceneDefinition(): {
+    lines: Line[];
+    curves: Curve[];
+    sceneDefinitionText: string;
+    sceneError: string | null;
+    isDebouncing: boolean;
+    debounceKey: number;
+    setLines: (newLines: Line[] | ((prev: Line[]) => Line[])) => void;
+    setCurves: (newCurves: Curve[] | ((prev: Curve[]) => Curve[])) => void;
+    setSceneDefinitionText: (text: string) => void;
+};