incyclist-services 1.0.61 → 1.0.63

package/lib/__tests__/utils/loadFile.d.ts

@@ -0,0 +1 @@
+export declare function loadFile(type: any, fileName: any): Promise<unknown>;

package/lib/__tests__/utils/loadFile.js

@@ -0,0 +1,28 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadFile = void 0;
+const fs_1 = __importDefault(require("fs"));
+function loadFile(type, fileName) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return new Promise((resolve, reject) => {
+            fs_1.default.readFile(fileName, type, (err, data) => {
+                if (err)
+                    return reject(err);
+                return resolve(data);
+            });
+        });
+    });
+}
+exports.loadFile = loadFile;

package/lib/api/index.d.ts

@@ -1,3 +1,6 @@
 export * from './rest/index';
 export * from './rest/types';
 export * from './repository';
+export * from './path';
+import path from './path';
+export { path };

package/lib/api/index.js

@@ -13,7 +13,14 @@ var __createBinding = (this && this.__createBinding) || (Object.create ? (functi
 var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.path = void 0;
 __exportStar(require("./rest/index"), exports);
 __exportStar(require("./rest/types"), exports);
 __exportStar(require("./repository"), exports);
+__exportStar(require("./path"), exports);
+const path_1 = __importDefault(require("./path"));
+exports.path = path_1.default;

package/lib/api/path/index.d.ts

@@ -0,0 +1,12 @@
+/// <reference types="node" />
+import path from "path";
+export interface IPathBinding {
+    join(...paths: string[]): any;
+    parse(path: string): path.ParsedPath;
+}
+export default class PathSupport {
+    static _binding: IPathBinding;
+    static initBinding(binding: IPathBinding): void;
+    static join(...paths: string[]): string;
+    static parse(path: string): path.ParsedPath;
+}

package/lib/api/path/index.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class PathSupport {
+    static initBinding(binding) {
+        PathSupport._binding = binding;
+    }
+    static join(...paths) {
+        const binding = PathSupport._binding;
+        if (!binding)
+            throw new Error('no binding');
+        return binding.join(...paths);
+    }
+    static parse(path) {
+        const binding = PathSupport._binding;
+        if (!binding)
+            throw new Error('no binding');
+        return binding.parse(path);
+    }
+}
+PathSupport._binding = undefined;
+exports.default = PathSupport;

package/lib/api/repository/types.d.ts

@@ -25,16 +25,14 @@ export interface FileLoaderResult {
     data?: any;
     epmEpp?: any;
 }
-export interface FileInfo {
-}
 export interface FileInfo {
     type: 'url' | 'file';
-    url: string;
+    url?: string;
     name: string;
     dir: string;
     ext: string;
     delimiter: string;
 }
 export interface IFileLoader {
-    processSingle(file: FileInfo): Promise<FileLoaderResult>;
+    open(file: FileInfo): Promise<FileLoaderResult>;
 }

package/lib/devices/access/service.js

@@ -175,7 +175,6 @@ class DeviceAccessService extends events_1.default {
                         this.connect(name); });
                     return;
                 }
-                console.log('~~~ DEBUG:connect if', ifaceName, this.interfaces[ifaceName]);
                 if (((_a = this.interfaces[ifaceName]) === null || _a === void 0 ? void 0 : _a.enabled) === false)
                     return;
                 const impl = this.getInterface(ifaceName);
