@golemio/pid 2.14.2-dev.1360232209 → 2.14.2

package/dist/integration-engine/vehicle-positions/workers/vehicle-positions/helpers/regional-bus/RegionalBusPositionsManager.js

@@ -15,12 +15,6 @@ var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (
 }) : function(o, v) {
     o["default"] = v;
 });
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
 var __importStar = (this && this.__importStar) || function (mod) {
     if (mod && mod.__esModule) return mod;
     var result = {};
@@ -28,12 +22,6 @@ var __importStar = (this && this.__importStar) || function (mod) {
     __setModuleDefault(result, mod);
     return result;
 };
-var __metadata = (this && this.__metadata) || function (k, v) {
-    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
-};
-var __param = (this && this.__param) || function (paramIndex, decorator) {
-    return function (target, key) { decorator(target, key, paramIndex); }
-};
 var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
     function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
     return new (P || (P = Promise))(function (resolve, reject) {
@@ -46,372 +34,365 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
+var _a;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RegionalBusPositionsManager = void 0;
-const VPContainerToken_1 = require("../../../../ioc/VPContainerToken");
-const moment_timezone_1 = __importDefault(require("@golemio/core/dist/shared/moment-timezone"));
-const tsyringe_1 = require("@golemio/core/dist/shared/tsyringe");
 const turf = __importStar(require("@turf/turf"));
+const moment_timezone_1 = __importDefault(require("@golemio/core/dist/shared/moment-timezone"));
 const const_1 = require("../../../../../../const");
 const DateTimeUtils_1 = require("../DateTimeUtils");
 const PositionHandlerEnum_1 = require("../PositionHandlerEnum");
-const ValidToCalculator_1 = require("../ValidToCalculator");
+const ValidToCalculator_1 = __importDefault(require("../ValidToCalculator"));
 const AnchorPointSegmenter_1 = require("../anchor-points/AnchorPointSegmenter");
 const RegionalBusComputeDelayHelper_1 = require("./compute-positions/RegionalBusComputeDelayHelper");
-let RegionalBusPositionsManager = exports.RegionalBusPositionsManager = class RegionalBusPositionsManager {
-    constructor(validToCalculator) {
-        this.validToCalculator = validToCalculator;
-        /**
-         * Compute positions and return computed positions
-         *
-         * @param {ITripPositionsWithGTFS} tripPositions - Trip positions with shape anchors data
-         * @returns {Promise<IProcessedPositions>} - Returns computed/updated positions
-         */
-        this.computePositions = (tripPositions) => __awaiter(this, void 0, void 0, function* () {
-            const startTimestamp = tripPositions.start_timestamp.getTime();
-            const startDayTimestamp = this.getStartDayTimestamp(startTimestamp, tripPositions.gtfsData.shapes_anchor_points[0].time_scheduled_seconds);
-            const gtfsRouteType = tripPositions.gtfs_route_type;
-            const context = this.getCurrentContext(tripPositions);
-            const computedPositions = [];
-            return this.updatePositions({
-                tripPositions,
-                startTimestamp,
-                startDayTimestamp,
-                endTimestamp: null,
-                context,
-                computedPositions,
-                gtfsRouteType,
-            });
-        });
-        /**
-         * Takes position one by one, set proper handler for type of position, and do the process of position
-         */
-        this.updatePositions = (options) => __awaiter(this, void 0, void 0, function* () {
-            var _a, _b, _c, _d, _e;
-            const { tripPositions, startDayTimestamp, startTimestamp, context, computedPositions, gtfsRouteType } = options;
-            for (let i = 0; i < tripPositions.positions.length; i++) {
-                const position = tripPositions.positions[i];
-                let positionToUpdate = null;
-                // situations
-                switch (this.setPositionUpdateHandler(position)) {
-                    case PositionHandlerEnum_1.PositionHandlerEnum.TRACKING:
-                        const currentPosition = turf.point([position.lng, position.lat], {
-                            id: position.id,
-                            origin_time: position.origin_time,
-                            origin_timestamp: position.origin_timestamp,
-                            scheduled_timestamp: position.scheduled_timestamp,
-                            this_stop_id: position.this_stop_id,
-                            tcp_event: position.tcp_event,
-                        });
-                        positionToUpdate = yield this.getEstimatedPoint(tripPositions.gtfsData, currentPosition, context, startDayTimestamp);
-                        positionToUpdate = RegionalBusComputeDelayHelper_1.RegionalBusComputeDelayHelper.updatePositionToUpdate(context, positionToUpdate, position, gtfsRouteType);
-                        positionToUpdate.bearing = (_a = position.bearing) !== null && _a !== void 0 ? _a : positionToUpdate.bearing;
-                        break;
-                    case PositionHandlerEnum_1.PositionHandlerEnum.NOT_TRACKING:
-                        // if there is no previous positions with tracking status, set position as before_track
-                        if (context.lastPositionTracking === null) {
-                            const firstStopTime = tripPositions.gtfsData.stop_times[0];
-                            positionToUpdate = Object.assign({ id: position.id, next_stop_arrival_time: new Date(startDayTimestamp + firstStopTime.arrival_time_seconds * 1000), next_stop_departure_time: new Date(startDayTimestamp + firstStopTime.departure_time_seconds * 1000), next_stop_id: firstStopTime.stop_id, next_stop_sequence: firstStopTime.stop_sequence, next_stop_name: firstStopTime.stop.stop_name, shape_dist_traveled: firstStopTime.shape_dist_traveled, state_position: const_1.StatePositionEnum.BEFORE_TRACK, state_process: const_1.StateProcessEnum.PROCESSED }, (firstStopTime.stop_headsign && {
-                                last_stop_headsign: firstStopTime.stop_headsign,
-                            }));
-                            if (positionToUpdate.state_position === const_1.StatePositionEnum.BEFORE_TRACK) {
-                                positionToUpdate.delay = 0;
-                            }
-                        }
-                        else {
-                            // if there is tracking 2 position with same origin_timestamp then this position is duplicate
-                            const statePosition = position.origin_timestamp.getTime() === context.lastPositionOriginTimestamp ||
-                                tripPositions.positions.findIndex((positionItem) => positionItem.origin_timestamp.getTime() === position.origin_timestamp.getTime() &&
-                                    positionItem.is_tracked) >= 0
-                                ? const_1.StatePositionEnum.DUPLICATE
-                                : const_1.StatePositionEnum.AFTER_TRACK;
-                            const lastShapesAnchorPoint = tripPositions.gtfsData.shapes_anchor_points[tripPositions.gtfsData.shapes_anchor_points.length - 1];
-                            const lastStopTime = tripPositions.gtfsData.stop_times[tripPositions.gtfsData.stop_times.length - 1];
-                            positionToUpdate = Object.assign({ id: position.id, last_stop_arrival_time: new Date(startDayTimestamp + lastShapesAnchorPoint.time_scheduled_seconds * 1000), last_stop_departure_time: new Date(startDayTimestamp + lastShapesAnchorPoint.time_scheduled_seconds * 1000), last_stop_id: lastStopTime.stop_id, last_stop_sequence: lastShapesAnchorPoint.last_stop_sequence, shape_dist_traveled: lastShapesAnchorPoint.shape_dist_traveled, state_position: statePosition, state_process: const_1.StateProcessEnum.PROCESSED }, (lastStopTime.stop_headsign && {
-                                last_stop_headsign: lastStopTime.stop_headsign,
-                            }));
-                            positionToUpdate = RegionalBusComputeDelayHelper_1.RegionalBusComputeDelayHelper.updatePositionToUpdate(context, positionToUpdate, position, gtfsRouteType);
-                        }
-                        break;
-                    case PositionHandlerEnum_1.PositionHandlerEnum.DO_NOTHING:
-                    default:
-                        break;
-                }
-                // if not null push to update
-                if (positionToUpdate) {
-                    (_b = positionToUpdate.is_tracked) !== null && _b !== void 0 ? _b : (positionToUpdate.is_tracked = position.is_tracked);
-                    positionToUpdate.valid_to = this.validToCalculator.getValidToAttribute(positionToUpdate, position, gtfsRouteType, tripPositions.gtfsData, startTimestamp);
-                    computedPositions.push(positionToUpdate);
-                }
-                context.lastPositionState = (_c = positionToUpdate === null || positionToUpdate === void 0 ? void 0 : positionToUpdate.state_position) !== null && _c !== void 0 ? _c : position.state_position;
-                // set last known BEFORE_TRACK_DELAYED position
-                if (position.state_position === const_1.StatePositionEnum.BEFORE_TRACK_DELAYED) {
-                    context.lastPositionBeforeTrackDelayed = {
-                        delay: (_d = positionToUpdate === null || positionToUpdate === void 0 ? void 0 : positionToUpdate.delay) !== null && _d !== void 0 ? _d : position.delay,
-                        origin_timestamp: (_e = positionToUpdate === null || positionToUpdate === void 0 ? void 0 : positionToUpdate.origin_timestamp) !== null && _e !== void 0 ? _e : position.origin_timestamp,
-                    };
-                }
-                // set last position tracking (only for at_stop and on_track)
-                if ((positionToUpdate === null || positionToUpdate === void 0 ? void 0 : positionToUpdate.state_position) === const_1.StatePositionEnum.AT_STOP ||
-                    (positionToUpdate === null || positionToUpdate === void 0 ? void 0 : positionToUpdate.state_position) === const_1.StatePositionEnum.ON_TRACK ||
-                    position.state_position === const_1.StatePositionEnum.AT_STOP ||
-                    position.state_position === const_1.StatePositionEnum.ON_TRACK) {
-                    context.lastPositionTracking = turf.point([position.lng, position.lat], Object.assign(Object.assign({}, position), positionToUpdate));
-                }
-                // set new first position at stop streak if this stop seqence is set and it is not same as before
-                if (positionToUpdate
-                    ? positionToUpdate.this_stop_sequence &&
-                        context.atStopStreak.stop_sequence !== positionToUpdate.this_stop_sequence
-                    : position.this_stop_sequence && context.atStopStreak.stop_sequence !== position.this_stop_sequence) {
-                    context.atStopStreak.stop_sequence = positionToUpdate
-                        ? positionToUpdate.this_stop_sequence
-                        : position.this_stop_sequence;
-                    context.atStopStreak.firstPositionTimestamp = position.origin_timestamp.getTime();
-                    context.atStopStreak.firstPositionDelay = positionToUpdate ? positionToUpdate.delay : position.delay;
-                }
-                // IF currently valid updated position / position was processed before
-                // and it is NOT AT_STOP
-                // then disrupt atStopStreak
-                if (positionToUpdate && !positionToUpdate.this_stop_sequence) {
-                    context.atStopStreak.stop_sequence = null;
-                }
-                else if (!positionToUpdate && !position.this_stop_sequence) {
-                    context.atStopStreak.stop_sequence = null;
+class RegionalBusPositionsManager {
+}
+exports.RegionalBusPositionsManager = RegionalBusPositionsManager;
+_a = RegionalBusPositionsManager;
+/**
+ * Compute positions and return computed positions
+ *
+ * @param {ITripPositionsWithGTFS} tripPositions - Trip positions with shape anchors data
+ * @returns {Promise<IProcessedPositions>} - Returns computed/updated positions
+ */
+RegionalBusPositionsManager.computePositions = (tripPositions) => __awaiter(void 0, void 0, void 0, function* () {
+    const startTimestamp = tripPositions.start_timestamp.getTime();
+    const startDayTimestamp = _a.getStartDayTimestamp(startTimestamp, tripPositions.gtfsData.shapes_anchor_points[0].time_scheduled_seconds);
+    const gtfsRouteType = tripPositions.gtfs_route_type;
+    const context = RegionalBusPositionsManager.getCurrentContext(tripPositions);
+    const computedPositions = [];
+    return RegionalBusPositionsManager.updatePositions({
+        tripPositions,
+        startTimestamp,
+        startDayTimestamp,
+        endTimestamp: null,
+        context,
+        computedPositions,
+        gtfsRouteType,
+    });
+});
+/**
+ * Takes position one by one, set proper handler for type of position, and do the process of position
+ */
+RegionalBusPositionsManager.updatePositions = (options) => __awaiter(void 0, void 0, void 0, function* () {
+    var _b, _c, _d, _e, _f;
+    const { tripPositions, startDayTimestamp, startTimestamp, context, computedPositions, gtfsRouteType } = options;
+    for (let i = 0; i < tripPositions.positions.length; i++) {
+        const position = tripPositions.positions[i];
+        let positionToUpdate = null;
+        // situations
+        switch (_a.setPositionUpdateHandler(position)) {
+            case PositionHandlerEnum_1.PositionHandlerEnum.TRACKING:
+                const currentPosition = turf.point([position.lng, position.lat], {
+                    id: position.id,
+                    origin_time: position.origin_time,
+                    origin_timestamp: position.origin_timestamp,
+                    scheduled_timestamp: position.scheduled_timestamp,
+                    this_stop_id: position.this_stop_id,
+                    tcp_event: position.tcp_event,
+                });
+                positionToUpdate = yield _a.getEstimatedPoint(tripPositions.gtfsData, currentPosition, context, startDayTimestamp);
+                positionToUpdate = RegionalBusComputeDelayHelper_1.RegionalBusComputeDelayHelper.updatePositionToUpdate(context, positionToUpdate, position, gtfsRouteType);
+                positionToUpdate.bearing = (_b = position.bearing) !== null && _b !== void 0 ? _b : positionToUpdate.bearing;
+                break;
+            case PositionHandlerEnum_1.PositionHandlerEnum.NOT_TRACKING:
+                // if there is no previous positions with tracking status, set position as before_track
+                if (context.lastPositionTracking === null) {
+                    const firstStopTime = tripPositions.gtfsData.stop_times[0];
+                    positionToUpdate = Object.assign({ id: position.id, next_stop_arrival_time: new Date(startDayTimestamp + firstStopTime.arrival_time_seconds * 1000), next_stop_departure_time: new Date(startDayTimestamp + firstStopTime.departure_time_seconds * 1000), next_stop_id: firstStopTime.stop_id, next_stop_sequence: firstStopTime.stop_sequence, next_stop_name: firstStopTime.stop.stop_name, shape_dist_traveled: firstStopTime.shape_dist_traveled, state_position: const_1.StatePositionEnum.BEFORE_TRACK, state_process: const_1.StateProcessEnum.PROCESSED }, (firstStopTime.stop_headsign && {
+                        last_stop_headsign: firstStopTime.stop_headsign,
+                    }));
+                    if (positionToUpdate.state_position === const_1.StatePositionEnum.BEFORE_TRACK) {
+                        positionToUpdate.delay = 0;
+                    }
                 }
-                // duplicated position should not be considered at all
-                if ((positionToUpdate === null || positionToUpdate === void 0 ? void 0 : positionToUpdate.state_position) !== const_1.StatePositionEnum.DUPLICATE) {
-                    context.lastPositionId = position.id;
-                    context.lastPositionCanceled = position.is_canceled;
-                    context.lastPositionOriginTimestamp = position.origin_timestamp.getTime();
-                    RegionalBusComputeDelayHelper_1.RegionalBusComputeDelayHelper.updateContext(context, positionToUpdate, position, gtfsRouteType);
+                else {
+                    // if there is tracking 2 position with same origin_timestamp then this position is duplicate
+                    const statePosition = position.origin_timestamp.getTime() === context.lastPositionOriginTimestamp ||
+                        tripPositions.positions.findIndex((positionItem) => positionItem.origin_timestamp.getTime() === position.origin_timestamp.getTime() &&
+                            positionItem.is_tracked) >= 0
+                        ? const_1.StatePositionEnum.DUPLICATE
+                        : const_1.StatePositionEnum.AFTER_TRACK;
+                    const lastShapesAnchorPoint = tripPositions.gtfsData.shapes_anchor_points[tripPositions.gtfsData.shapes_anchor_points.length - 1];
+                    const lastStopTime = tripPositions.gtfsData.stop_times[tripPositions.gtfsData.stop_times.length - 1];
+                    positionToUpdate = Object.assign({ id: position.id, last_stop_arrival_time: new Date(startDayTimestamp + lastShapesAnchorPoint.time_scheduled_seconds * 1000), last_stop_departure_time: new Date(startDayTimestamp + lastShapesAnchorPoint.time_scheduled_seconds * 1000), last_stop_id: lastStopTime.stop_id, last_stop_sequence: lastShapesAnchorPoint.last_stop_sequence, shape_dist_traveled: lastShapesAnchorPoint.shape_dist_traveled, state_position: statePosition, state_process: const_1.StateProcessEnum.PROCESSED }, (lastStopTime.stop_headsign && {
+                        last_stop_headsign: lastStopTime.stop_headsign,
+                    }));
+                    positionToUpdate = RegionalBusComputeDelayHelper_1.RegionalBusComputeDelayHelper.updatePositionToUpdate(context, positionToUpdate, position, gtfsRouteType);
                 }
-            }
-            return {
-                context,
-                positions: computedPositions,
+                break;
+            case PositionHandlerEnum_1.PositionHandlerEnum.DO_NOTHING:
+            default:
+                break;
+        }
+        // if not null push to update
+        if (positionToUpdate) {
+            (_c = positionToUpdate.is_tracked) !== null && _c !== void 0 ? _c : (positionToUpdate.is_tracked = position.is_tracked);
+            positionToUpdate.valid_to = ValidToCalculator_1.default.getValidToAttribute(positionToUpdate, position, gtfsRouteType, tripPositions.gtfsData, startTimestamp, startDayTimestamp);
+            computedPositions.push(positionToUpdate);
+        }
+        context.lastPositionState = (_d = positionToUpdate === null || positionToUpdate === void 0 ? void 0 : positionToUpdate.state_position) !== null && _d !== void 0 ? _d : position.state_position;
+        // set last known BEFORE_TRACK_DELAYED position
+        if (position.state_position === const_1.StatePositionEnum.BEFORE_TRACK_DELAYED) {
+            context.lastPositionBeforeTrackDelayed = {
+                delay: (_e = positionToUpdate === null || positionToUpdate === void 0 ? void 0 : positionToUpdate.delay) !== null && _e !== void 0 ? _e : position.delay,
+                origin_timestamp: (_f = positionToUpdate === null || positionToUpdate === void 0 ? void 0 : positionToUpdate.origin_timestamp) !== null && _f !== void 0 ? _f : position.origin_timestamp,
             };
+        }
+        // set last position tracking (only for at_stop and on_track)
+        if ((positionToUpdate === null || positionToUpdate === void 0 ? void 0 : positionToUpdate.state_position) === const_1.StatePositionEnum.AT_STOP ||
+            (positionToUpdate === null || positionToUpdate === void 0 ? void 0 : positionToUpdate.state_position) === const_1.StatePositionEnum.ON_TRACK ||
+            position.state_position === const_1.StatePositionEnum.AT_STOP ||
+            position.state_position === const_1.StatePositionEnum.ON_TRACK) {
+            context.lastPositionTracking = turf.point([position.lng, position.lat], Object.assign(Object.assign({}, position), positionToUpdate));
+        }
+        // set new first position at stop streak if this stop seqence is set and it is not same as before
+        if (positionToUpdate
+            ? positionToUpdate.this_stop_sequence &&
+                context.atStopStreak.stop_sequence !== positionToUpdate.this_stop_sequence
+            : position.this_stop_sequence && context.atStopStreak.stop_sequence !== position.this_stop_sequence) {
+            context.atStopStreak.stop_sequence = positionToUpdate
+                ? positionToUpdate.this_stop_sequence
+                : position.this_stop_sequence;
+            context.atStopStreak.firstPositionTimestamp = position.origin_timestamp.getTime();
+            context.atStopStreak.firstPositionDelay = positionToUpdate ? positionToUpdate.delay : position.delay;
+        }
+        // IF currently valid updated position / position was processed before
+        // and it is NOT AT_STOP
+        // then disrupt atStopStreak
+        if (positionToUpdate && !positionToUpdate.this_stop_sequence) {
+            context.atStopStreak.stop_sequence = null;
+        }
+        else if (!positionToUpdate && !position.this_stop_sequence) {
+            context.atStopStreak.stop_sequence = null;
+        }
+        // duplicated position should not be considered at all
+        if ((positionToUpdate === null || positionToUpdate === void 0 ? void 0 : positionToUpdate.state_position) !== const_1.StatePositionEnum.DUPLICATE) {
+            context.lastPositionId = position.id;
+            context.lastPositionCanceled = position.is_canceled;
+            context.lastPositionOriginTimestamp = position.origin_timestamp.getTime();
+            RegionalBusComputeDelayHelper_1.RegionalBusComputeDelayHelper.updateContext(context, positionToUpdate, position, gtfsRouteType);
+        }
+    }
+    return {
+        context,
+        positions: computedPositions,
+    };
+});
+RegionalBusPositionsManager.getCurrentContext = (tripPositions) => {
+    var _b;
+    const context = (_b = tripPositions.last_position_context) !== null && _b !== void 0 ? _b : {
+        atStopStreak: {
+            stop_sequence: null,
+            firstPositionTimestamp: null,
+            firstPositionDelay: null,
+        },
+        lastPositionLastStop: {
+            id: null,
+            sequence: null,
+            arrival_time: null,
+            arrival_delay: null,
+            departure_time: null,
+            departure_delay: null,
+        },
+        lastPositionDelay: null,
+        lastPositionId: null,
+        lastPositionOriginTimestamp: null,
+        lastPositionTracking: null,
+        lastPositionCanceled: null,
+        lastPositionBeforeTrackDelayed: null,
+        lastPositionState: null,
+        tripId: tripPositions.id,
+    };
+    return context;
+};
+/**
+ * Decide how to process input position data
+ *
+ * @param {IVPTripsPositionAttributes} position - Input vehiclepositions_positions row data
+ * @returns {PositionHandlerEnum} - Returns action handler enum
+ */
+RegionalBusPositionsManager.setPositionUpdateHandler = (position) => {
+    if (position.state_process === const_1.StateProcessEnum.PROCESSED)
+        return PositionHandlerEnum_1.PositionHandlerEnum.DO_NOTHING;
+    else if (position.is_tracked)
+        return PositionHandlerEnum_1.PositionHandlerEnum.TRACKING;
+    else
+        return PositionHandlerEnum_1.PositionHandlerEnum.NOT_TRACKING;
+};
+/**
+ * Returns estimate of point on shape, where the trip should be with appropriate delay
+ *
+ * @param {IShapeAnchorPoint[]} tripShapePoints - Precalculated trip shape equidistant points with scheduled times
+ * @param {Feature<Point, ICurrentPositionProperties>} currentPosition - Current position of trip
+ * @param {IVPTripsLastPositionContext | null} context - Context state, holds information about previous positions
+ * @param {number} startDayTimestamp - Unix timestamp of midnight before trip starts
+ * @returns {IPositionToUpdate} - Position object to update
+ */
+RegionalBusPositionsManager.getEstimatedPoint = (tripGtfsData, currentPosition, context, startDayTimestamp) => {
+    var _b, _c, _d, _e, _f, _g, _h, _j;
+    const anchorPointSegmenter = new AnchorPointSegmenter_1.AnchorPointSegmenter(tripGtfsData.shapes_anchor_points, currentPosition);
+    const defaultStatePosition = const_1.StatePositionEnum.OFF_TRACK;
+    // Initial value
+    let estimatedPoint = Object.assign({ id: currentPosition.properties.id, state_position: defaultStatePosition, state_process: const_1.StateProcessEnum.PROCESSED, tcp_event: currentPosition.properties.tcp_event, valid_to: ValidToCalculator_1.default.getDefaultValidToAttribute(currentPosition.properties.origin_timestamp) }, (context &&
+        ((_b = context.lastPositionTracking) === null || _b === void 0 ? void 0 : _b.properties.last_stop_sequence) && {
+        shape_dist_traveled: (_c = context.lastPositionTracking) === null || _c === void 0 ? void 0 : _c.properties.shape_dist_traveled,
+        last_stop_arrival_time: ((_d = context.lastPositionTracking) === null || _d === void 0 ? void 0 : _d.properties.last_stop_arrival_time)
+            ? new Date((_e = context.lastPositionTracking) === null || _e === void 0 ? void 0 : _e.properties.last_stop_arrival_time)
+            : undefined,
+        last_stop_departure_time: ((_f = context.lastPositionTracking) === null || _f === void 0 ? void 0 : _f.properties.last_stop_departure_time)
+            ? new Date((_g = context.lastPositionTracking) === null || _g === void 0 ? void 0 : _g.properties.last_stop_departure_time)
+            : undefined,
+        last_stop_sequence: (_h = context.lastPositionTracking) === null || _h === void 0 ? void 0 : _h.properties.last_stop_sequence,
+        last_stop_id: (_j = context.lastPositionTracking) === null || _j === void 0 ? void 0 : _j.properties.last_stop_id,
+    }));
+    let lastStopSequence = null;
+    if ((context === null || context === void 0 ? void 0 : context.lastPositionState) === const_1.StatePositionEnum.BEFORE_TRACK) {
+        lastStopSequence = 1;
+    }
+    else if (context === null || context === void 0 ? void 0 : context.lastPositionTracking) {
+        lastStopSequence = context.lastPositionTracking.properties.last_stop_sequence;
+    }
+    const closesPoint = anchorPointSegmenter.getClosesPoint(lastStopSequence);
+    if (!closesPoint) {
+        return estimatedPoint;
+    }
+    return _a.getClosestPoint(currentPosition, context, startDayTimestamp, closesPoint, tripGtfsData);
+};
+/**
+ * Picks only one closest point for multiple possible points based on delay of last position and stop times
+ *
+ * @param {Feature<Point, ICurrentPositionProperties>} currentPosition - Feature Point of current position
+ * @param {IVPTripsLastPositionContext | null} context - Context state, holds information about previous positions
+ * @param {number} startDayTimestamp - Unix timestamp of start of the day
+ * @param {IShapeAnchorPoint[]} closestPts - All closest points of possible segments
+ * @param {IComputationTrip} tripGtfsData - GTFS data and all set of known positions
+ * @returns {IPositionToUpdate} - Result point as position to update in DB
+ */
+RegionalBusPositionsManager.getClosestPoint = (currentPosition, context, startDayTimestamp, thisClosestPoint, tripGtfsData) => {
+    // want to find minimum difference of our prediction, where the bus should be
+    let minTimeRealDiff = Infinity;
+    const tripShapePoints = tripGtfsData.shapes_anchor_points;
+    const tripStopTimes = tripGtfsData.stop_times;
+    const firstTripShapePoint = tripShapePoints[0];
+    const lastTripShapePoint = tripShapePoints[tripShapePoints.length - 1];
+    const timeScheduledTimestamp = DateTimeUtils_1.DateTimeUtils.getStopDateTimeForDayStart(
+    // take stop arrival time if is point at stop
+    thisClosestPoint.this_stop_sequence
+        ? tripStopTimes[thisClosestPoint.this_stop_sequence - 1].arrival_time_seconds
+        : thisClosestPoint.time_scheduled_seconds, startDayTimestamp);
+    let timeDelayInSeconds = Math.round((currentPosition.properties.origin_timestamp.getTime() - timeScheduledTimestamp.getTime()) / 1000);
+    // lets correct delay if it is at stop
+    if (thisClosestPoint.this_stop_sequence) {
+        const thisStopSequence = thisClosestPoint.this_stop_sequence;
+        timeDelayInSeconds = _a.getCorrectedTimeDelay(timeDelayInSeconds, context, currentPosition, thisStopSequence, {
+            departureTime: tripStopTimes[thisStopSequence - 1].departure_time_seconds,
+            arrivalTime: tripStopTimes[thisStopSequence - 1].arrival_time_seconds,
         });
-        this.getCurrentContext = (tripPositions) => {
-            var _a;
-            const context = (_a = tripPositions.last_position_context) !== null && _a !== void 0 ? _a : {
-                atStopStreak: {
-                    stop_sequence: null,
-                    firstPositionTimestamp: null,
-                    firstPositionDelay: null,
-                },
-                lastPositionLastStop: {
-                    id: null,
-                    sequence: null,
-                    arrival_time: null,
-                    arrival_delay: null,
-                    departure_time: null,
-                    departure_delay: null,
-                },
-                lastPositionDelay: null,
-                lastPositionId: null,
-                lastPositionOriginTimestamp: null,
-                lastPositionTracking: null,
-                lastPositionCanceled: null,
-                lastPositionBeforeTrackDelayed: null,
-                lastPositionState: null,
-                tripId: tripPositions.id,
-            };
-            return context;
-        };
-        /**
-         * Decide how to process input position data
-         *
-         * @param {IVPTripsPositionAttributes} position - Input vehiclepositions_positions row data
-         * @returns {PositionHandlerEnum} - Returns action handler enum
-         */
-        this.setPositionUpdateHandler = (position) => {
-            if (position.state_process === const_1.StateProcessEnum.PROCESSED)
-                return PositionHandlerEnum_1.PositionHandlerEnum.DO_NOTHING;
-            else if (position.is_tracked)
-                return PositionHandlerEnum_1.PositionHandlerEnum.TRACKING;
-            else
-                return PositionHandlerEnum_1.PositionHandlerEnum.NOT_TRACKING;
-        };
-        /**
-         * Returns estimate of point on shape, where the trip should be with appropriate delay
-         *
-         * @param {IShapeAnchorPoint[]} tripShapePoints - Precalculated trip shape equidistant points with scheduled times
-         * @param {Feature<Point, ICurrentPositionProperties>} currentPosition - Current position of trip
-         * @param {IVPTripsLastPositionContext | null} context - Context state, holds information about previous positions
-         * @param {number} startDayTimestamp - Unix timestamp of midnight before trip starts
-         * @returns {IPositionToUpdate} - Position object to update
-         */
-        this.getEstimatedPoint = (tripGtfsData, currentPosition, context, startDayTimestamp) => {
-            var _a, _b, _c, _d, _e, _f, _g, _h;
-            const anchorPointSegmenter = new AnchorPointSegmenter_1.AnchorPointSegmenter(tripGtfsData.shapes_anchor_points, currentPosition);
-            const defaultStatePosition = const_1.StatePositionEnum.OFF_TRACK;
-            // Initial value
-            let estimatedPoint = Object.assign({ id: currentPosition.properties.id, state_position: defaultStatePosition, state_process: const_1.StateProcessEnum.PROCESSED, tcp_event: currentPosition.properties.tcp_event, valid_to: this.validToCalculator.getDefaultValidToAttribute(currentPosition.properties.origin_timestamp) }, (context &&
-                ((_a = context.lastPositionTracking) === null || _a === void 0 ? void 0 : _a.properties.last_stop_sequence) && {
-                shape_dist_traveled: (_b = context.lastPositionTracking) === null || _b === void 0 ? void 0 : _b.properties.shape_dist_traveled,
-                last_stop_arrival_time: ((_c = context.lastPositionTracking) === null || _c === void 0 ? void 0 : _c.properties.last_stop_arrival_time)
-                    ? new Date((_d = context.lastPositionTracking) === null || _d === void 0 ? void 0 : _d.properties.last_stop_arrival_time)
-                    : undefined,
-                last_stop_departure_time: ((_e = context.lastPositionTracking) === null || _e === void 0 ? void 0 : _e.properties.last_stop_departure_time)
-                    ? new Date((_f = context.lastPositionTracking) === null || _f === void 0 ? void 0 : _f.properties.last_stop_departure_time)
-                    : undefined,
-                last_stop_sequence: (_g = context.lastPositionTracking) === null || _g === void 0 ? void 0 : _g.properties.last_stop_sequence,
-                last_stop_id: (_h = context.lastPositionTracking) === null || _h === void 0 ? void 0 : _h.properties.last_stop_id,
-            }));
-            let lastStopSequence = null;
-            if ((context === null || context === void 0 ? void 0 : context.lastPositionState) === const_1.StatePositionEnum.BEFORE_TRACK) {
-                lastStopSequence = 1;
-            }
-            else if (context === null || context === void 0 ? void 0 : context.lastPositionTracking) {
-                lastStopSequence = context.lastPositionTracking.properties.last_stop_sequence;
-            }
-            const closesPoint = anchorPointSegmenter.getClosesPoint(lastStopSequence);
-            if (!closesPoint) {
-                return estimatedPoint;
-            }
-            return this.getClosestPoint(currentPosition, context, startDayTimestamp, closesPoint, tripGtfsData);
-        };
-        /**
-         * Picks only one closest point for multiple possible points based on delay of last position and stop times
-         *
-         * @param {Feature<Point, ICurrentPositionProperties>} currentPosition - Feature Point of current position
-         * @param {IVPTripsLastPositionContext | null} context - Context state, holds information about previous positions
-         * @param {number} startDayTimestamp - Unix timestamp of start of the day
-         * @param {IShapeAnchorPoint[]} closestPts - All closest points of possible segments
-         * @param {IComputationTrip} tripGtfsData - GTFS data and all set of known positions
-         * @returns {IPositionToUpdate} - Result point as position to update in DB
-         */
-        this.getClosestPoint = (currentPosition, context, startDayTimestamp, thisClosestPoint, tripGtfsData) => {
-            // want to find minimum difference of our prediction, where the bus should be
-            let minTimeRealDiff = Infinity;
-            const tripShapePoints = tripGtfsData.shapes_anchor_points;
-            const tripStopTimes = tripGtfsData.stop_times;
-            const firstTripShapePoint = tripShapePoints[0];
-            const lastTripShapePoint = tripShapePoints[tripShapePoints.length - 1];
-            const timeScheduledTimestamp = DateTimeUtils_1.DateTimeUtils.getStopDateTimeForDayStart(
-            // take stop arrival time if is point at stop
-            thisClosestPoint.this_stop_sequence
-                ? tripStopTimes[thisClosestPoint.this_stop_sequence - 1].arrival_time_seconds
-                : thisClosestPoint.time_scheduled_seconds, startDayTimestamp);
-            let timeDelayInSeconds = Math.round((currentPosition.properties.origin_timestamp.getTime() - timeScheduledTimestamp.getTime()) / 1000);
-            // lets correct delay if it is at stop
-            if (thisClosestPoint.this_stop_sequence) {
-                const thisStopSequence = thisClosestPoint.this_stop_sequence;
-                timeDelayInSeconds = this.getCorrectedTimeDelay(timeDelayInSeconds, context, currentPosition, thisStopSequence, {
-                    departureTime: tripStopTimes[thisStopSequence - 1].departure_time_seconds,
-                    arrivalTime: tripStopTimes[thisStopSequence - 1].arrival_time_seconds,
-                });
-                // delay can not be negative if the vehicle is at the first stop
-                if (thisStopSequence === firstTripShapePoint.this_stop_sequence) {
-                    timeDelayInSeconds = Math.max(timeDelayInSeconds, 0);
-                }
-            }
-            const statePosition = this.determineStatePosition(thisClosestPoint, lastTripShapePoint);
-            const thisStopSequence = thisClosestPoint.this_stop_sequence;
-            const lastStopSequence = thisClosestPoint.last_stop_sequence;
-            const nextStopSequence = thisClosestPoint.next_stop_sequence;
-            // save it for result
-            const estimatedPoint = {
-                id: currentPosition.properties.id,
-                bearing: thisClosestPoint.bearing,
-                shape_dist_traveled: thisClosestPoint.shape_dist_traveled,
-                next_stop_id: tripStopTimes[nextStopSequence - 1].stop_id,
-                last_stop_id: tripStopTimes[lastStopSequence - 1].stop_id,
-                next_stop_name: tripStopTimes[nextStopSequence - 1].stop.stop_name,
-                last_stop_name: tripStopTimes[lastStopSequence - 1].stop.stop_name,
-                next_stop_sequence: nextStopSequence,
-                last_stop_sequence: lastStopSequence,
-                next_stop_arrival_time: DateTimeUtils_1.DateTimeUtils.getStopDateTimeForDayStart(tripStopTimes[nextStopSequence - 1].arrival_time_seconds, startDayTimestamp),
-                last_stop_arrival_time: DateTimeUtils_1.DateTimeUtils.getStopDateTimeForDayStart(tripStopTimes[lastStopSequence - 1].arrival_time_seconds, startDayTimestamp),
-                next_stop_departure_time: DateTimeUtils_1.DateTimeUtils.getStopDateTimeForDayStart(tripStopTimes[nextStopSequence - 1].departure_time_seconds, startDayTimestamp),
-                last_stop_departure_time: DateTimeUtils_1.DateTimeUtils.getStopDateTimeForDayStart(tripStopTimes[lastStopSequence - 1].departure_time_seconds, startDayTimestamp),
-                delay: statePosition === const_1.StatePositionEnum.AFTER_TRACK ? 0 : timeDelayInSeconds,
-                this_stop_id: (statePosition === const_1.StatePositionEnum.AT_STOP &&
-                    thisStopSequence &&
-                    tripStopTimes[thisStopSequence - 1].stop_id) ||
-                    undefined,
-                this_stop_name: (statePosition === const_1.StatePositionEnum.AT_STOP &&
-                    thisStopSequence &&
-                    tripStopTimes[thisStopSequence - 1].stop.stop_name) ||
-                    undefined,
-                this_stop_sequence: (statePosition === const_1.StatePositionEnum.AT_STOP && thisStopSequence) || undefined,
-                last_stop_headsign: tripStopTimes[lastStopSequence - 1].stop_headsign || undefined,
-                state_position: statePosition,
-                state_process: const_1.StateProcessEnum.PROCESSED,
-                valid_to: this.validToCalculator.getDefaultValidToAttribute(currentPosition.properties.origin_timestamp),
-                is_tracked: statePosition !== const_1.StatePositionEnum.AFTER_TRACK,
-            };
-            return estimatedPoint;
-        };
-        /**
-         * Corrects time delay at stop with dwelling time
-         *
-         * @param {number} timeDelay - Initial computed delay in seconds, can be negative for trip ahead
-         * @param {IVPTripsLastPositionContext | null} context - Context state, holds information about previous positions
-         * @param {Feature<Point, ICurrentPositionProperties>} currentPosition - Feature Point of current position
-         * @param {IShapeAnchorPoint} thisClosestPoint - Closest point of shape anchors
-         * @param { departureTime: number; arrivalTime: number } stopTimes - departure and arrival stop times in seconds
-         * @returns {number} - Result delay in seconds, can be negative for trip ahead
-         */
-        this.getCorrectedTimeDelay = (timeDelay, context, currentPosition, thisStopSequence, stopTimes) => {
-            // compute dwell time in stop, most common is zero
-            const stopDwellTimeSeconds = stopTimes.departureTime - stopTimes.arrivalTime;
-            // if dwell time is sheduled as zero, return initial computed delay
-            if (stopDwellTimeSeconds <= 0) {
-                return timeDelay;
-            }
-            // if last position was not in this same stop or there is no last position at all
-            if (!context || context.atStopStreak.stop_sequence !== thisStopSequence) {
-                // timeDelay >= 0 trip is DELAYED
-                // we presume it will lower delay by shortening its scheduled dwell time,
-                // cant go under zero of course, trip should not go ahead
-                // else trip is AHeAD
-                // left computed delay as it was
-                return timeDelay >= 0 ? Math.max(timeDelay - stopDwellTimeSeconds, 0) : timeDelay;
-            }
-            // we presume that first position at same stop is real arrival time
-            if (context.atStopStreak.firstPositionDelay >= 0) {
-                // trip was DELAYED before
-                // we presume it will lower delay by shortening its scheduled dwell time,
-                // cant go under zero of course, trip should not go ahead
-                return Math.max(timeDelay - stopDwellTimeSeconds, 0);
-            }
-            // trip was AHEAD before
-            // real dwell time so far
-            const realDwellTimeSeconds = Math.round((currentPosition.properties.origin_timestamp.getTime() - context.atStopStreak.firstPositionTimestamp) / 1000);
-            // if real dwell is longer than scheduled, then add to negative delay time
-            return context.atStopStreak.firstPositionDelay + Math.max(realDwellTimeSeconds - stopDwellTimeSeconds, 0);
-        };
-        /**
-         * Compute UTC timestamp of start of day when trip starts
-         *
-         * @param {number} startTimestamp - Unix timestamp of start of the trip
-         * @param {number} firstStopTimeScheduledSeconds - Number of seconds from midnight of first stop departure
-         * @returns {number} - Returns unix timestamp in milliseconds.
-         */
-        this.getStartDayTimestamp = (startTimestamp, firstStopTimeScheduledSeconds) => {
-            let startDayTimestamp = moment_timezone_1.default.utc(startTimestamp).tz("Europe/Prague").startOf("day");
-            const stopTimeDayOverflow = Math.floor(firstStopTimeScheduledSeconds / (60 * 60 * 24));
-            // if trip has 24+ stop times set real startDay to yesterday
-            if (stopTimeDayOverflow > 0) {
-                startDayTimestamp.subtract(1, "day");
-            }
-            return startDayTimestamp.valueOf();
-        };
-        this.determineStatePosition = (thisClosestPoint, lastTripPoint) => {
-            if (thisClosestPoint.last_stop_sequence >= lastTripPoint.last_stop_sequence) {
-                return const_1.StatePositionEnum.AFTER_TRACK;
-            }
-            else if (thisClosestPoint.this_stop_sequence) {
-                return const_1.StatePositionEnum.AT_STOP;
-            }
-            return const_1.StatePositionEnum.ON_TRACK;
-        };
+        // delay can not be negative if the vehicle is at the first stop
+        if (thisStopSequence === firstTripShapePoint.this_stop_sequence) {
+            timeDelayInSeconds = Math.max(timeDelayInSeconds, 0);
+        }
+    }
+    const statePosition = _a.determineStatePosition(thisClosestPoint, lastTripShapePoint);
+    const thisStopSequence = thisClosestPoint.this_stop_sequence;
+    const lastStopSequence = thisClosestPoint.last_stop_sequence;
+    const nextStopSequence = thisClosestPoint.next_stop_sequence;
+    // save it for result
+    const estimatedPoint = {
+        id: currentPosition.properties.id,
+        bearing: thisClosestPoint.bearing,
+        shape_dist_traveled: thisClosestPoint.shape_dist_traveled,
+        next_stop_id: tripStopTimes[nextStopSequence - 1].stop_id,
+        last_stop_id: tripStopTimes[lastStopSequence - 1].stop_id,
+        next_stop_name: tripStopTimes[nextStopSequence - 1].stop.stop_name,
+        last_stop_name: tripStopTimes[lastStopSequence - 1].stop.stop_name,
+        next_stop_sequence: nextStopSequence,
+        last_stop_sequence: lastStopSequence,
+        next_stop_arrival_time: DateTimeUtils_1.DateTimeUtils.getStopDateTimeForDayStart(tripStopTimes[nextStopSequence - 1].arrival_time_seconds, startDayTimestamp),
+        last_stop_arrival_time: DateTimeUtils_1.DateTimeUtils.getStopDateTimeForDayStart(tripStopTimes[lastStopSequence - 1].arrival_time_seconds, startDayTimestamp),
+        next_stop_departure_time: DateTimeUtils_1.DateTimeUtils.getStopDateTimeForDayStart(tripStopTimes[nextStopSequence - 1].departure_time_seconds, startDayTimestamp),
+        last_stop_departure_time: DateTimeUtils_1.DateTimeUtils.getStopDateTimeForDayStart(tripStopTimes[lastStopSequence - 1].departure_time_seconds, startDayTimestamp),
+        delay: statePosition === const_1.StatePositionEnum.AFTER_TRACK ? 0 : timeDelayInSeconds,
+        this_stop_id: (statePosition === const_1.StatePositionEnum.AT_STOP &&
+            thisStopSequence &&
+            tripStopTimes[thisStopSequence - 1].stop_id) ||
+            undefined,
+        this_stop_name: (statePosition === const_1.StatePositionEnum.AT_STOP &&
+            thisStopSequence &&
+            tripStopTimes[thisStopSequence - 1].stop.stop_name) ||
+            undefined,
+        this_stop_sequence: (statePosition === const_1.StatePositionEnum.AT_STOP && thisStopSequence) || undefined,
+        last_stop_headsign: tripStopTimes[lastStopSequence - 1].stop_headsign || undefined,
+        state_position: statePosition,
+        state_process: const_1.StateProcessEnum.PROCESSED,
+        valid_to: ValidToCalculator_1.default.getDefaultValidToAttribute(currentPosition.properties.origin_timestamp),
+        is_tracked: statePosition !== const_1.StatePositionEnum.AFTER_TRACK,
+    };
+    return estimatedPoint;
+};
+/**
+ * Corrects time delay at stop with dwelling time
+ *
+ * @param {number} timeDelay - Initial computed delay in seconds, can be negative for trip ahead
+ * @param {IVPTripsLastPositionContext | null} context - Context state, holds information about previous positions
+ * @param {Feature<Point, ICurrentPositionProperties>} currentPosition - Feature Point of current position
+ * @param {IShapeAnchorPoint} thisClosestPoint - Closest point of shape anchors
+ * @param { departureTime: number; arrivalTime: number } stopTimes - departure and arrival stop times in seconds
+ * @returns {number} - Result delay in seconds, can be negative for trip ahead
+ */
+RegionalBusPositionsManager.getCorrectedTimeDelay = (timeDelay, context, currentPosition, thisStopSequence, stopTimes) => {
+    // compute dwell time in stop, most common is zero
+    const stopDwellTimeSeconds = stopTimes.departureTime - stopTimes.arrivalTime;
+    // if dwell time is sheduled as zero, return initial computed delay
+    if (stopDwellTimeSeconds <= 0) {
+        return timeDelay;
+    }
+    // if last position was not in this same stop or there is no last position at all
+    if (!context || context.atStopStreak.stop_sequence !== thisStopSequence) {
+        // timeDelay >= 0 trip is DELAYED
+        // we presume it will lower delay by shortening its scheduled dwell time,
+        // cant go under zero of course, trip should not go ahead
+        // else trip is AHeAD
+        // left computed delay as it was
+        return timeDelay >= 0 ? Math.max(timeDelay - stopDwellTimeSeconds, 0) : timeDelay;
+    }
+    // we presume that first position at same stop is real arrival time
+    if (context.atStopStreak.firstPositionDelay >= 0) {
+        // trip was DELAYED before
+        // we presume it will lower delay by shortening its scheduled dwell time,
+        // cant go under zero of course, trip should not go ahead
+        return Math.max(timeDelay - stopDwellTimeSeconds, 0);
+    }
+    // trip was AHEAD before
+    // real dwell time so far
+    const realDwellTimeSeconds = Math.round((currentPosition.properties.origin_timestamp.getTime() - context.atStopStreak.firstPositionTimestamp) / 1000);
+    // if real dwell is longer than scheduled, then add to negative delay time
+    return context.atStopStreak.firstPositionDelay + Math.max(realDwellTimeSeconds - stopDwellTimeSeconds, 0);
+};
+/**
+ * Compute UTC timestamp of start of day when trip starts
+ *
+ * @param {number} startTimestamp - Unix timestamp of start of the trip
+ * @param {number} firstStopTimeScheduledSeconds - Number of seconds from midnight of first stop departure
+ * @returns {number} - Returns unix timestamp in milliseconds.
+ */
+RegionalBusPositionsManager.getStartDayTimestamp = (startTimestamp, firstStopTimeScheduledSeconds) => {
+    let startDayTimestamp = moment_timezone_1.default.utc(startTimestamp).tz("Europe/Prague").startOf("day");
+    const stopTimeDayOverflow = Math.floor(firstStopTimeScheduledSeconds / (60 * 60 * 24));
+    // if trip has 24+ stop times set real startDay to yesterday
+    if (stopTimeDayOverflow > 0) {
+        startDayTimestamp.subtract(1, "day");
+    }
+    return startDayTimestamp.valueOf();
+};
+RegionalBusPositionsManager.determineStatePosition = (thisClosestPoint, lastTripPoint) => {
+    if (thisClosestPoint.last_stop_sequence >= lastTripPoint.last_stop_sequence) {
+        return const_1.StatePositionEnum.AFTER_TRACK;
+    }
+    else if (thisClosestPoint.this_stop_sequence) {
+        return const_1.StatePositionEnum.AT_STOP;
     }
+    return const_1.StatePositionEnum.ON_TRACK;
 };
-exports.RegionalBusPositionsManager = RegionalBusPositionsManager = __decorate([
-    (0, tsyringe_1.injectable)(),
-    __param(0, (0, tsyringe_1.inject)(VPContainerToken_1.VPContainerToken.ValidToCalculator)),
-    __metadata("design:paramtypes", [ValidToCalculator_1.ValidToCalculator])
-], RegionalBusPositionsManager);
 //# sourceMappingURL=RegionalBusPositionsManager.js.map