sgerp-frontend-lib 0.1.0 → 0.1.2

package/dist/sgerp/map-states/operations-location-state.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OperationsLocationByProjectMapState = exports.OperationsLocationMapState = void 0;
+/**
+ * Default map state for OperationsLocation visualization
+ * Displays locations as blue circles with hover interactions
+ */
+exports.OperationsLocationMapState = {
+    mapBoundingBox: [[-180, -90], [180, 90]],
+    mapLayers: {
+        locations: {
+            source: {
+                type: 'geojson',
+                data: {
+                    type: 'FeatureCollection',
+                    features: [], // Initially empty, will be populated with toGeoJSON()
+                },
+            },
+            layers: [
+                {
+                    id: 'operations-locations',
+                    type: 'circle',
+                    source: 'locations',
+                    paint: {
+                        'circle-radius': 8,
+                        'circle-color': '#3b82f6', // Blue
+                        'circle-stroke-width': 2,
+                        'circle-stroke-color': '#ffffff',
+                    },
+                },
+            ],
+            interactions: [
+                {
+                    layer_id: 'operations-locations',
+                    interaction_type: 'hover',
+                    properties: ['name', 'code', 'address', 'postal_code'],
+                },
+            ],
+        },
+    },
+};
+/**
+ * Map state with color coding by project
+ * Uses project_id to color code locations
+ */
+exports.OperationsLocationByProjectMapState = {
+    mapBoundingBox: [[-180, -90], [180, 90]],
+    mapLayers: {
+        locations: {
+            source: {
+                type: 'geojson',
+                data: {
+                    type: 'FeatureCollection',
+                    features: [],
+                },
+            },
+            layers: [
+                {
+                    id: 'operations-locations',
+                    type: 'circle',
+                    source: 'locations',
+                    paint: {
+                        'circle-radius': 8,
+                        'circle-color': [
+                            'match',
+                            ['get', 'project_id'],
+                            759, '#3b82f6', // Blue for project 759
+                            760, '#ef4444', // Red for project 760
+                            761, '#10b981', // Green for project 761
+                            '#94a3b8', // Default gray
+                        ],
+                        'circle-stroke-width': 2,
+                        'circle-stroke-color': '#ffffff',
+                    },
+                },
+            ],
+            interactions: [
+                {
+                    layer_id: 'operations-locations',
+                    interaction_type: 'hover',
+                    properties: ['name', 'code', 'project_id'],
+                },
+            ],
+        },
+    },
+};

package/dist/sgerp/routing/index.d.ts

