incyclist-services 1.7.52 → 1.7.53

package/lib/cjs/devices/ride/service.js

@@ -572,6 +572,8 @@ let DeviceRideService = (() => {
             if (startType === 'start') {
                 this.initForStart(ai, startProps, route, startPos, realityFactor, rideMode);
             }
+            ai.adapter.resumeLogging();
+            this.resumeLogging();
             const sType = (ai.isControl) ? 'bike' : 'sensor';
             const logProps = {};
             logProps[sType] = ai.adapter.getUniqueName();

package/lib/cjs/routes/library/service.js

@@ -44,8 +44,10 @@ const types_1 = require("../../base/types");
 const parsers_1 = require("../base/parsers");
 const service_2 = require("../list/service");
 const utils_1 = require("../../utils");
-const VIDEO_EXTENSIONS = new Set(['mp4', 'mov', 'mkv', 'm4v', 'mpg', 'mpeg', 'wmv', 'avi']);
-const IMAGE_EXTENSIONS = new Set(['jpg', 'jpeg', 'png', 'gif', 'bmp', 'webp']);
+const db_1 = require("../list/loaders/db");
+const route_1 = require("../base/model/route");
+const sleep_1 = require("../../utils/sleep");
+const i18n_1 = require("../../i18n");
 let RouteLibraryScannerService = (() => {
     let _classDecorators = [decorators_1.Singleton];
     let _classDescriptor;
@@ -55,53 +57,220 @@ let RouteLibraryScannerService = (() => {
     let _instanceExtraInitializers = [];
     let _getRouteList_decorators;
     let _getBindings_decorators;
+    let _getRoutesDBLoader_decorators;
+    let _getParsers_decorators;
+    let _getUnitConverter_decorators;
     var RouteLibraryScannerService = class extends _classSuper {
         static { _classThis = this; }
         static {
             const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
             _getRouteList_decorators = [decorators_1.Injectable];
             _getBindings_decorators = [decorators_1.Injectable];
+            _getRoutesDBLoader_decorators = [decorators_1.Injectable];
+            _getParsers_decorators = [decorators_1.Injectable];
+            _getUnitConverter_decorators = [decorators_1.Injectable];
             __esDecorate(this, 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);
             __esDecorate(this, null, _getBindings_decorators, { kind: "method", name: "getBindings", static: false, private: false, access: { has: obj => "getBindings" in obj, get: obj => obj.getBindings }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _getRoutesDBLoader_decorators, { kind: "method", name: "getRoutesDBLoader", static: false, private: false, access: { has: obj => "getRoutesDBLoader" in obj, get: obj => obj.getRoutesDBLoader }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _getParsers_decorators, { kind: "method", name: "getParsers", static: false, private: false, access: { has: obj => "getParsers" in obj, get: obj => obj.getParsers }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _getUnitConverter_decorators, { kind: "method", name: "getUnitConverter", static: false, private: false, access: { has: obj => "getUnitConverter" in obj, get: obj => obj.getUnitConverter }, metadata: _metadata }, null, _instanceExtraInitializers);
             __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
             RouteLibraryScannerService = _classThis = _classDescriptor.value;
             if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
             __runInitializers(_classThis, _classExtraInitializers);
         }
+        isCancelled = (__runInitializers(this, _instanceExtraInitializers), false);
+        scanResult = [];
+        importProps;
         constructor() {
             super('RouteLibraryScanner');
-            __runInitializers(this, _instanceExtraInitializers);
+        }
+        prepare() {
+            this.importProps = {
+                phase: 'landing',
+                routes: []
+            };
+        }
+        done() {
+            this.importProps = undefined;
+        }
+        getDisplayProps() {
+            return this.importProps;
+        }
+        importSingle(fileInfo) {
+            const observer = new types_1.Observer();
+            this.isCancelled = false;
+            this.importRoute(fileInfo, observer).catch(err => {
+                this.logError(err, 'importSingle', { file: fileInfo?.filename });
+                observer.emit('error', err.message);
+            });
+            observer.on('success', (route) => {
+                this.importProps.phase = 'result';
+                this.importProps.resultSuccess = { routeName: route.title };
+            });
+            observer.on('error', (error) => {
+                this.importProps.phase = 'result';
+                this.importProps.error = error;
+            });
+            return observer;
         }
         scan(folderInfo) {
+            if (!this.importProps)
+                this.prepare();
+            this.isCancelled = false;
+            this.scanResult = [];
+            this.importProps.phase = 'scanning';
             const observer = new types_1.Observer();
             this._scan(folderInfo, observer).catch(err => {
                 this.logError(err, 'scan', { uri: folderInfo.uri });
                 observer.emit('error', err.message);
             });
+            observer.on('scan-progress', (progress) => {
+                this.importProps.scanProgress = progress;
+            });
             return observer;
         }
-        ingest(routes, treeUri) {
+        parse(scannedRoutes) {
             const observer = new types_1.Observer();
-            this._ingest(routes, treeUri, observer).catch(err => {
-                this.logError(err, 'ingest', { treeUri });
+            if (!this.importProps)
+                this.prepare();
+            this._parse(scannedRoutes, observer).catch(err => {
+                this.logError(err, 'parse');
                 observer.emit('error', err.message);
             });
+            observer.on('parse-progress', (progress) => {
+                const { parsed, total } = progress;
+                this.importProps.parseProgress = { parsed, total };
+            });
+            observer.on('parse-result', (route) => {
+                this.importProps.routes.push(this.buildRouteDisplayItem(route));
+            });
+            observer.on('parse-complete', () => {
+                this.importProps.phase = 'selecting';
+            });
             return observer;
         }
+        ingest(routes) {
+            const observer = new types_1.Observer();
+            if (!this.importProps)
+                this.prepare();
+            const list = this.getRouteList();
+            list.pauseListUpdates();
+            this.importProps.phase = 'ingesting';
+            this._ingest(routes, observer)
+                .catch(err => {
+                this.logError(err, 'ingest');
+                observer.emit('error', err.message);
+            })
+                .finally(() => {
+                list.resumeListUpdates();
+                list.emitLists('updated', { source: 'system' });
+            });
+            observer.on('ingest-progress', (progress) => {
+                const { current, total, currentName } = progress;
+                this.importProps.ingestProgress = { current, total, currentName };
+            });
+            observer.on('ingest-complete', (status) => {
+                this.importProps.phase = 'complete';
+                const { imported, skipped, errors, failedRoutes } = status;
+                this.importProps.completionSummary = { imported, skipped, errors, failedRoutes };
+            });
+            return observer;
+        }
+        cancel() {
+            this.isCancelled = true;
+            this.importProps.phase = 'landing';
+        }
+        async importRoute(fileInfo, observer) {
+            await (0, sleep_1.sleep)(0);
+            observer.emit('parsing');
+            this.importProps.phase = 'parsing';
+            if (fileInfo?.ext === 'gpx') {
+                return this.importSingleGpxRoute(fileInfo, observer);
+            }
+            else {
+                return this.importSingleVideoRoute(fileInfo, observer);
+            }
+        }
+        async importSingleGpxRoute(fileInfo, observer) {
+            const list = this.getRouteList();
+            const db = this.getRoutesDBLoader();
+            try {
+                const { data, details } = await parsers_1.RouteParser.parse(fileInfo);
+                const route = new route_1.Route(data, details);
+                route.description.tsImported = Date.now();
+                await db.save(route, true);
+                list.addRoute(route, 'user');
+                observer.emit('success', route);
+            }
+            catch (err) {
+                observer.emit('error', err.message);
+            }
+        }
+        async importSingleVideoRoute(fileInfo, observer) {
+            const parsers = this.getParsers();
+            const { dir, ext, delimiter } = fileInfo;
+            const folderUri = dir.endsWith(delimiter ?? '/') ? dir.slice(0, -delimiter.length) : dir;
+            try {
+                if (!parsers.isPrimaryExtension(ext)) {
+                    observer.emit('error', 'not a route control file');
+                    return;
+                }
+                const scanObserver = new types_1.Observer();
+                await this.scanFolder(folderUri, folderUri, scanObserver, parsers, { scannedFolders: 0 }, { value: 0 }, false);
+                const files = this.scanResult;
+                this.scanResult = [];
+                scanObserver.stop();
+                if (files[0].scanError) {
+                    observer.emit('error', files[0].scanError);
+                    return;
+                }
+                else {
+                    const file = files.find(file => file.controlFileUri.includes(fileInfo.base));
+                    const parseObserver = this.parse([file]);
+                    parseObserver.on('parse-result', (result) => {
+                        parseObserver.stop();
+                        if (result.parseError) {
+                            observer.emit('error', result.parseError);
+                            return;
+                        }
+                        const ingest = this.ingest([result]);
+                        let ingestError;
+                        ingest.once('ingest-error', (_, reason) => {
+                            ingest.stop();
+                            observer.emit('error', reason);
+                            ingestError = reason;
+                        });
+                        ingest.once('ingest-complete', (summary) => {
+                            ingest.stop();
+                            if (!ingestError && summary.imported > 0) {
+                                observer.emit('success', summary.importedRoutes?.[0]?.title);
+                            }
+                            else if (!ingestError && summary.imported === 0) {
+                                observer.emit('error', 'not imported');
+                            }
+                        });
+                    });
+                }
+            }
+            catch (err) {
+                observer.emit('error', err.message);
+            }
+        }
         async _scan(folderInfo, observer) {
             await (0, utils_1.waitNextTick)();
-            const parsers = (0, parsers_1.useParsers)();
+            const parsers = this.getParsers();
             const progress = { scannedFolders: 0 };
             const discoveredCount = { value: 0 };
             await this.scanFolder(folderInfo.uri, folderInfo.displayName, observer, parsers, progress, discoveredCount);
             await this.upsertImportHistory(folderInfo, discoveredCount.value);
-            observer.emit('scan-complete');
+            observer.emit('scan-complete', this.scanResult);
         }
-        async scanFolder(uri, folderName, observer, parsers, progress, discoveredCount) {
+        async scanFolder(uri, folderName, observer, parsers, progress, discoveredCount, recursive = true) {
             const fs = this.getBindings().fs;
             let entries;
             try {
-                entries = await fs.readdir(uri, { extended: true });
+                entries = await fs.readdir(uri, { recursive: false, extended: true });
             }
             catch (err) {
                 this.logError(err, 'scanFolder', { uri });
@@ -111,137 +280,150 @@ let RouteLibraryScannerService = (() => {
             observer.emit('scan-progress', { scannedFolders: progress.scannedFolders });
             const files = entries.filter(e => !e.isDirectory);
             const dirs = entries.filter(e => e.isDirectory);
-            const primaryFiles = files.filter(f => {
-                const ext = this.getExtension(f.name);
+            const primaryFiles = files.filter((f) => {
+                const name = typeof (f) === 'string' ? f : f.name;
+                const ext = this.getExtension(name);
                 return ext && parsers.isPrimaryExtension(ext);
+            }).map((f) => {
+                if (typeof f === 'string') {
+                    return {
+                        name: f,
+                        isDirectory: false,
+                        uri: this.getBindings().path.join(uri, f)
+                    };
+                }
+                else
+                    return f;
             });
             for (const file of primaryFiles) {
-                const route = await this.buildDiscoveredRoute(file, files, uri, folderName, parsers);
-                discoveredCount.value++;
-                observer.emit('discovered', route);
+                if (!this.isCancelled) {
+                    const routeAnnouncement = await this.buildDiscoveredRoute(file, files, uri, folderName, parsers);
+                    discoveredCount.value++;
+                    observer.emit('scan-result', routeAnnouncement);
+                    this.scanResult.push(routeAnnouncement);
+                }
             }
             for (const dir of dirs) {
-                await this.scanFolder(dir.uri, dir.name, observer, parsers, progress, discoveredCount);
+                if (!this.isCancelled && recursive) {
+                    await this.scanFolder(dir.uri, dir.name, observer, parsers, progress, discoveredCount);
+                }
             }
         }
         async buildDiscoveredRoute(controlFile, folderFiles, folderUri, folderName, parsers) {
             const ext = this.getExtension(controlFile.name);
             const baseName = controlFile.name.slice(0, controlFile.name.length - ext.length - 1);
-            let importable = true;
             let skipReason;
             const companionExts = this.getCompanionExts(parsers, ext);
             for (const compExt of companionExts) {
                 const hasCompanion = folderFiles.some(f => this.getExtension(f.name).toLowerCase() === compExt.toLowerCase() &&
                     f.name.toLowerCase().startsWith(baseName.toLowerCase()));
                 if (!hasCompanion) {
-                    importable = false;
                     skipReason = `Missing companion file (.${compExt})`;
                     break;
                 }
             }
-            let hasVideo = false;
-            const hasThumbnail = folderFiles.some(f => IMAGE_EXTENSIONS.has(this.getExtension(f.name).toLowerCase()));
-            if (importable) {
-                const videoFiles = folderFiles.filter(f => VIDEO_EXTENSIONS.has(this.getExtension(f.name).toLowerCase()));
-                const nonAviVideo = videoFiles.find(f => this.getExtension(f.name).toLowerCase() !== 'avi');
-                if (videoFiles.length === 0) {
-                    importable = false;
-                    skipReason = 'No video file found in folder';
-                }
-                else if (nonAviVideo) {
-                    hasVideo = true;
-                }
-                else {
-                    importable = false;
-                    skipReason = 'Only AVI video format found; AVI is not supported';
-                }
-            }
-            if (importable) {
-                try {
-                    const fs = this.getBindings().fs;
-                    const content = await fs.readFile(controlFile.uri);
-                    const text = typeof content === 'string' ? content : content?.toString?.('utf8') ?? '';
-                    if (this.containsAbsolutePath(text.slice(0, 4096))) {
-                        importable = false;
-                        skipReason = 'Route references an absolute video path';
-                    }
-                }
-                catch {
-                }
-            }
-            const alreadyImported = await this.getRouteList()
-                .existsBySourceUri(controlFile.uri)
-                .catch(() => false);
             return {
-                id: (0, uuid_1.v4)(),
                 folderUri,
                 folderName,
                 controlFileUri: controlFile.uri,
                 format: ext,
-                hasVideo,
-                hasThumbnail,
-                alreadyImported,
-                importable,
-                skipReason
+                scanError: skipReason
             };
         }
-        async _ingest(routes, treeUri, observer) {
+        async _parse(scannedRoutes, observer) {
+            const service = this.getRouteList();
+            const targets = scannedRoutes.filter(r => !r.scanError);
+            const total = targets.length;
+            for (let i = 0; i < targets.length; i++) {
+                if (this.isCancelled)
+                    continue;
+                const parsed = i + 1;
+                const target = targets[i];
+                observer.emit('parse-progress', { current: parsed, parsed, total, currentFolder: target.folderName });
+                await this._parseTarget(target, service, observer);
+            }
+            observer.emit('parse-complete');
+        }
+        async _parseTarget(target, service, observer) {
+            if (service.existsBySourceUri(target.controlFileUri)) {
+                observer.emit('parse-result', {
+                    alreadyImported: true,
+                    route: service.getBySourceUri(target.controlFileUri),
+                    folderUri: target.folderUri,
+                    controlFileUri: target.controlFileUri,
+                    format: target.format
+                });
+                return;
+            }
+            let result;
+            const file = this.buildFileInfo(target.controlFileUri, target.format);
+            try {
+                try {
+                    result = await parsers_1.RouteParser.parse(file);
+                }
+                catch (err) {
+                    throw new Error(`Could not parse: [${err.message}]`);
+                }
+                if (result.data.hasVideo) {
+                    this.validateVideoUrl(result.details, target.folderUri);
+                }
+                observer.emit('parse-result', {
+                    alreadyImported: false,
+                    route: new route_1.Route(result.data, result.details),
+                    folderUri: target.folderUri,
+                    controlFileUri: target.controlFileUri,
+                    format: target.format
+                });
+            }
+            catch (err) {
+                observer.emit('parse-result', {
+                    alreadyImported: false,
+                    route: result ? new route_1.Route(result.data, result.details) : undefined,
+                    folderUri: target.folderUri,
+                    controlFileUri: target.controlFileUri,
+                    format: target.format,
+                    parseError: err?.message ?? String(err)
+                });
+            }
+        }
+        validateVideoUrl(routeDetail, folderUri) {
+            if (this.isMobile()) {
+                if (routeDetail.video.format === 'avi') {
+                    throw new Error('AVI video not supported');
+                }
+            }
+            if (routeDetail.video.file) {
+                routeDetail.video.file = this.resolveVideoUri(routeDetail.video.file, folderUri);
+            }
+        }
+        async _ingest(routes, observer) {
             await (0, utils_1.waitNextTick)();
-            const importable = routes.filter(r => r.importable && !r.alreadyImported);
-            const total = importable.length;
-            let imported = 0;
+            const service = this.getRouteList();
+            const db = this.getRoutesDBLoader();
+            const target = routes.filter(r => !r.alreadyImported && !r.parseError);
+            const total = target.length;
             let errors = 0;
             const failedRoutes = [];
-            for (let i = 0; i < importable.length; i++) {
-                const route = importable[i];
-                observer.emit('ingest-progress', { current: i + 1, total, currentName: route.folderName });
+            const importedRoutes = [];
+            for (let i = 0; i < target.length; i++) {
+                if (this.isCancelled)
+                    continue;
+                const { route } = target[i] ?? {};
                 try {
-                    await this.ingestRoute(route, treeUri);
-                    imported++;
+                    observer.emit('ingest-progress', { current: i + 1, total, currentName: route.title });
+                    await db.save(route, true);
+                    service.addRoute(route, 'user');
+                    importedRoutes.push(route);
                 }
                 catch (err) {
                     const reason = err?.message ?? String(err);
                     errors++;
-                    failedRoutes.push({ name: route.folderName, reason });
-                    observer.emit('ingest-error', { name: route.folderName, reason });
+                    failedRoutes.push({ name: route.title, reason });
+                    observer.emit('ingest-error', { name: route.title, reason });
                 }
             }
-            const skipped = routes.length - importable.length;
-            observer.emit('ingest-complete', { imported, skipped, errors, failedRoutes });
-        }
-        async ingestRoute(route, treeUri) {
-            const { format, controlFileUri, folderUri } = route;
-            const fileInfo = this.buildFileInfo(controlFileUri, format);
-            const { data } = await parsers_1.RouteParser.parse(fileInfo);
-            let thumbnailPath;
-            if (route.hasThumbnail) {
-                thumbnailPath = await this.copyThumbnail(route, folderUri).catch(() => undefined);
-            }
-            const videoUri = data.videoUrl ? this.resolveVideoUri(data.videoUrl, folderUri) : undefined;
-            const record = {
-                id: data.id ?? (0, uuid_1.v4)(),
-                name: data.title ?? route.folderName,
-                format,
-                thumbnailPath,
-                videoUri,
-                sourceTreeUri: treeUri
-            };
-            await this.getRouteList().addRoute(record);
-        }
-        async copyThumbnail(route, folderUri) {
-            const { fs, appInfo } = this.getBindings();
-            if (!fs || !appInfo)
-                return undefined;
-            const entries = await fs.readdir(folderUri, { extended: true });
-            const thumbnailFile = entries.find(e => !e.isDirectory && IMAGE_EXTENSIONS.has(this.getExtension(e.name).toLowerCase()));
-            if (!thumbnailFile)
-                return undefined;
-            const destDir = `${appInfo.getAppDir()}/thumbnails`;
-            await fs.ensureDir(destDir);
-            const srcContent = await fs.readFile(thumbnailFile.uri);
-            const destPath = `${destDir}/${route.id}.${this.getExtension(thumbnailFile.name)}`;
-            await fs.writeFile(destPath, srcContent);
-            return destPath;
+            const skipped = routes.length - target.length;
+            observer.emit('ingest-complete', { imported: importedRoutes.length, skipped, errors, failedRoutes, importedRoutes });
         }
         resolveVideoUri(videoRef, folderUri) {
             if (videoRef.startsWith('http://') || videoRef.startsWith('https://')) {
@@ -251,7 +433,9 @@ let RouteLibraryScannerService = (() => {
                 return videoRef;
             }
             if (videoRef.startsWith('/') || /^[A-Za-z]:[/\\]/.test(videoRef)) {
-                throw new Error('Absolute video path references are not supported during ingest');
+                if (this.isMobile())
+                    throw new Error('Absolute video path references are not supported during ingest');
+                return videoRef;
             }
             return `${folderUri}/${videoRef}`;
         }
@@ -292,6 +476,24 @@ let RouteLibraryScannerService = (() => {
                 delimiter: '/'
             };
         }
+        buildRouteDisplayItem(parsed) {
+            const { route, alreadyImported, parseError, format } = parsed;
+            const descr = route?.description ?? {};
+            const [C, U] = this.getUnitConversionShortcuts();
+            const distance = descr.distance === undefined ? undefined : {
+                value: C(descr.distance, 'distance', { digits: 1 }),
+                unit: U('distance')
+            };
+            return {
+                id: route.description.id,
+                distance,
+                label: route.title,
+                alreadyImported,
+                importable: parseError != null,
+                format,
+                errorReason: parseError
+            };
+        }
         getCompanionExts(parsers, primaryExt) {
             try {
                 const matching = parsers.suppertsExtension(primaryExt);
@@ -313,12 +515,27 @@ let RouteLibraryScannerService = (() => {
                 return true;
             return false;
         }
+        isMobile() {
+            return this.getBindings()?.appInfo?.getChannel() === 'mobile';
+        }
         getRouteList() {
             return (0, service_2.useRouteList)();
         }
         getBindings() {
             return (0, api_1.getBindings)();
         }
+        getRoutesDBLoader() {
+            return (0, db_1.useRoutesDbLoader)();
+        }
+        getParsers() {
+            return (0, parsers_1.useParsers)();
+        }
+        getUnitConversionShortcuts() {
+            return this.getUnitConverter().getUnitConversionShortcuts();
+        }
+        getUnitConverter() {
+            return (0, i18n_1.useUnitConverter)();
+        }
     };
     return RouteLibraryScannerService = _classThis;
 })();

package/lib/cjs/routes/list/loaders/db.js

@@ -37,7 +37,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.RoutesDbLoader = void 0;
+exports.useRoutesDbLoader = exports.RoutesDbLoader = void 0;
 const api_1 = require("../../../api");
 const types_1 = require("../../../base/types");
 const observer_1 = require("../../../base/types/observer");
@@ -339,3 +339,5 @@ let RoutesDbLoader = (() => {
     return RoutesDbLoader = _classThis;
 })();
 exports.RoutesDbLoader = RoutesDbLoader;
+const useRoutesDbLoader = () => new RoutesDbLoader();
+exports.useRoutesDbLoader = useRoutesDbLoader;

package/lib/cjs/routes/list/service.js

@@ -126,6 +126,7 @@ let RouteListService = (() => {
         syncInfo;
         currentView;
         stats;
+        isListUpdatePaused = false;
         constructor() {
             super('RouteList');
             this.myRoutes = new myroutes_1.MyRoutes('myRoutes', 'My Routes');
@@ -709,7 +710,15 @@ let RouteListService = (() => {
                 this.logError(err, 'import', info);
             }
         }
+        pauseListUpdates() {
+            this.isListUpdatePaused = true;
+        }
+        resumeListUpdates() {
+            this.isListUpdatePaused = false;
+        }
         emitLists(event, props) {
+            if (this.isListUpdatePaused)
+                return;
             try {
                 const { log, source = 'user' } = props ?? {};
                 if (this.currentView === 'grid' || this.currentView === 'list') {
@@ -791,6 +800,25 @@ let RouteListService = (() => {
                 return [];
             }
         }
+        existsBySourceUri(uri) {
+            try {
+                return this.routes.some(r => r.description?.sourceTreeUri === uri ||
+                    r.description?.videoUrl === uri);
+            }
+            catch (err) {
+                this.logError(err, 'existsBySourceUri', { uri });
+                return false;
+            }
+        }
+        getBySourceUri(uri) {
+            try {
+                return this.routes.find(r => r.description?.sourceTreeUri === uri ||
+                    r.description?.videoUrl === uri);
+            }
+            catch (err) {
+                this.logError(err, 'getBySourceUri', { uri });
+            }
+        }
         addRoute(route, source = 'system') {
             this.routes.push(route);
             if (route.description?.isDeleted) {