incyclist-services 1.5.3 → 1.5.5

package/lib/devices/ride/service.js

@@ -129,9 +129,11 @@ let DeviceRideService = (() => {
                 return this.rideAdapters;
             this.rideAdapters = this.adapters = this.getConfiguredAdapters(true);
             const controlDevice = (_b = (_a = this.adapters.find(d => d.capabilities.includes('control'))) !== null && _a !== void 0 ? _a : this.adapters.find(d => d.capabilities.includes('power'))) !== null && _b !== void 0 ? _b : this.adapters.find(d => d.capabilities.includes('speed'));
-            this.rideAdapters.forEach(ai => {
-                ai.isControl = (ai.udid === controlDevice.udid);
-            });
+            if (controlDevice) {
+                this.rideAdapters.forEach(ai => {
+                    ai.isControl = (ai.udid === controlDevice.udid);
+                });
+            }
             if (!this.simulatorEnforced)
                 return this.adapters;
             const adapter = incyclist_devices_1.AdapterFactory.create({ interface: 'simulator', name: 'Simulator' });

package/lib/ride/display/service.js

@@ -130,7 +130,7 @@ let RideDisplayService = (() => {
                 this.logEvent({ message: 'overlay shown', overlay: 'start overlay' });
             }
             catch (err) {
-                this.logError(err, 'stop');
+                this.logError(err, 'start');
             }
         }
         startWithMissingSensors() {
@@ -409,7 +409,7 @@ let RideDisplayService = (() => {
                     this.state = 'Idle';
                 }
                 catch (err) {
-                    this.logError(err, 'stop');
+                    this.logError(err, 'stopRide');
                 }
                 delete this.type;
                 delete this.displayService;

package/lib/ride/route/GpxDisplayService.js

@@ -164,9 +164,8 @@ let GpxDisplayService = (() => {
                 const rideView = this.getUserSettings().get('preferences.rideView', 'sv');
                 if (rideView === 'sv') {
                     const updatePending = (Date.now() - ((_b = this.tsPrevSVUpdate) !== null && _b !== void 0 ? _b : 0)) > this.getDefaultUpdateFrequency();
-                    const stillBusy = (!this.tsPositionUpdateConfirmed && (Date.now() - ((_c = this.tsPrevSVUpdate) !== null && _c !== void 0 ? _c : 0)) < 500) || (Date.now() - this.tsLastSVEvent) < this.getMinimalPause();
+                    const stillBusy = (!this.tsPositionUpdateConfirmed && (Date.now() - ((_c = this.tsPrevSVUpdate) !== null && _c !== void 0 ? _c : 0)) < 500) || (Date.now() - ((_d = this.tsLastSVEvent) !== null && _d !== void 0 ? _d : 0)) < this.getMinimalPause();
                     const updatePossible = this.tsPositionUpdateConfirmed && (Date.now() - this.tsLastSVEvent) > this.getBestCaseUpdateFrequency();
-                    console.log('# service.onPositionUpdate', rideView, this.tsLastSVEvent - ((_d = this.tsPrevSVUpdate) !== null && _d !== void 0 ? _d : 0), Object.assign({ stillBusy, updatePossible, updatePending }, state));
                     if ((!stillBusy || !this.tsPrevSVUpdate) && (updatePending || updatePossible)) {
                         if (position) {
                             const freq = this.tsPrevSVUpdate ? Date.now() - this.tsPrevSVUpdate : undefined;
@@ -180,6 +179,17 @@ let GpxDisplayService = (() => {
                             delete this.tsLastSVEvent;
                         }
                     }
+                    else {
+                        const duration = this.tsPrevSVUpdate ? Date.now() - this.tsPrevSVUpdate : undefined;
+                        if (stillBusy) {
+                            this.logEvent({ message: 'street view position update skipped', reason: 'busy', duration });
+                            if (duration > 10000) {
+                                delete this.tsPrevSVUpdate;
+                                delete this.tsPositionUpdateConfirmed;
+                                delete this.tsLastSVEvent;
+                            }
+                        }
+                    }
                 }
                 else {
                     console.log('# position update', this.position);

package/lib/routes/base/parsers/incyclist.js

@@ -58,8 +58,14 @@ class IncyclistXMLParser extends xml_1.XMLParser {
             try {
                 if (context.data['autoCorrect']) {
                     const gpx = yield new gpx_1.GPXParser({ addTime: true, keepZero: true }).import(gpxFile);
-                    route.points = gpx.details.points;
-                    (0, points_1.fixAnomalies)(route.points);
+                    const points = [...gpx.details.points];
+                    const { fixed, time, error } = (0, points_1.fixAnomalies)(points);
+                    this.logger.logEvent({ message: 'gpx file autocorrect', cntFixed: fixed, duration: time, error: error === null || error === void 0 ? void 0 : error.message });
+                    if (error) {
+                        route.points = gpx.details.points;
+                    }
+                    route.points = route.points.filter(p => p.distance !== 0);
+                    route.points.forEach((p, idx) => { p.cnt = idx; });
                     (0, utils_2.validateRoute)(route);
                 }
                 else {

package/lib/routes/base/utils/points.d.ts

@@ -12,6 +12,7 @@ interface Anomaly {
     retry?: number;
 }
 export declare const calculateSpeed: (points: RoutePoint[], idx: number) => number;
+export declare const getPointsWithSpeed: (points: RoutePoint[]) => RoutePointEval[];
 export declare const detectAnomalies: (points: RoutePoint[], maxCount?: number) => Anomaly[];
 export declare const fixAnomaly: (anomaly: Anomaly, points: RoutePoint[]) => void;
 export declare const fixAnomalies: (points: RoutePoint[], maxAttempts?: number) => {

package/lib/routes/base/utils/points.js

@@ -1,7 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.fixAnomalies = exports.fixAnomaly = exports.detectAnomalies = exports.calculateSpeed = void 0;
-const MAX_LOOKUP = 50;
+exports.fixAnomalies = exports.fixAnomaly = exports.detectAnomalies = exports.getPointsWithSpeed = exports.calculateSpeed = void 0;
+const MAX_LOOKUP = 100;
+const isJump = (v1, v2) => {
+    if (v2 === v1 || v1 < 0.2 || v2 < 0.2)
+        return false;
+    return (Math.abs(v2 - v1) > 3) ||
+        (v2 > v1 * 1.4 && Math.abs(v2 - v1) > 2);
+};
 const calculateSpeed = (points, idx) => {
     const p = points === null || points === void 0 ? void 0 : points[idx];
     if (!p || idx === 0)
@@ -11,51 +17,73 @@ const calculateSpeed = (points, idx) => {
     return speed;
 };
 exports.calculateSpeed = calculateSpeed;
-const detectAnomalies = (points, maxCount) => {
-    if (points[0].time === undefined)
-        return [];
-    const data = points.map((p, idx) => {
+const getPointsWithSpeed = (points) => {
+    return points.map((p, idx) => {
         const d = Object.assign({}, p);
         d.speed = (0, exports.calculateSpeed)(points, idx);
         return d;
     });
+};
+exports.getPointsWithSpeed = getPointsWithSpeed;
+const detectAnomalies = (points, maxCount) => {
+    if (points[0].time === undefined)
+        return [];
+    const data = (0, exports.getPointsWithSpeed)(points);
     const anomalies = [];
     let lastValidSpeedIdx = 0;
     let done = false;
     const isSpeedJump = (p1, p2) => {
-        return p2.speed && p1.speed &&
-            p2.speed > p1.speed * 1.5 && p2.speed > 2 ||
-            Math.abs(p2.speed - p1.speed) > 3;
+        return isJump(p1.speed, p2.speed);
     };
-    data.forEach((point, idx) => {
-        var _a;
-        if (idx === 0 || done)
+    const isCloseToNull = (p) => {
+        return (p.distance < 0.5 || p.speed < 0.5);
+    };
+    const onNullValueDetected = (point, idx) => {
+        const speedPrev = data[idx - 1].speed;
+        if (speedPrev < 2)
             return;
-        if (point.speed === 0 || point.distance === 0) {
-            let nextJumpIdx;
-            const idxPrev = lastValidSpeedIdx === 0 ? idx - 1 : lastValidSpeedIdx;
-            for (let j = idx + 1; j < idx + MAX_LOOKUP && nextJumpIdx === undefined; j++) {
-                if (isSpeedJump(data[idxPrev], data[j])) {
-                    nextJumpIdx = j;
-                }
+        const speedNext = data[idx + 1].speed;
+        if (speedPrev > speedNext && !isJump(speedPrev / 2, speedNext)) {
+            anomalies.push({ idx: idx - 1, type: 'speedJump', point, nextNullIdx: idx });
+        }
+        let nextJumpIdx;
+        const idxPrev = lastValidSpeedIdx === 0 ? idx - 1 : lastValidSpeedIdx;
+        for (let j = idx + 1; j < idx + MAX_LOOKUP && nextJumpIdx === undefined; j++) {
+            if (isSpeedJump(data[idxPrev], data[j])) {
+                nextJumpIdx = j;
             }
-            anomalies.push({ idx, type: 'noDistance', point, nextJumpIdx });
         }
+        anomalies.push({ idx, type: 'noDistance', point, nextJumpIdx });
+    };
+    const onSpeedJumpDetected = (point, idx) => {
         const prevPoint = data[lastValidSpeedIdx];
-        const speedJump = isSpeedJump(prevPoint, point);
-        if (speedJump) {
-            if (prevPoint.speed === 0) {
-                anomalies.push({ idx: lastValidSpeedIdx, type: 'noDistance', point });
-            }
-            else {
-                let nextNullIdx;
-                for (let j = idx + 1; j < idx + MAX_LOOKUP && nextNullIdx === undefined; j++) {
-                    if (data[j].distance < 0.5 || data[j].speed < 0.5) {
-                        nextNullIdx = j;
-                    }
+        let nextJumpIdx, nextNullIdx;
+        if (prevPoint.speed === 0) {
+            anomalies.push({ idx: lastValidSpeedIdx, type: 'noDistance', point });
+        }
+        else {
+            let nextJumpFound = false;
+            for (let j = idx + 1; j < idx + MAX_LOOKUP && !nextJumpFound && nextNullIdx === undefined; j++) {
+                if (isCloseToNull(data[j])) {
+                    nextNullIdx = j;
+                }
+                else if (j > idx + 1 && isSpeedJump(data[j], data[j - 1])) {
+                    nextJumpFound = true;
+                    continue;
                 }
-                anomalies.push({ idx, type: 'speedJump', point, nextNullIdx });
             }
+            anomalies.push({ idx, type: 'speedJump', point, nextNullIdx, nextJumpIdx });
+        }
+    };
+    data.forEach((point, idx) => {
+        var _a;
+        if (idx === 0 || done)
+            return;
+        if (point.speed === 0 || point.distance === 0) {
+            onNullValueDetected(point, idx);
+        }
+        else if (isSpeedJump(data[lastValidSpeedIdx], point)) {
+            onSpeedJumpDetected(point, idx);
         }
         if (!!maxCount && anomalies.length > maxCount - 1) {
             done = true;
@@ -70,119 +98,10 @@ const detectAnomalies = (points, maxCount) => {
 exports.detectAnomalies = detectAnomalies;
 const fixAnomaly = (anomaly, points) => {
     if (anomaly.type === 'speedJump') {
-        if (anomaly.nextNullIdx !== undefined && anomaly.retry > 0) {
-            const idx = anomaly.idx;
-            const idxNull = anomaly.nextNullIdx;
-            let offset;
-            if (idxNull === idx + 1) {
-                offset = ((0, exports.calculateSpeed)(points, idx) - (0, exports.calculateSpeed)(points, idxNull)) / 2;
-                const t = points[idx].time - points[idx - 1].time;
-                const vPrev = (0, exports.calculateSpeed)(points, idx);
-                const v = vPrev - offset;
-                const d = v * t;
-                const dOffset = points[idx].distance - d;
-                points[idx].distance = d;
-                points[idx].routeDistance -= dOffset;
-                const t0 = points[idxNull].time - points[idxNull - 1].time;
-                const v0 = offset;
-                points[idxNull].distance += v0 * t0;
-            }
-            else {
-                const offsetEnd = (0, exports.calculateSpeed)(points, idxNull - 1) - (0, exports.calculateSpeed)(points, idx - 1);
-                const offsetStart = (0, exports.calculateSpeed)(points, idx) - (0, exports.calculateSpeed)(points, idx - 1);
-                const offsetAverage = (offsetStart + offsetEnd) / 2;
-            }
-        }
-        if (anomaly.nextNullIdx !== undefined) {
-            const idx = anomaly.idx;
-            const idxNull = anomaly.nextNullIdx;
-            const offsetNext = idxNull === idx + 1 ? (0, exports.calculateSpeed)(points, idx) / 2 : (0, exports.calculateSpeed)(points, idxNull - 1);
-            const offsetPrev = idxNull === idx + 1 ? offsetNext : (0, exports.calculateSpeed)(points, idx) - (0, exports.calculateSpeed)(points, idx - 1);
-            const offset = (offsetNext + offsetPrev) / 2;
-            const t = points[idx].time - points[idx - 1].time;
-            const vPrev = (0, exports.calculateSpeed)(points, idx);
-            const v = vPrev - offset;
-            const d = v * t;
-            const dOffset = points[idx].distance - d;
-            points[idx].distance = d;
-            points[idx].routeDistance -= dOffset;
-            for (let j = idx + 1; j < idxNull; j++) {
-                points[j].routeDistance -= dOffset;
-            }
-            const t0 = points[idxNull].time - points[idxNull - 1].time;
-            const v0 = offset;
-            points[idxNull].distance = v0 * t0;
-        }
-        else {
-            const idx = anomaly.idx;
-            const next = points === null || points === void 0 ? void 0 : points[idx + 1];
-            const prev = points === null || points === void 0 ? void 0 : points[idx - 1];
-            if (next && prev) {
-                next.distance = next.routeDistance - prev.routeDistance;
-            }
-            points.splice(idx, 1);
-        }
+        fixSpeedJump(anomaly, points);
     }
     else if (anomaly.type === 'noDistance') {
-        const idx = anomaly.idx;
-        const next = points === null || points === void 0 ? void 0 : points[idx + 1];
-        const prev = points === null || points === void 0 ? void 0 : points[idx - 1];
-        if (anomaly.nextJumpIdx !== undefined) {
-            const endIdx = anomaly.nextJumpIdx;
-            const vEnd = (0, exports.calculateSpeed)(points, endIdx);
-            const vStart = (0, exports.calculateSpeed)(points, endIdx - 1);
-            if (endIdx === idx + 1) {
-                const offset = vEnd / 2;
-                const t0 = points[idx].time - points[idx - 1].time;
-                const v0 = offset;
-                const d0 = v0 * t0;
-                points[idx].distance = d0;
-                points[idx].routeDistance += d0;
-                const t = points[endIdx].time - points[endIdx - 1].time;
-                const vPrev = (0, exports.calculateSpeed)(points, endIdx);
-                const v = vPrev - offset;
-                const d = v * t;
-                points[endIdx].distance = d;
-            }
-            else {
-                const offset = vEnd - vStart;
-                for (let j = anomaly.idx; j < endIdx; j++) {
-                    const t = points[j].time - points[j - 1].time;
-                    const vPrev = (0, exports.calculateSpeed)(points, j);
-                    const v = vPrev + offset;
-                    const d = v * t;
-                    const dOffset = points[j].distance - d;
-                    points[j].distance = d;
-                    points[j].routeDistance += dOffset;
-                }
-                const t = points[endIdx].time - points[endIdx - 1].time;
-                const vPrev = (0, exports.calculateSpeed)(points, endIdx);
-                const v = vPrev - offset;
-                const d = v * t;
-                points[endIdx].distance = d;
-            }
-        }
-        else {
-            if (idx > 2 && idx < points.length - 2) {
-                const s = points[idx + 2].routeDistance - points[idx - 2].routeDistance;
-                const t = points[idx + 2].time - points[idx - 2].time;
-                const avgSpeed = s / t;
-                const nextSpeed = (0, exports.calculateSpeed)(points, idx + 1);
-                const prevSpeed = (0, exports.calculateSpeed)(points, idx - 1);
-                if ((Math.abs(prevSpeed - avgSpeed) - Math.abs(nextSpeed - avgSpeed)) > 0.5) {
-                    points[idx].distance = points[idx].routeDistance - points[idx - 2].routeDistance;
-                    points.splice(idx - 1, 1);
-                }
-                else {
-                    next.distance = next.routeDistance - prev.routeDistance;
-                    points.splice(idx, 1);
-                }
-            }
-            else {
-                next.distance = next.routeDistance - prev.routeDistance;
-                points.splice(idx, 1);
-            }
-        }
+        fixNoDistance(anomaly, points);
     }
 };
 exports.fixAnomaly = fixAnomaly;
@@ -194,19 +113,23 @@ const fixAnomalies = (points, maxAttempts = 1000) => {
     let prev;
     let stuck = false;
     let error;
+    let retry = 0;
     const fixedRecords = [];
     try {
         do {
             anomalies = (0, exports.detectAnomalies)(points, 1);
             if (anomalies.length > 0) {
                 const current = anomalies[0];
-                if ((prev === null || prev === void 0 ? void 0 : prev.idx) === current.idx) {
+                if ((prev === null || prev === void 0 ? void 0 : prev.idx) === current.idx && ++retry > 5) {
                     stuck = true;
                     continue;
                 }
-                else if ((prev === null || prev === void 0 ? void 0 : prev.type) === current.type && (prev === null || prev === void 0 ? void 0 : prev.type) === 'speedJump' && current.idx > (prev === null || prev === void 0 ? void 0 : prev.idx) && current.idx < (prev === null || prev === void 0 ? void 0 : prev.nextNullIdx)) {
-                    current.nextNullIdx = prev.nextNullIdx;
-                    current.retry = ((_a = prev.retry) !== null && _a !== void 0 ? _a : 0) + 1;
+                else {
+                    retry = 0;
+                    if ((prev === null || prev === void 0 ? void 0 : prev.type) === current.type && (prev === null || prev === void 0 ? void 0 : prev.type) === 'speedJump' && current.idx > (prev === null || prev === void 0 ? void 0 : prev.idx) && current.idx < (prev === null || prev === void 0 ? void 0 : prev.nextNullIdx)) {
+                        current.nextNullIdx = prev.nextNullIdx;
+                        current.retry = ((_a = prev.retry) !== null && _a !== void 0 ? _a : 0) + 1;
+                    }
                 }
                 (0, exports.fixAnomaly)(anomalies[0], points);
                 fixedRecords.push(anomalies[0]);
@@ -223,5 +146,161 @@ const fixAnomalies = (points, maxAttempts = 1000) => {
     return { fixed, time: tsStop - tsStart, fixedRecords, error };
 };
 exports.fixAnomalies = fixAnomalies;
-const detectCuts = (points) => {
+const fixNoDistance = (anomaly, points) => {
+    const idx = anomaly.idx;
+    const next = points === null || points === void 0 ? void 0 : points[idx + 1];
+    const prev = points === null || points === void 0 ? void 0 : points[idx - 1];
+    const fixNullWithoutJump = () => {
+        if (idx > 2 && idx < points.length - 2) {
+            const s = points[idx + 2].routeDistance - points[idx - 2].routeDistance;
+            const t = points[idx + 2].time - points[idx - 2].time;
+            const avgSpeed = s / t;
+            const nextSpeed = (0, exports.calculateSpeed)(points, idx + 1);
+            const prevSpeed = (0, exports.calculateSpeed)(points, idx - 1);
+            if ((Math.abs(prevSpeed - avgSpeed) - Math.abs(nextSpeed - avgSpeed)) > 0.5) {
+                points[idx].distance = points[idx].routeDistance - points[idx - 2].routeDistance;
+                points.splice(idx - 1, 1);
+            }
+            else {
+                next.distance = next.routeDistance - prev.routeDistance;
+                points.splice(idx, 1);
+            }
+        }
+        else {
+            next.distance = next.routeDistance - prev.routeDistance;
+            points.splice(idx, 1);
+        }
+    };
+    const fixNullFollowedByJump = () => {
+        const endIdx = anomaly.nextJumpIdx;
+        const vEnd = (0, exports.calculateSpeed)(points, endIdx);
+        const vStart = (0, exports.calculateSpeed)(points, endIdx - 1);
+        if (endIdx === idx + 1) {
+            const offset = vEnd / 2;
+            const t0 = points[idx].time - points[idx - 1].time;
+            const v0 = offset;
+            const d0 = v0 * t0;
+            points[idx].distance = d0;
+            points[idx].routeDistance += d0;
+            const t = points[endIdx].time - points[endIdx - 1].time;
+            const vPrev = (0, exports.calculateSpeed)(points, endIdx);
+            const v = vPrev - offset;
+            const d = v * t;
+            points[endIdx].distance = d;
+        }
+        else {
+            const offset = vEnd - vStart;
+            for (let j = anomaly.idx; j < endIdx; j++) {
+                const t = points[j].time - points[j - 1].time;
+                const vPrev = (0, exports.calculateSpeed)(points, j);
+                const v = vPrev + offset;
+                const d = v * t;
+                const dOffset = points[j].distance - d;
+                points[j].distance = d;
+                points[j].routeDistance += dOffset;
+            }
+            const t = points[endIdx].time - points[endIdx - 1].time;
+            const vPrev = (0, exports.calculateSpeed)(points, endIdx);
+            const v = vPrev - offset;
+            const d = v * t;
+            points[endIdx].distance = d;
+        }
+    };
+    if (anomaly.nextJumpIdx !== undefined) {
+        fixNullFollowedByJump();
+    }
+    else {
+        fixNullWithoutJump();
+    }
+};
+const fixSpeedJump = (anomaly, points) => {
+    const fixJumpFollowedByNull = () => {
+        const idx = anomaly.idx;
+        const idxNull = anomaly.nextNullIdx;
+        const vIssue = (0, exports.calculateSpeed)(points, idx);
+        let offset;
+        if (idx + 1 === idxNull) {
+            offset = vIssue / 2;
+        }
+        else {
+            const vEnd = (0, exports.calculateSpeed)(points, idxNull - 1);
+            const vStart = (0, exports.calculateSpeed)(points, idx - 1);
+            let vTarget;
+            const v1 = vIssue - vStart;
+            const v2 = vIssue - v1;
+            if (vStart > vEnd) {
+                vTarget = Math.max(v1, v2);
+            }
+            else {
+                vTarget = isJump(v1, v2) ? (v1 + v2) / 2 : Math.min(v1, v2);
+            }
+            offset = vIssue - vTarget;
+        }
+        let t = points[idx].time - points[idx - 1].time;
+        let v = vIssue - offset;
+        let s = v * t;
+        let dOffset = points[idx].distance - s;
+        points[idx].distance = s;
+        points[idx].routeDistance -= dOffset;
+        v = offset;
+        for (let j = idx + 1; j < idxNull; j++) {
+            t = points[j].time - points[j - 1].time;
+            s = v * t;
+            v = offset = (0, exports.calculateSpeed)(points, j);
+            dOffset = points[j].distance - s;
+            points[j].distance = s;
+            points[j].routeDistance -= dOffset;
+        }
+        t = points[idxNull].time - points[idxNull - 1].time;
+        v = offset;
+        points[idxNull].distance = v * t;
+    };
+    const fixJumpFollowedByNullRetry = () => {
+        const idx = anomaly.idx;
+        const idxNull = anomaly.nextNullIdx;
+        let offset;
+        if (idxNull === idx + 1) {
+            offset = ((0, exports.calculateSpeed)(points, idx) - (0, exports.calculateSpeed)(points, idxNull)) / 2;
+            const t = points[idx].time - points[idx - 1].time;
+            const vPrev = (0, exports.calculateSpeed)(points, idx);
+            const v = vPrev - offset;
+            const d = v * t;
+            const dOffset = points[idx].distance - d;
+            points[idx].distance = d;
+            points[idx].routeDistance -= dOffset;
+            const t0 = points[idxNull].time - points[idxNull - 1].time;
+            const v0 = offset;
+            points[idxNull].distance += v0 * t0;
+        }
+    };
+    const fixJumpFollowedByJump = () => {
+        const idx = anomaly.idx;
+        const current = points === null || points === void 0 ? void 0 : points[idx];
+        const next = points === null || points === void 0 ? void 0 : points[idx + 1];
+        const v = ((0, exports.calculateSpeed)(points, idx) + (0, exports.calculateSpeed)(points, idx + 1)) / 2;
+        const t = points[idx].time - points[idx - 1].time;
+        const d = v * t;
+        const offset = current.distance - d;
+        current.distance = d;
+        current.routeDistance -= offset;
+        next.distance += offset;
+    };
+    if (anomaly.nextNullIdx !== undefined && anomaly.retry > 0) {
+        fixJumpFollowedByNullRetry();
+    }
+    else if (anomaly.nextNullIdx !== undefined) {
+        fixJumpFollowedByNull();
+    }
+    else if (anomaly.nextJumpIdx !== undefined) {
+        fixJumpFollowedByJump();
+    }
+    else {
+        const idx = anomaly.idx;
+        const next = points === null || points === void 0 ? void 0 : points[idx + 1];
+        const prev = points === null || points === void 0 ? void 0 : points[idx - 1];
+        if (next && prev) {
+            next.distance = next.routeDistance - prev.routeDistance;
+        }
+        points.splice(idx, 1);
+    }
 };

package/lib/workouts/list/cards/WorkoutCard.d.ts

@@ -37,4 +37,5 @@ export declare class WorkoutCard extends BaseCard implements Card<Workout> {
     protected getRepo(): WorkoutsDbLoader;
     protected emitUpdate(): void;
     protected isSelected(): boolean;
+    protected getRouteList(): import("../../../routes").RouteListService;
 }

package/lib/workouts/list/cards/WorkoutCard.js

@@ -1,4 +1,38 @@
 "use strict";
+var __runInitializers = (this && this.__runInitializers) || function (thisArg, initializers, value) {
+    var useValue = arguments.length > 2;
+    for (var i = 0; i < initializers.length; i++) {
+        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
+    }
+    return useValue ? value : void 0;
+};
+var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
+    function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
+    var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
+    var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
+    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+    var _, done = false;
+    for (var i = decorators.length - 1; i >= 0; i--) {
+        var context = {};
+        for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
+        for (var p in contextIn.access) context.access[p] = contextIn.access[p];
+        context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
+        var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
+        if (kind === "accessor") {
+            if (result === void 0) continue;
+            if (result === null || typeof result !== "object") throw new TypeError("Object expected");
+            if (_ = accept(result.get)) descriptor.get = _;
+            if (_ = accept(result.set)) descriptor.set = _;
+            if (_ = accept(result.init)) initializers.unshift(_);
+        }
+        else if (_ = accept(result)) {
+            if (kind === "field") initializers.unshift(_);
+            else descriptor[key] = _;
+        }
+    }
+    if (target) Object.defineProperty(target, contextIn.name, descriptor);
+    done = true;
+};
 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) {
@@ -18,200 +52,223 @@ const settings_1 = require("../../../settings");
 const service_1 = require("../service");
 const utils_1 = require("../../../utils");
 const valid_1 = require("../../../utils/valid");
-class WorkoutCard extends base_1.BaseCard {
-    constructor(workout, props) {
-        super();
-        this.cardObserver = new observer_1.Observer();
-        const { list } = props || {};
-        this.workout = workout;
-        this.list = list;
-        this.deleteable = true;
-        this.initialized = false;
-        this.logger = new gd_eventlog_1.EventLogger('WorkoutCard');
-    }
-    openSettings() {
-        var _a, _b;
-        let settings, canStart, duration, ftpRequired, categories = [], category, canStartWorkoutOnly;
-        try {
-            const service = (0, service_1.useWorkoutList)();
-            canStart = service.canDisplayStart();
-            canStartWorkoutOnly = !canStart;
-            duration = this.calculateDuration();
-            ftpRequired = (0, valid_1.valid)(this.workout.steps.find(s => {
-                var _a;
-                return (s.type == 'step' && ((_a = s.power) === null || _a === void 0 ? void 0 : _a.type) === 'pct of FTP') ||
-                    (s.type == 'segment' && (s === null || s === void 0 ? void 0 : s.steps.find(s => { var _a; return (s.type == 'step' && ((_a = s.power) === null || _a === void 0 ? void 0 : _a.type) === 'pct of FTP'); })));
-            }));
-            settings = (_a = service.getStartSettings()) !== null && _a !== void 0 ? _a : {};
-            categories = ((_b = service.getLists()) !== null && _b !== void 0 ? _b : []).map(l => l.getTitle());
-            category = this.list.getTitle();
-        }
-        catch (err) {
-            this.logError(err, 'openSettings');
-        }
-        return { settings, ftpRequired, canStart, canStartWorkoutOnly, duration, categories, category };
-    }
-    select(settings) {
-        const service = (0, service_1.getWorkoutList)();
-        service.selectCard(this);
-        if (settings)
-            service.setStartSettings(settings);
-        this.emitUpdate();
-    }
-    unselect() {
-        const service = (0, service_1.getWorkoutList)();
-        service.unselect();
-        this.emitUpdate();
-    }
-    move(targetListName) {
-        if (!(targetListName === null || targetListName === void 0 ? void 0 : targetListName.length))
-            return;
-        const service = (0, service_1.getWorkoutList)();
-        const newList = service.moveCard(this, this.list, targetListName);
-        if (newList) {
-            this.list = newList;
-        }
-        this.workout.category = { name: targetListName, index: newList === null || newList === void 0 ? void 0 : newList.length };
-        this.save(true);
-    }
-    save() {
-        return __awaiter(this, arguments, void 0, function* (enforce = false) {
-            try {
-                return yield this.getRepo().save(this.workout, enforce);
+const routes_1 = require("../../../routes");
+const decorators_1 = require("../../../base/decorators");
+let WorkoutCard = (() => {
+    var _a;
+    let _classSuper = base_1.BaseCard;
+    let _instanceExtraInitializers = [];
+    let _getRouteList_decorators;
+    return _a = class WorkoutCard extends _classSuper {
+            constructor(workout, props) {
+                super();
+                this.workout = __runInitializers(this, _instanceExtraInitializers);
+                this.cardObserver = new observer_1.Observer();
+                const { list } = props || {};
+                this.workout = workout;
+                this.list = list;
+                this.deleteable = true;
+                this.initialized = false;
+                this.logger = new gd_eventlog_1.EventLogger('WorkoutCard');
             }
-            catch (err) {
-                this.logError(err, 'save');
+            openSettings() {
+                var _b, _c;
+                let settings, canStart, duration, ftpRequired, categories = [], category, canStartWorkoutOnly;
+                try {
+                    const service = (0, service_1.useWorkoutList)();
+                    canStart = service.canDisplayStart();
+                    canStartWorkoutOnly = !canStart;
+                    duration = this.calculateDuration();
+                    ftpRequired = (0, valid_1.valid)(this.workout.steps.find(s => {
+                        var _b;
+                        return (s.type == 'step' && ((_b = s.power) === null || _b === void 0 ? void 0 : _b.type) === 'pct of FTP') ||
+                            (s.type == 'segment' && (s === null || s === void 0 ? void 0 : s.steps.find(s => { var _b; return (s.type == 'step' && ((_b = s.power) === null || _b === void 0 ? void 0 : _b.type) === 'pct of FTP'); })));
+                    }));
+                    settings = (_b = service.getStartSettings()) !== null && _b !== void 0 ? _b : {};
+                    categories = ((_c = service.getLists()) !== null && _c !== void 0 ? _c : []).map(l => l.getTitle());
+                    category = this.list.getTitle();
+                }
+                catch (err) {
+                    this.logError(err, 'openSettings');
+                }
+                return { settings, ftpRequired, canStart, canStartWorkoutOnly, duration, categories, category };
             }
-        });
-    }
-    delete() {
-        try {
-            const service = (0, service_1.getWorkoutList)();
-            service.unselectCard(this);
-            if (this.deleteObserver)
-                return this.deleteObserver;
-            this.deleteObserver = new observer_1.PromiseObserver(this._delete());
-            return this.deleteObserver;
-        }
-        catch (err) {
-            this.logError(err, 'delete');
-        }
-    }
-    getId() {
-        return this.workout.id;
-    }
-    getTitle() {
-        return this.workout.name;
-    }
-    update(workout) {
-        if (!(0, valid_1.valid)(workout))
-            return;
-        try {
-            this.workout = workout;
-            this.save();
-            this.emitUpdate();
-        }
-        catch (err) {
-            this.logError(err, 'update');
-        }
-    }
-    getData() {
-        return this.workout;
-    }
-    getCardType() {
-        return "Workout";
-    }
-    getDisplayProperties() {
-        const userSettings = (0, settings_1.useUserSettings)();
-        let user;
-        try {
-            user = userSettings.get('user', {});
-        }
-        catch (_a) {
-            user = {};
-        }
-        const duration = this.calculateDuration();
-        return { title: this.workout.name, workout: this.workout, ftp: user === null || user === void 0 ? void 0 : user.ftp, duration,
-            canDelete: this.deleteable, visible: this.visible, selected: this.isSelected(),
-            observer: this.cardObserver };
-    }
-    enableDelete(enabled = true) {
-        this.deleteable = enabled;
-    }
-    canDelete() {
-        return this.deleteable;
-    }
-    setVisible(visible) {
-        try {
-            const prev = this.visible;
-            this.visible = visible;
-            if (visible !== prev)
+            select(settings) {
+                const service = (0, service_1.getWorkoutList)();
+                service.selectCard(this);
+                if (settings)
+                    service.setStartSettings(settings);
+                if (settings.noRoute) {
+                    this.getRouteList().unselect();
+                }
                 this.emitUpdate();
-        }
-        catch (err) {
-            this.logError(err, 'setVisible');
-        }
-    }
-    _delete() {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield (0, utils_1.waitNextTick)();
-            let deleted = false;
-            try {
-                this.deleteObserver.emit('started');
-                yield this.getRepo().delete(this.workout);
-                this.deleteFromUIList();
-                (0, service_1.getWorkoutList)().emitLists('updated');
-                deleted = true;
-            }
-            catch (_a) {
-                deleted = false;
-            }
-            finally {
-                this.deleteObserver.emit('done', deleted);
-                (0, utils_1.waitNextTick)().then(() => {
-                    delete this.deleteObserver;
+            }
+            unselect() {
+                const service = (0, service_1.getWorkoutList)();
+                service.unselect();
+                this.emitUpdate();
+            }
+            move(targetListName) {
+                if (!(targetListName === null || targetListName === void 0 ? void 0 : targetListName.length))
+                    return;
+                const service = (0, service_1.getWorkoutList)();
+                const newList = service.moveCard(this, this.list, targetListName);
+                if (newList) {
+                    this.list = newList;
+                }
+                this.workout.category = { name: targetListName, index: newList === null || newList === void 0 ? void 0 : newList.length };
+                this.save(true);
+            }
+            save() {
+                return __awaiter(this, arguments, void 0, function* (enforce = false) {
+                    try {
+                        return yield this.getRepo().save(this.workout, enforce);
+                    }
+                    catch (err) {
+                        this.logError(err, 'save');
+                    }
                 });
             }
-            return deleted;
-        });
-    }
-    calculateDuration() {
-        const { duration } = this.workout;
-        if (duration < 120)
-            return `${duration.toFixed(0)}s`;
-        if (duration % 60 === 0)
-            return `${duration / 60}min`;
-        const secVal = duration % 60;
-        const minVal = (duration - secVal) / 60 % 60;
-        const h = Math.floor((duration - secVal - minVal * 60) / 3600);
-        const sec = secVal < 10 ? `0${secVal}` : secVal;
-        const min = minVal < 10 ? `0${minVal}` : minVal;
-        if (h > 0)
-            return `${h}:${min}:${sec}`;
-        else
-            return `${min}:${sec}`;
-    }
-    deleteFromUIList() {
-        if (this.list) {
-            this.list.remove(this);
-        }
-    }
-    logError(err, fn) {
-        this.logger.logEvent({ message: 'error', error: err.message, fn, stack: err.stack });
-    }
-    getRepo() {
-        return new db_1.WorkoutsDbLoader();
-    }
-    emitUpdate() {
-        if (this.cardObserver)
-            this.cardObserver.emit('update', this.getDisplayProperties());
-    }
-    isSelected() {
-        const service = (0, service_1.getWorkoutList)();
-        const selectedWorkout = service.getSelected();
-        if ((selectedWorkout === null || selectedWorkout === void 0 ? void 0 : selectedWorkout.id) === this.workout.id)
-            return true;
-        return false;
-    }
-}
+            delete() {
+                try {
+                    const service = (0, service_1.getWorkoutList)();
+                    service.unselectCard(this);
+                    if (this.deleteObserver)
+                        return this.deleteObserver;
+                    this.deleteObserver = new observer_1.PromiseObserver(this._delete());
+                    return this.deleteObserver;
+                }
+                catch (err) {
+                    this.logError(err, 'delete');
+                }
+            }
+            getId() {
+                return this.workout.id;
+            }
+            getTitle() {
+                return this.workout.name;
+            }
+            update(workout) {
+                if (!(0, valid_1.valid)(workout))
+                    return;
+                try {
+                    this.workout = workout;
+                    this.save();
+                    this.emitUpdate();
+                }
+                catch (err) {
+                    this.logError(err, 'update');
+                }
+            }
+            getData() {
+                return this.workout;
+            }
+            getCardType() {
+                return "Workout";
+            }
+            getDisplayProperties() {
+                const userSettings = (0, settings_1.useUserSettings)();
+                let user;
+                try {
+                    user = userSettings.get('user', {});
+                }
+                catch (_b) {
+                    user = {};
+                }
+                const duration = this.calculateDuration();
+                return { title: this.workout.name, workout: this.workout, ftp: user === null || user === void 0 ? void 0 : user.ftp, duration,
+                    canDelete: this.deleteable, visible: this.visible, selected: this.isSelected(),
+                    observer: this.cardObserver };
+            }
+            enableDelete(enabled = true) {
+                this.deleteable = enabled;
+            }
+            canDelete() {
+                return this.deleteable;
+            }
+            setVisible(visible) {
+                try {
+                    const prev = this.visible;
+                    this.visible = visible;
+                    if (visible !== prev)
+                        this.emitUpdate();
+                }
+                catch (err) {
+                    this.logError(err, 'setVisible');
+                }
+            }
+            _delete() {
+                return __awaiter(this, void 0, void 0, function* () {
+                    yield (0, utils_1.waitNextTick)();
+                    let deleted = false;
+                    try {
+                        this.deleteObserver.emit('started');
+                        yield this.getRepo().delete(this.workout);
+                        this.deleteFromUIList();
+                        (0, service_1.getWorkoutList)().emitLists('updated');
+                        deleted = true;
+                    }
+                    catch (_b) {
+                        deleted = false;
+                    }
+                    finally {
+                        this.deleteObserver.emit('done', deleted);
+                        (0, utils_1.waitNextTick)().then(() => {
+                            delete this.deleteObserver;
+                        });
+                    }
+                    return deleted;
+                });
+            }
+            calculateDuration() {
+                const { duration } = this.workout;
+                if (duration < 120)
+                    return `${duration.toFixed(0)}s`;
+                if (duration % 60 === 0)
+                    return `${duration / 60}min`;
+                const secVal = duration % 60;
+                const minVal = (duration - secVal) / 60 % 60;
+                const h = Math.floor((duration - secVal - minVal * 60) / 3600);
+                const sec = secVal < 10 ? `0${secVal}` : secVal;
+                const min = minVal < 10 ? `0${minVal}` : minVal;
+                if (h > 0)
+                    return `${h}:${min}:${sec}`;
+                else
+                    return `${min}:${sec}`;
+            }
+            deleteFromUIList() {
+                if (this.list) {
+                    this.list.remove(this);
+                }
+            }
+            logError(err, fn) {
+                this.logger.logEvent({ message: 'error', error: err.message, fn, stack: err.stack });
+            }
+            getRepo() {
+                return new db_1.WorkoutsDbLoader();
+            }
+            emitUpdate() {
+                if (this.cardObserver)
+                    this.cardObserver.emit('update', this.getDisplayProperties());
+            }
+            isSelected() {
+                const service = (0, service_1.getWorkoutList)();
+                const selectedWorkout = service.getSelected();
+                if ((selectedWorkout === null || selectedWorkout === void 0 ? void 0 : selectedWorkout.id) === this.workout.id)
+                    return true;
+                return false;
+            }
+            getRouteList() {
+                return (0, routes_1.useRouteList)();
+            }
+        },
+        (() => {
+            var _b;
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create((_b = _classSuper[Symbol.metadata]) !== null && _b !== void 0 ? _b : null) : void 0;
+            _getRouteList_decorators = [decorators_1.Injectable];
+            __esDecorate(_a, null, _getRouteList_decorators, { kind: "method", name: "getRouteList", static: false, private: false, access: { has: obj => "getRouteList" in obj, get: obj => obj.getRouteList }, metadata: _metadata }, null, _instanceExtraInitializers);
+            if (_metadata) Object.defineProperty(_a, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        })(),
+        _a;
+})();
 exports.WorkoutCard = WorkoutCard;

package/lib/workouts/list/cards/types.d.ts

@@ -27,6 +27,7 @@ export interface ActiveImportProps {
 export interface WorkoutSettings {
     ftp?: number;
     useErgMode?: boolean;
+    noRoute?: boolean;
 }
 export interface WorkoutSettingsDisplayProps {
     settings: WorkoutSettings;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "incyclist-services",
-  "version": "1.5.3",
+  "version": "1.5.5",
   "peerDependencies": {
     "gd-eventlog": "^0.1.26"
   },