vehicle-path2 1.0.0

package/dist/useVehicleEvents-B2JQFNjc.js

@@ -0,0 +1,923 @@
+import { useState as T, useCallback as P, useRef as j, useMemo as F, useEffect as U, createContext as ae, useContext as ue } from "react";
+import { distance as fe, initializeAllVehicles as ee, buildGraph as le, updateAxlePosition as te, handleArrival as de, prepareCommandPath as H, calculateFrontAxlePosition as re } from "./core.js";
+import { v as z, p as me, a as B, f as ge, h as he, e as ve, V as se } from "./vehicle-helpers-_72KxCqO.js";
+import { jsx as pe } from "react/jsx-runtime";
+function G(r) {
+  return Array.isArray(r) ? { x: r[0], y: r[1] } : r;
+}
+function K(r) {
+  return {
+    id: r.id,
+    start: G(r.start),
+    end: G(r.end)
+  };
+}
+function k(r) {
+  const o = r.fromIsPercentage !== !1, I = r.toIsPercentage !== !1;
+  return {
+    fromLineId: r.from,
+    toLineId: r.to,
+    fromOffset: r.fromPosition !== void 0 ? o ? r.fromPosition * 100 : r.fromPosition : void 0,
+    fromIsPercentage: r.fromPosition !== void 0 ? o : void 0,
+    toOffset: r.toPosition !== void 0 ? I ? r.toPosition * 100 : r.toPosition : void 0,
+    toIsPercentage: r.toPosition !== void 0 ? I : void 0
+  };
+}
+function X(r) {
+  const o = r.position ?? 0, I = r.isPercentage !== !1;
+  return {
+    vehicleId: r.id,
+    lineId: r.lineId,
+    offset: I ? o * 100 : o,
+    isPercentage: I
+  };
+}
+function Y(r) {
+  const o = r.isPercentage !== !1, I = r.targetPosition ?? 1;
+  return {
+    vehicleId: r.vehicleId,
+    targetLineId: r.targetLineId,
+    targetOffset: o ? I * 100 : I,
+    isPercentage: o,
+    awaitConfirmation: r.wait,
+    payload: r.payload
+  };
+}
+function Pe(r) {
+  const o = [], I = /* @__PURE__ */ new Set();
+  for (const s of r.lines)
+    I.has(s.id) && o.push(`Duplicate line ID: ${s.id}`), I.add(s.id);
+  if (r.connections)
+    for (const s of r.connections) {
+      I.has(s.from) || o.push(`Connection references non-existent line: ${s.from}`), I.has(s.to) || o.push(`Connection references non-existent line: ${s.to}`);
+      const d = s.fromIsPercentage !== !1, t = s.toIsPercentage !== !1;
+      !d && s.fromPosition === void 0 && o.push("fromPosition is required when fromIsPercentage is false"), !t && s.toPosition === void 0 && o.push("toPosition is required when toIsPercentage is false"), s.fromPosition !== void 0 && (d && (s.fromPosition < 0 || s.fromPosition > 1) ? o.push(`Invalid fromPosition: ${s.fromPosition} (must be 0-1 for percentage)`) : !d && s.fromPosition < 0 && o.push(`Invalid fromPosition: ${s.fromPosition} (must be >= 0 for absolute distance)`)), s.toPosition !== void 0 && (t && (s.toPosition < 0 || s.toPosition > 1) ? o.push(`Invalid toPosition: ${s.toPosition} (must be 0-1 for percentage)`) : !t && s.toPosition < 0 && o.push(`Invalid toPosition: ${s.toPosition} (must be >= 0 for absolute distance)`));
+    }
+  return { valid: o.length === 0, errors: o };
+}
+function ne() {
+  const [r, o] = T([]), [I, s] = T([]), [d, t] = T(null), f = P((n, p) => {
+    o(n), s(p), t(null);
+  }, []), y = P((n) => {
+    const p = Pe(n);
+    if (!p.valid)
+      return t(p.errors.join("; ")), { success: !1, errors: p.errors };
+    const c = n.lines.map(K), l = n.connections?.map(k) || [];
+    return f(c, l), { success: !0 };
+  }, [f]), O = P((n) => {
+    if (r.some((c) => c.id === n.id)) {
+      const c = `Line with ID '${n.id}' already exists`;
+      return t(c), { success: !1, error: c };
+    }
+    return o((c) => [...c, K(n)]), t(null), { success: !0 };
+  }, [r]), S = P((n, p) => {
+    if (r.findIndex((l) => l.id === n) === -1) {
+      const l = `Line with ID '${n}' not found`;
+      return t(l), { success: !1, error: l };
+    }
+    return o((l) => l.map((x) => x.id !== n ? x : {
+      ...x,
+      start: p.start ? G(p.start) : x.start,
+      end: p.end ? G(p.end) : x.end
+    })), t(null), { success: !0 };
+  }, [r]), C = P((n) => {
+    if (!r.some((c) => c.id === n)) {
+      const c = `Line with ID '${n}' not found`;
+      return t(c), { success: !1, error: c };
+    }
+    return o((c) => c.filter((l) => l.id !== n)), s((c) => c.filter((l) => l.fromLineId !== n && l.toLineId !== n)), t(null), { success: !0 };
+  }, [r]), $ = P((n) => {
+    const p = r.some((i) => i.id === n.from), c = r.some((i) => i.id === n.to);
+    if (!p) {
+      const i = `Line '${n.from}' not found`;
+      return t(i), { success: !1, error: i };
+    }
+    if (!c) {
+      const i = `Line '${n.to}' not found`;
+      return t(i), { success: !1, error: i };
+    }
+    const l = n.fromIsPercentage !== !1, x = n.toIsPercentage !== !1;
+    if (!l && n.fromPosition === void 0) {
+      const i = "fromPosition is required when fromIsPercentage is false";
+      return t(i), { success: !1, error: i };
+    }
+    if (!x && n.toPosition === void 0) {
+      const i = "toPosition is required when toIsPercentage is false";
+      return t(i), { success: !1, error: i };
+    }
+    if (I.some((i) => i.fromLineId === n.from && i.toLineId === n.to)) {
+      const i = `Connection from '${n.from}' to '${n.to}' already exists`;
+      return t(i), { success: !1, error: i };
+    }
+    return s((i) => [...i, k(n)]), t(null), { success: !0 };
+  }, [r, I]), m = P((n, p, c) => {
+    const l = I.findIndex((e) => e.fromLineId === n && e.toLineId === p);
+    if (l === -1) {
+      const e = `Connection from '${n}' to '${p}' not found`;
+      return t(e), { success: !1, error: e };
+    }
+    const x = I[l], V = c.fromIsPercentage ?? x.fromIsPercentage, i = c.toIsPercentage ?? x.toIsPercentage;
+    let w;
+    c.fromOffset !== void 0 ? w = c.fromOffset : x.fromOffset !== void 0 && (w = x.fromIsPercentage !== !1 ? x.fromOffset / 100 : x.fromOffset);
+    let g;
+    if (c.toOffset !== void 0 ? g = c.toOffset : x.toOffset !== void 0 && (g = x.toIsPercentage !== !1 ? x.toOffset / 100 : x.toOffset), w !== void 0) {
+      if (V !== !1 && (w < 0 || w > 1)) {
+        const e = `Invalid fromOffset: ${w} (must be 0-1 for percentage)`;
+        return t(e), { success: !1, error: e };
+      }
+      if (V === !1 && w < 0) {
+        const e = `Invalid fromOffset: ${w} (must be >= 0 for absolute distance)`;
+        return t(e), { success: !1, error: e };
+      }
+    }
+    if (g !== void 0) {
+      if (i !== !1 && (g < 0 || g > 1)) {
+        const e = `Invalid toOffset: ${g} (must be 0-1 for percentage)`;
+        return t(e), { success: !1, error: e };
+      }
+      if (i === !1 && g < 0) {
+        const e = `Invalid toOffset: ${g} (must be >= 0 for absolute distance)`;
+        return t(e), { success: !1, error: e };
+      }
+    }
+    if (V === !1 && w === void 0) {
+      const e = "fromOffset is required when fromIsPercentage is false";
+      return t(e), { success: !1, error: e };
+    }
+    if (i === !1 && g === void 0) {
+      const e = "toOffset is required when toIsPercentage is false";
+      return t(e), { success: !1, error: e };
+    }
+    const M = {
+      from: n,
+      to: p,
+      fromPosition: w,
+      fromIsPercentage: V,
+      toPosition: g,
+      toIsPercentage: i
+    };
+    return s((e) => e.map(
+      (a, u) => u === l ? k(M) : a
+    )), t(null), { success: !0 };
+  }, [I]), h = P((n, p) => {
+    if (!I.some((l) => l.fromLineId === n && l.toLineId === p)) {
+      const l = `Connection from '${n}' to '${p}' not found`;
+      return t(l), { success: !1, error: l };
+    }
+    return s((l) => l.filter((x) => !(x.fromLineId === n && x.toLineId === p))), t(null), { success: !0 };
+  }, [I]), v = P(() => {
+    o([]), s([]), t(null);
+  }, []);
+  return {
+    lines: r,
+    curves: I,
+    setScene: y,
+    addLine: O,
+    updateLine: S,
+    removeLine: C,
+    addConnection: $,
+    updateConnection: m,
+    removeConnection: h,
+    clear: v,
+    error: d,
+    _loadScene: f
+  };
+}
+function oe({ lines: r, wheelbase: o }) {
+  const [I, s] = T([]), [d, t] = T(null), f = j([]), y = P((m) => {
+    f.current = m, s(m), t(null);
+  }, []), O = P((m) => {
+    const h = Array.isArray(m) ? m : [m], v = [];
+    for (const l of h)
+      f.current.some((V) => V.id === l.id) && v.push(`Vehicle with ID '${l.id}' already exists`);
+    if (v.length > 0)
+      return t(v.join("; ")), { success: !1, errors: v };
+    const n = h.map(X), { vehicles: p, errors: c } = z(
+      n,
+      r,
+      o
+    );
+    return c.length > 0 ? (t(c.join("; ")), { success: !1, errors: c }) : (f.current = [...f.current, ...p], s(f.current), t(null), { success: !0 });
+  }, [r, o]), S = P((m, h) => {
+    const v = f.current.findIndex((g) => g.id === m);
+    if (v === -1) {
+      const g = `Vehicle with ID '${m}' not found`;
+      return t(g), { success: !1, error: g };
+    }
+    const n = f.current[v];
+    if (n.state !== "idle") {
+      const g = `Cannot update vehicle '${m}' while it is ${n.state}. Vehicle must be idle.`;
+      return t(g), { success: !1, error: g };
+    }
+    const p = h.lineId ?? n.lineId;
+    if (!r.find((g) => g.id === p)) {
+      const g = `Line '${p}' not found`;
+      return t(g), { success: !1, error: g };
+    }
+    let l, x;
+    h.lineId !== void 0 && h.position === void 0 ? (l = 0, x = !0) : h.position !== void 0 ? (l = h.position, x = h.isPercentage ?? !0) : (l = n.offset, x = n.isPercentage);
+    const V = {
+      vehicleId: m,
+      lineId: p,
+      offset: x ? l * 100 : l,
+      // Convert to internal format (0-100 for %)
+      isPercentage: x
+    }, { vehicles: i, errors: w } = z(
+      [V],
+      r,
+      o
+    );
+    return w.length > 0 ? (t(w.join("; ")), { success: !1, error: w.join("; ") }) : (f.current = f.current.map(
+      (g, M) => M === v ? i[0] : g
+    ), s(f.current), t(null), { success: !0 });
+  }, [r, o]), C = P((m) => {
+    if (!f.current.some((v) => v.id === m)) {
+      const v = `Vehicle with ID '${m}' not found`;
+      return t(v), { success: !1, error: v };
+    }
+    return f.current = f.current.filter((v) => v.id !== m), s(f.current), t(null), { success: !0 };
+  }, []), $ = P(() => {
+    f.current = [], s([]), t(null);
+  }, []);
+  return {
+    vehicles: I,
+    addVehicles: O,
+    updateVehicle: S,
+    removeVehicle: C,
+    clear: $,
+    error: d,
+    _loadVehicles: y
+  };
+}
+function ce({ vehicles: r, lines: o }) {
+  const [I, s] = T(/* @__PURE__ */ new Map()), [d, t] = T(null), f = P((S) => {
+    s(S), t(null);
+  }, []), y = P((S, C) => {
+    if (!r.some((c) => c.id === S)) {
+      const c = `Vehicle '${S}' not found`;
+      return t(c), { success: !1, error: c };
+    }
+    const m = o.find((c) => c.id === C.targetLineId);
+    if (!m) {
+      const c = `Line '${C.targetLineId}' not found`;
+      return t(c), { success: !1, error: c };
+    }
+    const h = C.isPercentage !== !1, v = fe(m.start, m.end);
+    if (!h && C.targetPosition === void 0) {
+      const c = "targetPosition is required when isPercentage is false";
+      return t(c), { success: !1, error: c };
+    }
+    const n = C.targetPosition ?? 1;
+    if (h) {
+      if (n < 0 || n > 1) {
+        const c = `Invalid targetPosition: ${n} (must be 0-1 for percentage)`;
+        return t(c), { success: !1, error: c };
+      }
+    } else {
+      if (n < 0) {
+        const c = `Invalid targetPosition: ${n} (must be >= 0 for absolute distance)`;
+        return t(c), { success: !1, error: c };
+      }
+      if (n > v) {
+        const c = `Position ${n} exceeds line length ${v}`;
+        return t(c), { success: !1, error: c };
+      }
+    }
+    const p = Y({ vehicleId: S, ...C });
+    return s((c) => {
+      const l = new Map(c), x = l.get(S) || [];
+      return l.set(S, [...x, p]), l;
+    }), t(null), { success: !0 };
+  }, [r, o]), O = P((S) => {
+    if (S !== void 0) {
+      if (!r.some(($) => $.id === S)) {
+        const $ = `Vehicle '${S}' not found`;
+        return t($), { success: !1, error: $ };
+      }
+      s(($) => {
+        const m = new Map($);
+        return m.delete(S), m;
+      });
+    } else
+      s(/* @__PURE__ */ new Map());
+    return t(null), { success: !0 };
+  }, [r]);
+  return {
+    vehicleQueues: I,
+    queueMovement: y,
+    clearQueue: O,
+    error: d,
+    _loadQueues: f
+  };
+}
+function Ie({
+  vehicles: r,
+  lines: o,
+  vehicleQueues: I,
+  wheelbase: s,
+  tangentMode: d,
+  curves: t,
+  eventEmitter: f
+}) {
+  const [y, O] = T([]), S = F(() => ({
+    wheelbase: s,
+    tangentMode: d
+  }), [s, d]), C = F(
+    () => new Map(o.map((V) => [V.id, V])),
+    [o]
+  ), $ = j(/* @__PURE__ */ new Map());
+  U(() => {
+    const { movingVehicles: V, stateMap: i } = ee(r, C);
+    $.current = i;
+    const w = setTimeout(() => {
+      O(V);
+    }, 0);
+    return () => clearTimeout(w);
+  }, [r, C]);
+  const m = j(null);
+  U(() => {
+    o.length > 0 && (m.current = le(o, t, S));
+  }, [o, t, S]);
+  const h = j(0), v = j(!1), n = P((V) => {
+    if (!v.current) return !1;
+    let i = !1;
+    for (const [, g] of $.current)
+      if (g.vehicle.state === "moving") {
+        i = !0;
+        break;
+      }
+    if (!i)
+      return !1;
+    const w = [];
+    for (const [g, M] of $.current) {
+      if (M.vehicle.state !== "moving" || !M.execution) continue;
+      const e = M.execution;
+      let a;
+      if (e.front.currentSegmentIndex < e.path.segments.length) {
+        const D = e.path.segments[e.front.currentSegmentIndex];
+        if (D.type === "line") {
+          const L = C.get(D.lineId);
+          L && (a = Math.sqrt(
+            Math.pow(L.end.x - L.start.x, 2) + Math.pow(L.end.y - L.start.y, 2)
+          ));
+        }
+      }
+      const u = te(
+        M.vehicle.rear,
+        e.rear,
+        e.path,
+        V,
+        C,
+        e.curveDataMap
+      ), E = te(
+        M.vehicle.front,
+        e.front,
+        e.path,
+        V,
+        C,
+        e.curveDataMap,
+        a
+      );
+      if (M.vehicle = {
+        ...M.vehicle,
+        rear: u.axleState,
+        front: E.axleState
+      }, M.execution.rear = u.execution, M.execution.front = E.execution, u.completed) {
+        const L = de(M, {
+          linesMap: C,
+          config: S,
+          vehicleQueues: I,
+          curves: t,
+          graphRef: m,
+          prepareCommandPath: H,
+          onCommandComplete: (Q) => w.push({ type: "commandComplete", data: Q }),
+          onCommandStart: (Q) => w.push({ type: "commandStart", data: Q })
+        });
+        M.vehicle = L.vehicle, L.newExecution !== void 0 && (M.execution = L.newExecution), L.vehicle.state !== "moving" && w.push({
+          type: "stateChange",
+          data: { vehicleId: g, from: "moving", to: L.vehicle.state }
+        });
+        const q = L.vehicle.rear.position, b = L.vehicle.front.position;
+        w.push({
+          type: "positionUpdate",
+          data: {
+            vehicleId: g,
+            rear: q,
+            front: b,
+            center: { x: (q.x + b.x) / 2, y: (q.y + b.y) / 2 },
+            angle: Math.atan2(b.y - q.y, b.x - q.x)
+          }
+        });
+      }
+    }
+    if (O((g) => g.map((M) => {
+      const e = $.current.get(M.id);
+      return e ? e.vehicle : M;
+    })), f && w.length > 0) {
+      const g = h.current;
+      setTimeout(() => {
+        h.current === g && w.forEach(({ type: M, data: e }) => {
+          f.emit(M, e);
+        });
+      }, 0);
+    }
+    for (const [, g] of $.current)
+      if (g.vehicle.state === "moving")
+        return !0;
+    return !1;
+  }, [C, t, S, I, f]), p = P(() => {
+    if (v.current) return !0;
+    const V = m.current;
+    if (!V) return !1;
+    const i = [];
+    let w = !1;
+    for (const [g, M] of $.current) {
+      const e = M.vehicle, a = I.get(g);
+      if (!a || a.length === 0) continue;
+      const u = a[0], D = H(e, u, { graph: V, linesMap: C, curves: t, config: S });
+      if (!D) {
+        console.warn(`No path found for vehicle ${g}`);
+        continue;
+      }
+      const L = re(D.path, 0, 0, s);
+      $.current.set(g, {
+        ...M,
+        execution: {
+          path: D.path,
+          curveDataMap: D.curveDataMap,
+          currentCommandIndex: 0,
+          rear: { currentSegmentIndex: 0, segmentDistance: 0 },
+          front: L ? { currentSegmentIndex: L.segmentIndex, segmentDistance: L.segmentDistance } : { currentSegmentIndex: 0, segmentDistance: 0 }
+        },
+        vehicle: { ...e, state: "moving" }
+      }), w = !0, e.state !== "moving" && i.push({
+        id: g,
+        fromState: e.state,
+        command: u,
+        startPosition: {
+          lineId: e.rear.lineId,
+          absoluteOffset: e.rear.absoluteOffset,
+          position: e.rear.position
+        }
+      });
+    }
+    if (!w) return !1;
+    if (v.current = !0, O((g) => g.map((M) => {
+      const e = $.current.get(M.id);
+      return e ? e.vehicle : M;
+    })), f && i.length > 0) {
+      const g = h.current;
+      setTimeout(() => {
+        h.current === g && i.forEach(({ id: M, fromState: e, command: a, startPosition: u }) => {
+          f.emit("commandStart", {
+            vehicleId: M,
+            command: a,
+            commandIndex: 0,
+            startPosition: u
+          }), f.emit("stateChange", {
+            vehicleId: M,
+            from: e,
+            to: "moving"
+          });
+        });
+      }, 0);
+    }
+    return !0;
+  }, [C, t, I, S, s, f]), c = P(() => {
+    h.current++, v.current = !1;
+    const { movingVehicles: V, stateMap: i } = ee(r, C);
+    $.current = i, O(V);
+  }, [r, C]), l = P((V) => {
+    const i = $.current.get(V);
+    if (!i || i.vehicle.state !== "waiting")
+      return !1;
+    const w = I.get(V), g = i.execution;
+    if (!g) return !1;
+    const M = g.currentCommandIndex + 1;
+    if (w && M < w.length) {
+      const e = m.current;
+      if (e) {
+        const a = w[M], u = { graph: e, linesMap: C, curves: t, config: S }, E = H(i.vehicle, a, u);
+        if (E) {
+          const D = re(E.path, 0, 0, s);
+          if (i.execution = {
+            path: E.path,
+            curveDataMap: E.curveDataMap,
+            currentCommandIndex: M,
+            rear: { currentSegmentIndex: 0, segmentDistance: 0 },
+            front: D ? { currentSegmentIndex: D.segmentIndex, segmentDistance: D.segmentDistance } : { currentSegmentIndex: 0, segmentDistance: 0 }
+          }, i.vehicle = { ...i.vehicle, state: "moving" }, O((L) => L.map((q) => q.id === V ? i.vehicle : q)), f) {
+            const L = h.current;
+            setTimeout(() => {
+              h.current === L && f.emit("stateChange", {
+                vehicleId: V,
+                from: "waiting",
+                to: "moving"
+              });
+            }, 0);
+          }
+          return !0;
+        }
+      }
+    }
+    if (i.vehicle = { ...i.vehicle, state: "idle" }, i.execution = null, O((e) => e.map((a) => a.id === V ? i.vehicle : a)), f) {
+      const e = h.current;
+      setTimeout(() => {
+        h.current === e && f.emit("stateChange", {
+          vehicleId: V,
+          from: "waiting",
+          to: "idle"
+        });
+      }, 0);
+    }
+    return !0;
+  }, [I, C, t, S, s, f]), x = P(() => {
+    for (const [, V] of $.current)
+      if (V.vehicle.state === "moving")
+        return !0;
+    return !1;
+  }, []);
+  return {
+    movingVehicles: y,
+    prepare: p,
+    tick: n,
+    reset: c,
+    continueVehicle: l,
+    isMoving: x,
+    isPrepared: v.current
+  };
+}
+function Ve({
+  wheelbase: r,
+  tangentMode: o = "proportional-40",
+  eventEmitter: I
+}) {
+  const s = ne(), d = oe({ lines: s.lines, wheelbase: r }), t = ce({
+    vehicles: d.vehicles,
+    lines: s.lines,
+    curves: s.curves
+  }), f = Ie({
+    vehicles: d.vehicles,
+    lines: s.lines,
+    vehicleQueues: t.vehicleQueues,
+    wheelbase: r,
+    tangentMode: o,
+    curves: s.curves,
+    eventEmitter: I
+  }), y = P((e) => d.vehicles.filter((a) => a.lineId === e || a.rear.lineId === e), [d.vehicles]), O = P((e) => y(e).length > 0, [y]), S = P((e) => {
+    const a = s.addLine(e);
+    return a.success ? { success: !0 } : { success: !1, error: a.error };
+  }, [s]), C = P((e, a) => {
+    const u = s.updateLine(e, a);
+    return u.success ? { success: !0 } : { success: !1, error: u.error };
+  }, [s]), $ = P((e) => {
+    const a = [], u = y(e);
+    u.length > 0 && (a.push({
+      type: "vehicle_on_removed_line",
+      message: `${u.length} vehicle(s) are on line '${e}'`,
+      details: {
+        lineId: e,
+        vehicleIds: u.map((L) => L.id)
+      }
+    }), u.forEach((L) => {
+      d.removeVehicle(L.id), t.clearQueue(L.id);
+    }));
+    const E = s.curves.filter(
+      (L) => L.fromLineId === e || L.toLineId === e
+    );
+    E.length > 0 && a.push({
+      type: "orphaned_connection",
+      message: `${E.length} connection(s) will be removed`,
+      details: {
+        lineId: e,
+        connectionCount: E.length
+      }
+    });
+    const D = s.removeLine(e);
+    return D.success ? {
+      success: !0,
+      warnings: a.length > 0 ? a : void 0
+    } : { success: !1, error: D.error };
+  }, [s, y, d, t]), m = P(() => {
+    s.clear(), d.clear(), t.clearQueue();
+  }, [s, d, t]), h = P((e, a, u) => {
+    const E = s.addConnection({
+      from: e,
+      to: a,
+      fromPosition: u?.fromOffset,
+      fromIsPercentage: u?.fromIsPercentage,
+      toPosition: u?.toOffset,
+      toIsPercentage: u?.toIsPercentage
+    });
+    return E.success ? { success: !0 } : { success: !1, error: E.error };
+  }, [s]), v = P((e, a, u) => {
+    const E = s.updateConnection(e, a, u);
+    return E.success ? { success: !0 } : { success: !1, error: E.error };
+  }, [s]), n = P((e, a) => {
+    const u = s.removeConnection(e, a);
+    return u.success ? { success: !0 } : { success: !1, error: u.error };
+  }, [s]), p = P((e) => {
+    const a = d.addVehicles(e);
+    return a.success ? { success: !0 } : { success: !1, error: a.errors?.join("; ") };
+  }, [d]), c = P((e, a) => {
+    const u = d.updateVehicle(e, a);
+    return u.success ? { success: !0 } : { success: !1, error: u.error };
+  }, [d]), l = P((e) => {
+    const a = [], u = t.vehicleQueues.get(e);
+    u && u.length > 0 && (a.push({
+      type: "movement_queue_cleared",
+      message: `${u.length} queued movement(s) will be cleared for vehicle '${e}'`,
+      details: {
+        vehicleId: e
+      }
+    }), t.clearQueue(e));
+    const E = d.removeVehicle(e);
+    return E.success ? {
+      success: !0,
+      warnings: a.length > 0 ? a : void 0
+    } : { success: !1, error: E.error };
+  }, [d, t]), x = P(() => {
+    d.clear(), t.clearQueue();
+  }, [d, t]), V = P((e) => {
+    const a = {
+      targetLineId: e.lineId,
+      targetPosition: e.position ?? 1,
+      isPercentage: e.isPercentage,
+      wait: e.wait,
+      payload: e.payload
+    }, u = t.queueMovement(e.id, a);
+    return u.success ? { success: !0 } : { success: !1, error: u.error };
+  }, [t]), i = P((e) => {
+    const a = t.clearQueue(e);
+    return a.success ? { success: !0 } : { success: !1, error: a.error };
+  }, [t]), w = P((e) => {
+    const a = [], u = [], { scene: E, vehicles: D, movements: L } = me(e);
+    E.errors.length > 0 && u.push(...E.errors), D.errors.length > 0 && u.push(...D.errors), L.errors.length > 0 && u.push(...L.errors);
+    const q = E.data.lines.map(K), b = (E.data.connections || []).map(k), Q = D.data.map(X), { vehicles: _, errors: A } = z(Q, q, r);
+    A.length > 0 && u.push(...A);
+    const N = /* @__PURE__ */ new Map();
+    for (const J of L.data) {
+      const Z = N.get(J.vehicleId) || [];
+      Z.push(Y(J)), N.set(J.vehicleId, Z);
+    }
+    return s._loadScene(q, b), d._loadVehicles(_), t._loadQueues(N), u.length > 0 && a.push({
+      type: "dsl_parse_error",
+      message: `DSL loading had ${u.length} error(s)`,
+      details: { errors: u }
+    }), {
+      success: !0,
+      warnings: a.length > 0 ? a : void 0
+    };
+  }, [s, d, t, r]), g = P((e) => {
+    const a = [], u = [], E = e.lines.map(K), D = (e.connections || []).map(k), L = (e.vehicles || []).map(X), { vehicles: q, errors: b } = z(L, E, r);
+    b.length > 0 && u.push(...b);
+    const Q = /* @__PURE__ */ new Map();
+    for (const _ of e.movements || []) {
+      const A = Q.get(_.vehicleId) || [];
+      A.push(Y({
+        vehicleId: _.vehicleId,
+        targetLineId: _.targetLineId,
+        targetPosition: _.targetPosition,
+        isPercentage: _.isPercentage,
+        wait: _.wait,
+        payload: _.payload
+      })), Q.set(_.vehicleId, A);
+    }
+    return s._loadScene(E, D), d._loadVehicles(q), t._loadQueues(Q), u.length > 0 && a.push({
+      type: "dsl_parse_error",
+      message: `JSON loading had ${u.length} error(s)`,
+      details: { errors: u }
+    }), {
+      success: !0,
+      warnings: a.length > 0 ? a : void 0
+    };
+  }, [s, d, t, r]), M = F(() => s.error || d.error || t.error, [s.error, d.error, t.error]);
+  return {
+    // State
+    lines: s.lines,
+    curves: s.curves,
+    vehicles: d.vehicles,
+    movingVehicles: f.movingVehicles,
+    vehicleQueues: t.vehicleQueues,
+    error: M,
+    // Scene operations
+    addLine: S,
+    updateLine: C,
+    removeLine: $,
+    clearScene: m,
+    // Connection operations
+    connect: h,
+    updateConnection: v,
+    disconnect: n,
+    // Vehicle operations
+    addVehicles: p,
+    updateVehicle: c,
+    removeVehicle: l,
+    clearVehicles: x,
+    // Movement operations
+    goto: V,
+    clearQueue: i,
+    // Animation (delegated to useVehicleMovement)
+    prepare: f.prepare,
+    tick: f.tick,
+    reset: f.reset,
+    continueVehicle: f.continueVehicle,
+    isMoving: f.isMoving,
+    // DSL Loading
+    loadFromDSL: w,
+    // JSON Loading
+    loadFromJSON: g,
+    // Utility
+    getVehiclesOnLine: y,
+    hasVehiclesOnLine: O
+  };
+}
+function R(r) {
+  return r.map((o) => ({
+    id: o.id,
+    start: o.start,
+    end: o.end
+  }));
+}
+function W(r) {
+  return r.map((o) => ({
+    from: o.fromLineId,
+    to: o.toLineId,
+    fromPosition: o.fromOffset !== void 0 ? o.fromIsPercentage ? o.fromOffset / 100 : o.fromOffset : void 0,
+    fromIsPercentage: o.fromIsPercentage,
+    toPosition: o.toOffset !== void 0 ? o.toIsPercentage ? o.toOffset / 100 : o.toOffset : void 0,
+    toIsPercentage: o.toIsPercentage
+  }));
+}
+function we() {
+  const [r, o] = T(""), [I, s] = T(null), { lines: d, curves: t, setScene: f } = ne(), y = j(!1), O = j("");
+  U(() => {
+    O.current = r;
+  }, [r]), U(() => {
+    if (y.current)
+      return;
+    const m = {
+      lines: R(d),
+      connections: t.length > 0 ? W(t) : void 0
+    }, h = B(m);
+    h !== O.current && (y.current = !0, o(h), setTimeout(() => {
+      y.current = !1;
+    }, 50));
+  }, [d, t]);
+  const S = P((m) => {
+    y.current = !0, o(m);
+    try {
+      const { data: h, errors: v } = ge(m);
+      v.length > 0 && s(v.join("; "));
+      const n = f(h);
+      !n.success && n.errors ? s((p) => p ? `${p}; ${n.errors.join("; ")}` : n.errors.join("; ")) : v.length === 0 && s(null);
+    } catch (h) {
+      s(h instanceof Error ? h.message : "Invalid scene definition");
+    }
+    setTimeout(() => {
+      y.current = !1;
+    }, 50);
+  }, [f]), C = P((m) => {
+    const h = typeof m == "function" ? m(d) : m, v = W(t);
+    f({
+      lines: R(h),
+      connections: v.length > 0 ? v : void 0
+    });
+    const n = {
+      lines: R(h),
+      connections: v.length > 0 ? v : void 0
+    }, p = B(n);
+    y.current = !0, o(p), setTimeout(() => {
+      y.current = !1;
+    }, 50);
+  }, [d, t, f]), $ = P((m) => {
+    const h = typeof m == "function" ? m(t) : m, v = W(h);
+    f({
+      lines: R(d),
+      connections: v.length > 0 ? v : void 0
+    });
+    const n = {
+      lines: R(d),
+      connections: v.length > 0 ? v : void 0
+    }, p = B(n);
+    y.current = !0, o(p), setTimeout(() => {
+      y.current = !1;
+    }, 50);
+  }, [d, t, f]);
+  return {
+    lines: d,
+    curves: t,
+    sceneDefinitionText: r,
+    sceneError: I,
+    isDebouncing: !1,
+    // No debouncing - parsing is immediate
+    debounceKey: 0,
+    // Kept for API compatibility
+    setLines: C,
+    setCurves: $,
+    setSceneDefinitionText: S
+  };
+}
+function $e({ lines: r, wheelbase: o }) {
+  const [I, s] = T(""), [d, t] = T(null), { vehicles: f, addVehicles: y, clear: O, error: S } = oe({ lines: r, wheelbase: o }), C = j(!1), $ = P((m) => {
+    C.current = !0, s(m);
+    try {
+      const { data: h, errors: v } = he(m), n = [...v];
+      O();
+      for (const p of h) {
+        const c = y(p);
+        !c.success && c.errors && n.push(...c.errors);
+      }
+      n.length > 0 ? t(n.join(`
+`)) : t(null);
+    } catch (h) {
+      t(h instanceof Error ? h.message : "Invalid initial movement");
+    }
+    setTimeout(() => {
+      C.current = !1;
+    }, 50);
+  }, [y, O]);
+  return {
+    vehicles: f,
+    initialMovementText: I,
+    movementError: d || S,
+    isDebouncing: !1,
+    // No debouncing - parsing is immediate
+    debounceKey: 0,
+    // Kept for API compatibility
+    setInitialMovementText: $
+  };
+}
+function ye({ lines: r, vehicles: o }) {
+  const [I, s] = T(""), [d, t] = T([]), [f, y] = T(null), { vehicleQueues: O, queueMovement: S, clearQueue: C, error: $ } = ce({
+    vehicles: o,
+    lines: r
+  }), m = j(!1), h = P((v) => {
+    m.current = !0, s(v);
+    try {
+      const { data: n, errors: p } = ve(v), c = [...p];
+      C();
+      for (const l of n) {
+        const x = S(l.vehicleId, {
+          targetLineId: l.targetLineId,
+          targetPosition: l.targetPosition,
+          isPercentage: l.isPercentage,
+          wait: l.wait,
+          payload: l.payload
+        });
+        !x.success && x.error && c.push(x.error);
+      }
+      t(n), c.length > 0 ? y(c.join(`
+`)) : y(null);
+    } catch (n) {
+      y(n instanceof Error ? n.message : "Invalid movement sequence"), t([]);
+    }
+    setTimeout(() => {
+      m.current = !1;
+    }, 50);
+  }, [S, C]);
+  return {
+    movementSequenceText: I,
+    gotoCommands: d,
+    vehicleQueues: O,
+    sequenceError: f || $,
+    isDebouncing: !1,
+    // No debouncing - parsing is immediate
+    debounceKey: 0,
+    // Kept for API compatibility
+    setMovementSequenceText: h
+  };
+}
+const ie = ae(null);
+function xe() {
+  const r = ue(ie);
+  if (!r)
+    throw new Error("useVehicleEventEmitter must be used within a VehicleEventProvider");
+  return r;
+}
+function Ee() {
+  return F(() => new se(), []);
+}
+function Oe(r, o, I = []) {
+  const s = xe();
+  U(() => s.on(r, o), [s, r, ...I]);
+}
+function De({ children: r }) {
+  const o = F(() => new se(), []);
+  return /* @__PURE__ */ pe(ie.Provider, { value: o, children: r });
+}
+export {
+  ie as V,
+  De as a,
+  Ee as b,
+  $e as c,
+  ce as d,
+  ye as e,
+  ne as f,
+  we as g,
+  Oe as h,
+  xe as i,
+  Ve as j,
+  oe as k,
+  Ie as u
+};