@@ -189,6 +188,7 @@ class DeviceAccessService extends events_1.default {
                     return true;
                 this.interfaces[ifaceName].state = 'connecting';
                 this.emit('interface-changed', ifaceName, Object.assign(Object.assign({}, this.interfaces[ifaceName]), { state: 'connecting' }));
+                yield impl.disconnect();
                 const connected = yield impl.connect();
                 const state = connected ? 'connected' : 'disconnected';
                 this.interfaces[ifaceName].state = state;

package/lib/devices/pairing/model.d.ts

@@ -54,6 +54,7 @@ export interface InternalPairingState extends PairingState {
     check?: {
         preparing?: number;
         promise?: Promise<boolean>;
+        to?: NodeJS.Timeout;
     };
     scan?: {
         preparing?: number;

package/lib/devices/pairing/service.d.ts

@@ -1,3 +1,4 @@
+/// <reference types="node" />
 import { DeviceAccessService } from "../access/service";
 import { AdapterInfo, CapabilityInformation, DeviceConfigurationInfo, DeviceConfigurationService, IncyclistDeviceSettings, InterfaceSetting } from "../configuration";
 import { CapabilityData, DevicePairingData, DevicePairingStatus, DeviceSelectState, InternalPairingState, PairingProps, PairingSettings, PairingState } from "./model";
@@ -32,6 +33,7 @@ export declare class DevicePairingService extends IncyclistService {
     static getInstance(): DevicePairingService;
     constructor(services?: Services);
     start(onStateChanged: (newState: PairingState) => void): Promise<void>;
+    protected loadConfiguration(): Promise<void>;
     protected initConfigHandlers(): void;
     protected removeConfigHandlers(): void;
     stop(): Promise<void>;
@@ -41,6 +43,7 @@ export declare class DevicePairingService extends IncyclistService {
     deleteDevice(capability: IncyclistCapability, udid: string, deleteAll?: boolean): Promise<void>;
     unselectDevices(capability: IncyclistCapability): Promise<void>;
     changeInterfaceSettings(name: string, settings: InterfaceSetting): Promise<void>;
+    protected restartPair(): Promise<void>;
     protected restart(): Promise<void>;
     protected _stop(): Promise<void>;
     protected getCapability(capability: IncyclistCapability | CapabilityData): CapabilityData;
@@ -77,6 +80,7 @@ export declare class DevicePairingService extends IncyclistService {
     private stopPairing;
     protected run(props?: PairingProps): Promise<void>;
     private startPairing;
+    private isReadyToPair;
     private processConnectedDevices;
     private startScanning;
     protected deregisterScanningDataHandlers(): void;
@@ -105,6 +109,7 @@ export declare class DevicePairingService extends IncyclistService {
     protected deleteCapabilityDevice(capability: IncyclistCapability, udid: string, shouldEmit?: boolean): void;
     protected isScanning(): boolean;
     protected isPairing(): boolean;
+    protected isPairingWaiting(): NodeJS.Timeout;
     protected _stopDeviceSelection(changed: boolean): Promise<void>;
     private numberOfSelectedCababilities;
     protected addToDeletedList(capability: IncyclistCapability | CapabilityData, udid: string): void;

package/lib/devices/pairing/service.js

@@ -69,16 +69,7 @@ class DevicePairingService extends service_2.IncyclistService {
                     this.emitStateChange(this.state);
                     return;
                 }
-                yield this.waitForInit();
-                const { capabilities, interfaces } = this.configuration.load();
-                const state = Object.assign({}, this.state);
-                delete state.adapters;
-                this.state.capabilities = this.mappedCapabilities(capabilities);
-                this.state.interfaces = this.access.enrichWithAccessState(interfaces);
-                this.state.canStartRide = this.configuration.canStartRide();
-                this.state.stopRequested = false;
-                this.state.stopped = false;
-                this.logCapabilities();
+                yield this.loadConfiguration();
                 this.state.interfaces.forEach(i => {
                     if (!this.isInterfaceEnabled(i.name))
                         this.unselectOnInterface(i.name);
@@ -93,6 +84,20 @@ class DevicePairingService extends service_2.IncyclistService {
             }
         });
     }
+    loadConfiguration() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.waitForInit();
+            const { capabilities, interfaces } = this.configuration.load();
+            const state = Object.assign({}, this.state);
+            delete state.adapters;
+            this.state.capabilities = this.mappedCapabilities(capabilities);
+            this.state.interfaces = this.access.enrichWithAccessState(interfaces);
+            this.state.canStartRide = this.configuration.canStartRide();
+            this.state.stopRequested = false;
+            this.state.stopped = false;
+            this.logCapabilities();
+        });
+    }
     initConfigHandlers() {
         this.configuration.on('interface-changed', this.onInterfaceConfigChangedHandler);
         this.configuration.on('capability-changed', this.onConfigurationUpdateHandler);
@@ -242,6 +247,17 @@ class DevicePairingService extends service_2.IncyclistService {
             }
         });
     }
+    restartPair() {
+        var _a, _b;
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.isPairing())
+                return;
+            if ((_a = this.state.check) === null || _a === void 0 ? void 0 : _a.to)
+                clearTimeout((_b = this.state.check) === null || _b === void 0 ? void 0 : _b.to);
+            delete this.state.check;
+            this.run();
+        });
+    }
     restart() {
         return __awaiter(this, void 0, void 0, function* () {
             const wasActive = this.isPairing() || this.isScanning();
@@ -437,6 +453,7 @@ class DevicePairingService extends service_2.IncyclistService {
             this.logEvent({ message: 'interface state changed', interface: ifName, state: ifDetails.state });
             try {
                 let restartScan = false;
+                let restartPair = false;
                 if (interfacesNew) {
                     const getData = (i) => ({ name: i.name, enabled: i.enabled, state: i.state });
                     if (!prev)
@@ -449,6 +466,20 @@ class DevicePairingService extends service_2.IncyclistService {
                     const changedIdx = prev.findIndex(i => i.name === ifName);
                     if (ifDetails.state === 'disconnected' && current.state !== 'disconnected') {
                         this.failAdaptersOnInterface(ifName);
+                        if (this.isPairing()) {
+                            const pairing = this.getPairingInterfaces();
+                            if (pairing.includes(ifName)) {
+                                try {
+                                    current.state = 'disconnected';
+                                    this.emitStateChange({ interfaces: this.state.interfaces });
+                                    yield (0, utils_1.sleep)(1000);
+                                    this.access.connect(ifName);
+                                }
+                                catch (err) {
+                                    this.logError(err, 'reconnect');
+                                }
+                            }
+                        }
                     }
                     else if (ifDetails.state === 'unavailable' && current.state !== 'unavailable') {
                         this.disableAdaptersOnInterface(ifName);
@@ -460,12 +491,18 @@ class DevicePairingService extends service_2.IncyclistService {
                     else if (ifDetails.state === 'connected' && current.state !== 'connected' && !this.isPairing()) {
                         restartScan = true;
                     }
+                    else if (ifDetails.state === 'connected' && current.state !== 'connected' && this.isPairingWaiting()) {
+                        restartPair = true;
+                    }
                     if (changedIdx !== -1) {
                         prev[changedIdx].isScanning = ifDetails.isScanning;
                         prev[changedIdx].state = ifDetails.state;
                     }
                     if (restartScan)
                         this.restart();
+                    if (restartPair) {
+                        this.restartPair();
+                    }
                     this.emitStateChange({ interfaces: this.state.interfaces });
                 }
             }
@@ -770,16 +807,15 @@ class DevicePairingService extends service_2.IncyclistService {
             const preparing = DevicePairingService.checkCounter++;
             this.state.check = { preparing };
             this.emit('pairing-start');
-            const requiredInterfaces = this.getPairingInterfaces();
-            const busyRequired = this.state.interfaces
-                .filter(i => requiredInterfaces.includes(i.name))
-                .find(i => i.enabled && i.state !== 'connected' && i.state !== 'unavailable');
-            const isReady = busyRequired === undefined;
+            const { isReady, busyRequired } = this.isReadyToPair();
             if (!isReady) {
-                setTimeout(() => {
+                this.logEvent({ message: 'Pairing: waiting for interfaces', interfaces: busyRequired === null || busyRequired === void 0 ? void 0 : busyRequired.name });
+                this.state.check.to = setTimeout(() => {
                     if ((!this.isPairing() || this.state.check.preparing === preparing) && !this.isScanning()) {
-                        delete this.state.check;
-                        this.run();
+                        const { isReady } = this.isReadyToPair();
+                        if (isReady) {
+                            delete this.state.check;
+                        }
                     }
                 }, 1000);
                 return;
@@ -810,6 +846,14 @@ class DevicePairingService extends service_2.IncyclistService {
             }
         });
     }
+    isReadyToPair() {
+        const requiredInterfaces = this.getPairingInterfaces();
+        const busyRequired = this.state.interfaces
+            .filter(i => requiredInterfaces.includes(i.name))
+            .find(i => i.enabled && i.state !== 'connected' && i.state !== 'unavailable');
+        const isReady = busyRequired === undefined;
+        return { isReady, busyRequired };
+    }
     processConnectedDevices(adapters) {
         const started = adapters.filter(ai => ai.adapter.isStarted());
         started.forEach(ai => {
@@ -1105,6 +1149,9 @@ class DevicePairingService extends service_2.IncyclistService {
         var _a;
         return this.state.check !== undefined && ((_a = this.state) === null || _a === void 0 ? void 0 : _a.check) !== null;
     }
+    isPairingWaiting() {
+        return this.isPairing() && this.state.check.to;
+    }
     _stopDeviceSelection(changed) {
         return __awaiter(this, void 0, void 0, function* () {
             this.deviceSelectState = null;

package/lib/index.d.ts

@@ -1,5 +1,5 @@
 export * from './devices';
 export * from './utils';
-export { useUserSettings, initUserSettings, UserSettingsService, UserSettingsBinding, IUserSettingsBinding } from './settings';
 export * from './api';
 export * from './routes';
+export { useUserSettings, initUserSettings, UserSettingsService, UserSettingsBinding, IUserSettingsBinding } from './settings';

package/lib/index.js

@@ -17,10 +17,10 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.UserSettingsBinding = exports.UserSettingsService = exports.initUserSettings = exports.useUserSettings = void 0;
 __exportStar(require("./devices"), exports);
 __exportStar(require("./utils"), exports);
+__exportStar(require("./api"), exports);
+__exportStar(require("./routes"), exports);
 var settings_1 = require("./settings");
 Object.defineProperty(exports, "useUserSettings", { enumerable: true, get: function () { return settings_1.useUserSettings; } });
 Object.defineProperty(exports, "initUserSettings", { enumerable: true, get: function () { return settings_1.initUserSettings; } });
 Object.defineProperty(exports, "UserSettingsService", { enumerable: true, get: function () { return settings_1.UserSettingsService; } });
 Object.defineProperty(exports, "UserSettingsBinding", { enumerable: true, get: function () { return settings_1.UserSettingsBinding; } });
-__exportStar(require("./api"), exports);
-__exportStar(require("./routes"), exports);

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

@@ -22,6 +22,7 @@ export interface RouteApiDescription extends RouteBase {
     video?: VideoDescription;
     type?: RouteType;
     localizedTitle?: LocalizedText;
+    previewUrl?: string;
 }
 export type LegacyRouteGpxRepoDescription = {
     id: string;
@@ -52,10 +53,14 @@ export type RouteApiDetail = {
     elevation?: number;
     points?: Array<RoutePoint>;
     downloadUrl?: string;
-    downloadType: string;
+    downloadType?: string;
     version?: string;
     category?: RouteCategory;
     provider?: RouteProvider;
     video?: VideoDescription;
     localizedTitle?: LocalizedText;
+    previewUrl?: string;
+    previewUrlLocal?: string;
+    description?: LocalizedText;
+    next?: string;
 };

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

@@ -0,0 +1,12 @@
+import { Parser } from "../types";
+export declare class ParserFactory {
+    static _instance: ParserFactory;
+    static getInstance(): ParserFactory;
+    private parsers;
+    private initialized;
+    constructor();
+    add(parser: Parser<unknown, unknown>): void;
+    findMatching(extension: string, data: unknown): Parser<unknown, unknown>;
+    isInitialized(): boolean;
+    setInitialized(done: boolean): void;
+}

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

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ParserFactory = void 0;
+class ParserFactory {
+    static getInstance() {
+        if (!ParserFactory._instance)
+            ParserFactory._instance = new ParserFactory();
+        return ParserFactory._instance;
+    }
+    constructor() {
+        this.parsers = [];
+        this.initialized = false;
+    }
+    add(parser) {
+        this.parsers.push(parser);
+    }
+    findMatching(extension, data) {
+        const matching = this.parsers
+            .filter(p => p.supportsExtension(extension))
+            .filter(p => p.supportsContent(data));
+        if (!(matching === null || matching === void 0 ? void 0 : matching.length))
+            throw new Error(`invalid file format ${extension}`);
+        return matching[0];
+    }
+    isInitialized() {
+        return this.initialized;
+    }
+    setInitialized(done) {
+        this.initialized = done;
+    }
+}
+exports.ParserFactory = ParserFactory;

package/lib/routes/base/parsers/incyclist-xml.d.ts

@@ -0,0 +1,5 @@
+import { XMLParser } from './xml';
+export declare class IncyclistXMLParser extends XMLParser {
+    static SCHEME: string;
+    protected getGPXFileContent(url: any): Promise<any>;
+}

package/lib/routes/{list/bindings/mock.js → base/parsers/incyclist-xml.js}

@@ -8,25 +8,20 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.MockRouteBinding = exports.MockApi = void 0;
-class MockApi {
-    constructor() {
-        this.routes = [];
-    }
-    setRoutes(routes) {
-        this.routes = routes;
-    }
-    getRouteDescriptions() {
+exports.IncyclistXMLParser = void 0;
+const axios_1 = __importDefault(require("axios"));
+const xml_1 = require("./xml");
+class IncyclistXMLParser extends xml_1.XMLParser {
+    getGPXFileContent(url) {
         return __awaiter(this, void 0, void 0, function* () {
-            return this.routes;
+            const res = yield axios_1.default.get(url);
+            return res.data;
         });
     }
 }
-exports.MockApi = MockApi;
-class MockRouteBinding {
-    constructor() {
-        this.api = new MockApi();
-    }
-}
-exports.MockRouteBinding = MockRouteBinding;
+exports.IncyclistXMLParser = IncyclistXMLParser;
+IncyclistXMLParser.SCHEME = 'gpx-import';

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

@@ -0,0 +1,3 @@
+export * from './kwt';
+import { ParserFactory } from './factory';
+export declare const useParsers: () => ParserFactory;

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

@@ -0,0 +1,31 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useParsers = void 0;
+__exportStar(require("./kwt"), exports);
+const factory_1 = require("./factory");
+const incyclist_xml_1 = require("./incyclist-xml");
+const kwt_1 = require("./kwt");
+const multixml_1 = require("./multixml");
+const useParsers = () => {
+    const parsers = factory_1.ParserFactory.getInstance();
+    if (!parsers.isInitialized()) {
+        parsers.add(new multixml_1.MultipleXMLParser([kwt_1.KWTParser, incyclist_xml_1.IncyclistXMLParser]));
+        parsers.setInitialized(true);
+    }
+    return parsers;
+};
+exports.useParsers = useParsers;

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

@@ -1,9 +1,4 @@
-import { XmlJSON } from '../utils/xnl';
-import { RouteApiDescription } from '../api/types';
-import { ParseResult, Parser } from '../types';
-export declare function parseSegment(s: any): any;
-export declare function parseInfoText(infoText: any): any;
-export default function ImportKWT(xmljson: XmlJSON): Promise<ParseResult<RouteApiDescription>>;
-export declare class KWTParser implements Parser<string, RouteApiDescription> {
-    import(data: string): Promise<ParseResult<RouteApiDescription>>;
+import { XMLParser } from './xml';
+export declare class KWTParser extends XMLParser {
+    static SCHEME: string;
 }

package/lib/routes/base/parsers/kwt.js

@@ -1,52 +1,8 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.KWTParser = exports.parseInfoText = exports.parseSegment = void 0;
-let _logger;
-function parseSegment(s) {
-    const segment = s[0] ? (s[0].$ || s[0]) : (s.$ || s);
-    segment.start = segment.start !== undefined ? parseInt(segment.start) : undefined;
-    segment.end = segment.end !== undefined ? parseInt(segment.end) : undefined;
-    return segment;
-}
-exports.parseSegment = parseSegment;
-function parseInfoText(infoText) {
-    if (infoText.distance !== undefined)
-        infoText.distance = parseInt(infoText.distance);
-    const languageKeys = Object.keys(infoText).filter(k => k.length === 2);
-    if (languageKeys && languageKeys.length > 0) {
-        infoText.localizedText = {};
-        languageKeys.forEach(k => {
-            infoText.localizedText[k] = infoText[k];
-            delete infoText[k];
-        });
-    }
-    if (!infoText.text && infoText.localizedText) {
-        const languages = Object.keys(infoText.localizedText);
-        if (languages && languages.length > 0) {
-            infoText.text = infoText.localizedText[languages[0]];
-        }
-    }
-    return infoText;
-}
-exports.parseInfoText = parseInfoText;
-function ImportKWT(xmljson) {
-    return __awaiter(this, void 0, void 0, function* () {
-        throw new Error('not implemented');
-    });
-}
-exports.default = ImportKWT;
-class KWTParser {
-    import(data) {
-        throw new Error('Method not implemented.');
-    }
+exports.KWTParser = void 0;
+const xml_1 = require("./xml");
+class KWTParser extends xml_1.XMLParser {
 }
 exports.KWTParser = KWTParser;
+KWTParser.SCHEME = 'kwt';

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

@@ -0,0 +1,12 @@
+/// <reference types="node" />
+import { FileInfo, IFileLoader } from "../../../api";
+import { RouteApiDetail } from "../api/types";
+import { ParseResult, Parser } from "../types";
+import { XMLParser } from "./xml";
+export declare class MultipleXMLParser implements Parser<string | Buffer, RouteApiDetail> {
+    protected parsers: any;
+    constructor(classes: Array<typeof XMLParser>);
+    import(file: FileInfo, data: string | Buffer, loader?: IFileLoader): Promise<ParseResult<RouteApiDetail>>;
+    supportsExtension(extension: string): boolean;
+    supportsContent(): boolean;
+}

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

@@ -0,0 +1,37 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MultipleXMLParser = void 0;
+const xml_1 = require("../utils/xml");
+class MultipleXMLParser {
+    constructor(classes) {
+        this.parsers = [];
+        classes.forEach(C => {
+            const parser = new C();
+            this.parsers.push(parser);
+        });
+    }
+    import(file, data, loader) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const str = Buffer.isBuffer(data) ? data.toString() : data;
+            const xmlJson = yield (0, xml_1.parseXml)(str);
+            const parser = this.parsers.find(p => p.supportsContent(xmlJson));
+            return yield parser.import(file, xmlJson, loader);
+        });
+    }
+    supportsExtension(extension) {
+        return (extension === null || extension === void 0 ? void 0 : extension.toLowerCase()) === 'xml';
+    }
+    supportsContent() {
+        return true;
+    }
+}
+exports.MultipleXMLParser = MultipleXMLParser;

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

@@ -0,0 +1,10 @@
+export type Position = {
+    distance?: string;
+    lat?: string;
+    lon?: string;
+    fp?: string;
+};
+export type Altitude = {
+    distance?: string;
+    height?: string;
+};

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

@@ -1 +1,7 @@
-export function addVideoSpeed(route: any): void;
+import { FileInfo } from "../../../api";
+import { RoutePoint, VideoRoutePoint } from "../types";
+export declare const addVideoSpeed: (points: Array<RoutePoint>, video: any) => Array<VideoRoutePoint>;
+export declare const getReferencedFileInfo: (info: FileInfo, referenced: {
+    file?: string;
+    url?: string;
+}, scheme?: string) => string;