sgerp-frontend-lib 0.1.5 → 0.2.0

package/dist/sgerp/simulation-logic/fetchUtils.js

@@ -9,6 +9,7 @@ exports.fetchOperationsLocationsByProject = fetchOperationsLocationsByProject;
 exports.fetchGeofences = fetchGeofences;
 exports.fetchSimulationGeofence = fetchSimulationGeofence;
 exports.fetchSimulationData = fetchSimulationData;
+exports.fetchVRPToolboxData = fetchVRPToolboxData;
 const client_1 = require("../api/client");
 const referenceUtils_1 = require("./referenceUtils");
 /**
@@ -226,3 +227,196 @@ async function fetchSimulationData(api, simulationId, simulation = null) {
         mainGeofence
     };
 }
+/**
+ * Fetch and convert VRPToolbox job data to SGERP simulation format
+ * Based on dashviewer's INITIALIZE_VRPTOOLBOX and createStateFromCommuteOffers logic
+ *
+ * @param vrpServer - VRPToolbox server URL
+ * @param taskId - VRPToolbox job/task ID
+ * @returns Simulation data in same format as fetchSimulationData
+ */
+async function fetchVRPToolboxData(vrpServer, taskId) {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l;
+    // Fetch VRPToolbox job result with payload
+    const url = `${vrpServer}/jobs/${taskId}/result_with_payload`;
+    const response = await fetch(url);
+    if (!response.ok) {
+        throw new Error(`Failed to fetch VRPToolbox data: ${response.statusText}`);
+    }
+    const data = await response.json();
+    const { payload, result } = data;
+    console.log('[fetchVRPToolboxData] Raw VRPToolbox data:', {
+        payloadNodesCount: (_a = payload.nodes) === null || _a === void 0 ? void 0 : _a.length,
+        payloadVehiclesCount: (_b = payload.vehicles) === null || _b === void 0 ? void 0 : _b.length,
+        resultVehiclesKeys: Object.keys(result.vehicles || {}),
+        resultAssignedBookings: ((_c = result.assigned_bookings) === null || _c === void 0 ? void 0 : _c.length) || 0,
+        resultRejectedBookings: ((_d = result.rejected_bookings) === null || _d === void 0 ? void 0 : _d.length) || 0,
+        samplePayloadNode: (_e = payload.nodes) === null || _e === void 0 ? void 0 : _e[0],
+        sampleResultVehicleNodes: result.vehicles ? Object.values(result.vehicles)[0] : null,
+        allPayloadNodeTypes: (_f = payload.nodes) === null || _f === void 0 ? void 0 : _f.map((n) => ({ uid: n.uid, type: n.node_type, booking_uid: n.booking_uid })),
+        payloadKeys: Object.keys(payload),
+        payloadCalculationParameters: payload.calculation_parameters,
+        dataKeys: Object.keys(data)
+    });
+    // Set default routing engine on vehicles if missing
+    const defaultRoutingEngine = (_g = payload.engine_settings) === null || _g === void 0 ? void 0 : _g.routing_engine;
+    const vrpVehicles = payload.vehicles.map((vehicle) => (Object.assign(Object.assign({}, vehicle), { routing_engine: vehicle.routing_engine || defaultRoutingEngine })));
+    // Build assignedNodesCache from result.vehicles
+    const assignedNodesCache = {};
+    Object.entries(result.vehicles || {}).forEach(([vehicleAgentId, vehicleNodes]) => {
+        vehicleNodes.forEach((node) => {
+            assignedNodesCache[node.uid] = Object.assign(Object.assign({}, node), { assigned_vehicle_id: vehicleAgentId, status: 'assigned' });
+        });
+    });
+    // Collect partial route nodes from vehicle.assigned_nodes
+    const partialRoutesNodes = [];
+    vrpVehicles.forEach((vehicle) => {
+        const assignedNodes = vehicle.assigned_nodes || [];
+        const completedNodes = vehicle.completed_nodes || [];
+        assignedNodes.forEach((vehicleNode) => {
+            vehicleNode.id = vehicleNode.uid;
+            partialRoutesNodes.push(vehicleNode);
+        });
+    });
+    // Process vehicles to SGERP format
+    const vehicles = vrpVehicles.map((vehicle) => (Object.assign(Object.assign({}, vehicle), { id: vehicle.agent_id, simulation_id: taskId, routing_engine_settings: vehicle.routing_engine })));
+    // Process nodes to SGERP format
+    const nodes = [];
+    const included = {};
+    payload.nodes.forEach((node) => {
+        const processedNode = Object.assign(Object.assign({}, node), { simulation_id: taskId, booking_id: node.booking_uid, id: node.uid });
+        if (node.uid in assignedNodesCache) {
+            processedNode.scheduled_ts = assignedNodesCache[node.uid].scheduled_ts;
+            processedNode.assigned_vehicle_id = assignedNodesCache[node.uid].assigned_vehicle_id;
+            processedNode.status = assignedNodesCache[node.uid].status;
+        }
+        else {
+            processedNode.status = 'rejected_by_system';
+            processedNode.scheduled_ts = null;
+            processedNode.assigned_vehicle_id = null;
+        }
+        nodes.push(processedNode);
+        included[node.uid] = processedNode;
+    });
+    // Add partial route nodes that weren't in payload.nodes
+    partialRoutesNodes.forEach((partialRouteNode) => {
+        if (!(partialRouteNode.id in included)) {
+            const processedNode = Object.assign(Object.assign({}, partialRouteNode), { simulation_id: taskId });
+            if (partialRouteNode.id in assignedNodesCache) {
+                processedNode.scheduled_ts = assignedNodesCache[partialRouteNode.id].scheduled_ts;
+                processedNode.assigned_vehicle_id = assignedNodesCache[partialRouteNode.id].assigned_vehicle_id;
+                processedNode.status = assignedNodesCache[partialRouteNode.id].status;
+            }
+            else {
+                processedNode.scheduled_ts = null;
+                processedNode.assigned_vehicle_id = null;
+                processedNode.status = 'rejected_by_system';
+            }
+            nodes.push(processedNode);
+            included[partialRouteNode.id] = processedNode;
+        }
+    });
+    // Check if this is CVRP mode (prebook_cvrptw) and find depot/point node
+    // CVRP mode detection: check scheduling_mode OR presence of point nodes without pickup nodes
+    const schedulingMode = (_h = payload.calculation_parameters) === null || _h === void 0 ? void 0 : _h.scheduling_mode;
+    const hasPointNodes = nodes.some((n) => n.node_type === 'point');
+    const hasPickupNodes = nodes.some((n) => n.node_type === 'pickup');
+    const isCVRP = schedulingMode === 'prebook_cvrptw' || (hasPointNodes && !hasPickupNodes);
+    const depotNode = isCVRP ? nodes.find((n) => n.node_type === 'point') : null;
+    console.log('[fetchVRPToolboxData] CVRP mode detection:', {
+        schedulingMode,
+        hasPointNodes,
+        hasPickupNodes,
+        isCVRP,
+        hasDepotNode: !!depotNode,
+        depotNodeLocation: depotNode ? { lat: depotNode.lat, lon: depotNode.lon, name: depotNode.location_name } : null
+    });
+    // Build bookings from nodes (must be done AFTER all nodes are processed)
+    const bookingsMap = {};
+    const nodeTypeCount = { pickup: 0, dropoff: 0, point: 0, other: 0 };
+    nodes.forEach((node) => {
+        const nodeType = node.node_type;
+        if (nodeType === 'pickup')
+            nodeTypeCount.pickup++;
+        else if (nodeType === 'dropoff')
+            nodeTypeCount.dropoff++;
+        else if (nodeType === 'point')
+            nodeTypeCount.point++;
+        else
+            nodeTypeCount.other++;
+        if (node.booking_id !== null && node.booking_id !== undefined) {
+            if (!(node.booking_id in bookingsMap)) {
+                bookingsMap[node.booking_id] = {
+                    simulation_id: node.simulation_id,
+                    id: node.booking_id,
+                    uid: node.booking_id,
+                };
+            }
+            const booking = bookingsMap[node.booking_id];
+            // Update booking state from node status
+            booking.state = node.status;
+            // Set location data based on node type
+            booking[`${nodeType}_location_name`] = node.location_name;
+            booking[`${nodeType}_location_lat`] = node.lat;
+            booking[`${nodeType}_location_lon`] = node.lon;
+            booking[`${nodeType}_service_time`] = node.service_time;
+            // Set time windows and demand based on node type
+            if (nodeType === 'pickup') {
+                booking.min_pickup_time = node.open_time_ts;
+                booking.demand = node.demand;
+            }
+            else if (nodeType === 'dropoff') {
+                booking.max_dropoff_time = node.close_time_ts;
+                // In CVRP mode, set demand from dropoff node (take absolute values since dropoff has negative demand)
+                if (isCVRP && node.demand) {
+                    booking.demand = Object.fromEntries(Object.entries(node.demand).map(([key, value]) => [key, Math.abs(value)]));
+                }
+            }
+        }
+    });
+    // For CVRP mode: Set all bookings to use depot as pickup location
+    if (isCVRP && depotNode) {
+        Object.values(bookingsMap).forEach((booking) => {
+            booking.pickup_location_lat = depotNode.lat;
+            booking.pickup_location_lon = depotNode.lon;
+            booking.pickup_location_name = depotNode.location_name || 'Depot';
+            booking.pickup_service_time = depotNode.service_time || 0;
+            booking.min_pickup_time = depotNode.open_time_ts;
+        });
+    }
+    // Now attach booking_object to each node
+    nodes.forEach((node) => {
+        if (node.booking_id !== null && node.booking_id !== undefined) {
+            node.booking_object = bookingsMap[node.booking_id];
+        }
+    });
+    const bookings = Object.values(bookingsMap);
+    console.log('[fetchVRPToolboxData] Result:', {
+        vehiclesCount: vehicles.length,
+        bookingsCount: bookings.length,
+        nodesCount: nodes.length,
+        nodeTypeCount,
+        sampleBooking: bookings[0],
+        sampleBookingKeys: bookings[0] ? Object.keys(bookings[0]) : [],
+        sampleBookingId: (_j = bookings[0]) === null || _j === void 0 ? void 0 : _j.id,
+        sampleBookingUid: (_k = bookings[0]) === null || _k === void 0 ? void 0 : _k.uid,
+        sampleBookingState: (_l = bookings[0]) === null || _l === void 0 ? void 0 : _l.state,
+        sampleNode: nodes.find(n => n.booking_id),
+        bookingsWithCoordinates: bookings.filter(b => b.pickup_location_lat && b.pickup_location_lon &&
+            b.dropoff_location_lat && b.dropoff_location_lon).length,
+        bookingsWithPickup: bookings.filter(b => b.pickup_location_lat).length,
+        bookingsWithDropoff: bookings.filter(b => b.dropoff_location_lat).length,
+        bookingStates: bookings.map(b => b.state).filter((v, i, a) => a.indexOf(v) === i)
+    });
+    return {
+        vehicles,
+        bookings,
+        nodes,
+        drivers: [], // No drivers in VRPToolbox data
+        geofences: [], // No geofences in VRPToolbox data
+        mainGeofence: null,
+        // Also return raw payload and result for analyzer
+        rawPayload: payload,
+        rawResult: result
+    };
+}

