incyclist-services 1.7.51 → 1.7.52

package/lib/cjs/routes/base/parsers/epm.js

@@ -10,6 +10,12 @@ class EPMParser extends xml_1.XMLParser {
     supportsExtension(extension) {
         return extension.toLowerCase() === 'epm';
     }
+    getPrimaryExtension() {
+        return 'epm';
+    }
+    getCompanionExtensions() {
+        return ['epp'];
+    }
     async loadPoints(context) {
         const { data, route } = context;
         route.points = [];

package/lib/cjs/routes/base/parsers/factory.js

@@ -24,6 +24,11 @@ class ParserFactory {
             throw new Error(`invalid file format ${extension}`);
         return matching;
     }
+    isPrimaryExtension(extension) {
+        const ext = extension.toLowerCase();
+        const isPrimary = this.parsers.some(p => p.getPrimaryExtension() === ext);
+        return isPrimary;
+    }
     findMatching(extension, data) {
         const matching = this.parsers
             .filter(p => p.supportsExtension(extension))

package/lib/cjs/routes/base/parsers/geometry.js

@@ -52,6 +52,12 @@ let GeometryParser = (() => {
             const geometry = await this.getData(file, data);
             return await this.parse(file, geometry);
         }
+        getPrimaryExtension() {
+            return 'xml';
+        }
+        getCompanionExtensions() {
+            return [];
+        }
         supportsExtension(extension) {
             return extension.toLowerCase() === 'json';
         }

package/lib/cjs/routes/base/parsers/gpx.js

@@ -14,6 +14,12 @@ class GPXParser extends xml_1.XMLParser {
         super();
         this.props = props;
     }
+    getPrimaryExtension() {
+        return 'gpx';
+    }
+    getCompanionExtensions() {
+        return [];
+    }
     supportsExtension(extension) {
         return extension.toLowerCase() === 'gpx';
     }

package/lib/cjs/routes/base/parsers/multixml.js

@@ -20,6 +20,12 @@ class MultipleXMLParser {
     supportsExtension(extension) {
         return extension?.toLowerCase() === 'xml';
     }
+    getPrimaryExtension() {
+        return 'xml';
+    }
+    getCompanionExtensions() {
+        return [];
+    }
     supportsContent() {
         return true;
     }

package/lib/cjs/routes/base/parsers/tacx/TacxParser.js

@@ -39,6 +39,12 @@ class TacxParser {
     supportsContent(data) {
         return TacxReader_1.TacxFileReader.isValid(data);
     }
+    getPrimaryExtension() {
+        return 'rlv';
+    }
+    getCompanionExtensions() {
+        return ['pgmf'];
+    }
     buildContext(file) {
         const { dir, delimiter: d } = file;
         if (file.ext === 'rlv') {

package/lib/cjs/routes/base/parsers/xml.js

@@ -18,6 +18,12 @@ class XMLParser {
         const C = this.constructor;
         return C['SCHEME'];
     }
+    getPrimaryExtension() {
+        return 'xml';
+    }
+    getCompanionExtensions() {
+        return [];
+    }
     supportsExtension(extension) {
         return extension.toLowerCase() === 'xml';
     }

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

@@ -0,0 +1,327 @@
+"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;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useRouteLibraryScanner = exports.RouteLibraryScannerService = void 0;
+const uuid_1 = require("uuid");
+const api_1 = require("../../api");
+const json_1 = require("../../api/repository/json");
+const decorators_1 = require("../../base/decorators");
+const service_1 = require("../../base/service");
+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']);
+let RouteLibraryScannerService = (() => {
+    let _classDecorators = [decorators_1.Singleton];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _classSuper = service_1.IncyclistService;
+    let _instanceExtraInitializers = [];
+    let _getRouteList_decorators;
+    let _getBindings_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];
+            __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(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);
+        }
+        constructor() {
+            super('RouteLibraryScanner');
+            __runInitializers(this, _instanceExtraInitializers);
+        }
+        scan(folderInfo) {
+            const observer = new types_1.Observer();
+            this._scan(folderInfo, observer).catch(err => {
+                this.logError(err, 'scan', { uri: folderInfo.uri });
+                observer.emit('error', err.message);
+            });
+            return observer;
+        }
+        ingest(routes, treeUri) {
+            const observer = new types_1.Observer();
+            this._ingest(routes, treeUri, observer).catch(err => {
+                this.logError(err, 'ingest', { treeUri });
+                observer.emit('error', err.message);
+            });
+            return observer;
+        }
+        async _scan(folderInfo, observer) {
+            await (0, utils_1.waitNextTick)();
+            const parsers = (0, parsers_1.useParsers)();
+            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');
+        }
+        async scanFolder(uri, folderName, observer, parsers, progress, discoveredCount) {
+            const fs = this.getBindings().fs;
+            let entries;
+            try {
+                entries = await fs.readdir(uri, { extended: true });
+            }
+            catch (err) {
+                this.logError(err, 'scanFolder', { uri });
+                return;
+            }
+            progress.scannedFolders++;
+            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);
+                return ext && parsers.isPrimaryExtension(ext);
+            });
+            for (const file of primaryFiles) {
+                const route = await this.buildDiscoveredRoute(file, files, uri, folderName, parsers);
+                discoveredCount.value++;
+                observer.emit('discovered', route);
+            }
+            for (const dir of dirs) {
+                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
+            };
+        }
+        async _ingest(routes, treeUri, observer) {
+            await (0, utils_1.waitNextTick)();
+            const importable = routes.filter(r => r.importable && !r.alreadyImported);
+            const total = importable.length;
+            let imported = 0;
+            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 });
+                try {
+                    await this.ingestRoute(route, treeUri);
+                    imported++;
+                }
+                catch (err) {
+                    const reason = err?.message ?? String(err);
+                    errors++;
+                    failedRoutes.push({ name: route.folderName, reason });
+                    observer.emit('ingest-error', { name: route.folderName, 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;
+        }
+        resolveVideoUri(videoRef, folderUri) {
+            if (videoRef.startsWith('http://') || videoRef.startsWith('https://')) {
+                return videoRef;
+            }
+            if (videoRef.startsWith('content://')) {
+                return videoRef;
+            }
+            if (videoRef.startsWith('/') || /^[A-Za-z]:[/\\]/.test(videoRef)) {
+                throw new Error('Absolute video path references are not supported during ingest');
+            }
+            return `${folderUri}/${videoRef}`;
+        }
+        async upsertImportHistory(folderInfo, routeCount) {
+            try {
+                const repo = json_1.JsonRepository.create('importedLibraries');
+                const names = await repo.list();
+                const all = await Promise.all((names ?? []).map(n => repo.read(n)));
+                const existing = all
+                    .map(lib => lib)
+                    .find(lib => lib?.treeUri === folderInfo.uri);
+                const id = existing?.id ?? (0, uuid_1.v4)();
+                await repo.write(id, {
+                    id,
+                    treeUri: folderInfo.uri,
+                    displayName: folderInfo.displayName,
+                    lastScanned: new Date().toISOString(),
+                    routeCount
+                });
+            }
+            catch (err) {
+                this.logError(err, 'upsertImportHistory', { uri: folderInfo.uri });
+            }
+        }
+        buildFileInfo(uri, ext) {
+            const lastSlash = Math.max(uri.lastIndexOf('/'), uri.lastIndexOf('\\'));
+            const dir = uri.slice(0, lastSlash);
+            const base = uri.slice(lastSlash + 1);
+            const name = base.slice(0, base.length - ext.length - 1);
+            return {
+                type: 'url',
+                url: uri,
+                filename: uri,
+                base,
+                name,
+                dir,
+                ext,
+                delimiter: '/'
+            };
+        }
+        getCompanionExts(parsers, primaryExt) {
+            try {
+                const matching = parsers.suppertsExtension(primaryExt);
+                const parser = matching.find(p => p.getPrimaryExtension() === primaryExt);
+                return parser?.getCompanionExtensions() ?? [];
+            }
+            catch {
+                return [];
+            }
+        }
+        getExtension(filename) {
+            const dot = filename.lastIndexOf('.');
+            return dot >= 0 ? filename.slice(dot + 1).toLowerCase() : '';
+        }
+        containsAbsolutePath(content) {
+            if (/[>"']\//m.test(content))
+                return true;
+            if (/[A-Za-z]:[/\\]/m.test(content))
+                return true;
+            return false;
+        }
+        getRouteList() {
+            return (0, service_2.useRouteList)();
+        }
+        getBindings() {
+            return (0, api_1.getBindings)();
+        }
+    };
+    return RouteLibraryScannerService = _classThis;
+})();
+exports.RouteLibraryScannerService = RouteLibraryScannerService;
+const useRouteLibraryScanner = () => new RouteLibraryScannerService();
+exports.useRouteLibraryScanner = useRouteLibraryScanner;

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

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/esm/routes/base/parsers/epm.js

@@ -7,6 +7,12 @@ export class EPMParser extends XMLParser {
     supportsExtension(extension) {
         return extension.toLowerCase() === 'epm';
     }
+    getPrimaryExtension() {
+        return 'epm';
+    }
+    getCompanionExtensions() {
+        return ['epp'];
+    }
     async loadPoints(context) {
         const { data, route } = context;
         route.points = [];

package/lib/esm/routes/base/parsers/factory.js

@@ -21,6 +21,11 @@ export class ParserFactory {
             throw new Error(`invalid file format ${extension}`);
         return matching;
     }
+    isPrimaryExtension(extension) {
+        const ext = extension.toLowerCase();
+        const isPrimary = this.parsers.some(p => p.getPrimaryExtension() === ext);
+        return isPrimary;
+    }
     findMatching(extension, data) {
         const matching = this.parsers
             .filter(p => p.supportsExtension(extension))

package/lib/esm/routes/base/parsers/geometry.js

@@ -49,6 +49,12 @@ let GeometryParser = (() => {
             const geometry = await this.getData(file, data);
             return await this.parse(file, geometry);
         }
+        getPrimaryExtension() {
+            return 'xml';
+        }
+        getCompanionExtensions() {
+            return [];
+        }
         supportsExtension(extension) {
             return extension.toLowerCase() === 'json';
         }

package/lib/esm/routes/base/parsers/gpx.js

@@ -11,6 +11,12 @@ export class GPXParser extends XMLParser {
         super();
         this.props = props;
     }
+    getPrimaryExtension() {
+        return 'gpx';
+    }
+    getCompanionExtensions() {
+        return [];
+    }
     supportsExtension(extension) {
         return extension.toLowerCase() === 'gpx';
     }

package/lib/esm/routes/base/parsers/multixml.js

@@ -17,6 +17,12 @@ export class MultipleXMLParser {
     supportsExtension(extension) {
         return extension?.toLowerCase() === 'xml';
     }
+    getPrimaryExtension() {
+        return 'xml';
+    }
+    getCompanionExtensions() {
+        return [];
+    }
     supportsContent() {
         return true;
     }

package/lib/esm/routes/base/parsers/tacx/TacxParser.js

@@ -33,6 +33,12 @@ export class TacxParser {
     supportsContent(data) {
         return TacxFileReader.isValid(data);
     }
+    getPrimaryExtension() {
+        return 'rlv';
+    }
+    getCompanionExtensions() {
+        return ['pgmf'];
+    }
     buildContext(file) {
         const { dir, delimiter: d } = file;
         if (file.ext === 'rlv') {

package/lib/esm/routes/base/parsers/xml.js

@@ -15,6 +15,12 @@ export class XMLParser {
         const C = this.constructor;
         return C['SCHEME'];
     }
+    getPrimaryExtension() {
+        return 'xml';
+    }
+    getCompanionExtensions() {
+        return [];
+    }
     supportsExtension(extension) {
         return extension.toLowerCase() === 'xml';
     }

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

@@ -0,0 +1,323 @@
+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;
+};
+import { v4 as uuidv4 } from 'uuid';
+import { getBindings } from '../../api';
+import { JsonRepository } from '../../api/repository/json';
+import { Injectable, Singleton } from '../../base/decorators';
+import { IncyclistService } from '../../base/service';
+import { Observer } from '../../base/types';
+import { RouteParser, useParsers } from '../base/parsers';
+import { useRouteList } from '../list/service';
+import { waitNextTick } from '../../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']);
+let RouteLibraryScannerService = (() => {
+    let _classDecorators = [Singleton];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _classSuper = IncyclistService;
+    let _instanceExtraInitializers = [];
+    let _getRouteList_decorators;
+    let _getBindings_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 = [Injectable];
+            _getBindings_decorators = [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(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);
+        }
+        constructor() {
+            super('RouteLibraryScanner');
+            __runInitializers(this, _instanceExtraInitializers);
+        }
+        scan(folderInfo) {
+            const observer = new Observer();
+            this._scan(folderInfo, observer).catch(err => {
+                this.logError(err, 'scan', { uri: folderInfo.uri });
+                observer.emit('error', err.message);
+            });
+            return observer;
+        }
+        ingest(routes, treeUri) {
+            const observer = new Observer();
+            this._ingest(routes, treeUri, observer).catch(err => {
+                this.logError(err, 'ingest', { treeUri });
+                observer.emit('error', err.message);
+            });
+            return observer;
+        }
+        async _scan(folderInfo, observer) {
+            await waitNextTick();
+            const parsers = useParsers();
+            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');
+        }
+        async scanFolder(uri, folderName, observer, parsers, progress, discoveredCount) {
+            const fs = this.getBindings().fs;
+            let entries;
+            try {
+                entries = await fs.readdir(uri, { extended: true });
+            }
+            catch (err) {
+                this.logError(err, 'scanFolder', { uri });
+                return;
+            }
+            progress.scannedFolders++;
+            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);
+                return ext && parsers.isPrimaryExtension(ext);
+            });
+            for (const file of primaryFiles) {
+                const route = await this.buildDiscoveredRoute(file, files, uri, folderName, parsers);
+                discoveredCount.value++;
+                observer.emit('discovered', route);
+            }
+            for (const dir of dirs) {
+                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: uuidv4(),
+                folderUri,
+                folderName,
+                controlFileUri: controlFile.uri,
+                format: ext,
+                hasVideo,
+                hasThumbnail,
+                alreadyImported,
+                importable,
+                skipReason
+            };
+        }
+        async _ingest(routes, treeUri, observer) {
+            await waitNextTick();
+            const importable = routes.filter(r => r.importable && !r.alreadyImported);
+            const total = importable.length;
+            let imported = 0;
+            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 });
+                try {
+                    await this.ingestRoute(route, treeUri);
+                    imported++;
+                }
+                catch (err) {
+                    const reason = err?.message ?? String(err);
+                    errors++;
+                    failedRoutes.push({ name: route.folderName, reason });
+                    observer.emit('ingest-error', { name: route.folderName, 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 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 ?? uuidv4(),
+                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;
+        }
+        resolveVideoUri(videoRef, folderUri) {
+            if (videoRef.startsWith('http://') || videoRef.startsWith('https://')) {
+                return videoRef;
+            }
+            if (videoRef.startsWith('content://')) {
+                return videoRef;
+            }
+            if (videoRef.startsWith('/') || /^[A-Za-z]:[/\\]/.test(videoRef)) {
+                throw new Error('Absolute video path references are not supported during ingest');
+            }
+            return `${folderUri}/${videoRef}`;
+        }
+        async upsertImportHistory(folderInfo, routeCount) {
+            try {
+                const repo = JsonRepository.create('importedLibraries');
+                const names = await repo.list();
+                const all = await Promise.all((names ?? []).map(n => repo.read(n)));
+                const existing = all
+                    .map(lib => lib)
+                    .find(lib => lib?.treeUri === folderInfo.uri);
+                const id = existing?.id ?? uuidv4();
+                await repo.write(id, {
+                    id,
+                    treeUri: folderInfo.uri,
+                    displayName: folderInfo.displayName,
+                    lastScanned: new Date().toISOString(),
+                    routeCount
+                });
+            }
+            catch (err) {
+                this.logError(err, 'upsertImportHistory', { uri: folderInfo.uri });
+            }
+        }
+        buildFileInfo(uri, ext) {
+            const lastSlash = Math.max(uri.lastIndexOf('/'), uri.lastIndexOf('\\'));
+            const dir = uri.slice(0, lastSlash);
+            const base = uri.slice(lastSlash + 1);
+            const name = base.slice(0, base.length - ext.length - 1);
+            return {
+                type: 'url',
+                url: uri,
+                filename: uri,
+                base,
+                name,
+                dir,
+                ext,
+                delimiter: '/'
+            };
+        }
+        getCompanionExts(parsers, primaryExt) {
+            try {
+                const matching = parsers.suppertsExtension(primaryExt);
+                const parser = matching.find(p => p.getPrimaryExtension() === primaryExt);
+                return parser?.getCompanionExtensions() ?? [];
+            }
+            catch {
+                return [];
+            }
+        }
+        getExtension(filename) {
+            const dot = filename.lastIndexOf('.');
+            return dot >= 0 ? filename.slice(dot + 1).toLowerCase() : '';
+        }
+        containsAbsolutePath(content) {
+            if (/[>"']\//m.test(content))
+                return true;
+            if (/[A-Za-z]:[/\\]/m.test(content))
+                return true;
+            return false;
+        }
+        getRouteList() {
+            return useRouteList();
+        }
+        getBindings() {
+            return getBindings();
+        }
+    };
+    return RouteLibraryScannerService = _classThis;
+})();
+export { RouteLibraryScannerService };
+export const useRouteLibraryScanner = () => new RouteLibraryScannerService();

package/lib/esm/routes/library/types.js

@@ -0,0 +1 @@
+export {};

package/lib/types/api/fs/index.d.ts

@@ -1,3 +1,8 @@
+export interface ReadDirResult {
+    name: string;
+    uri: string;
+    isDirectory: boolean;
+}
 export interface IFileSystem {
     writeFile(...args: any[]): any;
     readFile(...args: any[]): any;
@@ -11,5 +16,11 @@ export interface IFileSystem {
     existsDir(path: any): Promise<boolean>;
     mkdir(path: any): Promise<void>;
     ensureDir(path: any): Promise<void>;
-    readdir?(path: string, options: any): Promise<string[]>;
+    readdir?(path: string, options?: {
+        recursive?: boolean;
+    }): Promise<string[]>;
+    readdir?(path: string, options: {
+        recursive?: boolean;
+        extended: true;
+    }): Promise<ReadDirResult[]>;
 }

package/lib/types/api/ui/index.d.ts

@@ -1,6 +1,7 @@
 export type SelectDirectoryResult = {
     selected?: string;
     canceled?: boolean;
+    displayName?: string;
 };
 export type TakeScreenshotProps = {
     fileName?: string;

package/lib/types/routes/base/parsers/epm.d.ts

@@ -9,6 +9,8 @@ export interface EpmParserContext extends XmlParserContext {
 export declare class EPMParser extends XMLParser {
     static readonly SCHEME = "roadmovie";
     supportsExtension(extension: any): boolean;
+    getPrimaryExtension(): string;
+    getCompanionExtensions(): string[];
     protected loadPoints(context: EpmParserContext): Promise<void>;
     protected loadEpp(context: EpmParserContext): Promise<Buffer>;
     protected getV7Program(reader: BinaryReader, json: any): DaumEpp;

package/lib/types/routes/base/parsers/factory.d.ts

@@ -1,4 +1,4 @@
-import { Parser } from "../types";
+import type { Parser } from "./types";
 export declare class ParserFactory {
     protected static _instance: ParserFactory;
     static getInstance(): ParserFactory;
@@ -7,6 +7,7 @@ export declare class ParserFactory {
     constructor();
     add(parser: Parser<unknown, unknown>): void;
     suppertsExtension(extension: string): Parser<unknown, unknown>[];
+    isPrimaryExtension(extension: string): boolean;
     findMatching(extension: string, data?: unknown): Parser<unknown, unknown>;
     isInitialized(): boolean;
     setInitialized(done: boolean): void;

package/lib/types/routes/base/parsers/geometry.d.ts

@@ -1,5 +1,6 @@
 import { FileInfo } from "../../../api";
-import { Parser, ParseResult, RouteBase, RoutePoint, VideoMapping } from "../types";
+import { RouteBase, RoutePoint, VideoMapping } from "../types";
+import type { Parser, ParseResult } from "./types";
 export type Geometry = {
     geometry: Array<GeometryPoint>;
     video_points: Array<VideoPoint>;
@@ -20,6 +21,8 @@ export interface GeoParserData extends RouteBase {
 }
 export declare class GeometryParser implements Parser<Geometry, GeoParserData> {
     import(file: FileInfo, data?: Geometry): Promise<ParseResult<GeoParserData>>;
+    getPrimaryExtension(): string;
+    getCompanionExtensions(): string[];
     supportsExtension(extension: string): boolean;
     supportsContent(data: Geometry): boolean;
     getData(file: FileInfo, data?: Geometry): Promise<Geometry>;

package/lib/types/routes/base/parsers/gpx.d.ts

@@ -12,6 +12,8 @@ export declare class GPXParser extends XMLParser {
     protected static SCHEME: string;
     protected props: GPXParserProps;
     constructor(props?: GPXParserProps);
+    getPrimaryExtension(): string;
+    getCompanionExtensions(): string[];
     supportsExtension(extension: any): boolean;
     protected loadDescription(context: XmlParserContext): Promise<void>;
     protected getNumberOfPoints(context: XmlParserContext): number;

package/lib/types/routes/base/parsers/index.d.ts

@@ -1,8 +1,8 @@
 export * from './kwt';
 import { FileInfo } from '../../../api';
 import { ParserFactory } from './factory';
-import { ParseResult } from '../types';
 import { RouteApiDetail } from '../api/types';
+import type { ParseResult } from './types';
 export declare const useParsers: () => ParserFactory;
 export declare class RouteParser {
     static parse(info: FileInfo): Promise<ParseResult<RouteApiDetail>>;

package/lib/types/routes/base/parsers/multixml.d.ts

@@ -1,13 +1,15 @@
 import { FileInfo } from "../../../api";
 import { RouteApiDetail } from "../api/types";
-import { ParseResult, Parser } from "../types";
 import { XmlJSON } from "../../../utils/xml";
 import { XMLParser } from "./xml";
+import type { ParseResult, Parser } from "./types";
 export declare class MultipleXMLParser implements Parser<XmlJSON, RouteApiDetail> {
     protected parsers: any;
     constructor(classes: Array<typeof XMLParser>);
     import(file: FileInfo, data?: XmlJSON): Promise<ParseResult<RouteApiDetail>>;
     supportsExtension(extension: string): boolean;
+    getPrimaryExtension(): string;
+    getCompanionExtensions(): string[];
     supportsContent(): boolean;
     getData(info: FileInfo, data?: XmlJSON): Promise<XmlJSON>;
 }

package/lib/types/routes/base/parsers/tacx/TacxParser.d.ts

@@ -1,7 +1,8 @@
 import { FileInfo } from "../../../../api";
 import { RouteApiDetail } from "../../api/types";
 import { PgmfFile, RlvCourseInfo, RlvFile } from "../../model/tacx";
-import { Parser, ParseResult, RouteInfo, RoutePoint } from "../../types";
+import { RouteInfo, RoutePoint } from "../../types";
+import type { Parser, ParseResult } from "../types";
 export interface TacxParserContext {
     rlvFile: FileInfo;
     pgmfFile: FileInfo;
@@ -13,6 +14,8 @@ export declare class TacxParser implements Parser<ArrayBuffer, RouteApiDetail> {
     import(file: FileInfo, data?: ArrayBuffer): Promise<ParseResult<RouteApiDetail>>;
     getData(info: FileInfo, data?: ArrayBuffer): Promise<ArrayBuffer>;
     supportsContent(data: ArrayBuffer): boolean;
+    getPrimaryExtension(): string;
+    getCompanionExtensions(): string[];
     protected buildContext(file: FileInfo): TacxParserContext;
     protected parseRlv(context: TacxParserContext): Promise<void>;
     protected parsePgmf(context: TacxParserContext): Promise<void>;

package/lib/types/routes/base/parsers/types.d.ts

@@ -1,3 +1,5 @@
+import { FileInfo } from "../../../api";
+import { RouteBase, RouteInfo } from "../types";
 export type Position = {
     distance?: string;
     lat?: string;
@@ -13,3 +15,15 @@ export type CutInfo = {
     startFrame?: number;
     endFrame?: number;
 };
+export interface ParseResult<T extends RouteBase> {
+    data: RouteInfo;
+    details: T;
+}
+export interface Parser<In, Out extends RouteBase> {
+    import(file: FileInfo, data?: In): Promise<ParseResult<Out>>;
+    supportsExtension(extension: string): boolean;
+    supportsContent(data: In): boolean;
+    getData(info: FileInfo, data?: In): Promise<In>;
+    getPrimaryExtension(): string;
+    getCompanionExtensions(): string[];
+}

package/lib/types/routes/base/parsers/xml.d.ts

@@ -1,8 +1,9 @@
 import { EventLogger } from 'gd-eventlog';
 import { JSONObject, XmlJSON } from '../../../utils/xml';
 import { RouteApiDetail } from '../api/types';
-import { ParseResult, Parser, RouteInfo } from '../types';
+import { RouteInfo } from '../types';
 import { FileInfo } from '../../../api';
+import type { ParseResult, Parser } from './types';
 export interface XmlParserContext {
     fileInfo: FileInfo;
     data: JSONObject;
@@ -12,6 +13,8 @@ export declare class XMLParser implements Parser<XmlJSON, RouteApiDetail> {
     protected logger?: EventLogger;
     import(file: FileInfo, data?: XmlJSON): Promise<ParseResult<RouteApiDetail>>;
     getSupportedSheme(): string;
+    getPrimaryExtension(): string;
+    getCompanionExtensions(): string[];
     supportsExtension(extension: string): boolean;
     supportsContent(xmljson: XmlJSON): boolean;
     getData(file: FileInfo, data?: XmlJSON): Promise<XmlJSON>;

package/lib/types/routes/base/types/index.d.ts

@@ -1,4 +1,3 @@
-import { FileInfo } from "../../../api";
 import { LocalizedText } from "../../../i18n";
 import { LatLng } from "../../../utils/geo";
 export type RouteType = 'gpx' | 'video';
@@ -120,16 +119,6 @@ export interface RouteInfo extends RouteBase {
     source?: string;
     isLoopVerified?: boolean;
 }
-export interface ParseResult<T extends RouteBase> {
-    data: RouteInfo;
-    details: T;
-}
-export interface Parser<In, Out extends RouteBase> {
-    import(file: FileInfo, data?: In): Promise<ParseResult<Out>>;
-    supportsExtension(extension: string): boolean;
-    supportsContent(data: In): boolean;
-    getData(info: FileInfo, data?: In): Promise<In>;
-}
 export interface AppStatus {
     isOnline?: boolean;
 }

package/lib/types/routes/library/service.d.ts

@@ -0,0 +1,28 @@
+import { IncyclistService } from '../../base/service';
+import { IObserver } from '../../base/typedefs';
+import { DiscoveredRoute, FolderInfo, RouteRecord } from './types';
+interface ILibraryRouteList {
+    existsBySourceUri(uri: string): Promise<boolean>;
+    addRoute(record: RouteRecord): Promise<void>;
+}
+export declare class RouteLibraryScannerService extends IncyclistService {
+    constructor();
+    scan(folderInfo: FolderInfo): IObserver;
+    ingest(routes: DiscoveredRoute[], treeUri: string): IObserver;
+    private _scan;
+    private scanFolder;
+    private buildDiscoveredRoute;
+    private _ingest;
+    private ingestRoute;
+    private copyThumbnail;
+    private resolveVideoUri;
+    private upsertImportHistory;
+    private buildFileInfo;
+    private getCompanionExts;
+    private getExtension;
+    private containsAbsolutePath;
+    protected getRouteList(): ILibraryRouteList;
+    protected getBindings(): import("../../api").IncyclistBindings;
+}
+export declare const useRouteLibraryScanner: () => RouteLibraryScannerService;
+export {};

package/lib/types/routes/library/types.d.ts

@@ -0,0 +1,57 @@
+export interface FolderInfo {
+    uri: string;
+    displayName: string;
+}
+export interface DiscoveredRoute {
+    id: string;
+    folderUri: string;
+    folderName: string;
+    controlFileUri: string;
+    format: string;
+    hasVideo: boolean;
+    hasThumbnail: boolean;
+    alreadyImported: boolean;
+    importable: boolean;
+    skipReason?: string;
+}
+export interface RouteRecord {
+    id: string;
+    name: string;
+    format: string;
+    thumbnailPath?: string;
+    videoUri?: string;
+    sourceTreeUri: string;
+}
+export interface FailedRoute {
+    name: string;
+    reason: string;
+}
+export interface ImportDisplayProps {
+    phase: 'landing' | 'scanning' | 'selecting' | 'ingesting' | 'complete' | 'result' | 'error';
+    discoveredRoutes: DiscoveredRoute[];
+    scanProgress?: {
+        scannedFolders: number;
+    };
+    ingestProgress?: {
+        current: number;
+        total: number;
+        currentName: string;
+    };
+    completionSummary?: {
+        imported: number;
+        skipped: number;
+        errors: number;
+        failedRoutes: FailedRoute[];
+    };
+    resultSuccess?: {
+        routeName: string;
+    };
+    error?: string;
+}
+export interface ImportedLibrary {
+    id: string;
+    treeUri: string;
+    displayName: string;
+    lastScanned: string;
+    routeCount: number;
+}

package/lib/types/routes/types.d.ts

@@ -4,4 +4,6 @@ export type * from './list/cards/types';
 export type * from './base/api/types';
 export type * from './base/types';
 export type * from './base/model/types';
+export type * from './base/parsers/types';
+export type * from './library/types';
 export type RouteImportStatus = 'idle' | 'parsing' | 'error' | 'success';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "incyclist-services",
-  "version": "1.7.51",
+  "version": "1.7.52",
   "peerDependencies": {
     "gd-eventlog": "^0.1.27"
   },