incyclist-services 1.7.54 → 1.7.56

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

@@ -45,6 +45,7 @@ const access_1 = require("../access");
 const configuration_1 = require("../configuration");
 const ui_1 = require("../../ui");
 const types_1 = require("../../base/types");
+const ride_1 = require("../ride");
 let DevicesPageService = (() => {
     let _classDecorators = [decorators_1.Singleton];
     let _classDescriptor;
@@ -53,6 +54,7 @@ let DevicesPageService = (() => {
     let _classSuper = pages_1.IncyclistPageService;
     let _instanceExtraInitializers = [];
     let _getDevicePairing_decorators;
+    let _getDeviceRide_decorators;
     let _getDeviceConfiguration_decorators;
     let _getIncyclist_decorators;
     var DevicesPageService = class extends _classSuper {
@@ -60,9 +62,11 @@ let DevicesPageService = (() => {
         static {
             const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
             _getDevicePairing_decorators = [decorators_1.Injectable];
+            _getDeviceRide_decorators = [decorators_1.Injectable];
             _getDeviceConfiguration_decorators = [decorators_1.Injectable];
             _getIncyclist_decorators = [decorators_1.Injectable];
             __esDecorate(this, null, _getDevicePairing_decorators, { kind: "method", name: "getDevicePairing", static: false, private: false, access: { has: obj => "getDevicePairing" in obj, get: obj => obj.getDevicePairing }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _getDeviceRide_decorators, { kind: "method", name: "getDeviceRide", static: false, private: false, access: { has: obj => "getDeviceRide" in obj, get: obj => obj.getDeviceRide }, metadata: _metadata }, null, _instanceExtraInitializers);
             __esDecorate(this, null, _getDeviceConfiguration_decorators, { kind: "method", name: "getDeviceConfiguration", static: false, private: false, access: { has: obj => "getDeviceConfiguration" in obj, get: obj => obj.getDeviceConfiguration }, metadata: _metadata }, null, _instanceExtraInitializers);
             __esDecorate(this, null, _getIncyclist_decorators, { kind: "method", name: "getIncyclist", static: false, private: false, access: { has: obj => "getIncyclist" in obj, get: obj => obj.getIncyclist }, metadata: _metadata }, null, _instanceExtraInitializers);
             __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
@@ -325,6 +329,12 @@ let DevicesPageService = (() => {
                 return [
                     { label: 'OK', primary: true, onClick: this.onOK.bind(this) }
                 ];
+            if (this.getDeviceRide().canEnforceSimulator()) {
+                return [
+                    { label: 'Simulate', primary: true, onClick: this.onSimulate.bind(this) },
+                    { label: 'Skip', primary: false, onClick: this.onSkip.bind(this) }
+                ];
+            }
             return [
                 { label: 'Skip', primary: true, onClick: this.onSkip.bind(this) }
             ];
@@ -375,7 +385,6 @@ let DevicesPageService = (() => {
             const simulator = this.getDeviceConfiguration().getSimulatorAdapterId();
             this.getDevicePairing().prepareStart([simulator]);
             const prevContentPage = this.getPrevContentPage();
-            const prevPage = this.getAppState().getState('prevPage');
             if (this.isPairingForRide)
                 this.moveTo('/rideSimulate');
             else
@@ -400,6 +409,9 @@ let DevicesPageService = (() => {
         getDevicePairing() {
             return (0, pairing_1.useDevicePairing)();
         }
+        getDeviceRide() {
+            return (0, ride_1.useDeviceRide)();
+        }
         getDeviceConfiguration() {
             return (0, configuration_1.useDeviceConfiguration)();
         }

package/lib/cjs/ride/route/RLVDisplayService.js

@@ -521,6 +521,8 @@ let RLVDisplayService = (() => {
                 return fileName;
             if (fileName.startsWith('file:') || fileName.startsWith('http:') || fileName.startsWith('https:') || fileName.startsWith('/'))
                 return fileName;
+            if (fileName.startsWith('content:'))
+                return fileName;
             return `./${fileName}`;
         }
         isLoopEnabled() {

package/lib/cjs/routes/base/model/route.js

@@ -90,10 +90,7 @@ let Route = (() => {
             return this.getLocalizedTitle(language);
         }
         getLocalizedTitle(language) {
-            if (this._details)
-                return (0, localization_1.getLocalizedText)(this._details.localizedTitle, language) ?? this._details.title;
-            else
-                return (0, localization_1.getLocalizedText)(this._description.localizedTitle, language) ?? this._description.title;
+            return (0, localization_1.getLocalizedText)(this._description.localizedTitle, language) ?? this._description.title;
         }
         clone() {
             const description = (0, clone_1.default)(this._description);

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

@@ -81,6 +81,7 @@ class EPMParser extends xml_1.XMLParser {
             return res.data;
         }
         catch (err) {
+            this.logger.logEvent({ message: 'could not load EPP file', reason: err.message });
             onError();
         }
     }

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

@@ -38,6 +38,7 @@ exports.GeometryParser = void 0;
 const api_1 = require("../../../api");
 const decorators_1 = require("../../../base/decorators");
 const utils_1 = require("../../../utils");
+const utils_2 = require("./utils");
 let GeometryParser = (() => {
     let _instanceExtraInitializers = [];
     let _getLoader_decorators;
@@ -75,10 +76,8 @@ let GeometryParser = (() => {
                 if (res.error) {
                     onError();
                 }
-                if ((typeof res.data) === 'string') {
-                    return JSON.parse(res.data);
-                }
-                return res.data;
+                const cleaned = (0, utils_2.getUtf8Data)(res.data);
+                return JSON.parse(cleaned);
             }
             catch {
                 onError();

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

@@ -30,8 +30,8 @@ class IncyclistXMLParser extends xml_1.XMLParser {
     async loadPoints(context) {
         const { data, fileInfo, route } = context;
         const gpxFile = { ...fileInfo };
-        const xmlName = fileInfo.name;
-        const fileName = data['gpx-file-path'] ?? xmlName.replace('xml', 'gpx');
+        const xmlBase = fileInfo.base;
+        const fileName = data['gpx-file-path'] ?? xmlBase.replace('.xml', '.gpx');
         if (fileName.startsWith('file') || fileName.startsWith('/') || fileName.startsWith('\\') || fileName.startsWith('.')) {
             gpxFile.type = 'file';
             gpxFile.filename = fileName;
@@ -41,10 +41,10 @@ class IncyclistXMLParser extends xml_1.XMLParser {
             gpxFile.url = fileName;
         }
         else if (fileInfo.type === 'url') {
-            gpxFile.url = gpxFile.url.replace(xmlName, fileName);
+            gpxFile.url = gpxFile.url.replace(xmlBase, fileName);
         }
         else {
-            gpxFile.filename = gpxFile.filename.replace(xmlName, fileName);
+            gpxFile.filename = gpxFile.filename.replace(xmlBase, fileName);
         }
         try {
             let points;

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

@@ -24,6 +24,8 @@ const multixml_1 = require("./multixml");
 const bikelab_1 = require("./bikelab");
 const epm_1 = require("./epm");
 const TacxParser_1 = require("./tacx/TacxParser");
+const utils_1 = require("./utils");
+const gd_eventlog_1 = require("gd-eventlog");
 const useParsers = () => {
     const parsers = factory_1.ParserFactory.getInstance();
     if (!parsers.isInitialized()) {
@@ -38,6 +40,8 @@ const useParsers = () => {
 exports.useParsers = useParsers;
 class RouteParser {
     static async parse(info) {
+        const logger = new gd_eventlog_1.EventLogger('RouteParser');
+        (0, utils_1.fixIncorrectFileInfo)(info);
         const parsers = (0, exports.useParsers)();
         const formatParsers = parsers.suppertsExtension(info.ext);
         const promises = [];
@@ -51,8 +55,12 @@ class RouteParser {
         });
         const res = await Promise.allSettled(promises);
         const matching = res.map(promise => promise.status === 'fulfilled' ? promise.value : undefined).find(p => p !== undefined);
-        if (matching)
-            return await matching.parser.import(info, matching.data);
+        if (matching) {
+            logger.logEvent({ message: 'before import' });
+            const res = await matching.parser.import(info, matching.data);
+            logger.logEvent({ message: 'after import' });
+            return res;
+        }
         if (formatParsers.length === 0)
             throw new Error('no matching parser found');
         else {

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

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.MultipleXMLParser = void 0;
 const api_1 = require("../../../api");
 const xml_1 = require("../../../utils/xml");
+const utils_1 = require("./utils");
 class MultipleXMLParser {
     parsers;
     constructor(classes) {
@@ -37,7 +38,8 @@ class MultipleXMLParser {
         if (res.error) {
             throw new Error('Could not open file');
         }
-        const xml = await (0, xml_1.parseXml)(res.data);
+        const cleaned = (0, utils_1.getUtf8Data)(res.data);
+        const xml = await (0, xml_1.parseXml)(cleaned);
         return xml;
     }
 }

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

@@ -30,7 +30,9 @@ class TacxParser {
             if (res.error) {
                 onError();
             }
-            return res.data;
+            const buf = Buffer.isBuffer(res.data) ? res.data : Buffer.from(res.data, 'binary');
+            const data = buf.buffer.slice(buf.byteOffset, buf.byteOffset + buf.byteLength);
+            return data;
         }
         catch {
             onError();
@@ -50,24 +52,18 @@ class TacxParser {
         if (file.ext === 'rlv') {
             const pgmfFile = (0, clone_1.default)(file);
             pgmfFile.ext = 'pgmf';
-            pgmfFile.name = pgmfFile.name.replace('.rlv', '.pgmf');
-            pgmfFile.filename = `${dir}${d}${pgmfFile.name}`;
-            pgmfFile.url = `file:///${dir}${d}${pgmfFile.name}`;
-            return {
-                rlvFile: file,
-                pgmfFile
-            };
+            pgmfFile.base = pgmfFile.base.replace('.rlv', '.pgmf');
+            pgmfFile.filename = `${dir}${d}${pgmfFile.base}`;
+            pgmfFile.url = `file:///${dir}${d}${pgmfFile.base}`;
+            return { rlvFile: file, pgmfFile };
         }
         else if (file.ext === 'pgmf') {
             const rlvFile = (0, clone_1.default)(file);
             rlvFile.ext = 'rlv';
-            rlvFile.name = rlvFile.name.replace('.pgmf', '.rlv');
-            rlvFile.filename = `${dir}${d}${rlvFile.name}`;
-            rlvFile.url = `file:///${dir}${d}${rlvFile.name}`;
-            return {
-                rlvFile,
-                pgmfFile: file
-            };
+            rlvFile.base = rlvFile.base.replace('.pgmf', '.rlv');
+            rlvFile.filename = `${dir}${d}${rlvFile.base}`;
+            rlvFile.url = `file:///${dir}${d}${rlvFile.base}`;
+            return { rlvFile, pgmfFile: file };
         }
         else {
             throw new Error(`Unsupported file type ${file.ext}`);

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

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseInformations = exports.getReferencedFileInfo = exports.BinaryReader = void 0;
+exports.getUtf8Data = exports.fixIncorrectFileInfo = exports.parseInformations = exports.getReferencedFileInfo = exports.BinaryReader = void 0;
 const api_1 = require("../../../api");
 class BinaryReader {
     pos;
@@ -73,7 +73,7 @@ class BinaryReader {
 exports.BinaryReader = BinaryReader;
 const getReferencedFileInfo = (info, referenced, scheme = 'file') => {
     if (info.type !== 'url') {
-        return buildFromFile(info, referenced, scheme);
+        return buildFromFile(info, referenced);
     }
     if (referenced.url) {
         return referenced.url;
@@ -81,6 +81,9 @@ const getReferencedFileInfo = (info, referenced, scheme = 'file') => {
     if (!referenced.file) {
         return;
     }
+    if (referenced.file && info.filename?.startsWith('content://')) {
+        return `${info.dir}${info.delimiter}${referenced.file}`;
+    }
     const targetFileName = referenced.file;
     const regex = /([\\/])/g;
     if (targetFileName.startsWith('http://') || targetFileName.startsWith('https://')) {
@@ -97,9 +100,12 @@ const getReferencedFileInfo = (info, referenced, scheme = 'file') => {
     }
 };
 exports.getReferencedFileInfo = getReferencedFileInfo;
-const buildFromFile = (info, referenced, scheme = 'file') => {
+const buildFromFile = (info, referenced) => {
     if (referenced.file) {
-        const fileName = info.filename?.replace(info.name, referenced.file);
+        if (info.filename?.startsWith('content://')) {
+            return `${info.dir}${info.delimiter}${referenced.file}`;
+        }
+        const fileName = info.filename?.replace(info.base, referenced.file);
         return `file:///${fileName}`;
     }
     return referenced.url;
@@ -107,9 +113,8 @@ const buildFromFile = (info, referenced, scheme = 'file') => {
 const buildAbsolutePathTarget = (fileName, info, scheme) => {
     const inputUrl = info.url;
     if (inputUrl.startsWith('incyclist:') || inputUrl.startsWith('file:')) {
-        const target = {};
         const parts = inputUrl.split('://');
-        const targetPath = parts[1].replace(info.name, fileName);
+        const targetPath = parts[1].replace(info.base, fileName);
         return `${scheme}://${targetPath}`;
     }
 };
@@ -134,3 +139,42 @@ const parseInformations = (informations) => {
     });
 };
 exports.parseInformations = parseInformations;
+const fixIncorrectFileInfo = (file) => {
+    if (!file.base) {
+        file.base = file.name;
+        file.name = file.base.replace(`.${file.ext}`, '');
+    }
+};
+exports.fixIncorrectFileInfo = fixIncorrectFileInfo;
+const decodeUtf16Be = (data) => {
+    const swapped = Buffer.alloc(data.length);
+    for (let i = 0; i + 1 < data.length; i += 2) {
+        swapped[i] = data[i + 1];
+        swapped[i + 1] = data[i];
+    }
+    return Buffer.from(swapped.toString('utf16le')).toString('utf-8');
+};
+const getUtf8Data = (res) => {
+    const buf = Buffer.isBuffer(res) ? res : Buffer.from(res, 'binary');
+    if (buf[0] === 0xFE && buf[1] === 0xFF) {
+        return decodeUtf16Be(buf.subarray(2));
+    }
+    if (buf[0] === 0xFF && buf[1] === 0xFE) {
+        return Buffer.from(buf.subarray(2).toString('utf16le')).toString('utf-8');
+    }
+    if (buf[0] === 0xFD && buf[1] === 0xFD) {
+        if (buf[2] === 0x00 && buf[3] === 0x3C) {
+            return decodeUtf16Be(buf.subarray(2));
+        }
+        if (buf[2] === 0x3C && buf[3] === 0x00) {
+            return Buffer.from(buf.subarray(2).toString('utf16le')).toString('utf-8');
+        }
+    }
+    const str = typeof res === 'string' ? res : buf.toString('utf-8');
+    if (str.charCodeAt(0) === 0xFEFF)
+        return str.slice(1);
+    if (buf[0] === 0xEF && buf[1] === 0xBB && buf[2] === 0xBF)
+        return buf.subarray(3).toString('utf-8');
+    return str;
+};
+exports.getUtf8Data = getUtf8Data;

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

@@ -38,16 +38,19 @@ class XMLParser {
         const onError = () => {
             throw new Error('Could not open file: ' + (0, utils_2.getFileName)(file));
         };
+        let cleaned;
         const loader = (0, api_1.getBindings)().loader;
         try {
             const res = await loader.open(file);
             if (res.error) {
                 onError();
             }
-            const xml = await (0, xml_1.parseXml)(res.data);
+            const resData = (0, utils_1.getUtf8Data)(res.data);
+            const xml = await (0, xml_1.parseXml)(resData);
             return xml;
         }
         catch {
+            console.log('# failed', Buffer.from(cleaned ?? '').toString('hex'));
             onError();
         }
     }

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

@@ -93,9 +93,10 @@ let RouteLibraryScannerService = (() => {
         }
         done() {
             this.importProps = undefined;
+            this.scanResult = [];
         }
         getDisplayProps() {
-            return this.importProps;
+            return { ...this.importProps };
         }
         importSingle(fileInfo) {
             const observer = new types_1.Observer();
@@ -125,8 +126,12 @@ let RouteLibraryScannerService = (() => {
                 this.logError(err, 'scan', { uri: folderInfo.uri });
                 observer.emit('error', err.message);
             });
-            observer.on('scan-progress', (progress) => {
+            observer
+                .on('scan-progress', (progress) => {
                 this.importProps.scanProgress = progress;
+            })
+                .on('scan-complete', () => {
+                this.importProps.phase = 'parsing';
             });
             return observer;
         }
@@ -143,7 +148,15 @@ let RouteLibraryScannerService = (() => {
                 this.importProps.parseProgress = { parsed, total };
             });
             observer.on('parse-result', (route) => {
-                this.importProps.routes.push(this.buildRouteDisplayItem(route));
+                const idx = this.importProps.routes.findIndex(r => r.id === route.controlFileUri);
+                if (idx !== -1) {
+                    const observer = this.importProps.routes[idx].observer;
+                    const displayProps = this.buildRouteDisplayItem(route, observer);
+                    this.importProps.routes[idx] = displayProps;
+                    if (observer) {
+                        observer.emit('updated', displayProps);
+                    }
+                }
             });
             observer.on('parse-complete', () => {
                 this.importProps.phase = 'selecting';
@@ -179,7 +192,8 @@ let RouteLibraryScannerService = (() => {
         }
         cancel() {
             this.isCancelled = true;
-            this.importProps.phase = 'landing';
+            this.done();
+            this.prepare();
         }
         async importRoute(fileInfo, observer) {
             await (0, sleep_1.sleep)(0);
@@ -283,7 +297,7 @@ let RouteLibraryScannerService = (() => {
             const primaryFiles = files.filter((f) => {
                 const name = typeof (f) === 'string' ? f : f.name;
                 const ext = this.getExtension(name);
-                return ext && parsers.isPrimaryExtension(ext);
+                return ext && ext !== 'gpx' && parsers.isPrimaryExtension(ext);
             }).map((f) => {
                 if (typeof f === 'string') {
                     return {
@@ -335,68 +349,118 @@ let RouteLibraryScannerService = (() => {
             const service = this.getRouteList();
             const targets = scannedRoutes.filter(r => !r.scanError);
             const total = targets.length;
+            targets.forEach(target => {
+                const file = this.buildFileInfo(target.controlFileUri, target.format);
+                this.importProps.routes.push({
+                    format: target.format,
+                    importable: false,
+                    label: file.base,
+                    id: target.controlFileUri,
+                    alreadyImported: false,
+                    observer: new types_1.Observer()
+                });
+            });
+            observer.emit('parse-start');
             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);
+                await this._parseTarget(target, service, observer, i);
             }
             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;
-            }
+        async _parseTarget(target, service, observer, idx) {
+            this.logEvent({ message: '_parseTarget', target: target.controlFileUri });
             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}]`);
+                this.logEvent({ message: '_parseTarget:parse', target: target.controlFileUri });
+                result = await parsers_1.RouteParser.parse(file);
+                this.logEvent({ message: '_parseTarget:parse done', target: target.controlFileUri });
+                const route = new route_1.Route(result.data, result.details);
+                const existing = this.importProps.routes.find(ri => ri.id === route.description.id);
+                if (existing) {
+                    result = undefined;
+                    throw new Error(`Duplicate of ${existing.label}`);
                 }
                 if (result.data.hasVideo) {
-                    this.validateVideoUrl(result.details, target.folderUri, target.files);
+                    this.validateVideoUrl(route, target.folderUri, target.files);
                 }
-                observer.emit('parse-result', {
+                const parsed = {
                     alreadyImported: false,
-                    route: new route_1.Route(result.data, result.details),
+                    route,
                     folderUri: target.folderUri,
                     controlFileUri: target.controlFileUri,
                     format: target.format
-                });
+                };
+                if (service.getRoute(route.description.id)) {
+                    parsed.alreadyImported = true;
+                }
+                observer.emit('parse-result', parsed);
             }
             catch (err) {
-                observer.emit('parse-result', {
+                const parsed = {
                     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)
-                });
+                };
+                this.logEvent({ message: 'could not parse route file', file: file.base, reason: err.message, stack: err.stack });
+                observer.emit('parse-result', parsed);
             }
         }
-        validateVideoUrl(routeDetail, folderUri, folderFiles) {
+        validateVideoUrl(route, folderUri, folderFiles) {
+            const routeDetail = route.details;
+            const routeDescr = route.description;
             if (this.isMobile()) {
                 if (routeDetail.video.format === 'avi') {
-                    throw new Error('AVI video not supported');
+                    const hasUrl = routeDetail.video.url != null;
+                    const url = routeDetail.video.url ?? routeDetail.video.file;
+                    this.logEvent({ message: '# here', url });
+                    try {
+                        if (url) {
+                            const mp4Url = this.findMatchingMp4(url, folderFiles);
+                            if (mp4Url) {
+                                routeDetail.video.format = 'mp4';
+                                if (hasUrl)
+                                    routeDetail.video.url = mp4Url;
+                                else
+                                    routeDetail.video.file = mp4Url;
+                                routeDescr.videoFormat = 'mp4';
+                            }
+                            else {
+                                throw new Error('AVI video not supported');
+                            }
+                        }
+                        else {
+                            this.logEvent({ message: 'video file not found', video: routeDetail.video });
+                            throw new Error('no video found');
+                        }
+                    }
+                    catch (err) {
+                        this.logEvent({ message: 'video check failed', url });
+                        throw err;
+                    }
                 }
             }
             if (routeDetail.video.file) {
                 routeDetail.video.file = this.resolveVideoUri(routeDetail.video.file, folderUri, folderFiles);
             }
         }
+        findMatchingMp4(videoUrl, folderFiles) {
+            const path = this.getBindings().path;
+            const fileName = path.parse(videoUrl)?.base;
+            const target = fileName.replace('.avi', '.mp4');
+            const folderFile = folderFiles.find(file => file.name === target);
+            if (!folderFile)
+                return;
+            const info = path.parse(videoUrl);
+            return videoUrl.replace(info.base, folderFile.name);
+        }
         async _ingest(routes, observer) {
             await (0, utils_1.waitNextTick)();
             const service = this.getRouteList();
@@ -465,37 +529,37 @@ let RouteLibraryScannerService = (() => {
             }
         }
         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);
+            const { dir, base, name } = this.getBindings().path.parse(uri);
             return {
-                type: 'url',
+                type: 'file',
                 url: uri,
                 filename: uri,
                 base,
                 name,
                 dir,
                 ext,
-                delimiter: '/'
+                delimiter: uri?.startsWith('content://') ? '%2F' : '/'
             };
         }
-        buildRouteDisplayItem(parsed) {
-            const { route, alreadyImported, parseError, format } = parsed;
+        buildRouteDisplayItem(parsed, observer) {
+            const { route, alreadyImported, parseError, format, controlFileUri } = 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')
             };
+            const path = this.getBindings().path;
+            const info = path.parse(controlFileUri);
             return {
-                id: route.description.id,
+                id: route?.description?.id ?? info?.base,
                 distance,
-                label: route.title,
+                label: route?.title ?? info?.base,
                 alreadyImported,
                 importable: parseError == null,
                 format,
-                errorReason: parseError
+                errorReason: parseError,
+                observer: observer ?? new types_1.Observer()
             };
         }
         getCompanionExts(parsers, primaryExt) {