package/dist/sgerp/simulation-logic/index.d.ts

@@ -2,7 +2,7 @@
  * Simulation page logic utilities
  * Inspired by dashviewer's SimulationPage/logic structure
  */
-export { fetchVehicles, fetchBookings, fetchNodes, fetchDrivers, fetchDriversByProject, fetchOperationsLocationsByProject, fetchSimulationData } from './fetchUtils';
+export { fetchVehicles, fetchBookings, fetchNodes, fetchDrivers, fetchDriversByProject, fetchOperationsLocationsByProject, fetchSimulationData, fetchVRPToolboxData } from './fetchUtils';
 export { createIndexMaps, attachReferences } from './referenceUtils';
 export { calculateBoundingBoxCenter } from './mapUtils';
 export { vehicleComplexRearrange, buildVehicleRouteMap } from './manualEditUtils';
@@ -13,4 +13,7 @@ export { processUnassignResponse } from './optimisticUpdateUtils';
 export type { UnassignResponse, ProcessUnassignResult } from './optimisticUpdateUtils';
 export { LIVE_UPDATE_INTERVALS, PROCESSOR_LIVE_UPDATE_PARAMS, getVehicleLiveUpdateConfig, getBookingLiveUpdateConfig, getNodeLiveUpdateConfig, getProcessorLiveUpdateConfig, triggerAllSimulationUpdates } from './liveUpdates';
 export type { SimulationLiveUpdatesConfig, SimulationLiveUpdateTriggers } from './liveUpdates';
