vehicle-path2 2.0.0 → 2.2.0

package/dist/core/algorithms/pathFinding.d.ts

@@ -35,21 +35,21 @@ export interface VehiclePosition {
  */
 export declare function calculateBezierArcLength(bezier: BezierCurve, segments?: number): number;
 /**
- * Resolve offset untuk FROM line (garis asal kurva)
- * - 0% → wheelbase (bukan 0, untuk memberi ruang vehicle)
- * - 100% → lineLength (ujung garis)
+ * Resolve offset untuk FROM line (garis asal kurva).
+ * Kurva bisa ditempatkan di mana saja pada line: range [0, lineLength].
  *
- * Effective range: [wheelbase, lineLength]
+ * Untuk absolute offset: clamp ke [0, lineLength].
+ * Untuk percentage (0-1): map ke [0, lineLength].
  */
-export declare function resolveFromLineOffset(line: Line, offset: number | undefined, isPercentage: boolean | undefined, defaultPercentage: number, maxWheelbase: number): number;
+export declare function resolveFromLineOffset(line: Line, offset: number | undefined, isPercentage: boolean | undefined, defaultPercentage: number, _maxWheelbase: number): number;
 /**
- * Resolve offset untuk TO line (garis tujuan kurva)
- * - 0% → 0 (awal garis)
- * - 100% → lineLength - wheelbase (untuk memberi ruang vehicle)
+ * Resolve offset untuk TO line (garis tujuan kurva).
+ * Kurva bisa ditempatkan di mana saja pada line: range [0, lineLength].
  *
- * Effective range: [0, lineLength - wheelbase]
+ * Untuk absolute offset: clamp ke [0, lineLength].
+ * Untuk percentage (0-1): map ke [0, lineLength].
  */
-export declare function resolveToLineOffset(line: Line, offset: number | undefined, isPercentage: boolean | undefined, defaultPercentage: number, maxWheelbase: number): number;
+export declare function resolveToLineOffset(line: Line, offset: number | undefined, isPercentage: boolean | undefined, defaultPercentage: number, _maxWheelbase: number): number;
 /**
  * Membangun graph dari lines dan curves
  */

package/dist/core/index.d.ts

@@ -19,3 +19,4 @@ export { buildGraph, findPath, calculateBezierArcLength, resolveFromLineOffset,
 export { initializeMovingVehicle, createInitialMovementState, initializeAllVehicles, calculateInitialAxlePositions, type InitializationResult, updateAxlePosition, calculatePositionOnLine, calculatePositionOnCurve, calculateFrontAxlePosition, getCumulativeArcLength, arcLengthToSegmentPosition, prepareCommandPath, type PreparedPath, handleArrival, type SegmentCompletionContext, type SegmentCompletionResult, type SegmentVehicleState, moveVehicle, getPositionFromOffset, getLineLength } from './algorithms/vehicleMovement';
 export { PathEngine, type PathEngineConfig, type VehiclePathState, type PathExecution } from './engine';
 export { distance, normalize, getPointOnLine, getPointOnLineByOffset, getPointOnBezier, createBezierCurve, buildArcLengthTable, distanceToT, getArcLength, calculateTangentLength, isPointNearPoint, type ArcLengthEntry, type CurveOffsetOptions } from './algorithms/math';
+export { serializeScene, deserializeScene, type SceneSnapshot } from './snapshot';

package/dist/core/snapshot.d.ts

@@ -0,0 +1,54 @@
+import type { Line } from './types/geometry';
+export interface SceneSnapshot {
+    lines: Line[];
+    curves: Array<{
+        id: string;
+        fromLineId: string;
+        toLineId: string;
+        fromOffset: number;
+        fromIsPercentage: boolean;
+        toOffset: number;
+        toIsPercentage: boolean;
+    }>;
+    vehicles: Array<{
+        id: string;
+        lineId: string;
+        axles: Array<{
+            offset: number;
+        }>;
+        axleSpacings: number[];
+        isPercentage: boolean;
+    }>;
+}
+/**
+ * Serialize scene state to a JSON string suitable for clipboard or storage.
+ * Strips derived fields (bezier curves, axle positions) — only source-of-truth
+ * data is included.
+ *
+ * Note: lineId is per-vehicle (not per-axle) because this snapshot captures
+ * static placement where all axles share the same line. For mid-movement state,
+ * use AxleState directly.
+ */
+export declare function serializeScene(lines: Line[], curves: Array<{
+    id: string;
+    fromLineId: string;
+    toLineId: string;
+    fromOffset: number;
+    fromIsPercentage?: boolean;
+    toOffset: number;
+    toIsPercentage?: boolean;
+}>, vehicles: Array<{
+    id: string;
+    axles: Array<{
+        lineId: string;
+        offset: number;
+        [key: string]: unknown;
+    }>;
+    axleSpacings: number[];
+    isPercentage?: boolean;
+}>): string;
+/**
+ * Deserialize a JSON string back into a SceneSnapshot.
+ * Throws if the string is not valid JSON or missing required fields.
+ */
+export declare function deserializeScene(json: string): SceneSnapshot;

package/dist/core.cjs

@@ -1 +1 @@
-"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const e=require("./vehicle-path.cjs");exports.PathEngine=e.PathEngine;exports.arcLengthToSegmentPosition=e.arcLengthToSegmentPosition;exports.buildArcLengthTable=e.buildArcLengthTable;exports.buildGraph=e.buildGraph;exports.calculateBezierArcLength=e.calculateBezierArcLength;exports.calculateFrontAxlePosition=e.calculateFrontAxlePosition;exports.calculateInitialAxlePositions=e.calculateInitialAxlePositions;exports.calculatePositionOnCurve=e.calculatePositionOnCurve;exports.calculatePositionOnLine=e.calculatePositionOnLine;exports.calculateTangentLength=e.calculateTangentLength;exports.createBezierCurve=e.createBezierCurve;exports.createInitialMovementState=e.createInitialMovementState;exports.distance=e.distance;exports.distanceToT=e.distanceToT;exports.findPath=e.findPath;exports.getArcLength=e.getArcLength;exports.getCumulativeArcLength=e.getCumulativeArcLength;exports.getLineLength=e.getLineLength;exports.getPointOnBezier=e.getPointOnBezier;exports.getPointOnLine=e.getPointOnLine;exports.getPointOnLineByOffset=e.getPointOnLineByOffset;exports.getPositionFromOffset=e.getPositionFromOffset;exports.handleArrival=e.handleArrival;exports.initializeAllVehicles=e.initializeAllVehicles;exports.initializeMovingVehicle=e.initializeMovingVehicle;exports.isPointNearPoint=e.isPointNearPoint;exports.moveVehicle=e.moveVehicle;exports.normalize=e.normalize;exports.prepareCommandPath=e.prepareCommandPath;exports.resolveFromLineOffset=e.resolveFromLineOffset;exports.resolveToLineOffset=e.resolveToLineOffset;exports.updateAxlePosition=e.updateAxlePosition;
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const e=require("./index-DA33ne3M.cjs");function o(r,n,t){const a={lines:r,curves:n.map(i=>({id:i.id,fromLineId:i.fromLineId,toLineId:i.toLineId,fromOffset:i.fromOffset,fromIsPercentage:i.fromIsPercentage??!1,toOffset:i.toOffset,toIsPercentage:i.toIsPercentage??!1})),vehicles:t.map(i=>({id:i.id,lineId:i.axles[0].lineId,axles:i.axles.map(l=>({offset:l.offset})),axleSpacings:i.axleSpacings,isPercentage:i.isPercentage??!1}))};return JSON.stringify(a,null,2)}function s(r){let n;try{n=JSON.parse(r)}catch{throw new Error("deserializeScene: invalid JSON")}if(!n||typeof n!="object"||Array.isArray(n))throw new Error("deserializeScene: expected a JSON object");const t=n;if(!Array.isArray(t.lines))throw new Error('deserializeScene: missing "lines"');if(!Array.isArray(t.curves))throw new Error('deserializeScene: missing "curves"');if(!Array.isArray(t.vehicles))throw new Error('deserializeScene: missing "vehicles"');return{lines:t.lines,curves:t.curves,vehicles:t.vehicles}}exports.PathEngine=e.PathEngine;exports.arcLengthToSegmentPosition=e.arcLengthToSegmentPosition;exports.buildArcLengthTable=e.buildArcLengthTable;exports.buildGraph=e.buildGraph;exports.calculateBezierArcLength=e.calculateBezierArcLength;exports.calculateFrontAxlePosition=e.calculateFrontAxlePosition;exports.calculateInitialAxlePositions=e.calculateInitialAxlePositions;exports.calculatePositionOnCurve=e.calculatePositionOnCurve;exports.calculatePositionOnLine=e.calculatePositionOnLine;exports.calculateTangentLength=e.calculateTangentLength;exports.createBezierCurve=e.createBezierCurve;exports.createInitialMovementState=e.createInitialMovementState;exports.distance=e.distance;exports.distanceToT=e.distanceToT;exports.findPath=e.findPath;exports.getArcLength=e.getArcLength;exports.getCumulativeArcLength=e.getCumulativeArcLength;exports.getLineLength=e.getLineLength;exports.getPointOnBezier=e.getPointOnBezier;exports.getPointOnLine=e.getPointOnLine;exports.getPointOnLineByOffset=e.getPointOnLineByOffset;exports.getPositionFromOffset=e.getPositionFromOffset;exports.handleArrival=e.handleArrival;exports.initializeAllVehicles=e.initializeAllVehicles;exports.initializeMovingVehicle=e.initializeMovingVehicle;exports.isPointNearPoint=e.isPointNearPoint;exports.moveVehicle=e.moveVehicle;exports.normalize=e.normalize;exports.prepareCommandPath=e.prepareCommandPath;exports.resolveFromLineOffset=e.resolveFromLineOffset;exports.resolveToLineOffset=e.resolveToLineOffset;exports.updateAxlePosition=e.updateAxlePosition;exports.deserializeScene=s;exports.serializeScene=o;

package/dist/core.js

@@ -1,35 +1,78 @@
-import { PathEngine as i, arcLengthToSegmentPosition as n, buildArcLengthTable as a, buildGraph as o, calculateBezierArcLength as l, calculateFrontAxlePosition as r, calculateInitialAxlePositions as c, calculatePositionOnCurve as s, calculatePositionOnLine as g, c as h, createBezierCurve as P, createInitialMovementState as u, distance as L, distanceToT as f, findPath as m, getArcLength as v, getCumulativeArcLength as A, getLineLength as O, getPointOnBezier as d, getPointOnLine as z, getPointOnLineByOffset as T, getPositionFromOffset as p, handleArrival as x, initializeAllVehicles as B, initializeMovingVehicle as C, i as b, moveVehicle as F, normalize as V, prepareCommandPath as I, resolveFromLineOffset as M, resolveToLineOffset as S, updateAxlePosition as y } from "./vehicle-path.js";
+import { P as f, a as g, b as h, c as d, d as u, e as m, f as P, g as A, h as v, i as L, j as O, k as p, l as S, m as z, n as y, o as w, p as x, q as I, r as b, s as E, t as T, u as B, v as C, w as N, x as j, y as J, z as F, A as V, B as M, C as k, D as q, E as D } from "./index-B3uagMdY.js";
+function n(s, a, i) {
+  const r = {
+    lines: s,
+    curves: a.map((e) => ({
+      id: e.id,
+      fromLineId: e.fromLineId,
+      toLineId: e.toLineId,
+      fromOffset: e.fromOffset,
+      fromIsPercentage: e.fromIsPercentage ?? !1,
+      toOffset: e.toOffset,
+      toIsPercentage: e.toIsPercentage ?? !1
+    })),
+    vehicles: i.map((e) => ({
+      id: e.id,
+      lineId: e.axles[0].lineId,
+      axles: e.axles.map((t) => ({ offset: t.offset })),
+      axleSpacings: e.axleSpacings,
+      isPercentage: e.isPercentage ?? !1
+    }))
+  };
+  return JSON.stringify(r, null, 2);
+}
+function o(s) {
+  let a;
+  try {
+    a = JSON.parse(s);
+  } catch {
+    throw new Error("deserializeScene: invalid JSON");
+  }
+  if (!a || typeof a != "object" || Array.isArray(a))
+    throw new Error("deserializeScene: expected a JSON object");
+  const i = a;
+  if (!Array.isArray(i.lines)) throw new Error('deserializeScene: missing "lines"');
+  if (!Array.isArray(i.curves)) throw new Error('deserializeScene: missing "curves"');
+  if (!Array.isArray(i.vehicles)) throw new Error('deserializeScene: missing "vehicles"');
+  return {
+    lines: i.lines,
+    curves: i.curves,
+    vehicles: i.vehicles
+  };
+}
 export {
-  i as PathEngine,
-  n as arcLengthToSegmentPosition,
-  a as buildArcLengthTable,
-  o as buildGraph,
-  l as calculateBezierArcLength,
-  r as calculateFrontAxlePosition,
-  c as calculateInitialAxlePositions,
-  s as calculatePositionOnCurve,
-  g as calculatePositionOnLine,
-  h as calculateTangentLength,
-  P as createBezierCurve,
-  u as createInitialMovementState,
-  L as distance,
-  f as distanceToT,
-  m as findPath,
-  v as getArcLength,
-  A as getCumulativeArcLength,
-  O as getLineLength,
-  d as getPointOnBezier,
-  z as getPointOnLine,
+  f as PathEngine,
+  g as arcLengthToSegmentPosition,
+  h as buildArcLengthTable,
+  d as buildGraph,
+  u as calculateBezierArcLength,
+  m as calculateFrontAxlePosition,
+  P as calculateInitialAxlePositions,
+  A as calculatePositionOnCurve,
+  v as calculatePositionOnLine,
+  L as calculateTangentLength,
+  O as createBezierCurve,
+  p as createInitialMovementState,
+  o as deserializeScene,
+  S as distance,
+  z as distanceToT,
+  y as findPath,
+  w as getArcLength,
+  x as getCumulativeArcLength,
+  I as getLineLength,
+  b as getPointOnBezier,
+  E as getPointOnLine,
   T as getPointOnLineByOffset,
-  p as getPositionFromOffset,
-  x as handleArrival,
-  B as initializeAllVehicles,
-  C as initializeMovingVehicle,
-  b as isPointNearPoint,
+  B as getPositionFromOffset,
+  C as handleArrival,
+  N as initializeAllVehicles,
+  j as initializeMovingVehicle,
+  J as isPointNearPoint,
   F as moveVehicle,
   V as normalize,
-  I as prepareCommandPath,
-  M as resolveFromLineOffset,
-  S as resolveToLineOffset,
-  y as updateAxlePosition
+  M as prepareCommandPath,
+  k as resolveFromLineOffset,
+  q as resolveToLineOffset,
+  n as serializeScene,
+  D as updateAxlePosition
 };