incyclist-services 1.5.13 → 1.5.15

package/lib/index.d.ts

@@ -13,4 +13,5 @@ export * from './routes';
 export * from './services';
 export { useUserSettings, initUserSettings, UserSettingsService, UserSettingsBinding, IUserSettingsBinding } from './settings';
 export * from './utils';
+export * from './video';
 export * from './workouts';

package/lib/index.js

@@ -34,4 +34,5 @@ Object.defineProperty(exports, "initUserSettings", { enumerable: true, get: func
 Object.defineProperty(exports, "UserSettingsService", { enumerable: true, get: function () { return settings_1.UserSettingsService; } });
 Object.defineProperty(exports, "UserSettingsBinding", { enumerable: true, get: function () { return settings_1.UserSettingsBinding; } });
 __exportStar(require("./utils"), exports);
+__exportStar(require("./video"), exports);
 __exportStar(require("./workouts"), exports);

package/lib/maps/MapArea/MapArea.d.ts

@@ -6,6 +6,7 @@ export declare class MapArea implements IMapArea {
     protected queryLocation: IncyclistNode;
     protected bounds: Boundary;
     protected logger: EventLogger;
+    protected lastUsed: number;
     constructor(data: FreeRideDataSet, queryLocation: IncyclistNode, bounds: Boundary);
     getQueryLocation(): IncyclistNode;
     getBoundary(): Boundary;
@@ -13,6 +14,7 @@ export declare class MapArea implements IMapArea {
     getWay(id: string): IncyclistWay;
     getNode(id: string): IncyclistNode;
     getStats(): Record<string, number>;
+    getLastUsed(): number;
     isWithinBoundary(location: LatLng): boolean;
     getNearestPath(point: IncyclistNode): NearestPathInfo;
     getFirstBranch(way: WayInfo, ignore?: string): SplitPointInfo;

package/lib/maps/MapArea/MapArea.js

@@ -14,6 +14,7 @@ class MapArea {
         this.queryLocation = queryLocation;
         this.bounds = bounds;
         this.logger = new gd_eventlog_1.EventLogger('MapArea');
+        this.lastUsed = Date.now();
         this.correctRoundabouts();
     }
     getQueryLocation() {
@@ -23,22 +24,30 @@ class MapArea {
         return this.bounds;
     }
     getWays() {
+        this.lastUsed = Date.now();
         return this.data.ways;
     }
     getWay(id) {
+        this.lastUsed = Date.now();
         return this.data.waysLookup[id];
     }
     getNode(id) {
+        this.lastUsed = Date.now();
         return this.data.nodesLookup[id];
     }
     getStats() {
         return this.data.typeStats;
     }
+    getLastUsed() {
+        return this.lastUsed;
+    }
     isWithinBoundary(location) {
+        this.lastUsed = Date.now();
         return (0, utils_1.isWithinBoundary)(location, this.bounds);
     }
     getNearestPath(point) {
         var _a, _b;
+        this.lastUsed = Date.now();
         const ways = (_b = (_a = this.data) === null || _a === void 0 ? void 0 : _a.ways) !== null && _b !== void 0 ? _b : [];
         if (!(ways === null || ways === void 0 ? void 0 : ways.length))
             return;
@@ -55,6 +64,7 @@ class MapArea {
         return min;
     }
     getFirstBranch(way, ignore) {
+        this.lastUsed = Date.now();
         if ((way === null || way === void 0 ? void 0 : way.path) === undefined)
             return;
         let pFound = undefined;
@@ -78,6 +88,7 @@ class MapArea {
         return pFound;
     }
     splitAtFirstBranch(way) {
+        this.lastUsed = Date.now();
         if ((way === null || way === void 0 ? void 0 : way.path) === undefined)
             return;
         const path = [...way.path];
@@ -107,6 +118,7 @@ class MapArea {
         return result;
     }
     splitAtCrossingPoint(way, crossing) {
+        this.lastUsed = Date.now();
         if ((way === null || way === void 0 ? void 0 : way.path) === undefined || (crossing === null || crossing === void 0 ? void 0 : crossing.idx) === undefined || (crossing === null || crossing === void 0 ? void 0 : crossing.point) === undefined)
             return;
         const { point, idx: crossingIdx, distance } = crossing;
@@ -172,6 +184,7 @@ class MapArea {
         return res;
     }
     buildSegmentInfo(from, parts) {
+        this.lastUsed = Date.now();
         const segments = [];
         const points = [];
         parts.forEach((option, i) => {
@@ -188,6 +201,7 @@ class MapArea {
     }
     getHeading(way, position = 'start') {
         var _a;
+        this.lastUsed = Date.now();
         if (((_a = way === null || way === void 0 ? void 0 : way.path) === null || _a === void 0 ? void 0 : _a.length) < 2)
             return;
         let fullWay = this.getWay(way.id);

package/lib/maps/MapArea/options.d.ts

@@ -17,7 +17,7 @@ export declare class OptionManager {
     protected getOptionsRoundabout(location: IncyclistNode, w: IncyclistWay, options: FreeRideContinuation[]): any;
     protected getWay(props: string | IncyclistWay): IncyclistWay;
     protected getNode(props?: string | IncyclistNode): IncyclistNode;
-    getRemaining(partial: IncyclistWay): IncyclistWay;
+    protected getRemaining(partial: IncyclistWay): IncyclistWay;
     protected findClosestPoint(path: IncyclistNode[], point: IncyclistNode, exclude: IncyclistNode): number;
     getOptionsOnCurrentWay(location: IncyclistNode, way: IncyclistWay, options: Array<FreeRideContinuation>): Array<FreeRideContinuation>;
     protected logError(err: Error, fn: string, args?: any): void;

package/lib/maps/MapArea/options.js

@@ -32,7 +32,7 @@ class OptionManager {
             const options = [];
             const parts = this.map.splitAtCrossingPoint(way, crossing);
             const { segments, points } = this.map.buildSegmentInfo(way, parts);
-            for (const segment of segments) {
+            for (const segment of segments !== null && segments !== void 0 ? segments : []) {
                 try {
                     const path = segment.path;
                     const opts = yield this.getNextOptions(segment);
@@ -65,51 +65,71 @@ class OptionManager {
     }
     getNextOptions(from, props) {
         return __awaiter(this, void 0, void 0, function* () {
-            if ((from === null || from === void 0 ? void 0 : from.id) === undefined || (from === null || from === void 0 ? void 0 : from.path) === undefined || (from === null || from === void 0 ? void 0 : from.path.length) < 1) {
-                return [];
-            }
-            const way = Object.assign(Object.assign({}, this.getWay(from.id)), { path: from.path });
-            let location = way.path[way.path.length - 1];
-            if (location.id === undefined) {
-                if (way.path.length > 1)
-                    location = way.path[way.path.length - 2];
-                else {
+            var _a;
+            try {
+                if ((from === null || from === void 0 ? void 0 : from.id) === undefined || (from === null || from === void 0 ? void 0 : from.path) === undefined || (from === null || from === void 0 ? void 0 : from.path.length) < 1) {
                     return [];
                 }
-            }
-            const map = yield this.service.load(location);
-            if (!map) {
-                if (!this.map)
-                    return [];
-            }
-            else {
-                this.setMap(map);
-            }
-            const node = this.getNode(location);
-            const remaining = this.getRemaining(way);
-            let options = [];
-            if (node !== undefined) {
-                node.ways.forEach((wid) => {
-                    if (wid === remaining.id) {
-                        options = this.getOptionsOnCurrentWay(node, remaining, options);
+                let originalWay = this.getWay(from.id);
+                if (!originalWay) {
+                    const map = this.service.getMap(from.path[0]);
+                    const query = { id: from.id, path: from.path, map: map };
+                    originalWay = this.getWay(query);
+                    if (!originalWay) {
+                        return [];
                     }
+                }
+                const way = Object.assign(Object.assign({}, originalWay), { path: from.path });
+                let location = way.path[way.path.length - 1];
+                if (location.id === undefined) {
+                    if (way.path.length > 1)
+                        location = way.path[way.path.length - 2];
                     else {
-                        const w = this.getWay(wid);
-                        options = this.checkOptionsOnDifferentWay(node, w, options);
+                        return [];
                     }
+                }
+                const map = yield this.service.load(location);
+                if (!map) {
+                    if (!this.map)
+                        return [];
+                }
+                else {
+                    this.setMap(map);
+                }
+                const node = this.getNode(location);
+                const remaining = this.getRemaining(way);
+                let options = [];
+                if (node !== undefined) {
+                    node.ways.forEach((wid) => {
+                        if (wid === remaining.id) {
+                            options = this.getOptionsOnCurrentWay(node, remaining, options);
+                        }
+                        else {
+                            const w = this.getWay(wid);
+                            options = this.checkOptionsOnDifferentWay(node, w, options);
+                        }
+                    });
+                }
+                const currentDirection = this.map.getHeading(way, 'end');
+                options.forEach((option) => {
+                    const direction = this.map.getHeading(option, 'start');
+                    option.direction = direction - currentDirection;
+                    if (option.direction > 180)
+                        option.direction = option.direction - 360;
                 });
+                if (props === null || props === void 0 ? void 0 : props.minDistance) {
+                    yield this.checkMinDistance(options, props.minDistance);
+                }
+                if (options === null || options === void 0 ? void 0 : options.length) {
+                    const fromNode = (_a = from.path) === null || _a === void 0 ? void 0 : _a[from.path.length - 2];
+                    options = options.filter(o => o.path.length > 0 && o.path[1].id !== fromNode.id);
+                }
+                return options;
             }
-            const currentDirection = this.map.getHeading(way, 'end');
-            options.forEach((option) => {
-                const direction = this.map.getHeading(option, 'start');
-                option.direction = direction - currentDirection;
-                if (option.direction > 180)
-                    option.direction = option.direction - 360;
-            });
-            if (props === null || props === void 0 ? void 0 : props.minDistance) {
-                yield this.checkMinDistance(options, props.minDistance);
+            catch (err) {
+                this.logError(err, 'getNextOptions');
+                return [];
             }
-            return options;
         });
     }
     checkMinDistance(options, minDistance) {
@@ -293,8 +313,10 @@ class OptionManager {
         if (typeof props === 'string') {
             return (0, clone_1.default)((_a = this.map) === null || _a === void 0 ? void 0 : _a.getWay(props));
         }
-        if (props.id !== undefined)
-            return (0, clone_1.default)((_b = this.map) === null || _b === void 0 ? void 0 : _b.getWay(props.id));
+        if (props.id !== undefined) {
+            const map = (_b = props.map) !== null && _b !== void 0 ? _b : this.map;
+            return (0, clone_1.default)(map.getWay(props.id));
+        }
     }
     getNode(props) {
         var _a, _b;
@@ -311,37 +333,43 @@ class OptionManager {
         }
     }
     getRemaining(partial) {
-        const originalWay = this.getWay(partial);
-        const path = originalWay.path;
-        const roundabout = (0, utils_1.isRoundabout)(originalWay);
-        if (roundabout)
-            return Object.assign(Object.assign({}, originalWay), { roundabout });
-        let newPath = path;
-        const last = partial.path[partial.path.length - 1];
-        const prev = partial.path[partial.path.length - 2];
-        const idxLast = path.findIndex((p) => (0, utils_1.pointEquals)(p, last));
-        let idxPrev = path.findIndex((p) => (0, utils_1.pointEquals)(p, prev));
-        if (idxPrev === -1)
-            idxPrev = this.findClosestPoint(path, prev, last);
-        let lastOriginal;
-        if (idxPrev > idxLast) {
-            lastOriginal = originalWay.path[0];
-        }
-        else {
-            lastOriginal = originalWay.path[originalWay.path.length - 1];
-        }
-        if (last.id === lastOriginal.id) {
-            return Object.assign(Object.assign({}, originalWay), { path: [], roundabout: false });
-        }
-        if (idxLast !== -1 && idxPrev !== -1) {
-            if (idxPrev < idxLast)
-                newPath = path.slice(idxLast);
+        try {
+            const originalWay = this.getWay(partial);
+            const path = originalWay.path;
+            const roundabout = (0, utils_1.isRoundabout)(originalWay);
+            if (roundabout)
+                return Object.assign(Object.assign({}, originalWay), { roundabout });
+            let newPath = path;
+            const last = partial.path[partial.path.length - 1];
+            const prev = partial.path[partial.path.length - 2];
+            const idxLast = path.findIndex((p) => (0, utils_1.pointEquals)(p, last));
+            let idxPrev = path.findIndex((p) => (0, utils_1.pointEquals)(p, prev));
+            if (idxPrev === -1)
+                idxPrev = this.findClosestPoint(path, prev, last);
+            let lastOriginal;
+            if (idxPrev > idxLast) {
+                lastOriginal = originalWay.path[0];
+            }
             else {
-                newPath = path.slice(0, idxLast + 1);
-                newPath.reverse();
+                lastOriginal = originalWay.path[originalWay.path.length - 1];
+            }
+            if (last.id === lastOriginal.id) {
+                return Object.assign(Object.assign({}, originalWay), { path: [], roundabout: false });
             }
+            if (idxLast !== -1 && idxPrev !== -1) {
+                if (idxPrev < idxLast)
+                    newPath = path.slice(idxLast);
+                else {
+                    newPath = path.slice(0, idxLast + 1);
+                    newPath.reverse();
+                }
+            }
+            return Object.assign(Object.assign({}, originalWay), { path: newPath, roundabout });
+        }
+        catch (err) {
+            this.logError(err, 'getRemaining');
+            return Object.assign(Object.assign({}, partial), { path: [], roundabout: false });
         }
-        return Object.assign(Object.assign({}, originalWay), { path: newPath, roundabout });
     }
     findClosestPoint(path, point, exclude) {
         let found = -1;

package/lib/maps/MapArea/service.d.ts

@@ -9,8 +9,8 @@ type MapAreaRecord = {
     lastUsed: number;
     radius: number;
 };
-export declare const getMapInfo: (m: any) => string;
-export declare const getMapsInfo: (maps: any, key: string) => string;
+export declare const getMapInfo: (m: MapAreaRecord) => string;
+export declare const getMapsInfo: (maps: Record<string, MapAreaRecord>, key: string) => string;
 export declare class MapAreaService extends IncyclistService implements IMapAreaService {
     protected static consts: {
         DEFAULT_RADIUS: number;
@@ -32,7 +32,7 @@ export declare class MapAreaService extends IncyclistService implements IMapArea
     protected iv: NodeJS.Timeout;
     constructor();
     load(location: IncyclistNode): Promise<IMapArea>;
-    getMap(location: IncyclistNode): MapArea;
+    getMap(location: IncyclistNode): IMapArea;
     getOptionManager(): OptionManager;
     setFilter(filter: Array<string> | null): void;
     protected findBestMap(location: IncyclistNode): Promise<IMapArea | undefined>;

package/lib/maps/MapArea/service.js

@@ -66,19 +66,22 @@ const getMapInfo = (m) => {
     try {
         const boundary = m.map.getBoundary();
         const bInfo = `${boundary.northeast.lat},${boundary.northeast.lng},${boundary.southwest.lat},${boundary.southwest.lng}`;
-        return `${m.radius},[${bInfo}]`;
+        return `${m.radius},{${bInfo}}`;
     }
-    catch (_a) {
+    catch (err) {
+        console.log('# ERROR', err);
         return '';
     }
 };
 exports.getMapInfo = getMapInfo;
 const getMapsInfo = (maps, key) => {
+    var _a;
     try {
         const m = maps[key];
-        return `${key}:${(0, exports.getMapInfo)(m)}`;
+        const time = Number((Date.now() - ((_a = m.map.getLastUsed()) !== null && _a !== void 0 ? _a : m.lastUsed)) / 1000).toFixed(1);
+        return `${key}:${(0, exports.getMapInfo)(m)}:age=${time}s`;
     }
-    catch (_a) {
+    catch (_b) {
         return '';
     }
 };
@@ -131,7 +134,6 @@ let MapAreaService = (() => {
                 const records = this.getMapsForLocation(location);
                 let updateRequired = true;
                 let minDist = Number.MAX_VALUE;
-                let minPct;
                 let best;
                 do {
                     if (records.length === 0)
@@ -144,17 +146,13 @@ let MapAreaService = (() => {
                     updateRequired = dist > (radius / 5);
                     if (!updateRequired) {
                         minDist = dist;
-                        minPct = minDist / radius * 100;
                         best = record;
                     }
                     else if (dist < minDist) {
                         minDist = dist;
-                        minPct = minDist / radius * 100;
                     }
                     yield (0, utils_2.waitNextTick)();
                 } while (records.length > 0 && updateRequired);
-                const { lat, lng, id } = location;
-                this.logEvent({ message: 'distance between previous overpass request', location: { lat, lng, id }, dist: minDist, pct: minPct, updateRequired, map: (0, exports.getMapInfo)(best === null || best === void 0 ? void 0 : best.map) });
                 return best === null || best === void 0 ? void 0 : best.map;
             });
         }
@@ -195,22 +193,16 @@ let MapAreaService = (() => {
         }
         addMap(map, location) {
             this.current = map;
-            this.maps[this.mapsKey(location)] = { map, lastUsed: Date.now(), radius: this.radius };
-            this.logEvent({ message: 'Map added', cnt: Object.keys(this.maps).length, maps: Object.keys(this.maps).map(k => (0, exports.getMapsInfo)(this.maps, k)) });
+            const record = { map, lastUsed: Date.now(), radius: this.radius };
+            this.maps[this.mapsKey(location)] = record;
+            const mapInfo = `${location.lat},${location.lng},${(0, exports.getMapInfo)(record)}`;
+            this.logEvent({ message: 'Map added', map: mapInfo, cnt: Object.keys(this.maps).length, maps: Object.keys(this.maps).map(k => (0, exports.getMapsInfo)(this.maps, k)) });
         }
         getMapsForLocation(location) {
             return Object.values(this.maps).filter(m => m.map.isWithinBoundary(location));
         }
         createMapData(openmapData) {
-            var _a, _b;
-            let ts = Date.now();
             const data = (0, utils_1.parseMapData)(openmapData, this.filter);
-            let ts1 = Date.now();
-            this.logger.logEvent({ message: 'Parse', duration: (ts1 - ts),
-                ways: (_a = data === null || data === void 0 ? void 0 : data.ways.length) !== null && _a !== void 0 ? _a : 0,
-                nodes: Object.keys((_b = data === null || data === void 0 ? void 0 : data.nodesLookup) !== null && _b !== void 0 ? _b : {}).length,
-                typeStats: data === null || data === void 0 ? void 0 : data.typeStats
-            });
             if (data !== undefined) {
                 this.loaded = 'success';
             }
@@ -250,8 +242,9 @@ let MapAreaService = (() => {
             this.iv = undefined;
         }
         garbageCollection() {
+            const tsLastUsed = (m) => { var _a; return (_a = m.map.getLastUsed()) !== null && _a !== void 0 ? _a : m.lastUsed; };
             const now = Date.now();
-            const maps = Object.values(this.maps).filter(m => now - m.lastUsed < 1000 * 60 * 5);
+            const maps = Object.values(this.maps).filter(m => now - tsLastUsed(m) < 1000 * 60 * 5);
             const keyLastUsed = this.mapsKey(this.current.getQueryLocation());
             const deleteTarget = maps.filter(m => this.mapsKey(m.map.getQueryLocation()) !== keyLastUsed);
             if (deleteTarget.length > MAX_MAPS) {

package/lib/maps/MapArea/types.d.ts

@@ -39,6 +39,7 @@ export type FreeRideContinuation = {
 };
 export interface IMapAreaService {
     load(location: IncyclistNode): Promise<IMapArea>;
+    getMap(location: IncyclistNode): IMapArea;
 }
 export type Boundary = {
     southwest: LatLng;
@@ -104,6 +105,7 @@ export interface IncyclistWay extends WayInfo {
     name: string;
     tags: Record<string, any>;
     bounds: OverpassBounds;
+    map?: IMapArea;
     roundabout?: boolean;
     originalId?: string;
 }

package/lib/maps/MapArea/utils.d.ts

@@ -1,12 +1,13 @@
 import { Vector } from "../../utils";
 import { LatLng } from "../../utils/geo";
 import { Boundary, CrossingInfo, IncyclistNode, IncyclistWay, FreeRideDataSet, SplitPointInfo, PathCrossingInfo, WayInfo } from "./types";
+import { RoutePoint } from "../../routes/base/types";
 export declare function addNode(node: number, nodesLookup: Record<string, IncyclistNode>, id: number, path: Array<IncyclistNode>): void;
 export declare function addWay(w: IncyclistWay, ways: Array<IncyclistWay>, waysLookup: Record<string, IncyclistWay>): void;
 export declare function updateTypeStats(types: Record<string, number>, type: string): void;
 export declare function parseMapData(str: JSON | string, filter: any): FreeRideDataSet;
 export declare function splitAtIndex(way: any, idxSplit: any): any[][];
-export declare function concatPaths(path: IncyclistNode[], path2: IncyclistNode[], position: 'before' | 'after'): void;
+export declare function concatPaths(path: IncyclistNode[] | RoutePoint[], path2: IncyclistNode[] | RoutePoint[], position: 'before' | 'after'): void;
 export declare function splitAtPointInfo(way: WayInfo, split: SplitPointInfo): Array<Array<IncyclistNode>>;
 export declare function isRoundabout(w: IncyclistWay, strictCheck?: boolean): boolean;
 export declare function removeDuplicates(options: any): any;

package/lib/maps/MapArea/utils.js

@@ -126,7 +126,7 @@ function splitAtIndex(way, idxSplit) {
     return result;
 }
 function concatPaths(path, path2, position) {
-    const append = [...path2];
+    const append = path2.map(p => (Object.assign({}, p)));
     if (position === 'after') {
         append.shift();
         path.push(...append);

package/lib/ride/base/types.d.ts

@@ -9,6 +9,7 @@ import { ActiveRideListAvatar, ActivityDetails, PrevRidesListDisplayProps, Scree
 import { Workout } from "../../workouts";
 import { FreeRideOption } from "../../routes/list/types";
 import { MapViewPort } from "../route/types";
+import { LatLng } from "../../utils/geo";
 export type RideType = 'Free-Ride' | 'GPX' | 'Video' | 'Workout';
 export type CurrentRideState = 'Idle' | 'Starting' | 'Started' | 'Active' | 'Paused' | 'Error' | 'Finished';
 export type CurrentRideDeviceState = 'Starting' | 'Started' | 'Error';
@@ -53,21 +54,41 @@ export interface RouteDisplayProps extends IRideModeServiceDisplayProps {
     upcomingElevation?: OverlayDisplayProps;
     totalElevation?: OverlayDisplayProps;
 }
+export interface VideoDisplayProps {
+    src: any;
+    playback: 'native' | 'converted';
+    startTime?: number;
+    observer: Observer;
+    muted?: boolean;
+    onPlaybackUpdate?: (time: number, rate: number) => void;
+    onLoaded?: () => void;
+    onPlaybackError?: (error: string) => void;
+    onLoadError?: (error: string) => void;
+}
+export interface RLVDisplayProps extends RouteDisplayProps {
+    video?: VideoDisplayProps;
+}
 export interface MapOverlayDisplayProps extends OverlayDisplayProps {
     viewport?: MapViewPort;
     viewportOverwrite?: boolean;
+    center?: LatLng;
+    bounds?: Number[][];
     onViewportChange?: (viewport: MapViewPort) => void;
 }
 export interface GpxDisplayProps extends RouteDisplayProps {
     rideView: 'sv' | 'map' | 'sat';
 }
-export interface FreeRideDisplayProps extends GpxDisplayProps {
-    options?: FreeRideOption[];
+export interface RouteOptionDisplayProps {
     optionsDelay?: number;
     optionsId?: string;
     onOptionsVisibleChanged: (visible: boolean) => void;
+    isNearby?: boolean;
+    distance?: number;
+    turn?: boolean;
 }
-export interface VideoDisplayProps extends RouteDisplayProps {
+export interface FreeRideDisplayProps extends GpxDisplayProps {
+    options?: FreeRideOption[];
+    optionProps?: RouteOptionDisplayProps;
 }
 export interface StartOverlayProps {
     mode: RideType;
@@ -76,7 +97,7 @@ export interface StartOverlayProps {
     readyToStart: boolean;
 }
 export interface OverlayDisplayProps {
-    show: boolean;
+    show?: boolean;
     minimized?: boolean;
 }
 export interface PrevRidesDisplayProps extends OverlayDisplayProps {

package/lib/ride/display/service.js

@@ -61,9 +61,9 @@ const utils_1 = require("../../utils");
 const base_1 = require("../base/base");
 const FreeRideDisplayService_1 = require("../route/FreeRideDisplayService");
 const FollowRouteDisplayService_1 = require("../route/FollowRouteDisplayService");
-const VideoDisplayService_1 = require("../route/VideoDisplayService");
 const WorkoutDisplayService_1 = require("../workout/WorkoutDisplayService");
 const api_1 = require("../../api");
+const RLVDisplayService_1 = require("../route/RLVDisplayService");
 let RideDisplayService = (() => {
     let _classDecorators = [types_1.Singleton];
     let _classDescriptor;
@@ -359,8 +359,11 @@ let RideDisplayService = (() => {
             if (!this.type) {
                 try {
                     this.type = this.detectRideType();
+                    console.log('#ride type', this.type);
+                }
+                catch (err) {
+                    console.log('# error detecting ride type', err);
                 }
-                catch (_a) { }
             }
             return this.type;
         }
@@ -375,14 +378,14 @@ let RideDisplayService = (() => {
             return (_a = this.getWorkoutRide().getWorkout()) !== null && _a !== void 0 ? _a : this.getWorkoutList().getSelected();
         }
         get route() {
-            var _a;
+            var _a, _b;
             const route = this.getRouteList().getSelected();
             const settings = this.getRouteList().getStartSettings();
             if (!route && (settings === null || settings === void 0 ? void 0 : settings.type) === 'Free-Ride') {
                 return this.getRideModeService().getCurrentRoute();
             }
             if (((_a = route === null || route === void 0 ? void 0 : route.description) === null || _a === void 0 ? void 0 : _a.hasVideo) && (settings === null || settings === void 0 ? void 0 : settings.type) === 'Route') {
-                return this.getRideModeService().getCurrentRoute();
+                return (_b = this.getRideModeService().getCurrentRoute()) !== null && _b !== void 0 ? _b : route;
             }
             return route;
         }
@@ -445,18 +448,21 @@ let RideDisplayService = (() => {
             (_a = this.observer) === null || _a === void 0 ? void 0 : _a.emit('state-update', this.state);
         }
         detectRideType() {
-            var _a, _b, _c, _d;
+            var _a;
+            const route = this.getRouteList().getSelected();
             const startSettings = this.getRouteList().getStartSettings();
             const workout = this.getWorkoutList().getSelected();
             if ((startSettings === null || startSettings === void 0 ? void 0 : startSettings.type) === 'Free-Ride') {
                 return 'Free-Ride';
             }
-            if (!((_a = this.route) === null || _a === void 0 ? void 0 : _a.details) && !!workout) {
+            if (!(route === null || route === void 0 ? void 0 : route.details) && !!workout) {
                 return 'Workout';
             }
-            if (!((_b = this.route) === null || _b === void 0 ? void 0 : _b.details))
-                throw new Error('unknown ride typpe');
-            return ((_d = (_c = this.route) === null || _c === void 0 ? void 0 : _c.description) === null || _d === void 0 ? void 0 : _d.hasVideo) ? 'Video' : 'GPX';
+            if (!(route === null || route === void 0 ? void 0 : route.details)) {
+                console.log('# this.route?.details', route === null || route === void 0 ? void 0 : route.details, route);
+                throw new Error('unknown ride type');
+            }
+            return ((_a = route === null || route === void 0 ? void 0 : route.description) === null || _a === void 0 ? void 0 : _a.hasVideo) ? 'Video' : 'GPX';
         }
         getRideModeService(overwrite) {
             if (this.displayService && !overwrite)
@@ -466,7 +472,7 @@ let RideDisplayService = (() => {
                 switch (type) {
                     case 'Free-Ride': return new FreeRideDisplayService_1.FreeRideDisplayService();
                     case 'GPX': return new FollowRouteDisplayService_1.FollowRouteDisplayService();
-                    case 'Video': return new VideoDisplayService_1.VideoDisplayService();
+                    case 'Video': return new RLVDisplayService_1.RLVDisplayService();
                     case 'Workout': return new WorkoutDisplayService_1.WorkoutDisplayService();
                     default:
                         return new base_1.RideModeService();
@@ -567,13 +573,13 @@ let RideDisplayService = (() => {
             console.log('# lap completed', oldLap, newLap);
         }
         onRouteUpdated(route) {
-            console.log('# route updated', this.route.points);
             this.getActivityRide().onRouteUpdate(route.points);
         }
         onRouteCompleted() {
             var _a;
             if (this.state !== 'Active' && this.state !== 'Paused')
                 return;
+            console.log('# route completed', this.getWorkoutRide().inUse());
             if (this.getWorkoutRide().inUse()) {
                 this.getRouteList().unselect();
                 this.type = 'Workout';