+export { processVRPStatistics, calculateFleetStats } from './vrpStatsCalculator';
+export type { VRPVehicleStats, FleetStats, ProcessedNode } from './vrpStatsCalculator';
+export { formatSeconds, getDistanceFromLatLonInKm, toDisplayDate } from './vrpStatsUtils';
 //# sourceMappingURL=index.d.ts.map

package/dist/sgerp/simulation-logic/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../sgerplib/sgerp/simulation-logic/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EACL,aAAa,EACb,aAAa,EACb,UAAU,EACV,YAAY,EACZ,qBAAqB,EACrB,iCAAiC,EACjC,mBAAmB,EACpB,MAAM,cAAc,CAAC;AAEtB,OAAO,EACL,eAAe,EACf,gBAAgB,EACjB,MAAM,kBAAkB,CAAC;AAE1B,OAAO,EACL,0BAA0B,EAC3B,MAAM,YAAY,CAAC;AAEpB,OAAO,EACL,uBAAuB,EACvB,oBAAoB,EACrB,MAAM,mBAAmB,CAAC;AAE3B,YAAY,EACV,8BAA8B,EAC9B,kBAAkB,EAClB,eAAe,EACf,eAAe,EAChB,MAAM,mBAAmB,CAAC;AAE3B,OAAO,EACL,mBAAmB,EACnB,uBAAuB,EACxB,MAAM,kBAAkB,CAAC;AAE1B,OAAO,EACL,qBAAqB,EACrB,eAAe,EACf,uBAAuB,EACxB,MAAM,yBAAyB,CAAC;AAEjC,OAAO,EACL,uBAAuB,EACxB,MAAM,yBAAyB,CAAC;AAEjC,YAAY,EACV,gBAAgB,EAChB,qBAAqB,EACtB,MAAM,yBAAyB,CAAC;AAEjC,OAAO,EACL,qBAAqB,EACrB,4BAA4B,EAC5B,0BAA0B,EAC1B,0BAA0B,EAC1B,uBAAuB,EACvB,4BAA4B,EAC5B,2BAA2B,EAC5B,MAAM,eAAe,CAAC;AAEvB,YAAY,EACV,2BAA2B,EAC3B,4BAA4B,EAC7B,MAAM,eAAe,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../sgerplib/sgerp/simulation-logic/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EACL,aAAa,EACb,aAAa,EACb,UAAU,EACV,YAAY,EACZ,qBAAqB,EACrB,iCAAiC,EACjC,mBAAmB,EACnB,mBAAmB,EACpB,MAAM,cAAc,CAAC;AAEtB,OAAO,EACL,eAAe,EACf,gBAAgB,EACjB,MAAM,kBAAkB,CAAC;AAE1B,OAAO,EACL,0BAA0B,EAC3B,MAAM,YAAY,CAAC;AAEpB,OAAO,EACL,uBAAuB,EACvB,oBAAoB,EACrB,MAAM,mBAAmB,CAAC;AAE3B,YAAY,EACV,8BAA8B,EAC9B,kBAAkB,EAClB,eAAe,EACf,eAAe,EAChB,MAAM,mBAAmB,CAAC;AAE3B,OAAO,EACL,mBAAmB,EACnB,uBAAuB,EACxB,MAAM,kBAAkB,CAAC;AAE1B,OAAO,EACL,qBAAqB,EACrB,eAAe,EACf,uBAAuB,EACxB,MAAM,yBAAyB,CAAC;AAEjC,OAAO,EACL,uBAAuB,EACxB,MAAM,yBAAyB,CAAC;AAEjC,YAAY,EACV,gBAAgB,EAChB,qBAAqB,EACtB,MAAM,yBAAyB,CAAC;AAEjC,OAAO,EACL,qBAAqB,EACrB,4BAA4B,EAC5B,0BAA0B,EAC1B,0BAA0B,EAC1B,uBAAuB,EACvB,4BAA4B,EAC5B,2BAA2B,EAC5B,MAAM,eAAe,CAAC;AAEvB,YAAY,EACV,2BAA2B,EAC3B,4BAA4B,EAC7B,MAAM,eAAe,CAAC;AAEvB,OAAO,EACL,oBAAoB,EACpB,mBAAmB,EACpB,MAAM,sBAAsB,CAAC;AAE9B,YAAY,EACV,eAAe,EACf,UAAU,EACV,aAAa,EACd,MAAM,sBAAsB,CAAC;AAE9B,OAAO,EACL,aAAa,EACb,yBAAyB,EACzB,aAAa,EACd,MAAM,iBAAiB,CAAC"}

