vehicle-path2 4.0.1 → 4.0.3

package/dist/index-DUYG8fxI.js

@@ -1,699 +0,0 @@
-function y(t, e) {
-  const s = e.x - t.x, n = e.y - t.y;
-  return Math.sqrt(s * s + n * n);
-}
-function V(t, e) {
-  const s = e.x - t.x, n = e.y - t.y, i = Math.sqrt(s * s + n * n);
-  return i === 0 ? { x: 0, y: 0 } : { x: s / i, y: n / i };
-}
-function F(t, e) {
-  return e * (t === "proportional-40" ? 0.4 : 0.5522);
-}
-function q(t, e, s, n) {
-  const { tangentMode: i } = s;
-  let c;
-  n?.fromOffset !== void 0 ? c = z(t, n.fromOffset, n.fromIsPercentage ?? !1) : c = t.end;
-  let o;
-  n?.toOffset !== void 0 ? o = z(e, n.toOffset, n.toIsPercentage ?? !1) : o = e.start;
-  const r = V(t.start, t.end), u = V(e.start, e.end), h = y(c, o), a = F(i, h), l = { x: c.x + r.x * a, y: c.y + r.y * a }, d = { x: o.x - u.x * a, y: o.y - u.y * a };
-  return { p0: c, p1: l, p2: d, p3: o };
-}
-function K(t, e) {
-  return {
-    x: t.start.x + (t.end.x - t.start.x) * e,
-    y: t.start.y + (t.end.y - t.start.y) * e
-  };
-}
-function z(t, e, s) {
-  const n = y(t.start, t.end);
-  let i;
-  return s ? i = e : i = n > 0 ? e / n : 0, i = Math.max(0, Math.min(1, i)), K(t, i);
-}
-function A(t, e) {
-  const { p0: s, p1: n, p2: i, p3: c } = t, o = 1 - e, r = o * o, u = r * o, h = e * e, a = h * e;
-  return {
-    x: u * s.x + 3 * r * e * n.x + 3 * o * h * i.x + a * c.x,
-    y: u * s.y + 3 * r * e * n.y + 3 * o * h * i.y + a * c.y
-  };
-}
-function ne(t, e, s = 10) {
-  return y(t, e) <= s;
-}
-function N(t, e = 100) {
-  const s = [{ t: 0, distance: 0 }];
-  let n = t.p0, i = 0;
-  for (let c = 1; c <= e; c++) {
-    const o = c / e, r = A(t, o);
-    i += y(n, r), s.push({ t: o, distance: i }), n = r;
-  }
-  return s;
-}
-function R(t, e) {
-  if (e <= 0) return 0;
-  const s = t[t.length - 1].distance;
-  if (e >= s) return 1;
-  let n = 0, i = t.length - 1;
-  for (; n < i - 1; ) {
-    const a = Math.floor((n + i) / 2);
-    t[a].distance < e ? n = a : i = a;
-  }
-  const c = t[n].distance, o = t[i].distance, r = t[n].t, u = t[i].t;
-  if (o === c) return r;
-  const h = (e - c) / (o - c);
-  return r + h * (u - r);
-}
-function se(t) {
-  return t[t.length - 1].distance;
-}
-function G(t, e = 100) {
-  let s = 0, n = t.p0;
-  for (let i = 1; i <= e; i++) {
-    const c = i / e, o = A(t, c);
-    s += y(n, o), n = o;
-  }
-  return s;
-}
-function E(t, e, s, n) {
-  const i = y(t.start, t.end);
-  return e === void 0 ? n * i : s ? Math.max(0, Math.min(e, 1)) * i : Math.max(0, Math.min(e, i));
-}
-function B(t, e, s, n) {
-  const i = y(t.start, t.end);
-  return e === void 0 ? n * i : s ? Math.max(0, Math.min(e, 1)) * i : Math.max(0, Math.min(e, i));
-}
-function I(t, e, s) {
-  const n = /* @__PURE__ */ new Map(), i = /* @__PURE__ */ new Map(), c = /* @__PURE__ */ new Map();
-  for (const o of t)
-    i.set(o.id, o), c.set(o.id, y(o.start, o.end)), n.set(o.id, []);
-  for (let o = 0; o < e.length; o++) {
-    const r = e[o], u = i.get(r.fromLineId), h = i.get(r.toLineId);
-    if (!u || !h) continue;
-    const a = E(u, r.fromOffset, r.fromIsPercentage, 1), l = B(h, r.toOffset, r.toIsPercentage, 0), d = q(
-      u,
-      h,
-      s,
-      {
-        fromOffset: a,
-        fromIsPercentage: !1,
-        toOffset: l,
-        toIsPercentage: !1
-      }
-    ), g = G(d), v = {
-      curveIndex: o,
-      fromLineId: r.fromLineId,
-      toLineId: r.toLineId,
-      fromOffset: a,
-      toOffset: l,
-      curveLength: g
-    };
-    n.get(r.fromLineId).push(v);
-  }
-  return { adjacency: n, lines: i, lineLengths: c };
-}
-function b(t, e) {
-  return t.curveCount !== e.curveCount ? t.curveCount - e.curveCount : t.totalDistance - e.totalDistance;
-}
-function Q(t, e, s, n, i = !1) {
-  const { adjacency: c, lines: o, lineLengths: r } = t;
-  if (!o.get(s)) return null;
-  const h = r.get(s), a = i ? n / 100 * h : n, l = [], d = /* @__PURE__ */ new Map(), g = (f, p) => `${f}:${Math.round(p)}`;
-  if (e.lineId === s && a >= e.offset) {
-    const f = a - e.offset;
-    return {
-      segments: [{
-        type: "line",
-        lineId: e.lineId,
-        startOffset: e.offset,
-        endOffset: a,
-        length: f
-      }],
-      totalDistance: f,
-      curveCount: 0
-    };
-  }
-  const v = c.get(e.lineId) || [];
-  for (const f of v) {
-    if (f.fromOffset < e.offset) continue;
-    const p = f.fromOffset - e.offset, x = p + f.curveLength, L = {
-      type: "line",
-      lineId: e.lineId,
-      startOffset: e.offset,
-      endOffset: f.fromOffset,
-      length: p
-    }, m = {
-      type: "curve",
-      curveIndex: f.curveIndex,
-      startOffset: 0,
-      endOffset: f.curveLength,
-      length: f.curveLength
-    };
-    l.push({
-      lineId: f.toLineId,
-      entryOffset: f.toOffset,
-      totalDistance: x,
-      curveCount: 1,
-      path: [L, m]
-    });
-  }
-  for (l.sort(b); l.length > 0; ) {
-    const f = l.shift(), p = g(f.lineId, f.entryOffset), x = d.get(p);
-    if (x !== void 0 && (x.curveCount < f.curveCount || x.curveCount === f.curveCount && x.distance <= f.totalDistance))
-      continue;
-    if (d.set(p, { curveCount: f.curveCount, distance: f.totalDistance }), f.lineId === s) {
-      const m = Math.abs(a - f.entryOffset);
-      if (a >= f.entryOffset) {
-        const C = {
-          type: "line",
-          lineId: s,
-          startOffset: f.entryOffset,
-          endOffset: a,
-          length: m
-        };
-        return {
-          segments: [...f.path, C],
-          totalDistance: f.totalDistance + m,
-          curveCount: f.curveCount
-        };
-      }
-    }
-    const L = c.get(f.lineId) || [];
-    for (const m of L) {
-      if (m.fromOffset < f.entryOffset) continue;
-      const C = m.fromOffset - f.entryOffset, T = f.totalDistance + C + m.curveLength, w = f.curveCount + 1, j = g(m.toLineId, m.toOffset), D = d.get(j);
-      if (D !== void 0 && (D.curveCount < w || D.curveCount === w && D.distance <= T))
-        continue;
-      const $ = {
-        type: "line",
-        lineId: f.lineId,
-        startOffset: f.entryOffset,
-        endOffset: m.fromOffset,
-        length: C
-      }, k = {
-        type: "curve",
-        curveIndex: m.curveIndex,
-        startOffset: 0,
-        endOffset: m.curveLength,
-        length: m.curveLength
-      };
-      l.push({
-        lineId: m.toLineId,
-        entryOffset: m.toOffset,
-        totalDistance: T,
-        curveCount: w,
-        path: [...f.path, $, k]
-      });
-    }
-    l.sort(b);
-  }
-  return null;
-}
-function S(t, e) {
-  const s = Math.sqrt(
-    Math.pow(t.end.x - t.start.x, 2) + Math.pow(t.end.y - t.start.y, 2)
-  ), n = s > 0 ? e / s : 0;
-  return {
-    x: t.start.x + (t.end.x - t.start.x) * Math.min(1, Math.max(0, n)),
-    y: t.start.y + (t.end.y - t.start.y) * Math.min(1, Math.max(0, n))
-  };
-}
-function O(t) {
-  return Math.sqrt(
-    Math.pow(t.end.x - t.start.x, 2) + Math.pow(t.end.y - t.start.y, 2)
-  );
-}
-function W(t, e, s) {
-  let n = 0;
-  for (let i = 0; i < e; i++)
-    n += t.segments[i].length;
-  return n += s, n;
-}
-function _(t, e) {
-  let s = 0;
-  for (let n = 0; n < t.segments.length; n++) {
-    const i = t.segments[n], c = s + i.length;
-    if (e < c)
-      return {
-        segmentIndex: n,
-        segmentDistance: e - s
-      };
-    if (e === c)
-      return n + 1 < t.segments.length ? {
-        segmentIndex: n + 1,
-        segmentDistance: 0
-      } : {
-        segmentIndex: n,
-        segmentDistance: i.length
-      };
-    s += i.length;
-  }
-  return null;
-}
-function ie(t, e, s, n) {
-  const c = W(
-    t,
-    e,
-    s
-  ) + n;
-  return _(t, c);
-}
-function H(t, e, s, n) {
-  const i = O(n), c = s.length + 1, o = new Array(c);
-  o[c - 1] = {
-    lineId: t,
-    absoluteOffset: e,
-    position: S(n, e)
-  };
-  let r = e;
-  for (let u = c - 2; u >= 0; u--)
-    r = Math.min(r + s[u], i), o[u] = {
-      lineId: t,
-      absoluteOffset: r,
-      position: S(n, r)
-    };
-  return o;
-}
-function J(t, e) {
-  return {
-    ...t,
-    state: "idle"
-  };
-}
-function U(t) {
-  return {
-    vehicle: t,
-    execution: null
-  };
-}
-function re(t, e) {
-  const s = [], n = /* @__PURE__ */ new Map();
-  for (const i of t) {
-    if (!e.get(i.lineId)) continue;
-    const o = J(i);
-    s.push(o);
-    const r = U(o);
-    n.set(i.id, r);
-  }
-  return { movingVehicles: s, stateMap: n };
-}
-function M(t, e) {
-  return { position: S(t, e), lineId: t.id, absoluteOffset: e };
-}
-function P(t, e) {
-  const s = R(t.arcLengthTable, e);
-  return { position: A(t.bezier, s) };
-}
-function X(t, e, s, n, i, c, o) {
-  const r = s.segments[e.currentSegmentIndex], u = e.segmentDistance + n;
-  if (u >= r.length) {
-    const a = u - r.length, l = e.currentSegmentIndex + 1;
-    if (l >= s.segments.length) {
-      if (o !== void 0 && r.type === "line") {
-        const f = i.get(r.lineId), p = r.startOffset + u;
-        if (p <= o) {
-          const L = M(f, p);
-          return {
-            axleState: { ...t, ...L },
-            execution: { ...e, segmentDistance: u },
-            completed: !1
-          };
-        }
-        const x = M(f, o);
-        return {
-          axleState: { ...t, ...x },
-          execution: { ...e, segmentDistance: o - r.startOffset },
-          completed: !0
-        };
-      }
-      const v = r.type === "line" ? M(
-        i.get(r.lineId),
-        r.endOffset
-      ) : P(
-        c.get(r.curveIndex),
-        r.length
-      );
-      return {
-        axleState: { ...t, ...v },
-        execution: { ...e, segmentDistance: r.length },
-        completed: !0
-      };
-    }
-    const d = s.segments[l], g = d.type === "line" ? M(
-      i.get(d.lineId),
-      d.startOffset + a
-    ) : P(
-      c.get(d.curveIndex),
-      a
-    );
-    return {
-      axleState: { ...t, ...g },
-      execution: {
-        currentSegmentIndex: l,
-        segmentDistance: a
-      },
-      completed: !1
-    };
-  }
-  const h = r.type === "line" ? M(
-    i.get(r.lineId),
-    r.startOffset + u
-  ) : P(
-    c.get(r.curveIndex),
-    u
-  );
-  return {
-    axleState: { ...t, ...h },
-    execution: { ...e, segmentDistance: u },
-    completed: !1
-  };
-}
-function Y(t, e, s, n) {
-  const i = /* @__PURE__ */ new Map();
-  for (const c of t.segments)
-    if (c.type === "curve" && c.curveIndex !== void 0) {
-      const o = e[c.curveIndex];
-      if (o) {
-        const r = s.get(o.fromLineId), u = s.get(o.toLineId);
-        if (r && u) {
-          const h = E(
-            r,
-            o.fromOffset,
-            o.fromIsPercentage,
-            1
-          ), a = B(
-            u,
-            o.toOffset,
-            o.toIsPercentage,
-            0
-          ), l = q(
-            r,
-            u,
-            n,
-            {
-              fromOffset: h,
-              fromIsPercentage: !1,
-              toOffset: a,
-              toIsPercentage: !1
-            }
-          ), d = N(l);
-          i.set(c.curveIndex, { bezier: l, arcLengthTable: d });
-        }
-      }
-    }
-  return i;
-}
-function Z(t, e, s) {
-  const { graph: n, linesMap: i, curves: c, config: o } = s, r = i.get(e.targetLineId);
-  if (!r) return null;
-  const u = t.axleSpacings.reduce((f, p) => f + p, 0), a = O(r) - u;
-  if (a <= 0) return null;
-  const l = e.isPercentage ? e.targetOffset * a : Math.min(e.targetOffset, a), d = t.axles[t.axles.length - 1], g = Q(
-    n,
-    { lineId: d.lineId, offset: d.absoluteOffset },
-    e.targetLineId,
-    l,
-    !1
-  );
-  if (!g) return null;
-  const v = Y(g, c, i, o);
-  return { path: g, curveDataMap: v };
-}
-function oe(t, e) {
-  const s = t.execution, i = e.vehicleQueues.get(t.vehicle.id)?.[s.currentCommandIndex];
-  return i && e.onCommandComplete && e.onCommandComplete({
-    vehicleId: t.vehicle.id,
-    command: i,
-    finalPosition: {
-      lineId: t.vehicle.axles[t.vehicle.axles.length - 1].lineId,
-      absoluteOffset: t.vehicle.axles[t.vehicle.axles.length - 1].absoluteOffset,
-      position: t.vehicle.axles[t.vehicle.axles.length - 1].position
-    },
-    payload: i.payload
-  }), {
-    handled: !0,
-    vehicle: { ...t.vehicle, state: "waiting" },
-    newExecution: s,
-    // Keep execution state for resume
-    isWaiting: !0
-  };
-}
-function ee(t, e, s, n, i, c) {
-  const o = t.map((r, u) => {
-    const h = u === t.length - 1;
-    let a;
-    if (!h) {
-      const l = e[u];
-      if (l.currentSegmentIndex < s.segments.length) {
-        const d = s.segments[l.currentSegmentIndex];
-        if (d.type === "line") {
-          const g = i.get(d.lineId);
-          g && (a = O(g));
-        }
-      }
-    }
-    return X(r, e[u], s, n, i, c, a);
-  });
-  return {
-    axles: o.map((r) => r.axleState),
-    axleExecutions: o.map((r) => r.execution),
-    arrived: o[o.length - 1].completed
-    // axles[N-1] = rearmost menentukan arrived
-  };
-}
-class ce {
-  graph = null;
-  linesMap = /* @__PURE__ */ new Map();
-  curves = [];
-  config;
-  constructor(e) {
-    this.config = {
-      tangentMode: e.tangentMode
-    };
-  }
-  // ---------------------------------------------------------------------------
-  // Accessors
-  // ---------------------------------------------------------------------------
-  get movementConfig() {
-    return this.config;
-  }
-  get lines() {
-    return Array.from(this.linesMap.values());
-  }
-  getCurves() {
-    return this.curves;
-  }
-  // ---------------------------------------------------------------------------
-  // Scene management
-  // ---------------------------------------------------------------------------
-  /**
-   * Replace the entire scene and rebuild the graph.
-   */
-  setScene(e, s) {
-    this.linesMap.clear();
-    for (const n of e)
-      this.linesMap.set(n.id, n);
-    this.curves = s, this.graph = I(e, s, this.config);
-  }
-  /**
-   * Add a single line. Returns false if a line with the same ID already exists.
-   */
-  addLine(e) {
-    return this.linesMap.has(e.id) ? !1 : (this.linesMap.set(e.id, e), this.graph = I(Array.from(this.linesMap.values()), this.curves, this.config), !0);
-  }
-  /**
-   * Update start and/or end coordinates of an existing line.
-   */
-  updateLine(e, s) {
-    const n = this.linesMap.get(e);
-    return n ? (s.start && (n.start = s.start), s.end && (n.end = s.end), this.graph = I(Array.from(this.linesMap.values()), this.curves, this.config), !0) : !1;
-  }
-  /**
-   * Update a single endpoint ('start' or 'end') of a line.
-   */
-  updateLineEndpoint(e, s, n) {
-    return this.updateLine(e, { [s]: n });
-  }
-  /**
-   * Rename a line ID and cascade the change to all connected curves.
-   */
-  renameLine(e, s) {
-    const n = s.trim();
-    if (!n) return { success: !1, error: "Name cannot be empty" };
-    if (n === e) return { success: !0 };
-    if (this.linesMap.has(n)) return { success: !1, error: `"${n}" already exists` };
-    const i = this.linesMap.get(e);
-    if (!i) return { success: !1, error: `Line "${e}" not found` };
-    i.id = n, this.linesMap.delete(e), this.linesMap.set(n, i);
-    for (const c of this.curves)
-      c.fromLineId === e && (c.fromLineId = n), c.toLineId === e && (c.toLineId = n);
-    return this.graph = I(Array.from(this.linesMap.values()), this.curves, this.config), { success: !0 };
-  }
-  /**
-   * Remove a line and all curves connected to it.
-   */
-  removeLine(e) {
-    return this.linesMap.has(e) ? (this.linesMap.delete(e), this.curves = this.curves.filter((s) => s.fromLineId !== e && s.toLineId !== e), this.graph = I(Array.from(this.linesMap.values()), this.curves, this.config), !0) : !1;
-  }
-  /**
-   * Add a directional curve (connection) from one line to another.
-   */
-  addCurve(e) {
-    this.curves.push(e), this.graph = I(Array.from(this.linesMap.values()), this.curves, this.config);
-  }
-  /**
-   * Update a curve by index. Returns false if index is out of bounds.
-   */
-  updateCurve(e, s) {
-    return e < 0 || e >= this.curves.length ? !1 : (this.curves[e] = { ...this.curves[e], ...s }, this.graph = I(Array.from(this.linesMap.values()), this.curves, this.config), !0);
-  }
-  /**
-   * Remove a curve by index. Returns false if index is out of bounds.
-   */
-  removeCurve(e) {
-    return e < 0 || e >= this.curves.length ? !1 : (this.curves.splice(e, 1), this.graph = I(Array.from(this.linesMap.values()), this.curves, this.config), !0);
-  }
-  // ---------------------------------------------------------------------------
-  // Vehicle operations
-  // ---------------------------------------------------------------------------
-  /**
-   * Initialize a vehicle's N-axle position on a line.
-   *
-   * @param lineId - The line to place the vehicle on
-   * @param rearOffset - Absolute distance offset untuk axle paling belakang
-   * @param vehicle - VehicleDefinition (or any object extending it with axleSpacings)
-   * @returns Initial VehiclePathState, or null if lineId does not exist
-   * @throws if axleSpacings is empty
-   */
-  initializeVehicle(e, s, n) {
-    const i = this.linesMap.get(e);
-    if (!i) return null;
-    const { axleSpacings: c } = n;
-    if (c.length === 0)
-      throw new Error("initializeVehicle: axleSpacings must have at least one entry (vehicle needs ≥2 axles)");
-    const o = c.reduce((a, l) => a + l, 0), r = O(i), u = Math.min(s, r - o);
-    return {
-      axles: H(e, u, c, i).map((a) => ({ lineId: a.lineId, offset: a.absoluteOffset, position: a.position })),
-      axleSpacings: c
-    };
-  }
-  /**
-   * Prepare a path from the vehicle's current position to a target.
-   *
-   * Must be called before moveVehicle(). Returns null if no path exists.
-   *
-   * @param vehicleState - Current vehicle state (from initializeVehicle or previous tick)
-   * @param targetLineId - ID of the target line
-   * @param targetOffset - Position on the target line
-   * @param isPercentage - If true, targetOffset is 0-1 fraction; if false, absolute distance
-   */
-  preparePath(e, s, n, i = !1) {
-    if (!this.graph) return null;
-    const c = e.axleSpacings.reduce((g, v) => g + v, 0), o = e.axles[e.axles.length - 1], r = {
-      lineId: o.lineId,
-      offset: o.offset,
-      axles: e.axles.map((g) => ({
-        lineId: g.lineId,
-        position: g.position,
-        absoluteOffset: g.offset
-      })),
-      axleSpacings: e.axleSpacings
-    }, u = Z(r, {
-      targetLineId: s,
-      targetOffset: n,
-      isPercentage: i
-    }, {
-      graph: this.graph,
-      linesMap: this.linesMap,
-      curves: this.curves,
-      config: this.config
-    });
-    if (!u) return null;
-    let h = n;
-    const a = this.linesMap.get(s);
-    if (a) {
-      const g = Math.max(0, O(a) - c);
-      h = i ? n * g : Math.min(n, g);
-    }
-    let l = 0;
-    const d = [
-      { segmentIndex: 0, segmentDistance: c }
-      // axles[0] = front
-    ];
-    for (let g = 0; g < e.axleSpacings.length; g++)
-      l += e.axleSpacings[g], d.push({ segmentIndex: 0, segmentDistance: c - l });
-    return {
-      path: u.path,
-      curveDataMap: u.curveDataMap,
-      axleExecutions: d,
-      targetLineId: s,
-      targetOffset: h
-    };
-  }
-  /**
-   * Advance a vehicle by `distance` along its prepared path.
-   *
-   * Call this every tick. The returned `state` and `execution` replace the
-   * previous values. When `arrived` is true, the vehicle has reached the target.
-   *
-   * @param state - Current vehicle state
-   * @param execution - Current path execution (from preparePath or previous tick)
-   * @param distance - Distance to advance this tick (speed × deltaTime)
-   */
-  moveVehicle(e, s, n) {
-    const i = e.axles.map((r) => ({
-      lineId: r.lineId,
-      position: r.position,
-      absoluteOffset: r.offset
-    })), c = s.axleExecutions.map((r) => ({
-      currentSegmentIndex: r.segmentIndex,
-      segmentDistance: r.segmentDistance
-    })), o = ee(i, c, s.path, n, this.linesMap, s.curveDataMap);
-    return {
-      state: {
-        axles: o.axles.map((r) => ({ lineId: r.lineId, offset: r.absoluteOffset, position: r.position })),
-        axleSpacings: e.axleSpacings
-      },
-      execution: {
-        ...s,
-        axleExecutions: o.axleExecutions.map((r) => ({
-          segmentIndex: r.currentSegmentIndex,
-          segmentDistance: r.segmentDistance
-        }))
-      },
-      arrived: o.arrived
-    };
-  }
-}
-export {
-  V as A,
-  Z as B,
-  E as C,
-  B as D,
-  X as E,
-  ce as P,
-  O as a,
-  _ as b,
-  N as c,
-  I as d,
-  G as e,
-  ie as f,
-  W as g,
-  H as h,
-  P as i,
-  M as j,
-  F as k,
-  q as l,
-  ee as m,
-  U as n,
-  y as o,
-  R as p,
-  Q as q,
-  se as r,
-  A as s,
-  K as t,
-  z as u,
-  S as v,
-  oe as w,
-  re as x,
-  J as y,
-  ne as z
-};