@@ -0,0 +1,51 @@
+interface Coordinates {
+    type: 'LineString';
+    coordinates: number[][];
+}
+export declare class Step {
+    key: string;
+    feature: Coordinates;
+    duration: number;
+    distance: number;
+    constructor(key: string, coordinates: number[][], duration: number, distance: number);
+}
+export declare class Leg {
+    key: string;
+    start: number[];
+    end: number[];
+    steps: Step[];
+    duration: number;
+    distance: number;
+    feature: Coordinates;
+    constructor(key: string, start: number[], end: number[], steps: Step[], duration: number, distance: number);
+}
+export declare function airLeg(coordsFrom: number[], coordsTo: number[]): Leg;
+export declare class Route {
+    legs: Leg[];
+    distance: number;
+    feature: Coordinates;
+    constructor(legs: Leg[], coordinates: number[][]);
+}
+interface RoutingSettings {
+    continue_straight?: boolean;
+    speed?: number;
+}
+type RouteCallback = (result: {
+    osrmRoute: Route;
+} | undefined, status: 'ok' | 'error', message?: string) => void;
+export declare class RoutingEngine {
+    routing_engine_name: string;
+    default_backend: string;
+    settings: RoutingSettings | null;
+    useAirDistance: boolean;
+    url: string;
+    road_network: string;
+    key: string;
+    requestCache: Record<string, unknown>;
+    constructor(routing_engine_name: string, url: string, road_network: string, key: string, default_backend?: string, settings?: RoutingSettings | null);
+    getUrl(): string;
+    route(coords: number[][], curb: boolean, callback: RouteCallback, airDistanceOnly?: boolean): Promise<void>;
+    haversineDistance(coords1: number[], coords2: number[]): number;
+}
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/sgerp/routing/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../sgerplib/sgerp/routing/index.ts"],"names":[],"mappings":"AAIA,UAAU,WAAW;IACnB,IAAI,EAAE,YAAY,CAAC;IACnB,WAAW,EAAE,MAAM,EAAE,EAAE,CAAC;CACzB;AAED,qBAAa,IAAI;IACf,GAAG,EAAE,MAAM,CAAC;IACZ,OAAO,EAAE,WAAW,CAAC;IACrB,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;gBAEL,GAAG,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,EAAE,EAAE,EAAE,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM;CASrF;AAED,qBAAa,GAAG;IACd,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,GAAG,EAAE,MAAM,EAAE,CAAC;IACd,KAAK,EAAE,IAAI,EAAE,CAAC;IACd,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,WAAW,CAAC;gBAGnB,GAAG,EAAE,MAAM,EACX,KAAK,EAAE,MAAM,EAAE,EACf,GAAG,EAAE,MAAM,EAAE,EACb,KAAK,EAAE,IAAI,EAAE,EACb,QAAQ,EAAE,MAAM,EAChB,QAAQ,EAAE,MAAM;CAoBnB;AAED,wBAAgB,MAAM,CAAC,UAAU,EAAE,MAAM,EAAE,EAAE,QAAQ,EAAE,MAAM,EAAE,GAAG,GAAG,CAUpE;AAED,qBAAa,KAAK;IAChB,IAAI,EAAE,GAAG,EAAE,CAAC;IACZ,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,WAAW,CAAC;gBAET,IAAI,EAAE,GAAG,EAAE,EAAE,WAAW,EAAE,MAAM,EAAE,EAAE;CAYjD;AAmKD,UAAU,eAAe;IACvB,iBAAiB,CAAC,EAAE,OAAO,CAAC;IAC5B,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED,KAAK,aAAa,GAAG,CACnB,MAAM,EAAE;IAAE,SAAS,EAAE,KAAK,CAAA;CAAE,GAAG,SAAS,EACxC,MAAM,EAAE,IAAI,GAAG,OAAO,EACtB,OAAO,CAAC,EAAE,MAAM,KACb,IAAI,CAAC;AAEV,qBAAa,aAAa;IACxB,mBAAmB,EAAE,MAAM,CAAC;IAC5B,eAAe,EAAE,MAAM,CAAC;IACxB,QAAQ,EAAE,eAAe,GAAG,IAAI,CAAC;IACjC,cAAc,EAAE,OAAO,CAAC;IACxB,GAAG,EAAE,MAAM,CAAC;IACZ,YAAY,EAAE,MAAM,CAAC;IACrB,GAAG,EAAE,MAAM,CAAC;IACZ,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;gBAGpC,mBAAmB,EAAE,MAAM,EAC3B,GAAG,EAAE,MAAM,EACX,YAAY,EAAE,MAAM,EACpB,GAAG,EAAE,MAAM,EACX,eAAe,GAAE,MAAqB,EACtC,QAAQ,GAAE,eAAe,GAAG,IAAW;IAoDzC,MAAM,IAAI,MAAM;IAiBV,KAAK,CACT,MAAM,EAAE,MAAM,EAAE,EAAE,EAClB,IAAI,EAAE,OAAO,EACb,QAAQ,EAAE,aAAa,EACvB,eAAe,GAAE,OAAe,GAC/B,OAAO,CAAC,IAAI,CAAC;IAqHhB,iBAAiB,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE,OAAO,EAAE,MAAM,EAAE,GAAG,MAAM;CAgBhE"}

package/dist/sgerp/routing/index.js