package/dist/sgerp/simulation-logic/index.js

@@ -4,7 +4,7 @@
  * Inspired by dashviewer's SimulationPage/logic structure
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.triggerAllSimulationUpdates = exports.getProcessorLiveUpdateConfig = exports.getNodeLiveUpdateConfig = exports.getBookingLiveUpdateConfig = exports.getVehicleLiveUpdateConfig = exports.PROCESSOR_LIVE_UPDATE_PARAMS = exports.LIVE_UPDATE_INTERVALS = exports.processUnassignResponse = exports.recalculateVehicleRoute = exports.hasRouteChanged = exports.calculateVehicleRoute = exports.shiftWaypointTimestamps = exports.shiftNodeTimestamps = exports.buildVehicleRouteMap = exports.vehicleComplexRearrange = exports.calculateBoundingBoxCenter = exports.attachReferences = exports.createIndexMaps = exports.fetchSimulationData = exports.fetchOperationsLocationsByProject = exports.fetchDriversByProject = exports.fetchDrivers = exports.fetchNodes = exports.fetchBookings = exports.fetchVehicles = void 0;
+exports.toDisplayDate = exports.getDistanceFromLatLonInKm = exports.formatSeconds = exports.calculateFleetStats = exports.processVRPStatistics = exports.triggerAllSimulationUpdates = exports.getProcessorLiveUpdateConfig = exports.getNodeLiveUpdateConfig = exports.getBookingLiveUpdateConfig = exports.getVehicleLiveUpdateConfig = exports.PROCESSOR_LIVE_UPDATE_PARAMS = exports.LIVE_UPDATE_INTERVALS = exports.processUnassignResponse = exports.recalculateVehicleRoute = exports.hasRouteChanged = exports.calculateVehicleRoute = exports.shiftWaypointTimestamps = exports.shiftNodeTimestamps = exports.buildVehicleRouteMap = exports.vehicleComplexRearrange = exports.calculateBoundingBoxCenter = exports.attachReferences = exports.createIndexMaps = exports.fetchVRPToolboxData = exports.fetchSimulationData = exports.fetchOperationsLocationsByProject = exports.fetchDriversByProject = exports.fetchDrivers = exports.fetchNodes = exports.fetchBookings = exports.fetchVehicles = void 0;
 var fetchUtils_1 = require("./fetchUtils");
 Object.defineProperty(exports, "fetchVehicles", { enumerable: true, get: function () { return fetchUtils_1.fetchVehicles; } });
 Object.defineProperty(exports, "fetchBookings", { enumerable: true, get: function () { return fetchUtils_1.fetchBookings; } });
