sgerp-frontend-lib 0.1.3 → 0.1.5

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.processUnassignResponse = 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.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;
 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; } });
@@ -27,5 +27,14 @@ Object.defineProperty(exports, "shiftWaypointTimestamps", { enumerable: true, ge
 var routeCalculationUtils_1 = require("./routeCalculationUtils");
 Object.defineProperty(exports, "calculateVehicleRoute", { enumerable: true, get: function () { return routeCalculationUtils_1.calculateVehicleRoute; } });
 Object.defineProperty(exports, "hasRouteChanged", { enumerable: true, get: function () { return routeCalculationUtils_1.hasRouteChanged; } });
+Object.defineProperty(exports, "recalculateVehicleRoute", { enumerable: true, get: function () { return routeCalculationUtils_1.recalculateVehicleRoute; } });
 var optimisticUpdateUtils_1 = require("./optimisticUpdateUtils");
 Object.defineProperty(exports, "processUnassignResponse", { enumerable: true, get: function () { return optimisticUpdateUtils_1.processUnassignResponse; } });
+var liveUpdates_1 = require("./liveUpdates");
+Object.defineProperty(exports, "LIVE_UPDATE_INTERVALS", { enumerable: true, get: function () { return liveUpdates_1.LIVE_UPDATE_INTERVALS; } });
+Object.defineProperty(exports, "PROCESSOR_LIVE_UPDATE_PARAMS", { enumerable: true, get: function () { return liveUpdates_1.PROCESSOR_LIVE_UPDATE_PARAMS; } });
+Object.defineProperty(exports, "getVehicleLiveUpdateConfig", { enumerable: true, get: function () { return liveUpdates_1.getVehicleLiveUpdateConfig; } });
+Object.defineProperty(exports, "getBookingLiveUpdateConfig", { enumerable: true, get: function () { return liveUpdates_1.getBookingLiveUpdateConfig; } });
+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; } });

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

