vehicle-path 1.0.0

package/dist/vehicle-path.js

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