@@ -13,6 +13,7 @@ Object.defineProperty(exports, "fetchDrivers", { enumerable: true, get: function
 Object.defineProperty(exports, "fetchDriversByProject", { enumerable: true, get: function () { return fetchUtils_1.fetchDriversByProject; } });
 Object.defineProperty(exports, "fetchOperationsLocationsByProject", { enumerable: true, get: function () { return fetchUtils_1.fetchOperationsLocationsByProject; } });
 Object.defineProperty(exports, "fetchSimulationData", { enumerable: true, get: function () { return fetchUtils_1.fetchSimulationData; } });
+Object.defineProperty(exports, "fetchVRPToolboxData", { enumerable: true, get: function () { return fetchUtils_1.fetchVRPToolboxData; } });
 var referenceUtils_1 = require("./referenceUtils");
 Object.defineProperty(exports, "createIndexMaps", { enumerable: true, get: function () { return referenceUtils_1.createIndexMaps; } });
 Object.defineProperty(exports, "attachReferences", { enumerable: true, get: function () { return referenceUtils_1.attachReferences; } });
@@ -38,3 +39,10 @@ Object.defineProperty(exports, "getBookingLiveUpdateConfig", { enumerable: true,
 Object.defineProperty(exports, "getNodeLiveUpdateConfig", { enumerable: true, get: function () { return liveUpdates_1.getNodeLiveUpdateConfig; } });
 Object.defineProperty(exports, "getProcessorLiveUpdateConfig", { enumerable: true, get: function () { return liveUpdates_1.getProcessorLiveUpdateConfig; } });
 Object.defineProperty(exports, "triggerAllSimulationUpdates", { enumerable: true, get: function () { return liveUpdates_1.triggerAllSimulationUpdates; } });
+var vrpStatsCalculator_1 = require("./vrpStatsCalculator");
+Object.defineProperty(exports, "processVRPStatistics", { enumerable: true, get: function () { return vrpStatsCalculator_1.processVRPStatistics; } });
+Object.defineProperty(exports, "calculateFleetStats", { enumerable: true, get: function () { return vrpStatsCalculator_1.calculateFleetStats; } });
+var vrpStatsUtils_1 = require("./vrpStatsUtils");
+Object.defineProperty(exports, "formatSeconds", { enumerable: true, get: function () { return vrpStatsUtils_1.formatSeconds; } });
+Object.defineProperty(exports, "getDistanceFromLatLonInKm", { enumerable: true, get: function () { return vrpStatsUtils_1.getDistanceFromLatLonInKm; } });
+Object.defineProperty(exports, "toDisplayDate", { enumerable: true, get: function () { return vrpStatsUtils_1.toDisplayDate; } });

package/dist/sgerp/simulation-logic/vrpStatsCalculator.d.ts

@@ -0,0 +1,52 @@
+/**
+ * VRPToolbox Statistics Calculator
+ * Processes VRP payload and result to calculate fleet statistics, timeline data, and utilization
+ */
+export interface ProcessedNode {
+    uid?: string;
+    lat: number;
+    lon: number;
+    scheduled_ts: string;
+    location_name?: string;
+    node_type: string;
+    service_time: number;
+    travel_time_from_prev: number;
+    nodeBreakDuration: number;
+    adjustedSlack: number;
+    booking_uid?: string;
+    slack?: number;
+    demand?: Record<string, number>;
+    open_time_ts?: string;
+    close_time_ts?: string;
+    scheduled_cumulative_dist?: number;
+}
+export interface VRPVehicleStats {
+    vehicleId: string;
+    vehicleName: string;
+    timelineWaypoints: ProcessedNode[];
+    utilizationData: Array<{
+        time: string;
+        utilization: number;
+    }>;
+    color: string;
+    totalDistance: string;
+    totalTime: string;
+    totalSlack: string;
+    totalBreakTime: string;
+    totalDrivingTime: string;
+}
+export interface FleetStats {
+    totalSlack: string;
+    totalDistance: string;
+    totalDrivingTime: string;
+    totalBreakTime: string;
+}
+/**
+ * Calculate fleet-wide statistics from processed vehicles
+ */
+export declare function calculateFleetStats(vehicles: VRPVehicleStats[]): FleetStats;
+/**
+ * Process VRP result and payload to generate vehicle statistics
+ */
+export declare function processVRPStatistics(result: any, payload: any): Promise<VRPVehicleStats[]>;
+//# sourceMappingURL=vrpStatsCalculator.d.ts.map

package/dist/sgerp/simulation-logic/vrpStatsCalculator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vrpStatsCalculator.d.ts","sourceRoot":"","sources":["../../../sgerplib/sgerp/simulation-logic/vrpStatsCalculator.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAIH,MAAM,WAAW,aAAa;IAC5B,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,GAAG,EAAE,MAAM,CAAC;IACZ,GAAG,EAAE,MAAM,CAAC;IACZ,YAAY,EAAE,MAAM,CAAC;IACrB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,SAAS,EAAE,MAAM,CAAC;IAClB,YAAY,EAAE,MAAM,CAAC;IACrB,qBAAqB,EAAE,MAAM,CAAC;IAC9B,iBAAiB,EAAE,MAAM,CAAC;IAC1B,aAAa,EAAE,MAAM,CAAC;IACtB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAChC,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,yBAAyB,CAAC,EAAE,MAAM,CAAC;CACpC;AAED,MAAM,WAAW,eAAe;IAC9B,SAAS,EAAE,MAAM,CAAC;IAClB,WAAW,EAAE,MAAM,CAAC;IACpB,iBAAiB,EAAE,aAAa,EAAE,CAAC;IACnC,eAAe,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,WAAW,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IAC9D,KAAK,EAAE,MAAM,CAAC;IACd,aAAa,EAAE,MAAM,CAAC;IACtB,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;IACnB,cAAc,EAAE,MAAM,CAAC;IACvB,gBAAgB,EAAE,MAAM,CAAC;CAC1B;AAED,MAAM,WAAW,UAAU;IACzB,UAAU,EAAE,MAAM,CAAC;IACnB,aAAa,EAAE,MAAM,CAAC;IACtB,gBAAgB,EAAE,MAAM,CAAC;IACzB,cAAc,EAAE,MAAM,CAAC;CACxB;AAaD;;GAEG;AACH,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,eAAe,EAAE,GAAG,UAAU,CAsB3E;AAED;;GAEG;AACH,wBAAsB,oBAAoB,CACxC,MAAM,EAAE,GAAG,EACX,OAAO,EAAE,GAAG,GACX,OAAO,CAAC,eAAe,EAAE,CAAC,CAsR5B"}

package/dist/sgerp/simulation-logic/vrpStatsCalculator.js

@@ -0,0 +1,247 @@
+"use strict";
+/**
+ * VRPToolbox Statistics Calculator
+ * Processes VRP payload and result to calculate fleet statistics, timeline data, and utilization
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.calculateFleetStats = calculateFleetStats;
+exports.processVRPStatistics = processVRPStatistics;
+const vrpStatsUtils_1 = require("./vrpStatsUtils");
+const VEHICLE_COLORS = [
+    'red',
+    'blue',
+    'green',
+    'orange',
+    'purple',
+    'brown',
+    'magenta',
+    'teal',
+];
+/**
+ * Calculate fleet-wide statistics from processed vehicles
+ */
+function calculateFleetStats(vehicles) {
+    let totalSlack = 0;
+    let totalDistance = 0;
+    let totalDrivingTime = 0;
+    let totalBreakTime = 0;
+    vehicles.forEach((vehicle) => {
+        totalDistance += parseFloat(vehicle.totalDistance || '0');
+        vehicle.timelineWaypoints.forEach((wp) => {
+            totalSlack += wp.adjustedSlack || 0;
+            totalDrivingTime += wp.travel_time_from_prev || 0;
+            totalBreakTime += wp.nodeBreakDuration || 0;
+        });
+    });
+    return {
+        totalSlack: (0, vrpStatsUtils_1.formatSeconds)(totalSlack),
+        totalDistance: totalDistance.toFixed(2),
+        totalDrivingTime: (0, vrpStatsUtils_1.formatSeconds)(totalDrivingTime),
+        totalBreakTime: (0, vrpStatsUtils_1.formatSeconds)(totalBreakTime),
+    };
+}
+/**
+ * Process VRP result and payload to generate vehicle statistics
+ */
+async function processVRPStatistics(result, payload) {
+    if (!result || !result.vehicles) {
+        console.warn('No vehicles in result', result);
+        return [];
+    }
+    const inputVehicles = (payload === null || payload === void 0 ? void 0 : payload.vehicles) || [];
+    const vehicleList = Array.isArray(result.vehicles)
+        ? result.vehicles
+            .filter((v) => v.nodes && v.nodes.length > 0) // Only vehicles with nodes
+            .map((v) => ({
+            agent_id: v.agent_id,
+            nodes: v.nodes,
+        }))
+        : Object.entries(result.vehicles)
+            .filter(([id, nodes]) => nodes && nodes.length > 0) // Only vehicles with nodes
+            .map(([id, nodes]) => ({
+            agent_id: id,
+            nodes: nodes,
+        }));
+    const vehicles = await Promise.all(vehicleList.map(async (vehicleData, index) => {
+        var _a, _b, _c, _d;
+        const inputVehicle = inputVehicles.find((v) => v.agent_id === vehicleData.agent_id);
+        let vehicleBreakDuration = 0;
+        if (inputVehicle &&
+            typeof inputVehicle.dynamic_break_duration === 'number') {
+            vehicleBreakDuration = inputVehicle.dynamic_break_duration;
+        }
+        let sortedNodes = JSON.parse(JSON.stringify(vehicleData.nodes));
+        sortedNodes.sort((a, b) => new Date(a.scheduled_ts).getTime() - new Date(b.scheduled_ts).getTime());
+        // Add start/end nodes if vehicle has start/end times
+        if (inputVehicle) {
+            if (inputVehicle.start_time) {
+                const startNode = ((payload === null || payload === void 0 ? void 0 : payload.nodes) || []).find((n) => { var _a; return n.uid === ((_a = inputVehicle.partial_route) === null || _a === void 0 ? void 0 : _a[0]); }) || vehicleData.nodes[0];
+                if (startNode) {
+                    sortedNodes.unshift({
+                        lat: startNode.lat,
+                        lon: startNode.lon,
+                        scheduled_ts: inputVehicle.start_time,
+                        location_name: 'Start',
+                        node_type: 'vehicle_start',
+                        service_time: 0,
+                    });
+                }
+            }
+            if (inputVehicle.end_time) {
+                const lastRouteUid = (_a = inputVehicle.partial_route) === null || _a === void 0 ? void 0 : _a[((_b = inputVehicle.partial_route) === null || _b === void 0 ? void 0 : _b.length) - 1];
+                const endNode = ((payload === null || payload === void 0 ? void 0 : payload.nodes) || []).find((n) => n.uid === lastRouteUid) ||
+                    vehicleData.nodes[vehicleData.nodes.length - 1];
+                if (endNode) {
+                    sortedNodes.push({
+                        lat: endNode.lat,
+                        lon: endNode.lon,
+                        scheduled_ts: inputVehicle.end_time,
+                        location_name: 'End',
+                        node_type: 'vehicle_end',
+                        service_time: 0,
+                    });
+                }
+            }
+        }
+        // Process nodes with travel times, breaks, and slack
+        const processedNodes = sortedNodes.map((node, idx, array) => {
+            const prevNode = array[idx - 1];
+            let prevNodeDepartureTime;
+            if (prevNode) {
+                let prevNodeActualBreakDuration = 0;
+                let prevNodeEffectiveSlack = 0;
+                if (typeof prevNode.dynamic_break_time === 'number') {
+                    prevNodeActualBreakDuration = prevNode.dynamic_break_time;
+                    prevNodeEffectiveSlack = prevNode.slack || 0;
+                }
+                else {
+                    const prevNodeBreakCount = prevNode.dynamic_break || 0;
+                    prevNodeActualBreakDuration =
+                        prevNodeBreakCount * vehicleBreakDuration;
+                    prevNodeEffectiveSlack = Math.max(0, (prevNode.slack || 0) - prevNodeActualBreakDuration);
+                }
+                const prevScheduled = new Date(prevNode.scheduled_ts);
+                const departureMs = prevScheduled.getTime() +
+                    ((prevNode.service_time || 0) +
+                        prevNodeEffectiveSlack +
+                        prevNodeActualBreakDuration) *
+                        1000;
+                prevNodeDepartureTime = new Date(departureMs);
+            }
+            let travel_time_from_prev = 0;
+            if (prevNode && node.node_type !== 'vehicle_end') {
+                const nodeScheduled = new Date(node.scheduled_ts);
+                if (prevNodeDepartureTime) {
+                    travel_time_from_prev =
+                        (nodeScheduled.getTime() - prevNodeDepartureTime.getTime()) /
+                            1000;
+                }
+            }
+            let nodeBreakDuration = 0;
+            let adjustedSlack = 0;
+            if (typeof node.dynamic_break_time === 'number') {
+                nodeBreakDuration = node.dynamic_break_time;
+                adjustedSlack = node.slack || 0;
+            }
+            else {
+                const nodeBreakCount = node.dynamic_break || 0;
+                nodeBreakDuration = nodeBreakCount * vehicleBreakDuration;
+                adjustedSlack = Math.max(0, (node.slack || 0) - nodeBreakDuration);
+            }
+            return Object.assign(Object.assign({}, node), { travel_time_from_prev,
+                nodeBreakDuration,
+                adjustedSlack, service_time: node.service_time || 0 });
+        });
+        // Calculate total distance (try multiple methods)
+        let totalDistance = 0;
+        const lastNode = processedNodes[processedNodes.length - 1];
+        // Method 1: Use scheduled_cumulative_dist if available
+        if (lastNode &&
+            typeof lastNode.scheduled_cumulative_dist === 'number') {
+            totalDistance = lastNode.scheduled_cumulative_dist / 1000;
+        }
+        // Method 2: Fallback to Euclidean distance
+        else if (processedNodes.length > 1) {
+            for (let i = 1; i < processedNodes.length; i++) {
+                const prev = processedNodes[i - 1];
+                const curr = processedNodes[i];
+                totalDistance += (0, vrpStatsUtils_1.getDistanceFromLatLonInKm)(prev.lat, prev.lon, curr.lat, curr.lon);
+            }
+        }
+        // Calculate total time
+        let totalTime = 0;
+        if (processedNodes.length > 0 && lastNode) {
+            const startTime = new Date(processedNodes[0].scheduled_ts);
+            const endTime = new Date(lastNode.scheduled_ts);
+            totalTime = (endTime.getTime() - startTime.getTime()) / 1000;
+        }
+        // Calculate utilization over time
+        const utilizationData = [];
+        const vehicleCapacity = (inputVehicle === null || inputVehicle === void 0 ? void 0 : inputVehicle.capacity) || (inputVehicle === null || inputVehicle === void 0 ? void 0 : inputVehicle.limits) || {};
+        const totalCapacity = Object.values(vehicleCapacity).reduce((sum, val) => sum + val, 0);
+        const currentLoad = {};
+        // Initialize load for prebook_cvrptw mode
+        if (((_d = (_c = payload.engine_settings) === null || _c === void 0 ? void 0 : _c.calculation_parameters) === null || _d === void 0 ? void 0 : _d.scheduling_mode) ===
+            'prebook_cvrptw') {
+            const inputNodes = payload.nodes || [];
+            const allDemands = inputNodes
+                .filter((n) => n.node_type === 'dropoff' &&
+                n.demand &&
+                vehicleData.nodes.some((vn) => vn.booking_uid && vn.booking_uid === n.booking_uid))
+                .flatMap((n) => Object.entries(n.demand));
+            for (const [key, value] of allDemands) {
+                currentLoad[key] = (currentLoad[key] || 0) + Math.abs(value);
+            }
+        }
+        else {
+            Object.keys(vehicleCapacity).forEach((key) => (currentLoad[key] = 0));
+        }
+        // Track utilization at each node
+        processedNodes.forEach((node) => {
+            const originalNode = (payload.nodes || []).find((n) => n.uid === node.uid || n.id === node.uid);
+            if (originalNode === null || originalNode === void 0 ? void 0 : originalNode.demand) {
+                if (node.node_type === 'dropoff') {
+                    for (const [key, value] of Object.entries(originalNode.demand)) {
+                        currentLoad[key] =
+                            (currentLoad[key] || 0) - Math.abs(value);
+                    }
+                }
+                else if (node.node_type === 'pickup') {
+                    for (const [key, value] of Object.entries(originalNode.demand)) {
+                        currentLoad[key] =
+                            (currentLoad[key] || 0) + Math.abs(value);
+                    }
+                }
+            }
+            let utilizationAfter = 0;
+            if (totalCapacity > 0) {
+                const totalLoad = Object.values(currentLoad).reduce((sum, val) => sum + val, 0);
+                utilizationAfter = (totalLoad / totalCapacity) * 100;
+            }
+            utilizationData.push({
+                time: node.scheduled_ts,
+                utilization: Math.max(0, Math.min(100, utilizationAfter)),
+            });
+        });
+        // Calculate vehicle-specific stats
+        const vehicleStats = processedNodes.reduce((acc, node) => {
+            acc.slack += node.adjustedSlack || 0;
+            acc.breakTime += node.nodeBreakDuration || 0;
+            acc.drivingTime += node.travel_time_from_prev || 0;
+            return acc;
+        }, { slack: 0, breakTime: 0, drivingTime: 0 });
+        return {
+            vehicleId: vehicleData.agent_id,
+            vehicleName: (inputVehicle === null || inputVehicle === void 0 ? void 0 : inputVehicle.service_number) || vehicleData.agent_id,
+            timelineWaypoints: processedNodes,
+            utilizationData: utilizationData,
+            color: VEHICLE_COLORS[index % VEHICLE_COLORS.length],
+            totalDistance: totalDistance.toFixed(2),
+            totalTime: (0, vrpStatsUtils_1.formatSeconds)(totalTime),
+            totalSlack: (0, vrpStatsUtils_1.formatSeconds)(vehicleStats.slack),
+            totalBreakTime: (0, vrpStatsUtils_1.formatSeconds)(vehicleStats.breakTime),
+            totalDrivingTime: (0, vrpStatsUtils_1.formatSeconds)(vehicleStats.drivingTime),
+        };
+    }));
+    return vehicles;
+}

package/dist/sgerp/simulation-logic/vrpStatsUtils.d.ts

@@ -0,0 +1,17 @@
+/**
+ * VRPToolbox Statistics Utilities
+ * Helper functions for calculating and formatting VRP statistics
+ */
+/**
+ * Format seconds into HH:MM:SS format
+ */
+export declare function formatSeconds(seconds: number): string;
+/**
+ * Calculate distance between two lat/lon coordinates in kilometers (Haversine formula)
+ */
+export declare function getDistanceFromLatLonInKm(lat1: number, lon1: number, lat2: number, lon2: number): number;
+/**
+ * Convert timestamp to display Date (handles timezone conversions)
+ */
+export declare function toDisplayDate(ts: string): Date;
+//# sourceMappingURL=vrpStatsUtils.d.ts.map

package/dist/sgerp/simulation-logic/vrpStatsUtils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vrpStatsUtils.d.ts","sourceRoot":"","sources":["../../../sgerplib/sgerp/simulation-logic/vrpStatsUtils.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;GAEG;AACH,wBAAgB,aAAa,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAUrD;AAED;;GAEG;AACH,wBAAgB,yBAAyB,CACvC,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,GACX,MAAM,CAaR;AAMD;;GAEG;AACH,wBAAgB,aAAa,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI,CAc9C"}

package/dist/sgerp/simulation-logic/vrpStatsUtils.js

@@ -0,0 +1,48 @@
+"use strict";
+/**
+ * VRPToolbox Statistics Utilities
+ * Helper functions for calculating and formatting VRP statistics
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatSeconds = formatSeconds;
+exports.getDistanceFromLatLonInKm = getDistanceFromLatLonInKm;
+exports.toDisplayDate = toDisplayDate;
+/**
+ * Format seconds into HH:MM:SS format
+ */
+function formatSeconds(seconds) {
+    const hours = Math.floor(seconds / 3600);
+    const minutes = Math.floor((seconds % 3600) / 60);
+    const remainingSeconds = Math.floor(seconds % 60);
+    const formattedHours = String(hours).padStart(2, '0');
+    const formattedMinutes = String(minutes).padStart(2, '0');
+    const formattedSeconds = String(remainingSeconds).padStart(2, '0');
+    return `${formattedHours}:${formattedMinutes}:${formattedSeconds}`;
+}
+/**
+ * Calculate distance between two lat/lon coordinates in kilometers (Haversine formula)
+ */
+function getDistanceFromLatLonInKm(lat1, lon1, lat2, lon2) {
+    const R = 6371; // Earth's radius in km
+    const dLat = deg2rad(lat2 - lat1);
+    const dLon = deg2rad(lon2 - lon1);
+    const a = Math.sin(dLat / 2) * Math.sin(dLat / 2) +
+        Math.cos(deg2rad(lat1)) *
+            Math.cos(deg2rad(lat2)) *
+            Math.sin(dLon / 2) *
+            Math.sin(dLon / 2);
+    const c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a));
+    const d = R * c;
+    return d;
+}
+function deg2rad(deg) {
+    return deg * (Math.PI / 180);
+}
+/**
+ * Convert timestamp to display Date (handles timezone conversions)
+ */
+function toDisplayDate(ts) {
+    // Parse as UTC and return as local Date object
+    const date = new Date(ts);
+    return new Date(Date.UTC(date.getUTCFullYear(), date.getUTCMonth(), date.getUTCDate(), date.getUTCHours(), date.getUTCMinutes(), date.getUTCSeconds(), date.getUTCMilliseconds()));
+}

package/dist/sgerp/utils/timezone.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Timezone utility functions
+ */
+/**
+ * Get the effective timezone based on the current mode
+ * In VRPToolbox mode, uses the VRP timezone selector
+ * Otherwise, uses the project timezone (or falls back to UTC)
+ *
+ * @param mode - The current effective mode ('vrptoolbox' or other)
+ * @param vrpTimezone - The timezone selected in VRPToolbox mode
+ * @param projectTimezone - The project's configured timezone
+ * @returns The effective timezone string (e.g., 'UTC', 'Asia/Singapore')
+ */
+export declare function getEffectiveTimezone(mode: string, vrpTimezone: string, projectTimezone?: string): string;
+//# sourceMappingURL=timezone.d.ts.map

package/dist/sgerp/utils/timezone.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"timezone.d.ts","sourceRoot":"","sources":["../../../sgerplib/sgerp/utils/timezone.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH;;;;;;;;;GASG;AACH,wBAAgB,oBAAoB,CAClC,IAAI,EAAE,MAAM,EACZ,WAAW,EAAE,MAAM,EACnB,eAAe,CAAC,EAAE,MAAM,GACvB,MAAM,CAER"}