@@ -0,0 +1,373 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RoutingEngine = exports.Route = exports.Leg = exports.Step = void 0;
+exports.airLeg = airLeg;
+const polyline_1 = __importDefault(require("@mapbox/polyline"));
+const domains_1 = require("../domains");
+class Step {
+    constructor(key, coordinates, duration, distance) {
+        this.key = key;
+        this.feature = {
+            type: 'LineString',
+            coordinates: coordinates,
+        };
+        this.duration = duration;
+        this.distance = distance;
+    }
+}
+exports.Step = Step;
+class Leg {
+    constructor(key, start, end, steps, duration, distance) {
+        this.key = key;
+        this.start = start;
+        this.end = end;
+        this.steps = steps;
+        this.duration = duration;
+        this.distance = distance;
+        // Flatten step coordinates into one continuous LineString
+        this.feature = {
+            type: 'LineString',
+            coordinates: steps.reduce((acc, step) => {
+                const downsizedCoordinates = step.feature.coordinates.map(([lat, lon]) => [
+                    parseFloat(lat.toFixed(6)),
+                    parseFloat(lon.toFixed(6)),
+                ]);
+                return [...acc, ...downsizedCoordinates];
+            }, []),
+        };
+    }
+}
+exports.Leg = Leg;
+function airLeg(coordsFrom, coordsTo) {
+    const legKey = `${coordsFrom.join(',')}-${coordsTo.join(',')}`;
+    const step = new Step(legKey, [coordsFrom, coordsTo], 0, // todo
+    0 // todo
+    );
+    return new Leg(legKey, coordsFrom, coordsTo, [step], 0, 0);
+}
+class Route {
+    constructor(legs, coordinates) {
+        this.legs = legs;
+        this.distance = parseInt(legs
+            .reduce((totalDistance, currentLeg) => totalDistance + currentLeg.distance, 0)
+            .toString());
+        this.feature = {
+            type: 'LineString',
+            coordinates: coordinates,
+        };
+    }
+}
+exports.Route = Route;
+// IndexedDB utilities
+const dbName = 'MapRoutingCache';
+const storeName = 'routes';
+function openDB() {
+    return new Promise((resolve, reject) => {
+        const request = indexedDB.open(dbName, 1);
+        request.onerror = () => {
+            reject(request.error);
+        };
+        request.onupgradeneeded = (event) => {
+            const db = event.target.result;
+            // Check if the object store exists, if not create it
+            if (!db.objectStoreNames.contains(storeName)) {
+                db.createObjectStore(storeName);
+            }
+        };
+        request.onsuccess = (event) => {
+            const db = event.target.result;
+            // Verify the object store exists
+            if (!db.objectStoreNames.contains(storeName)) {
+                // If it doesn't exist, close the database and recreate it with the correct schema
+                db.close();
+                const deleteRequest = indexedDB.deleteDatabase(dbName);
+                deleteRequest.onsuccess = () => {
+                    // Recursively try opening again, which will trigger onupgradeneeded
+                    openDB().then(resolve).catch(reject);
+                };
+                deleteRequest.onerror = () => reject(deleteRequest.error);
+            }
+            else {
+                resolve(db);
+            }
+        };
+    });
+}
+async function ensureStoreExists() {
+    let db;
+    try {
+        db = await openDB();
+        const transaction = db.transaction(storeName, 'readonly');
+        await new Promise((resolve, reject) => {
+            transaction.oncomplete = () => resolve();
+            transaction.onerror = () => reject(transaction.error);
+        });
+        return true;
+    }
+    catch (error) {
+        console.error('Error ensuring store exists:', error);
+        return false;
+    }
+    finally {
+        if (db)
+            db.close();
+    }
+}
+async function readFromDB(key) {
+    if (!(await ensureStoreExists())) {
+        return null;
+    }
+    let db;
+    try {
+        db = await openDB();
+        return new Promise((resolve, reject) => {
+            const transaction = db.transaction(storeName, 'readonly');
+            const store = transaction.objectStore(storeName);
+            const request = store.get(key);
+            request.onsuccess = () => resolve(request.result);
+            request.onerror = () => reject(request.error);
+            transaction.oncomplete = () => {
+                db.close();
+            };
+        });
+    }
+    catch (error) {
+        console.error('Error reading from DB:', error);
+        return null;
+    }
+    finally {
+        if (db)
+            db.close();
+    }
+}
+async function writeToDB(key, data) {
+    if (!(await ensureStoreExists())) {
+        return false;
+    }
+    let db;
+    try {
+        db = await openDB();
+        return new Promise((resolve, reject) => {
+            const transaction = db.transaction(storeName, 'readwrite');
+            const store = transaction.objectStore(storeName);
+            const request = store.put(data, key);
+            request.onsuccess = () => resolve(true);
+            request.onerror = () => reject(request.error);
+            transaction.oncomplete = () => {
+                db.close();
+            };
+        });
+    }
+    catch (error) {
+        console.error('Error writing to DB:', error);
+        return false;
+    }
+    finally {
+        if (db)
+            db.close();
+    }
+}
+const fetchData = async (url) => {
+    const cacheKey = `routing-${url}`;
+    try {
+        // Try to read from cache
+        const cachedData = await readFromDB(cacheKey);
+        if (cachedData) {
+            return JSON.parse(cachedData);
+        }
+        // If no cached data, fetch from network
+        let response = await fetch(url);
+        // If 401 error, try the alternative environment
+        if (response.status === 401) {
+            let fallbackUrl = null;
+            if (url.includes('gcprod')) {
+                console.log('401 error with gcprod, trying with gcdev...');
+                fallbackUrl = url.replace('gcprod', 'gcdev');
+            }
+            else if (url.includes('gcdev')) {
+                console.log('401 error with gcdev, trying with gcprod...');
+                fallbackUrl = url.replace('gcdev', 'gcprod');
+            }
+            if (fallbackUrl) {
+                response = await fetch(fallbackUrl);
+                // Update cache key to use the successful URL
+                const fallbackCacheKey = `routing-${fallbackUrl}`;
+                const data = await response.json();
+                await writeToDB(fallbackCacheKey, JSON.stringify(data));
+                return data;
+            }
+        }
+        const data = await response.json();
+        // Cache the new data
+        await writeToDB(cacheKey, JSON.stringify(data));
+        return data;
+    }
+    catch (error) {
+        console.error('Error in fetchData:', error);
+        return null;
+    }
+};
+class RoutingEngine {
+    constructor(routing_engine_name, url, road_network, key, default_backend = 'production', settings = null) {
+        this.routing_engine_name = routing_engine_name;
+        this.default_backend = default_backend;
+        console.log(`default backend in routing engine ${default_backend}`);
+        this.settings = settings;
+        this.useAirDistance = !url || url === 'null' || url === '' || url === undefined;
+        if (!this.useAirDistance) {
+            if (url.includes('gcstage')) {
+                url = url.replace('gcstage', 'gcdev');
+            }
+            if (url === '' ||
+                url === 'null' ||
+                url === undefined ||
+                url.includes('localhost')) {
+                url = 'http://mapbox-osrm-proxy';
+            }
+        }
+        if (road_network === undefined ||
+            road_network === '' ||
+            road_network === null ||
+            road_network === 'sgvan' ||
+            road_network === 'sghorrorvan' ||
+            road_network === 'sghorrorbus' ||
+            road_network === 'euclidean') {
+            road_network = 'van';
+        }
+        if (key === undefined || key === '' || key === 'token') {
+            key = process.env.NEXT_PUBLIC_ROUTING_ENGINE_DEFAULT_KEY || '';
+        }
+        if (url.endsWith('/')) {
+            url = url.slice(0, -1);
+        }
+        this.url = url;
+        if (road_network === 'driving') {
+            road_network = 'van';
+        }
+        this.road_network = road_network;
+        this.key = key;
+        this.requestCache = {};
+    }
+    getUrl() {
+        if (this.url === 'http://mapbox-osrm-proxy') {
+            if (this.default_backend === 'production') {
+                return domains_1.SGERP_DOMAINS.osrm.production;
+            }
+            else if (this.default_backend === 'tc') {
+                return domains_1.SGERP_DOMAINS.osrm.tc;
+            }
+            else if (this.default_backend === 'tcp') {
+                return domains_1.SGERP_DOMAINS.osrm.tcp;
+            }
+            else if (this.default_backend === 'ppe') {
+                return domains_1.SGERP_DOMAINS.osrm.ppe;
+            }
+            else {
+                return domains_1.SGERP_DOMAINS.osrm.development;
+            }
+        }
+        return this.url;
+    }
+    async route(coords, curb, callback, airDistanceOnly = false) {
+        var _a;
+        const validCoords = coords.filter((coord) => !(coord[0] === 0 && coord[1] === 0));
+        if (validCoords.length < 2) {
+            callback(undefined, 'error', 'Not enough valid coordinates');
+            return;
+        }
+        // Handle spheroid and euclidean routing engines - use straight-line distance
+        if (this.routing_engine_name === 'spheroid' || this.routing_engine_name === 'euclidean') {
+            try {
+                // Speed in m/s - default to 7 m/s if not specified
+                const speed = ((_a = this.settings) === null || _a === void 0 ? void 0 : _a.speed) || 7;
+                const spheroidLegs = [];
+                const allCoordinates = [];
+                for (let i = 0; i < validCoords.length - 1; i++) {
+                    const start = validCoords[i];
+                    const end = validCoords[i + 1];
+                    // Calculate haversine distance
+                    const distance = this.haversineDistance(start, end);
+                    // Calculate duration based on speed (distance in meters, speed in m/s, result in seconds)
+                    const duration = distance / speed;
+                    const legKey = `${start.join(',')}-${end.join(',')}`;
+                    // Create a step with straight line between points
+                    const step = new Step(legKey, [[start[1], start[0]], [end[1], end[0]]], // Convert to [lon, lat]
+                    duration, distance);
+                    // Create leg
+                    const leg = new Leg(legKey, [end[1], end[0]], // start in [lon, lat]
+                    [end[1], end[0]], // end in [lon, lat]
+                    [step], duration, distance);
+                    spheroidLegs.push(leg);
+                    allCoordinates.push([start[1], start[0]]);
+                }
+                // Add last coordinate
+                const lastCoord = validCoords[validCoords.length - 1];
+                allCoordinates.push([lastCoord[1], lastCoord[0]]);
+                const spheroidRoute = new Route(spheroidLegs, allCoordinates);
+                callback({ osrmRoute: spheroidRoute }, 'ok');
+                return;
+            }
+            catch (error) {
+                console.error('Error in spheroid routing:', error);
+                callback(undefined, 'error', error.message);
+                return;
+            }
+        }
+        const approach = curb ? 'curb' : 'unrestricted';
+        const lngLats = validCoords.map((coord) => `${coord[1]},${coord[0]}`).join(';');
+        const approaches = validCoords.map(() => approach).join(';');
+        let endpointUrl = `${this.getUrl()}/route/v1/${this.road_network}/${lngLats}?overview=full&alternatives=true&steps=true&approaches=${approaches}`;
+        if (this.key) {
+            endpointUrl += `&access_token=${this.key}`;
+        }
+        if (this.settings && this.settings.continue_straight != null) {
+            endpointUrl += `&continue_straight=${this.settings.continue_straight}`;
+        }
+        if (this.useAirDistance || !airDistanceOnly) {
+            try {
+                const data = (await fetchData(endpointUrl));
+                if (!data || !data.routes || data.routes.length === 0) {
+                    callback(undefined, 'error', 'No routes returned from routing service');
+                    return;
+                }
+                const osrmLegs = data.routes[0].legs.map((leg, index) => {
+                    const steps = leg.steps.map((step) => {
+                        const stepCoordinates = polyline_1.default
+                            .decode(step.geometry)
+                            .map((coord) => [coord[1], coord[0]]);
+                        const firstCoord = stepCoordinates[0];
+                        const lastCoord = stepCoordinates[stepCoordinates.length - 1];
+                        const stepKey = `${firstCoord.join(',')}-${lastCoord.join(',')}`;
+                        return new Step(stepKey, stepCoordinates, step.duration, step.distance);
+                    });
+                    const legKey = `${validCoords[index].join(',')}-${validCoords[index + 1].join(',')}`;
+                    return new Leg(legKey, leg.steps[0].maneuver.location, leg.steps[leg.steps.length - 1].maneuver.location, steps, leg.duration, leg.distance);
+                });
+                const coordsLatLon = polyline_1.default.decode(data.routes[0].geometry);
+                const coordsLonLat = coordsLatLon.map((coord) => [coord[1], coord[0]]);
+                const osrmRoute = new Route(osrmLegs, coordsLonLat);
+                callback({ osrmRoute }, 'ok');
+            }
+            catch (error) {
+                console.error('Error in route processing:', error);
+                callback(undefined, 'error', error.message);
+            }
+        }
+    }
+    haversineDistance(coords1, coords2) {
+        const toRadians = (degree) => (degree * Math.PI) / 180;
+        const R = 6371e3; // Earth radius in meters
+        const lat1 = toRadians(coords1[0]);
+        const lat2 = toRadians(coords2[0]);
+        const deltaLat = lat2 - lat1;
+        const deltaLon = toRadians(coords2[1] - coords1[1]);
+        const a = Math.sin(deltaLat / 2) * Math.sin(deltaLat / 2) +
+            Math.cos(lat1) * Math.cos(lat2) * Math.sin(deltaLon / 2) * Math.sin(deltaLon / 2);
+        const c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a));
+        return R * c; // Distance in meters
+    }
+}
+exports.RoutingEngine = RoutingEngine;