@@ -0,0 +1,102 @@
+/**
+ * Live updates configuration for simulation pages
+ * Encapsulates polling intervals and params for vehicle, booking, node, and processor updates
+ */
+/**
+ * Configuration for simulation live updates
+ */
+export interface SimulationLiveUpdatesConfig {
+    /**
+     * Simulation ID to poll updates for
+     */
+    simulationId: number | string;
+    /**
+     * Whether live updates are enabled (typically disabled during initial loading)
+     */
+    enabled: boolean;
+    /**
+     * Callback when any collection receives updates
+     */
+    onUpdate?: (hasUpdates: boolean) => void;
+}
+/**
+ * Standard intervals for different collection types
+ */
+export declare const LIVE_UPDATE_INTERVALS: {
+    readonly VEHICLE: 5000;
+    readonly BOOKING: 5000;
+    readonly NODE: 5000;
+    readonly PROCESSOR: 3000;
+};
+/**
+ * Standard parameters for processor live updates
+ */
+export declare const PROCESSOR_LIVE_UPDATE_PARAMS: {
+    readonly processor_lifecycle_type: "one_shot";
+    readonly only_fields: "id,simulation_id,created_at,modified_at,start_time,state,processor_lifecycle_type,username";
+    readonly order_by: "-id";
+    readonly limit: 100;
+};
+/**
+ * Setup configuration for vehicle live updates
+ */
+export declare function getVehicleLiveUpdateConfig(config: SimulationLiveUpdatesConfig): {
+    enabled: boolean;
+    params: {
+        simulation_id: string | number;
+    };
+    interval: 5000;
+    onUpdate: ((hasUpdates: boolean) => void) | undefined;
+};
+/**
+ * Setup configuration for booking live updates
+ */
+export declare function getBookingLiveUpdateConfig(config: SimulationLiveUpdatesConfig): {
+    enabled: boolean;
+    params: {
+        simulation_id: string | number;
+    };
+    interval: 5000;
+    onUpdate: ((hasUpdates: boolean) => void) | undefined;
+};
+/**
+ * Setup configuration for node live updates
+ */
+export declare function getNodeLiveUpdateConfig(config: SimulationLiveUpdatesConfig): {
+    enabled: boolean;
+    params: {
+        simulation_id: string | number;
+    };
+    interval: 5000;
+    onUpdate: ((hasUpdates: boolean) => void) | undefined;
+};
+/**
+ * Setup configuration for processor live updates
+ */
+export declare function getProcessorLiveUpdateConfig(config: SimulationLiveUpdatesConfig): {
+    enabled: boolean;
+    params: {
+        processor_lifecycle_type: "one_shot";
+        only_fields: "id,simulation_id,created_at,modified_at,start_time,state,processor_lifecycle_type,username";
+        order_by: "-id";
+        limit: 100;
+        simulation_id: string | number;
+    };
+    interval: 3000;
+    onUpdate: ((hasUpdates: boolean) => void) | undefined;
+};
+/**
+ * Trigger functions for manual updates
+ */
+export interface SimulationLiveUpdateTriggers {
+    triggerVehicleUpdate?: () => Promise<void>;
+    triggerBookingUpdate?: () => Promise<void>;
+    triggerNodeUpdate?: () => Promise<void>;
+    triggerProcessorUpdate?: () => Promise<void>;
+}
+/**
+ * Trigger all simulation live updates manually
+ * Useful after operations like autoplan, import, or bulk edits
+ */
+export declare function triggerAllSimulationUpdates(triggers: SimulationLiveUpdateTriggers): Promise<void>;
+//# sourceMappingURL=liveUpdates.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"liveUpdates.d.ts","sourceRoot":"","sources":["../../../sgerplib/sgerp/simulation-logic/liveUpdates.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAIH;;GAEG;AACH,MAAM,WAAW,2BAA2B;IAC1C;;OAEG;IACH,YAAY,EAAE,MAAM,GAAG,MAAM,CAAC;IAC9B;;OAEG;IACH,OAAO,EAAE,OAAO,CAAC;IACjB;;OAEG;IACH,QAAQ,CAAC,EAAE,CAAC,UAAU,EAAE,OAAO,KAAK,IAAI,CAAC;CAC1C;AAED;;GAEG;AACH,eAAO,MAAM,qBAAqB;;;;;CAKxB,CAAC;AAEX;;GAEG;AACH,eAAO,MAAM,4BAA4B;;;;;CAK/B,CAAC;AAEX;;GAEG;AACH,wBAAgB,0BAA0B,CAAC,MAAM,EAAE,2BAA2B;;;;;;4BA1BpD,OAAO,KAAK,IAAI;EAiCzC;AAED;;GAEG;AACH,wBAAgB,0BAA0B,CAAC,MAAM,EAAE,2BAA2B;;;;;;4BAtCpD,OAAO,KAAK,IAAI;EA6CzC;AAED;;GAEG;AACH,wBAAgB,uBAAuB,CAAC,MAAM,EAAE,2BAA2B;;;;;;4BAlDjD,OAAO,KAAK,IAAI;EAyDzC;AAED;;GAEG;AACH,wBAAgB,4BAA4B,CAAC,MAAM,EAAE,2BAA2B;;;;;;;;;;4BA9DtD,OAAO,KAAK,IAAI;EAwEzC;AAED;;GAEG;AACH,MAAM,WAAW,4BAA4B;IAC3C,oBAAoB,CAAC,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;IAC3C,oBAAoB,CAAC,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;IAC3C,iBAAiB,CAAC,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;IACxC,sBAAsB,CAAC,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;CAC9C;AAED;;;GAGG;AACH,wBAAsB,2BAA2B,CAAC,QAAQ,EAAE,4BAA4B,iBAOvF"}

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

