incyclist-services 1.7.51 → 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/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,544 @@
+"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 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;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _classSuper = service_1.IncyclistService;
+    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');
+        }
+        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;
+        }
+        parse(scannedRoutes) {
+            const observer = new types_1.Observer();
+            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 = 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', this.scanResult);
+        }
+        async scanFolder(uri, folderName, observer, parsers, progress, discoveredCount, recursive = true) {
+            const fs = this.getBindings().fs;
+            let entries;
+            try {
+                entries = await fs.readdir(uri, { recursive: false, 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 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) {
+                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) {
+                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 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) {
+                    skipReason = `Missing companion file (.${compExt})`;
+                    break;
+                }
+            }
+            return {
+                folderUri,
+                folderName,
+                controlFileUri: controlFile.uri,
+                format: ext,
+                scanError: skipReason
+            };
+        }
+        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 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 = [];
+            const importedRoutes = [];
+            for (let i = 0; i < target.length; i++) {
+                if (this.isCancelled)
+                    continue;
+                const { route } = target[i] ?? {};
+                try {
+                    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.title, reason });
+                    observer.emit('ingest-error', { name: route.title, reason });
+                }
+            }
+            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://')) {
+                return videoRef;
+            }
+            if (videoRef.startsWith('content://')) {
+                return videoRef;
+            }
+            if (videoRef.startsWith('/') || /^[A-Za-z]:[/\\]/.test(videoRef)) {
+                if (this.isMobile())
+                    throw new Error('Absolute video path references are not supported during ingest');
+                return videoRef;
+            }
+            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: '/'
+            };
+        }
+        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);
+                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;
+        }
+        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;
+})();
+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/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;