@golemio/pid 2.2.11-dev.611073518 → 2.2.11-dev.615513481

package/dist/integration-engine/vehicle-positions/VehiclePositionsWorker.d.ts

@@ -80,87 +80,6 @@ export declare class VehiclePositionsWorker extends BaseWorker {
      * @returns {Object[]} - Arrays of inserted/updated positions and array of (inserted)/updated trips
      */
     private updateComputedPositionsAndTrips;
-    /**
-     * 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.
-     */
-    private getStartDayTimestamp;
-    /**
-     * Compute positions and return computed positions
-     *
-     * @param {ITripPositionsWithGTFS} tripPositions - Trip positions with shape anchors data
-     * @returns {Promise<IProcessedPositions>} - Returns computed/updated positions
-     */
-    private computePositions;
-    /**
-     * Decide how to process input position data
-     *
-     * @param {IPosition} position - Input vehiclepositions_positions row data
-     * @returns {PositionHandlerEnum} - Returns action handler enum
-     */
-    private setPositionUpdateHandler;
-    /**
-     * Takes position one by one, set proper handler for type of position, and do the process of position
-     *
-     * @param {number} i - Iteration
-     * @param {IUpdatePositionsIteratorOptions} options - Initial options
-     * @param {number} cb - Callback function of iterator
-     * @returns {void} - void
-     */
-    private updatePositionsIterator;
-    /**
-     * Returns unix in miliseconds for stop time
-     * + given by start of day when trip starts
-     * + and GTFS HH:mm:ss format of stop time in seconds
-     *
-     * @param {number} startDayTimestamp - Unix timestamp of local time midnight before trip starts
-     * @param {number} timeSeconds - Number of seconds given by HH:mm:ss format of GTFS stop time
-     * @returns {number} - Returns unix milisecods
-     */
-    private getLocalTimeToUnix;
-    /**
-     * Picks only one closest point for each segment/array of points of shape
-     *
-     * @param {IShapeAnchorPoint[][]} ptsInRadius - Feature Point of current position
-     * @param {Feature<Point, ICurrentPositionProperties>} currentPosition - Feature Point of current position
-     * @returns {IShapeAnchorPoint[]} - Result closest point for each segment
-     */
-    private getClosestPoints;
-    /**
-     * Corrects time delay at stop with dwelling time
-     *
-     * @param {number} timeDelay - Initial computed delay in seconds, can be negative for trip ahead
-     * @param {IPositionsContext | 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
-     */
-    private getCorrectedTimeDelay;
-    /**
-     * 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 {IPositionsContext | 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
-     */
-    private getClosestPoint;
-    /**
-     * 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 {IPositionsContext | 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
-     */
-    private getEstimatedPoint;
     /**
      * Returns shape anchor points along trip track shape with stop times parameters
      *

package/dist/integration-engine/vehicle-positions/VehiclePositionsWorker.js

@@ -51,24 +51,13 @@ const golemio_errors_1 = require("@golemio/core/dist/shared/golemio-errors");
 const golemio_validator_1 = require("@golemio/core/dist/shared/golemio-validator");
 const moment_timezone_1 = __importDefault(require("@golemio/core/dist/shared/moment-timezone"));
 const turf = __importStar(require("@turf/turf"));
-const cheap_ruler_1 = __importDefault(require("cheap-ruler"));
 const const_1 = require("../../const");
-const DPPUtils_1 = __importDefault(require("./helpers/DPPUtils"));
 const GtfsTripManager_1 = __importDefault(require("./helpers/GtfsTripManager"));
-const PositionCalculator_1 = __importDefault(require("./helpers/PositionCalculator"));
-const ValidToCalculator_1 = __importDefault(require("./helpers/ValidToCalculator"));
+const PositionsManager_1 = __importDefault(require("./helpers/PositionsManager"));
 const models_2 = require("./models");
 const transformations_1 = require("./transformations");
 const VehiclePositionsUtils_1 = require("./VehiclePositionsUtils");
 const GtfsOvapi = require("@golemio/ovapi-gtfs-realtime-bindings/dist/gtfs-realtime");
-var PositionHandlerEnum;
-(function (PositionHandlerEnum) {
-    PositionHandlerEnum["TRACKING"] = "TRACKING";
-    PositionHandlerEnum["NOT_TRACKING"] = "NOT_TRACKING";
-    PositionHandlerEnum["CANCELED"] = "CANCELED";
-    PositionHandlerEnum["DO_NOTHING"] = "DO_NOTHING";
-})(PositionHandlerEnum || (PositionHandlerEnum = {}));
-const ruler = (0, cheap_ruler_1.default)(50);
 const gtfsRealtime = GtfsOvapi.transit_realtime;
 class VehiclePositionsWorker extends workers_1.BaseWorker {
     constructor() {
@@ -463,7 +452,7 @@ class VehiclePositionsWorker extends workers_1.BaseWorker {
                                 return;
                             }
                         }
-                        return this.computePositions(trip, inputData.schedule);
+                        return PositionsManager_1.default.computePositions(trip, inputData.schedule);
                     })));
                     const validProcessedPositions = processedPositions.filter((e) => !!e);
                     yield this.updateComputedPositionsAndTrips(validProcessedPositions);
@@ -646,447 +635,6 @@ class VehiclePositionsWorker extends workers_1.BaseWorker {
                 tripsUpdated,
             };
         });
-        /**
-         * 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();
-        };
-        /**
-         * 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, schedule) => __awaiter(this, void 0, void 0, function* () {
-            const startTimestamp = parseInt(tripPositions.start_timestamp, 10);
-            const startDayTimestamp = this.getStartDayTimestamp(startTimestamp, tripPositions.gtfsData.shapes_anchor_points[0].time_scheduled_seconds);
-            const gtfsRouteType = tripPositions.gtfs_route_type;
-            return new Promise((resolve) => {
-                const context = {
-                    atStopStreak: {
-                        stop_sequence: null,
-                        firstPositionTimestamp: null,
-                        firstPositionDelay: null,
-                    },
-                    lastPositionLastStop: {
-                        id: null,
-                        sequence: null,
-                        arrival_time: null,
-                        departure_time: null,
-                    },
-                    lastPositionDelay: null,
-                    lastPositionId: null,
-                    lastPositionOriginTimestamp: null,
-                    lastPositionTracking: null,
-                    lastPositionCanceled: null,
-                    lastPositionBeforeTrackDelayed: null,
-                    isLastPositionAfterTrack: false,
-                    tripId: tripPositions.id,
-                };
-                const computedPositions = [];
-                this.updatePositionsIterator(0, { tripPositions, startTimestamp, startDayTimestamp, context, computedPositions, gtfsRouteType }, schedule, () => {
-                    resolve({
-                        context,
-                        positions: computedPositions,
-                    });
-                });
-            });
-        });
-        /**
-         * Decide how to process input position data
-         *
-         * @param {IPosition} 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.DO_NOTHING;
-            if (position.is_canceled)
-                return PositionHandlerEnum.CANCELED;
-            if (position.lat && position.lng && position.tracking === const_1.PositionTrackingEnum.TRACKING)
-                return PositionHandlerEnum.TRACKING;
-            if (position.tracking !== const_1.PositionTrackingEnum.TRACKING)
-                return PositionHandlerEnum.NOT_TRACKING;
-            return PositionHandlerEnum.NOT_TRACKING;
-        };
-        /**
-         * Takes position one by one, set proper handler for type of position, and do the process of position
-         *
-         * @param {number} i - Iteration
-         * @param {IUpdatePositionsIteratorOptions} options - Initial options
-         * @param {number} cb - Callback function of iterator
-         * @returns {void} - void
-         */
-        this.updatePositionsIterator = (i, options, schedule, cb) => __awaiter(this, void 0, void 0, function* () {
-            const { tripPositions, startDayTimestamp, startTimestamp, context, computedPositions, gtfsRouteType } = options;
-            if (i === tripPositions.positions.length) {
-                return cb();
-            }
-            const position = tripPositions.positions[i];
-            let positionToUpdate = null;
-            // situations
-            switch (this.setPositionUpdateHandler(position)) {
-                case PositionHandlerEnum.TRACKING:
-                    const currentPosition = turf.point([position.lng, position.lat], {
-                        id: position.id,
-                        origin_time: position.origin_time,
-                        origin_timestamp: position.origin_timestamp,
-                        tcp_event: position.tcp_event,
-                    });
-                    positionToUpdate = yield this.getEstimatedPoint(tripPositions.gtfsData, currentPosition, context, startDayTimestamp, tripPositions.gtfs_route_type);
-                    break;
-                case PositionHandlerEnum.NOT_TRACKING:
-                    // if there is no previous positions with tracking status, set position as before_track
-                    const firstShapesAnchorPoint = tripPositions.gtfsData.shapes_anchor_points[0];
-                    if (context.lastPositionTracking === null) {
-                        const firstStopTime = tripPositions.gtfsData.stop_times[0];
-                        // if there is propagated delay within 10 minutes we can use it for new position
-                        const canDuplicatePropagatedDelay = context.lastPositionBeforeTrackDelayed !== null &&
-                            position.origin_timestamp - context.lastPositionBeforeTrackDelayed.origin_timestamp <= 10 * 60 * 1000;
-                        // if there is no delay to duplicate and DPP trip is far from start then invisible
-                        const setAsInvisible = !canDuplicatePropagatedDelay &&
-                            DPPUtils_1.default.isInvisible(tripPositions.agency_name_scheduled, position.origin_timestamp, startTimestamp, [position.lng, position.lat], firstShapesAnchorPoint.coordinates, schedule, tripPositions.gtfs_trip_id, context.lastPositionTracking, position.tracking);
-                        positionToUpdate = Object.assign({ id: position.id, next_stop_arrival_time: startDayTimestamp + firstStopTime.arrival_time_seconds * 1000, next_stop_departure_time: 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: setAsInvisible ? const_1.StatePositionEnum.INVISIBLE : const_1.StatePositionEnum.BEFORE_TRACK, state_process: const_1.StateProcessEnum.PROCESSED }, (firstStopTime.stop_headsign && {
-                            last_stop_headsign: firstStopTime.stop_headsign,
-                        }));
-                        if (!setAsInvisible && canDuplicatePropagatedDelay) {
-                            positionToUpdate.delay = context.lastPositionBeforeTrackDelayed.delay;
-                        }
-                    }
-                    else {
-                        // if there is tracking 2 position with same origin_timestamp then this position is duplicate
-                        const statePosition = tripPositions.positions.find((e) => e.origin_timestamp === position.origin_timestamp && e.tracking === const_1.PositionTrackingEnum.TRACKING)
-                            ? 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];
-                        // set as invisible if there are some AFTER_TRACK before
-                        const setAsInvisible = DPPUtils_1.default.isInvisible(tripPositions.agency_name_scheduled, position.origin_timestamp, startTimestamp, [position.lng, position.lat], firstShapesAnchorPoint.coordinates, schedule, tripPositions.gtfs_trip_id, context.lastPositionTracking, position.tracking) && statePosition === const_1.StatePositionEnum.AFTER_TRACK;
-                        positionToUpdate = Object.assign({ id: position.id, last_stop_arrival_time: startDayTimestamp + lastShapesAnchorPoint.time_scheduled_seconds * 1000, last_stop_departure_time: 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: setAsInvisible ? const_1.StatePositionEnum.INVISIBLE : statePosition, state_process: const_1.StateProcessEnum.PROCESSED }, (lastStopTime.stop_headsign && {
-                            last_stop_headsign: lastStopTime.stop_headsign,
-                        }));
-                    }
-                    break;
-                case PositionHandlerEnum.CANCELED:
-                    positionToUpdate = {
-                        id: position.id,
-                        state_position: const_1.StatePositionEnum.CANCELED,
-                        state_process: const_1.StateProcessEnum.PROCESSED,
-                    };
-                    break;
-                case PositionHandlerEnum.DO_NOTHING:
-                    break;
-                default:
-                    break;
-            }
-            // if not null push to update
-            if (positionToUpdate) {
-                positionToUpdate.valid_to = ValidToCalculator_1.default.getValidToAttribute(positionToUpdate, position, gtfsRouteType, tripPositions.gtfsData, startTimestamp, startDayTimestamp);
-                computedPositions.push(positionToUpdate);
-            }
-            // set if last position is AFTER_TRACK
-            context.isLastPositionAfterTrack =
-                (positionToUpdate === null || positionToUpdate === void 0 ? void 0 : positionToUpdate.state_position) === const_1.StatePositionEnum.AFTER_TRACK ||
-                    position.state_position === const_1.StatePositionEnum.AFTER_TRACK;
-            // set last known BEFORE_TRACK_DELAYED position
-            if (position.state_position === const_1.StatePositionEnum.BEFORE_TRACK_DELAYED) {
-                context.lastPositionBeforeTrackDelayed = {
-                    delay: position.delay,
-                    origin_timestamp: 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;
-                context.atStopStreak.firstPositionDelay = positionToUpdate ? positionToUpdate.delay : position.delay;
-            }
-            // IF currently updated position / position was processed before
-            // and it is NOT AT_STOP
-            if (positionToUpdate ? !positionToUpdate.this_stop_sequence : !position.this_stop_sequence) {
-                // THEN disrupt atStopStreak
-                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 &&
-                (positionToUpdate === null || positionToUpdate === void 0 ? void 0 : positionToUpdate.state_position) !== const_1.StatePositionEnum.INVISIBLE) {
-                context.lastPositionId = position.id;
-                context.lastPositionCanceled = position.is_canceled;
-                context.lastPositionOriginTimestamp = position.origin_timestamp;
-            }
-            // set delay
-            context.lastPositionDelay = positionToUpdate ? positionToUpdate.delay : position.delay;
-            this.updatePositionsIterator(i + 1, options, schedule, cb);
-        });
-        /**
-         * Returns unix in miliseconds for stop time
-         * + given by start of day when trip starts
-         * + and GTFS HH:mm:ss format of stop time in seconds
-         *
-         * @param {number} startDayTimestamp - Unix timestamp of local time midnight before trip starts
-         * @param {number} timeSeconds - Number of seconds given by HH:mm:ss format of GTFS stop time
-         * @returns {number} - Returns unix milisecods
-         */
-        this.getLocalTimeToUnix = (startDayTimestamp, timeSeconds) => {
-            return (0, moment_timezone_1.default)(startDayTimestamp)
-                .tz("Europe/Prague")
-                .startOf("day")
-                .hours(Math.floor(timeSeconds / 3600))
-                .minutes(Math.floor((timeSeconds % 3600) / 60))
-                .seconds(timeSeconds % 60)
-                .valueOf();
-        };
-        /**
-         * Picks only one closest point for each segment/array of points of shape
-         *
-         * @param {IShapeAnchorPoint[][]} ptsInRadius - Feature Point of current position
-         * @param {Feature<Point, ICurrentPositionProperties>} currentPosition - Feature Point of current position
-         * @returns {IShapeAnchorPoint[]} - Result closest point for each segment
-         */
-        this.getClosestPoints = (ptsInRadius, currentPosition) => __awaiter(this, void 0, void 0, function* () {
-            const closestPts = [];
-            const innerPtsInRadiusIterator = (i, options, cb) => {
-                // end of iteration
-                if (ptsInRadius[i].length === options.k) {
-                    return cb(options.nPt);
-                }
-                const distance = ruler.distance(currentPosition.geometry.coordinates, ptsInRadius[i][options.k].coordinates);
-                if (distance < options.nPt.distance) {
-                    options.nPt = ptsInRadius[i][options.k];
-                    options.nPt.distance = distance;
-                }
-                // next step
-                options.k++;
-                innerPtsInRadiusIterator(i, options, cb);
-            };
-            const ptsInRadiusIterator = (i, cb) => {
-                // end of iteration
-                if (ptsInRadius.length === i) {
-                    return cb();
-                }
-                const nPt = { distance: Infinity };
-                innerPtsInRadiusIterator(i, {
-                    k: 0,
-                    nPt,
-                }, (res) => {
-                    // so now you have all possible nearest points on shape
-                    // (could be more if shape line is overlaping itself)
-                    closestPts.push(res);
-                    // next step
-                    ptsInRadiusIterator(i + 1, cb);
-                });
-            };
-            return new Promise((resolve) => {
-                ptsInRadiusIterator(0, () => {
-                    resolve(closestPts);
-                });
-            });
-        });
-        /**
-         * Corrects time delay at stop with dwelling time
-         *
-         * @param {number} timeDelay - Initial computed delay in seconds, can be negative for trip ahead
-         * @param {IPositionsContext | 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, thisClosestPoint, 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 !== thisClosestPoint.this_stop_sequence) {
-                // 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 - 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);
-        };
-        /**
-         * 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 {IPositionsContext | 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, closestPts, tripGtfsData, gtfsRouteType) => __awaiter(this, void 0, void 0, function* () {
-            // 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 lastTripShapePoint = tripShapePoints[tripShapePoints.length - 1];
-            const closestPtsIterator = (i, prevTimeDelay, estimatedPoint, cb) => {
-                // end of iteration
-                if (closestPts.length === i) {
-                    return cb(estimatedPoint);
-                }
-                let thisClosestPoint = closestPts[i];
-                const timeScheduledTimestamp = this.getLocalTimeToUnix(startDayTimestamp, 
-                // 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);
-                let timeDelay = moment_timezone_1.default
-                    .utc(currentPosition.properties.origin_timestamp)
-                    .diff(timeScheduledTimestamp, "seconds");
-                // time where the bus should on this point
-                const timeProposed = thisClosestPoint.time_scheduled_seconds + prevTimeDelay;
-                // difference
-                const timeRealDiff = thisClosestPoint.time_scheduled_seconds + timeDelay - timeProposed;
-                // we look for the best fitting point
-                if (Math.abs(timeRealDiff) < Math.abs(minTimeRealDiff)) {
-                    const isBusOrTram = gtfsRouteType === models_2.GTFSRouteTypeEnum.BUS || gtfsRouteType === models_2.GTFSRouteTypeEnum.TRAM;
-                    minTimeRealDiff = timeRealDiff;
-                    // push trip into nearest at_stop shape anchor point if trip "P" event (tram) / "V" event (bus)
-                    if (isBusOrTram &&
-                        currentPosition.properties.tcp_event === const_1.TCPEventEnum.ARRIVAL_ANNOUNCED &&
-                        thisClosestPoint.this_stop_sequence === null) {
-                        let movingShapePointIndex = thisClosestPoint.index;
-                        while (thisClosestPoint.this_stop_sequence === null && movingShapePointIndex < lastTripShapePoint.index) {
-                            movingShapePointIndex++;
-                            thisClosestPoint = tripShapePoints[movingShapePointIndex];
-                        }
-                    }
-                    let statePosition = thisClosestPoint.this_stop_sequence ? const_1.StatePositionEnum.AT_STOP : const_1.StatePositionEnum.ON_TRACK;
-                    // test if TCP trip with DEPARTURED event should not bet at stop (not applied for last stop)
-                    if (currentPosition.properties.tcp_event === const_1.TCPEventEnum.DEPARTURED &&
-                        thisClosestPoint.this_stop_sequence !== lastTripShapePoint.this_stop_sequence) {
-                        statePosition = const_1.StatePositionEnum.ON_TRACK;
-                    }
-                    // interpret the position state on the "V" event for trams and buses as "after track"
-                    if (isBusOrTram && currentPosition.properties.tcp_event === const_1.TCPEventEnum.V) {
-                        statePosition = const_1.StatePositionEnum.AFTER_TRACK;
-                        thisClosestPoint = lastTripShapePoint;
-                        timeDelay = null;
-                    }
-                    // lets correct delay if it is at stop
-                    if (thisClosestPoint.this_stop_sequence && timeDelay) {
-                        timeDelay = this.getCorrectedTimeDelay(timeDelay, context, currentPosition, thisClosestPoint, {
-                            departureTime: tripStopTimes[thisClosestPoint.this_stop_sequence - 1].departure_time_seconds,
-                            arrivalTime: tripStopTimes[thisClosestPoint.this_stop_sequence - 1].arrival_time_seconds,
-                        });
-                    }
-                    // save it for result
-                    estimatedPoint = {
-                        id: currentPosition.properties.id,
-                        bearing: thisClosestPoint.bearing,
-                        shape_dist_traveled: Math.round(thisClosestPoint.shape_dist_traveled * 1000) / 1000,
-                        next_stop_id: tripStopTimes[thisClosestPoint.next_stop_sequence - 1].stop_id,
-                        last_stop_id: tripStopTimes[thisClosestPoint.last_stop_sequence - 1].stop_id,
-                        next_stop_name: tripStopTimes[thisClosestPoint.next_stop_sequence - 1].stop.stop_name,
-                        last_stop_name: tripStopTimes[thisClosestPoint.last_stop_sequence - 1].stop.stop_name,
-                        next_stop_sequence: thisClosestPoint.next_stop_sequence,
-                        last_stop_sequence: thisClosestPoint.last_stop_sequence,
-                        next_stop_arrival_time: this.getLocalTimeToUnix(startDayTimestamp, tripStopTimes[thisClosestPoint.next_stop_sequence - 1].arrival_time_seconds),
-                        last_stop_arrival_time: this.getLocalTimeToUnix(startDayTimestamp, tripStopTimes[thisClosestPoint.last_stop_sequence - 1].arrival_time_seconds),
-                        next_stop_departure_time: this.getLocalTimeToUnix(startDayTimestamp, tripStopTimes[thisClosestPoint.next_stop_sequence - 1].departure_time_seconds),
-                        last_stop_departure_time: this.getLocalTimeToUnix(startDayTimestamp, tripStopTimes[thisClosestPoint.last_stop_sequence - 1].departure_time_seconds),
-                        delay: timeDelay,
-                        this_stop_id: (statePosition === const_1.StatePositionEnum.AT_STOP &&
-                            thisClosestPoint.this_stop_sequence &&
-                            tripStopTimes[thisClosestPoint.this_stop_sequence - 1].stop_id) ||
-                            undefined,
-                        this_stop_name: (statePosition === const_1.StatePositionEnum.AT_STOP &&
-                            thisClosestPoint.this_stop_sequence &&
-                            tripStopTimes[thisClosestPoint.this_stop_sequence - 1].stop.stop_name) ||
-                            undefined,
-                        this_stop_sequence: (statePosition === const_1.StatePositionEnum.AT_STOP && thisClosestPoint.this_stop_sequence) || undefined,
-                        last_stop_headsign: tripStopTimes[thisClosestPoint.last_stop_sequence - 1].stop_headsign || undefined,
-                        state_position: statePosition,
-                        state_process: const_1.StateProcessEnum.PROCESSED,
-                        valid_to: ValidToCalculator_1.default.getDefaultValidToAttribute(currentPosition.properties.origin_timestamp),
-                    };
-                }
-                // next step
-                closestPtsIterator(i + 1, prevTimeDelay, estimatedPoint, cb);
-            };
-            return new Promise((resolve) => {
-                var _a, _b;
-                closestPtsIterator(0, (_b = (_a = context === null || context === void 0 ? void 0 : context.lastPositionTracking) === null || _a === void 0 ? void 0 : _a.properties.delay) !== null && _b !== void 0 ? _b : 0, null, (estimatedPoint) => {
-                    resolve(estimatedPoint);
-                });
-            });
-        });
-        /**
-         * 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 {IPositionsContext | 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, gtfsRouteType) => __awaiter(this, void 0, void 0, function* () {
-            var _e, _f, _g, _h, _j, _k;
-            // init radius around GPS position ( 200 meters radius, 16 points polygon aka circle)
-            const radius = 0.2;
-            //Initial value
-            let estimatedPoint = Object.assign({ id: currentPosition.properties.id, state_position: const_1.StatePositionEnum.OFF_TRACK, state_process: const_1.StateProcessEnum.PROCESSED, tcp_event: currentPosition.properties.tcp_event, valid_to: ValidToCalculator_1.default.getDefaultValidToAttribute(currentPosition.properties.origin_timestamp) }, (context &&
-                ((_e = context.lastPositionTracking) === null || _e === void 0 ? void 0 : _e.properties.last_stop_sequence) && {
-                shape_dist_traveled: (_f = context.lastPositionTracking) === null || _f === void 0 ? void 0 : _f.properties.shape_dist_traveled,
-                last_stop_arrival_time: (_g = context.lastPositionTracking) === null || _g === void 0 ? void 0 : _g.properties.last_stop_arrival_time,
-                last_stop_departure_time: (_h = context.lastPositionTracking) === null || _h === void 0 ? void 0 : _h.properties.last_stop_departure_time,
-                last_stop_sequence: (_j = context.lastPositionTracking) === null || _j === void 0 ? void 0 : _j.properties.last_stop_sequence,
-                last_stop_id: (_k = context.lastPositionTracking) === null || _k === void 0 ? void 0 : _k.properties.last_stop_id,
-            }));
-            // returns array of segments (row of points) of shape anchor points around gps
-            const ptsInRadius = yield PositionCalculator_1.default.getShapePointsAroundPosition(tripGtfsData.shapes_anchor_points, currentPosition, radius, tripGtfsData.trip_id);
-            if (ptsInRadius.length < 1) {
-                return estimatedPoint;
-            }
-            // picks only closest point for each segment
-            const closestPts = yield this.getClosestPoints(ptsInRadius, currentPosition);
-            if (closestPts.length < 1) {
-                return estimatedPoint;
-            }
-            // DECIDE WHICH POINT IS PROBABLY RIGHT
-            return this.getClosestPoint(currentPosition, context, startDayTimestamp, closestPts, tripGtfsData, gtfsRouteType);
-        });
         /**
          * Returns shape anchor points along trip track shape with stop times parameters
          *