@@ -0,0 +1,87 @@
+"use strict";
+/**
+ * Live updates configuration for simulation pages
+ * Encapsulates polling intervals and params for vehicle, booking, node, and processor updates
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PROCESSOR_LIVE_UPDATE_PARAMS = exports.LIVE_UPDATE_INTERVALS = void 0;
+exports.getVehicleLiveUpdateConfig = getVehicleLiveUpdateConfig;
+exports.getBookingLiveUpdateConfig = getBookingLiveUpdateConfig;
+exports.getNodeLiveUpdateConfig = getNodeLiveUpdateConfig;
+exports.getProcessorLiveUpdateConfig = getProcessorLiveUpdateConfig;
+exports.triggerAllSimulationUpdates = triggerAllSimulationUpdates;
+/**
+ * Standard intervals for different collection types
+ */
+exports.LIVE_UPDATE_INTERVALS = {
+    VEHICLE: 5000, // 5 seconds
+    BOOKING: 5000, // 5 seconds
+    NODE: 5000, // 5 seconds
+    PROCESSOR: 3000, // 3 seconds (more frequent to catch state changes quickly)
+};
+/**
+ * Standard parameters for processor live updates
+ */
+exports.PROCESSOR_LIVE_UPDATE_PARAMS = {
+    processor_lifecycle_type: 'one_shot',
+    only_fields: 'id,simulation_id,created_at,modified_at,start_time,state,processor_lifecycle_type,username',
+    order_by: '-id',
+    limit: 100,
+};
+/**
+ * Setup configuration for vehicle live updates
+ */
+function getVehicleLiveUpdateConfig(config) {
+    return {
+        enabled: config.enabled,
+        params: { simulation_id: config.simulationId },
+        interval: exports.LIVE_UPDATE_INTERVALS.VEHICLE,
+        onUpdate: config.onUpdate,
+    };
+}
+/**
+ * Setup configuration for booking live updates
+ */
+function getBookingLiveUpdateConfig(config) {
+    return {
+        enabled: config.enabled,
+        params: { simulation_id: config.simulationId },
+        interval: exports.LIVE_UPDATE_INTERVALS.BOOKING,
+        onUpdate: config.onUpdate,
+    };
+}
+/**
+ * Setup configuration for node live updates
+ */
+function getNodeLiveUpdateConfig(config) {
+    return {
+        enabled: config.enabled,
+        params: { simulation_id: config.simulationId },
+        interval: exports.LIVE_UPDATE_INTERVALS.NODE,
+        onUpdate: config.onUpdate,
+    };
+}
+/**
+ * Setup configuration for processor live updates
+ */
+function getProcessorLiveUpdateConfig(config) {
+    return {
+        enabled: config.enabled,
+        params: Object.assign({ simulation_id: config.simulationId }, exports.PROCESSOR_LIVE_UPDATE_PARAMS),
+        interval: exports.LIVE_UPDATE_INTERVALS.PROCESSOR,
+        onUpdate: config.onUpdate,
+    };
+}
+/**
+ * Trigger all simulation live updates manually
+ * Useful after operations like autoplan, import, or bulk edits
+ */
+async function triggerAllSimulationUpdates(triggers) {
+    var _a, _b, _c, _d;
+    await Promise.all([
+        (_a = triggers.triggerVehicleUpdate) === null || _a === void 0 ? void 0 : _a.call(triggers),
+        (_b = triggers.triggerBookingUpdate) === null || _b === void 0 ? void 0 : _b.call(triggers),
+        (_c = triggers.triggerNodeUpdate) === null || _c === void 0 ? void 0 : _c.call(triggers),
+        (_d = triggers.triggerProcessorUpdate) === null || _d === void 0 ? void 0 : _d.call(triggers),
+    ]);
+}

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

@@ -0,0 +1,36 @@
+import type { SGERPClient } from '../client';
+import type { Simulation } from '../types/simulation/simulation';
+import type { Booking } from '../types/simulation/booking';
+import type { Vehicle } from '../types/simulation/vehicle';
+import type { Driver } from '../types/simulation/driver';
+import type { Geofence } from '../types/simulation/geofence';
+import type { RouteNode } from '../utils/routeUtils';
+export interface SimulationDataResult {
+    vehicles: Vehicle[];
+    bookings: Booking[];
+    nodes: RouteNode[];
+    drivers: Driver[];
+    geofences: Geofence[];
+    mainGeofence: Geofence | null;
+    vehicleRoutes: Map<number, {
+        waypoints: any[];
+        polyline?: any;
+    }>;
+    vehicleData: Map<number, {
+        assigned_nodes: RouteNode[];
+        completed_nodes: RouteNode[];
+        assigned_booking_uids: Set<string>;
+        completed_booking_uids: Set<string>;
+    }>;
+}
+/**
+ * Prepare all simulation data: fetch, attach references, generate routes
+ * This is a comprehensive function that handles the entire data preparation pipeline
+ *
+ * @param api - SGERP client instance
+ * @param simulationId - Simulation ID to fetch data for
+ * @param simulation - Optional simulation object (for fetching main geofence)
+ * @returns Complete simulation data with references attached and routes generated
+ */
+export declare function prepareSimulationData(api: SGERPClient, simulationId: number | string, simulation?: Simulation | null): Promise<SimulationDataResult>;
+//# sourceMappingURL=prepareSimulationData.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"prepareSimulationData.d.ts","sourceRoot":"","sources":["../../../sgerplib/sgerp/simulation-logic/prepareSimulationData.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,WAAW,CAAC;AAC7C,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gCAAgC,CAAC;AACjE,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,6BAA6B,CAAC;AAC3D,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,6BAA6B,CAAC;AAC3D,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,4BAA4B,CAAC;AACzD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,8BAA8B,CAAC;AAC7D,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAC;AAKrD,MAAM,WAAW,oBAAoB;IACnC,QAAQ,EAAE,OAAO,EAAE,CAAC;IACpB,QAAQ,EAAE,OAAO,EAAE,CAAC;IACpB,KAAK,EAAE,SAAS,EAAE,CAAC;IACnB,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,SAAS,EAAE,QAAQ,EAAE,CAAC;IACtB,YAAY,EAAE,QAAQ,GAAG,IAAI,CAAC;IAC9B,aAAa,EAAE,GAAG,CAAC,MAAM,EAAE;QAAE,SAAS,EAAE,GAAG,EAAE,CAAC;QAAC,QAAQ,CAAC,EAAE,GAAG,CAAA;KAAE,CAAC,CAAC;IACjE,WAAW,EAAE,GAAG,CAAC,MAAM,EAAE;QACvB,cAAc,EAAE,SAAS,EAAE,CAAC;QAC5B,eAAe,EAAE,SAAS,EAAE,CAAC;QAC7B,qBAAqB,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;QACnC,sBAAsB,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;KACrC,CAAC,CAAC;CACJ;AAED;;;;;;;;GAQG;AACH,wBAAsB,qBAAqB,CACzC,GAAG,EAAE,WAAW,EAChB,YAAY,EAAE,MAAM,GAAG,MAAM,EAC7B,UAAU,GAAE,UAAU,GAAG,IAAW,GACnC,OAAO,CAAC,oBAAoB,CAAC,CAyB/B"}

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

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.prepareSimulationData = prepareSimulationData;
+const fetchUtils_1 = require("./fetchUtils");
+const referenceUtils_1 = require("./referenceUtils");
+const routeUtils_1 = require("../utils/routeUtils");
+/**
+ * Prepare all simulation data: fetch, attach references, generate routes
+ * This is a comprehensive function that handles the entire data preparation pipeline
+ *
+ * @param api - SGERP client instance
+ * @param simulationId - Simulation ID to fetch data for
+ * @param simulation - Optional simulation object (for fetching main geofence)
+ * @returns Complete simulation data with references attached and routes generated
+ */
+async function prepareSimulationData(api, simulationId, simulation = null) {
+    // Step 1: Fetch all data
+    const { vehicles, bookings, nodes, drivers, geofences, mainGeofence } = await (0, fetchUtils_1.fetchSimulationData)(api, simulationId, simulation);
+    // Step 2: Attach references between models
+    const { vehicleData } = (0, referenceUtils_1.attachReferences)(bookings, vehicles, nodes);
+    // Step 3: Generate vehicle routes from nodes
+    const vehicleIds = vehicles.map(v => v.id);
+    const vehicleRoutes = (0, routeUtils_1.createVehicleRoutesFromNodes)(nodes, vehicleIds);
+    return {
+        vehicles,
+        bookings,
+        nodes: nodes,
+        drivers,
+        geofences,
+        mainGeofence,
+        vehicleRoutes,
+        vehicleData
+    };
+}

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

@@ -1,6 +1,7 @@
 import type { Vehicle } from '../types/simulation/vehicle';
-import type { RouteNode } from '../utils/routeUtils';
+import type { RouteNode, Waypoint } from '../utils/routeUtils';
 import { Route } from '../routing';
+import type { Connection } from '../types/config';
 /**
  * Calculate OSRM route for a vehicle based on its assigned nodes
  */
@@ -9,4 +10,9 @@ export declare function calculateVehicleRoute(vehicle: Vehicle, sortedNodes: Rou
  * Check if a vehicle's route has changed by comparing node IDs
  */
 export declare function hasRouteChanged(existingNodes: RouteNode[] | undefined, newNodes: RouteNode[]): boolean;
+/**
+ * Recalculate route for a vehicle when waypoints change
+ * Handles route calculation and scheduled timestamp updates
+ */
+export declare function recalculateVehicleRoute(vehicle: Vehicle, updatedWaypoints: Waypoint[], activeConnection: Connection | null): Promise<Route | null>;
 //# sourceMappingURL=routeCalculationUtils.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"routeCalculationUtils.d.ts","sourceRoot":"","sources":["../../../sgerplib/sgerp/simulation-logic/routeCalculationUtils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,6BAA6B,CAAC;AAC3D,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAC;AACrD,OAAO,EAAiB,KAAK,EAAE,MAAM,YAAY,CAAC;AAElD;;GAEG;AACH,wBAAsB,qBAAqB,CACzC,OAAO,EAAE,OAAO,EAChB,WAAW,EAAE,SAAS,EAAE,EACxB,cAAc,EAAE,MAAM,GACrB,OAAO,CAAC,KAAK,GAAG,IAAI,CAAC,CAuCvB;AAED;;GAEG;AACH,wBAAgB,eAAe,CAC7B,aAAa,EAAE,SAAS,EAAE,GAAG,SAAS,EACtC,QAAQ,EAAE,SAAS,EAAE,GACpB,OAAO,CAIT"}
+{"version":3,"file":"routeCalculationUtils.d.ts","sourceRoot":"","sources":["../../../sgerplib/sgerp/simulation-logic/routeCalculationUtils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,6BAA6B,CAAC;AAE3D,OAAO,KAAK,EAAE,SAAS,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAC;AAC/D,OAAO,EAAiB,KAAK,EAAE,MAAM,YAAY,CAAC;AAClD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAGlD;;GAEG;AACH,wBAAsB,qBAAqB,CACzC,OAAO,EAAE,OAAO,EAChB,WAAW,EAAE,SAAS,EAAE,EACxB,cAAc,EAAE,MAAM,GACrB,OAAO,CAAC,KAAK,GAAG,IAAI,CAAC,CAuCvB;AAED;;GAEG;AACH,wBAAgB,eAAe,CAC7B,aAAa,EAAE,SAAS,EAAE,GAAG,SAAS,EACtC,QAAQ,EAAE,SAAS,EAAE,GACpB,OAAO,CAIT;AAED;;;GAGG;AACH,wBAAsB,uBAAuB,CAC3C,OAAO,EAAE,OAAO,EAChB,gBAAgB,EAAE,QAAQ,EAAE,EAC5B,gBAAgB,EAAE,UAAU,GAAG,IAAI,GAClC,OAAO,CAAC,KAAK,GAAG,IAAI,CAAC,CAgHvB"}

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

@@ -2,7 +2,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.calculateVehicleRoute = calculateVehicleRoute;
 exports.hasRouteChanged = hasRouteChanged;
+exports.recalculateVehicleRoute = recalculateVehicleRoute;
 const routing_1 = require("../routing");
+const domains_1 = require("../domains");
 /**
  * Calculate OSRM route for a vehicle based on its assigned nodes
  */
@@ -41,3 +43,82 @@ function hasRouteChanged(existingNodes, newNodes) {
     const newNodeIds = newNodes.map(n => n.id).join(',');
     return existingNodeIds !== newNodeIds;
 }
+/**
+ * Recalculate route for a vehicle when waypoints change
+ * Handles route calculation and scheduled timestamp updates
+ */
+async function recalculateVehicleRoute(vehicle, updatedWaypoints, activeConnection) {
+    // console.log('Recalculating route for vehicle', vehicle.id, 'with', updatedWaypoints.length, 'waypoints')
+    // Extract all nodes from updated waypoints and flatten
+    const updatedNodes = [];
+    updatedWaypoints.forEach((waypoint) => {
+        waypoint.nodes.forEach((node) => {
+            updatedNodes.push(node);
+        });
+    });
+    // Sort nodes by sequence (they should already be in order from waypoints)
+    const sortedNodes = updatedNodes.filter((n) => n.lat && n.lon);
+    let calculatedRoute = null;
+    // Calculate OSRM route if we have enough waypoints
+    if (sortedNodes.length >= 2) {
+        const coordinates = sortedNodes.map((node) => [node.lat, node.lon]);
+        // Get routing engine settings from vehicle or use defaults
+        const settings = vehicle.routing_engine_settings || {};
+        const routingEngineName = settings.routing_engine_name || "osrm";
+        const url = settings.url || "http://mapbox-osrm-proxy";
+        const roadNetwork = settings.road_network || "van";
+        const key = settings.key || "dmVyeSBzZWNyZXQga2V5";
+        const curb = settings.curb !== undefined ? settings.curb : false;
+        // Determine backend from active connection
+        let defaultBackend = "production"; // default
+        if (activeConnection === null || activeConnection === void 0 ? void 0 : activeConnection.baseUrl) {
+            defaultBackend = (0, domains_1.detectBackendFromUrl)(activeConnection.baseUrl);
+        }
+        // Create routing engine with vehicle-specific settings
+        const routingEngine = new routing_1.RoutingEngine(routingEngineName, url, roadNetwork, key, defaultBackend, settings.speed ? { speed: settings.speed } : null);
+        await new Promise((resolve) => {
+            routingEngine.route(coordinates, curb, (result, status, message) => {
+                if (status === "ok" && (result === null || result === void 0 ? void 0 : result.osrmRoute)) {
+                    calculatedRoute = result.osrmRoute;
+                    // console.log('Route calculated successfully', result.osrmRoute)
+                }
+                else {
+                    console.error(`Failed to recalculate route for vehicle ${vehicle.id}:`, message);
+                }
+                resolve();
+            });
+        });
+    }
+    // Recalculate scheduled_ts for all nodes based on route legs
+    if (calculatedRoute &&
+        calculatedRoute.legs) {
+        const route = calculatedRoute;
+        if (sortedNodes.length > 0 && sortedNodes[0].scheduled_ts) {
+            let cumulativeDurationSeconds = 0;
+            const startTime = new Date(sortedNodes[0].scheduled_ts).getTime();
+            sortedNodes.forEach((node, index) => {
+                if (index === 0) {
+                    // Keep first node's scheduled_ts as is (it's the starting point)
+                    return;
+                }
+                // Add duration from previous leg
+                if (route.legs[index - 1]) {
+                    cumulativeDurationSeconds += route.legs[index - 1].duration || 0;
+                }
+                // Calculate new scheduled_ts
+                const newScheduledTime = new Date(startTime + cumulativeDurationSeconds * 1000);
+                node.scheduled_ts = newScheduledTime.toISOString();
+            });
+            // Update waypoints with new scheduled_ts
+            updatedWaypoints.forEach((waypoint) => {
+                waypoint.nodes.forEach((waypointNode) => {
+                    const updatedNode = sortedNodes.find((n) => n.id === waypointNode.id);
+                    if (updatedNode && updatedNode.scheduled_ts) {
+                        waypointNode.scheduled_ts = updatedNode.scheduled_ts;
+                    }
+                });
+            });
+        }
+    }
+    return calculatedRoute;
+}

package/dist/utils/countries.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Comprehensive list of countries with their phone codes and flag emojis
+ */
+export interface Country {
+    code: string;
+    name: string;
+    flag: string;
+    dialCode: string;
+}
+export declare const COUNTRIES: Country[];
+export declare const POPULAR_COUNTRIES: string[];
+export declare const getCountryByDialCode: (dialCode: string) => Country | undefined;
+export declare const getCountryByCode: (code: string) => Country | undefined;
+export declare const getLocalizedCountryName: (country: Country, getText: (key: string) => string) => string;
+//# sourceMappingURL=countries.d.ts.map

package/dist/utils/countries.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"countries.d.ts","sourceRoot":"","sources":["../../sgerplib/utils/countries.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,MAAM,WAAW,OAAO;IACtB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED,eAAO,MAAM,SAAS,EAAE,OAAO,EAoF9B,CAAC;AAMF,eAAO,MAAM,iBAAiB,UAE7B,CAAC;AAEF,eAAO,MAAM,oBAAoB,GAAI,UAAU,MAAM,KAAG,OAAO,GAAG,SAEjE,CAAC;AAEF,eAAO,MAAM,gBAAgB,GAAI,MAAM,MAAM,KAAG,OAAO,GAAG,SAEzD,CAAC;AAEF,eAAO,MAAM,uBAAuB,GAClC,SAAS,OAAO,EAChB,SAAS,CAAC,GAAG,EAAE,MAAM,KAAK,MAAM,KAC/B,MAKF,CAAC"}

package/dist/utils/countries.js

@@ -0,0 +1,112 @@
+"use strict";
+/**
+ * Comprehensive list of countries with their phone codes and flag emojis
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getLocalizedCountryName = exports.getCountryByCode = exports.getCountryByDialCode = exports.POPULAR_COUNTRIES = exports.COUNTRIES = void 0;
+exports.COUNTRIES = [
+    { code: 'US', name: 'United States', flag: '🇺🇸', dialCode: '+1' },
+    { code: 'CA', name: 'Canada', flag: '🇨🇦', dialCode: '+1' },
+    { code: 'GB', name: 'United Kingdom', flag: '🇬🇧', dialCode: '+44' },
+    { code: 'AU', name: 'Australia', flag: '🇦🇺', dialCode: '+61' },
+    { code: 'NZ', name: 'New Zealand', flag: '🇳🇿', dialCode: '+64' },
+    { code: 'SG', name: 'Singapore', flag: '🇸🇬', dialCode: '+65' },
+    { code: 'MY', name: 'Malaysia', flag: '🇲🇾', dialCode: '+60' },
+    { code: 'TH', name: 'Thailand', flag: '🇹🇭', dialCode: '+66' },
+    { code: 'ID', name: 'Indonesia', flag: '🇮🇩', dialCode: '+62' },
+    { code: 'PH', name: 'Philippines', flag: '🇵🇭', dialCode: '+63' },
+    { code: 'VN', name: 'Vietnam', flag: '🇻🇳', dialCode: '+84' },
+    { code: 'JP', name: 'Japan', flag: '🇯🇵', dialCode: '+81' },
+    { code: 'KR', name: 'South Korea', flag: '🇰🇷', dialCode: '+82' },
+    { code: 'CN', name: 'China', flag: '🇨🇳', dialCode: '+86' },
+    { code: 'HK', name: 'Hong Kong', flag: '🇭🇰', dialCode: '+852' },
+    { code: 'TW', name: 'Taiwan', flag: '🇹🇼', dialCode: '+886' },
+    { code: 'IN', name: 'India', flag: '🇮🇳', dialCode: '+91' },
+    { code: 'PK', name: 'Pakistan', flag: '🇵🇰', dialCode: '+92' },
+    { code: 'BD', name: 'Bangladesh', flag: '🇧🇩', dialCode: '+880' },
+    { code: 'LK', name: 'Sri Lanka', flag: '🇱🇰', dialCode: '+94' },
+    { code: 'AE', name: 'United Arab Emirates', flag: '🇦🇪', dialCode: '+971' },
+    { code: 'SA', name: 'Saudi Arabia', flag: '🇸🇦', dialCode: '+966' },
+    { code: 'IL', name: 'Israel', flag: '🇮🇱', dialCode: '+972' },
+    { code: 'TR', name: 'Turkey', flag: '🇹🇷', dialCode: '+90' },
+    { code: 'RU', name: 'Russia', flag: '🇷🇺', dialCode: '+7' },
+    { code: 'DE', name: 'Germany', flag: '🇩🇪', dialCode: '+49' },
+    { code: 'FR', name: 'France', flag: '🇫🇷', dialCode: '+33' },
+    { code: 'IT', name: 'Italy', flag: '🇮🇹', dialCode: '+39' },
+    { code: 'ES', name: 'Spain', flag: '🇪🇸', dialCode: '+34' },
+    { code: 'PT', name: 'Portugal', flag: '🇵🇹', dialCode: '+351' },
+    { code: 'NL', name: 'Netherlands', flag: '🇳🇱', dialCode: '+31' },
+    { code: 'BE', name: 'Belgium', flag: '🇧🇪', dialCode: '+32' },
+    { code: 'CH', name: 'Switzerland', flag: '🇨🇭', dialCode: '+41' },
+    { code: 'AT', name: 'Austria', flag: '🇦🇹', dialCode: '+43' },
+    { code: 'SE', name: 'Sweden', flag: '🇸🇪', dialCode: '+46' },
+    { code: 'NO', name: 'Norway', flag: '🇳🇴', dialCode: '+47' },
+    { code: 'DK', name: 'Denmark', flag: '🇩🇰', dialCode: '+45' },
+    { code: 'FI', name: 'Finland', flag: '🇫🇮', dialCode: '+358' },
+    { code: 'PL', name: 'Poland', flag: '🇵🇱', dialCode: '+48' },
+    { code: 'CZ', name: 'Czech Republic', flag: '🇨🇿', dialCode: '+420' },
+    { code: 'GR', name: 'Greece', flag: '🇬🇷', dialCode: '+30' },
+    { code: 'IE', name: 'Ireland', flag: '🇮🇪', dialCode: '+353' },
+    { code: 'ZA', name: 'South Africa', flag: '🇿🇦', dialCode: '+27' },
+    { code: 'EG', name: 'Egypt', flag: '🇪🇬', dialCode: '+20' },
+    { code: 'NG', name: 'Nigeria', flag: '🇳🇬', dialCode: '+234' },
+    { code: 'KE', name: 'Kenya', flag: '🇰🇪', dialCode: '+254' },
+    { code: 'BR', name: 'Brazil', flag: '🇧🇷', dialCode: '+55' },
+    { code: 'MX', name: 'Mexico', flag: '🇲🇽', dialCode: '+52' },
+    { code: 'AR', name: 'Argentina', flag: '🇦🇷', dialCode: '+54' },
+    { code: 'CL', name: 'Chile', flag: '🇨🇱', dialCode: '+56' },
+    { code: 'CO', name: 'Colombia', flag: '🇨🇴', dialCode: '+57' },
+    { code: 'PE', name: 'Peru', flag: '🇵🇪', dialCode: '+51' },
+    { code: 'VE', name: 'Venezuela', flag: '🇻🇪', dialCode: '+58' },
+    { code: 'KH', name: 'Cambodia', flag: '🇰🇭', dialCode: '+855' },
+    { code: 'LA', name: 'Laos', flag: '🇱🇦', dialCode: '+856' },
+    { code: 'MM', name: 'Myanmar', flag: '🇲🇲', dialCode: '+95' },
+    { code: 'BN', name: 'Brunei', flag: '🇧🇳', dialCode: '+673' },
+    { code: 'NP', name: 'Nepal', flag: '🇳🇵', dialCode: '+977' },
+    { code: 'MV', name: 'Maldives', flag: '🇲🇻', dialCode: '+960' },
+    { code: 'AF', name: 'Afghanistan', flag: '🇦🇫', dialCode: '+93' },
+    { code: 'IQ', name: 'Iraq', flag: '🇮🇶', dialCode: '+964' },
+    { code: 'IR', name: 'Iran', flag: '🇮🇷', dialCode: '+98' },
+    { code: 'JO', name: 'Jordan', flag: '🇯🇴', dialCode: '+962' },
+    { code: 'KW', name: 'Kuwait', flag: '🇰🇼', dialCode: '+965' },
+    { code: 'LB', name: 'Lebanon', flag: '🇱🇧', dialCode: '+961' },
+    { code: 'OM', name: 'Oman', flag: '🇴🇲', dialCode: '+968' },
+    { code: 'QA', name: 'Qatar', flag: '🇶🇦', dialCode: '+974' },
+    { code: 'BH', name: 'Bahrain', flag: '🇧🇭', dialCode: '+973' },
+    { code: 'UA', name: 'Ukraine', flag: '🇺🇦', dialCode: '+380' },
+    { code: 'RO', name: 'Romania', flag: '🇷🇴', dialCode: '+40' },
+    { code: 'HU', name: 'Hungary', flag: '🇭🇺', dialCode: '+36' },
+    { code: 'BG', name: 'Bulgaria', flag: '🇧🇬', dialCode: '+359' },
+    { code: 'HR', name: 'Croatia', flag: '🇭🇷', dialCode: '+385' },
+    { code: 'RS', name: 'Serbia', flag: '🇷🇸', dialCode: '+381' },
+    { code: 'SI', name: 'Slovenia', flag: '🇸🇮', dialCode: '+386' },
+    { code: 'SK', name: 'Slovakia', flag: '🇸🇰', dialCode: '+421' },
+    { code: 'EE', name: 'Estonia', flag: '🇪🇪', dialCode: '+372' },
+    { code: 'LV', name: 'Latvia', flag: '🇱🇻', dialCode: '+371' },
+    { code: 'LT', name: 'Lithuania', flag: '🇱🇹', dialCode: '+370' },
+    { code: 'IS', name: 'Iceland', flag: '🇮🇸', dialCode: '+354' },
+    { code: 'LU', name: 'Luxembourg', flag: '🇱🇺', dialCode: '+352' },
+    { code: 'MT', name: 'Malta', flag: '🇲🇹', dialCode: '+356' },
+    { code: 'CY', name: 'Cyprus', flag: '🇨🇾', dialCode: '+357' },
+];
+// Sort by name by default
+exports.COUNTRIES.sort((a, b) => a.name.localeCompare(b.name));
+// Popular countries (shown at top)
+exports.POPULAR_COUNTRIES = [
+    'US', 'GB', 'SG', 'AU', 'JP', 'CN', 'IN', 'TH', 'MY', 'ID'
+];
+const getCountryByDialCode = (dialCode) => {
+    return exports.COUNTRIES.find(c => c.dialCode === dialCode);
+};
+exports.getCountryByDialCode = getCountryByDialCode;
+const getCountryByCode = (code) => {
+    return exports.COUNTRIES.find(c => c.code === code);
+};
+exports.getCountryByCode = getCountryByCode;
+const getLocalizedCountryName = (country, getText) => {
+    const key = `country.${country.code.toLowerCase()}`;
+    const translated = getText(key);
+    // If translation key is returned as-is, it means no translation exists, fallback to English name
+    return translated === key ? country.name : translated;
+};
+exports.getLocalizedCountryName = getLocalizedCountryName;

package/dist/utils.d.ts

@@ -0,0 +1,3 @@
+import { type ClassValue } from "clsx";
+export declare function cn(...inputs: ClassValue[]): string;
+//# sourceMappingURL=utils.d.ts.map

package/dist/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../sgerplib/utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAQ,KAAK,UAAU,EAAE,MAAM,MAAM,CAAA;AAG5C,wBAAgB,EAAE,CAAC,GAAG,MAAM,EAAE,UAAU,EAAE,UAEzC"}

package/dist/utils.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cn = cn;
+const clsx_1 = require("clsx");
+const tailwind_merge_1 = require("tailwind-merge");
+function cn(...inputs) {
+    return (0, tailwind_merge_1.twMerge)((0, clsx_1.clsx)(inputs));
+}

package/dist/vrptoolbox/collection.d.ts

@@ -0,0 +1,16 @@
+import type { OptimizationJob } from './types/job';
+import { Collection } from '../sgerp/collection';
+/**
+ * Collection class for VRP Toolbox Optimization Jobs
+ */
+export declare class OptimizationJobCollection extends Collection<OptimizationJob> {
+    private baseUrl;
+    private username?;
+    private password?;
+    constructor(baseUrl: string, username?: string, password?: string);
+    /**
+     * Set authentication credentials
+     */
+    setCredentials(username: string, password: string): void;
+}
+//# sourceMappingURL=collection.d.ts.map

package/dist/vrptoolbox/collection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"collection.d.ts","sourceRoot":"","sources":["../../sgerplib/vrptoolbox/collection.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAA0B,MAAM,aAAa,CAAC;AAE3E,OAAO,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAC;AAqBjD;;GAEG;AACH,qBAAa,yBAA0B,SAAQ,UAAU,CAAC,eAAe,CAAC;IACxE,OAAO,CAAC,OAAO,CAAS;IACxB,OAAO,CAAC,QAAQ,CAAC,CAAS;IAC1B,OAAO,CAAC,QAAQ,CAAC,CAAS;gBAEd,OAAO,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM;IAqCjE;;OAEG;IACH,cAAc,CAAC,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,IAAI;CAIzD"}