incyclist-services 1.0.42 → 1.0.44

package/lib/api/index.d.ts

@@ -0,0 +1,2 @@
+export * from './rest/index';
+export * from './rest/types';

package/lib/api/index.js

@@ -0,0 +1,18 @@
+"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 });
+__exportStar(require("./rest/index"), exports);
+__exportStar(require("./rest/types"), exports);

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

@@ -0,0 +1,18 @@
+import { AxiosInstance } from 'axios';
+import { EventLogger } from 'gd-eventlog';
+import { ApiClientInitProps } from './types';
+export declare class ApiClient {
+    static _instance: any;
+    protected axios: AxiosInstance;
+    protected logger: EventLogger;
+    protected requests: Array<{
+        tid: string;
+        ts: number;
+    }>;
+    static getInstance(): ApiClient;
+    static getClient(): AxiosInstance;
+    init(props: ApiClientInitProps): void;
+    client(): AxiosInstance;
+    protected onRequest(req: any): any;
+    protected onResponse(res: any): any;
+}

package/lib/api/rest/index.js

@@ -0,0 +1,79 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApiClient = void 0;
+const axios_1 = __importDefault(require("axios"));
+const gd_eventlog_1 = require("gd-eventlog");
+const uuid_1 = require("uuid");
+class ApiClient {
+    static getInstance() {
+        if (!ApiClient._instance) {
+            ApiClient._instance = new ApiClient();
+        }
+        return ApiClient._instance;
+    }
+    static getClient() {
+        return ApiClient.getInstance().client();
+    }
+    init(props) {
+        const { uuid, apiKey, requestLog = true, version, appVersion, channel = 'desktop' } = props;
+        const headers = {
+            "X-uuid": uuid,
+            "X-API-Key": apiKey,
+            "x-app-channel": channel,
+            "x-app-version": appVersion,
+            "x-react-version": version
+        };
+        this.axios = axios_1.default.create({ headers });
+        if (requestLog) {
+            this.logger = new gd_eventlog_1.EventLogger('API');
+            this.requests = [];
+            this.axios.interceptors.request.use((req) => this.onRequest(req));
+            this.axios.interceptors.response.use((res) => this.onResponse(res));
+        }
+    }
+    client() {
+        if (this.axios)
+            return this.axios;
+        return axios_1.default;
+    }
+    onRequest(req) {
+        if (!req)
+            return;
+        try {
+            const ts = Date.now();
+            const tid = (0, uuid_1.v4)();
+            req.headers['x-transaction-id'] = tid;
+            this.requests.push({ tid, ts });
+        }
+        catch (err) {
+            this.logger.logEvent({ message: 'error', fn: 'onRequest()', error: err.message || err, stack: err.stack });
+        }
+        return req;
+    }
+    onResponse(res) {
+        if (!res)
+            return;
+        try {
+            const { config, status } = res || {};
+            const { headers = {}, url, method, params } = config;
+            const tid = headers['x-transaction-id'];
+            if (!tid)
+                return res;
+            const idx = this.requests.findIndex(r => r.tid === tid);
+            if (idx !== -1) {
+                const tsStart = this.requests[idx].ts;
+                this.requests.splice(idx, 1);
+                this.logger.logEvent({ message: 'api call', method, url, tid, status, duration: Date.now() - tsStart, params });
+            }
+        }
+        catch (err) {
+            this.logger.logEvent({ message: 'error', fn: 'onResponse', error: err.message || err, stack: err.stack });
+        }
+        return res;
+    }
+}
+exports.ApiClient = ApiClient;
+ApiClient._instance = null;

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

@@ -0,0 +1,9 @@
+export type AppChannel = 'desktop' | 'mobile' | 'web' | 'tv' | 'backend';
+export type ApiClientInitProps = {
+    uuid: string;
+    apiKey: string;
+    version: string;
+    appVersion: string;
+    requestLog?: boolean;
+    channel?: AppChannel;
+};

package/lib/api/rest/types.js

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

package/lib/base/service.d.ts

@@ -0,0 +1,11 @@
+/// <reference types="node" />
+import EventEmitter from 'events';
+import { EventLogger } from 'gd-eventlog';
+export declare class IncyclistService extends EventEmitter {
+    protected logger: EventLogger;
+    protected debug: any;
+    constructor(serviceName: string);
+    protected logEvent(event: any): void;
+    protected setDebug(enabled: boolean): void;
+    protected logError(err: Error, fn: string, args?: any): void;
+}

package/lib/base/service.js

@@ -0,0 +1,30 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IncyclistService = void 0;
+const events_1 = __importDefault(require("events"));
+const gd_eventlog_1 = require("gd-eventlog");
+class IncyclistService extends events_1.default {
+    constructor(serviceName) {
+        super();
+        this.logger = new gd_eventlog_1.EventLogger(serviceName);
+        this.debug = false;
+    }
+    logEvent(event) {
+        this.logger.logEvent(event);
+        this.emit('log', event);
+        const w = global.window;
+        if (this.debug || (w === null || w === void 0 ? void 0 : w.SERVICE_DEBUG) || process.env.DEBUG)
+            console.log(`~~~ ${this.logger.getName().toUpperCase()}-SVC`, event);
+    }
+    setDebug(enabled) {
+        this.debug = enabled;
+    }
+    logError(err, fn, args) {
+        const logInfo = args || {};
+        this.logger.logEvent(Object.assign(Object.assign({ message: 'Error', fn }, logInfo), { error: err.message, stack: err.stack }));
+    }
+}
+exports.IncyclistService = IncyclistService;

package/lib/devices/configuration/service.js

@@ -105,19 +105,27 @@ class DeviceConfigurationService extends events_1.default {
     verifyCapabilitySettings() {
         const { capabilities } = this.settings;
         const isNewUi = this.isNewUi();
+        const bikeCapIdx = capabilities.findIndex(c => c.capability === 'bike');
         if (isNewUi) {
-            const bikeCapIdx = capabilities.findIndex(c => c.capability === 'bike');
             if (bikeCapIdx !== -1) {
                 capabilities.splice(bikeCapIdx, 1);
             }
             return;
         }
+        else {
+            if (bikeCapIdx === -1) {
+                const control = capabilities.find(c => c.capability === incyclist_devices_1.IncyclistCapability.Control && c.selected !== undefined);
+                const bike = Object.assign({}, control);
+                bike.capability = 'bike';
+                capabilities.push(bike);
+            }
+        }
+        const bikeCap = capabilities.find(c => c.capability === 'bike');
         for (const capability of ['bike', incyclist_devices_1.IncyclistCapability.Control]) {
             const info = capabilities.find(c => c.capability === capability);
             if (info && info.devices.length > 0 && info.selected === undefined)
                 this.select(info.devices[0], capability);
         }
-        const bikeCap = capabilities.find(c => c.capability === 'bike');
         if (bikeCap && bikeCap.selected) {
             const bike = bikeCap.selected;
             const power = capabilities.find(c => c.capability === incyclist_devices_1.IncyclistCapability.Power && c.selected !== undefined);

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

@@ -1,11 +1,9 @@
-/// <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";
-import { EventLogger } from 'gd-eventlog';
 import { DeviceData, IncyclistCapability, IncyclistDeviceAdapter } from "incyclist-devices";
 import { AdapterStateInfo, DeviceRideService } from "../ride";
-import EventEmitter from "events";
+import { IncyclistService } from "../../base/service";
 export declare const mappedCapability: (c: CapabilityInformation) => CapabilityData;
 export declare const mappedCapabilities: (capabilities: DeviceConfigurationInfo) => Array<CapabilityData>;
 export interface Services {
@@ -13,13 +11,11 @@ export interface Services {
     access?: DeviceAccessService;
     ride?: DeviceRideService;
 }
-export declare class DevicePairingService extends EventEmitter {
+export declare class DevicePairingService extends IncyclistService {
     protected static _instance: DevicePairingService;
     protected configuration: DeviceConfigurationService;
     protected access: DeviceAccessService;
     protected rideService: DeviceRideService;
-    protected logger: EventLogger;
-    protected debug: any;
     protected settings: PairingSettings;
     protected state: InternalPairingState;
     protected deviceSelectState: DeviceSelectState | null;
@@ -45,9 +41,6 @@ export declare class DevicePairingService extends EventEmitter {
     changeInterfaceSettings(name: string, settings: InterfaceSetting): Promise<void>;
     private restart;
     protected _stop(): Promise<void>;
-    protected logEvent(event: any): void;
-    protected setDebug(enabled: boolean): void;
-    protected logError(err: Error, fn: string): void;
     protected getCapability(capability: IncyclistCapability | CapabilityData): CapabilityData;
     protected getCapabilityDevice(capability: IncyclistCapability | CapabilityData, udid?: string): DevicePairingData;
     protected onConfigLoaded(capabilitiesLoaded: DeviceConfigurationInfo, interfacesLoaded: Array<InterfaceSetting>): Promise<void>;

package/lib/devices/pairing/service.js

@@ -15,12 +15,11 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.useDevicePairing = exports.DevicePairingService = exports.mappedCapabilities = exports.mappedCapability = void 0;
 const service_1 = require("../access/service");
 const configuration_1 = require("../configuration");
-const gd_eventlog_1 = require("gd-eventlog");
 const incyclist_devices_1 = require("incyclist-devices");
 const ride_1 = require("../ride");
 const clone_1 = __importDefault(require("../../utils/clone"));
-const events_1 = __importDefault(require("events"));
 const utils_1 = require("incyclist-devices/lib/utils/utils");
+const service_2 = require("../../base/service");
 const Units = [
     { capability: incyclist_devices_1.IncyclistCapability.HeartRate, unit: 'bpm', value: 'heartrate', decimals: 0 },
     { capability: incyclist_devices_1.IncyclistCapability.Power, unit: 'W', value: 'power', decimals: 0 },
@@ -54,14 +53,14 @@ const getInterfaceSettings = (ifName, v) => {
         return {};
     return v.find(i => i.name === ifName);
 };
-class DevicePairingService extends events_1.default {
+class DevicePairingService extends service_2.IncyclistService {
     static getInstance() {
         if (!DevicePairingService._instance)
             DevicePairingService._instance = new DevicePairingService();
         return DevicePairingService._instance;
     }
     constructor(services) {
-        super();
+        super('Pairing');
         this.settings = {};
         this.state = { initialized: false };
         this.deviceSelectState = null;
@@ -79,8 +78,6 @@ class DevicePairingService extends events_1.default {
             this.rideService = services.ride;
         }
         this.state.initialized = false;
-        this.logger = new gd_eventlog_1.EventLogger('Pairing');
-        this.debug = false;
     }
     start(onStateChanged) {
         return __awaiter(this, void 0, void 0, function* () {
@@ -268,19 +265,6 @@ class DevicePairingService extends events_1.default {
                 yield this.stopScanning();
         });
     }
-    logEvent(event) {
-        this.logger.logEvent(event);
-        this.emit('log', event);
-        const w = global.window;
-        if (this.debug || (w === null || w === void 0 ? void 0 : w.SERVICE_DEBUG) || process.env.DEBUG)
-            console.log('~~~ PAIRING-SVC', event);
-    }
-    setDebug(enabled) {
-        this.debug = enabled;
-    }
-    logError(err, fn) {
-        this.logger.logEvent({ message: 'Error', fn, error: err.message, stack: err.stack });
-    }
     getCapability(capability) {
         const target = typeof capability === 'object' ? capability.capability : capability;
         const { capabilities = [] } = this.state;

package/lib/index.d.ts

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

package/lib/index.js

@@ -22,3 +22,5 @@ Object.defineProperty(exports, "useUserSettings", { enumerable: true, get: funct
 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/consts.d.ts

@@ -0,0 +1,9 @@
+export declare const ROUTE_API = "ROUTE_API";
+export declare const DEFAULT_ROUTE_API = "https://dlws.incyclist.com/api/v1/routes";
+export declare const NO_CACHE: {
+    headers: {
+        'Cache-Control': string;
+        Pragma: string;
+        Expires: string;
+    };
+};

package/lib/routes/base/api/consts.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NO_CACHE = exports.DEFAULT_ROUTE_API = exports.ROUTE_API = void 0;
+const DEFAULT_ROUTE_API_PROD = 'https://dlws.incyclist.com/api/v1/routes';
+exports.ROUTE_API = 'ROUTE_API';
+exports.DEFAULT_ROUTE_API = DEFAULT_ROUTE_API_PROD;
+exports.NO_CACHE = {
+    headers: {
+        'Cache-Control': 'no-cache',
+        'Pragma': 'no-cache',
+        'Expires': '0',
+    },
+};

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

@@ -0,0 +1,19 @@
+import { EventLogger } from 'gd-eventlog';
+import { RouteApiDescription, RouteApiDetail, RouteDescriptionQuery } from "./types";
+import { AxiosInstance } from "axios";
+import { RoutePoint } from '../types';
+export default class IncyclistRoutesApi {
+    protected static _instance: any;
+    static getInstance(): IncyclistRoutesApi;
+    protected logger: EventLogger;
+    protected api: AxiosInstance;
+    constructor();
+    protected logError(err: Error, fn: string, logInfo?: any): void;
+    protected getApi(): AxiosInstance;
+    protected getBaseUrl(): any;
+    getRouteDescriptions(query: RouteDescriptionQuery): Promise<Array<RouteApiDescription>>;
+    fixMissingRouteDistances(points: Array<RoutePoint>): void;
+    getRouteDetails(routeId: string): Promise<RouteApiDetail>;
+    reload(): Promise<any>;
+    protected _get(url: string, ...args: any[]): Promise<import("axios").AxiosResponse<any, any>>;
+}

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

@@ -0,0 +1,100 @@
+"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 });
+const gd_eventlog_1 = require("gd-eventlog");
+const consts_1 = require("./consts");
+const api_1 = require("../../../api");
+const settings_1 = require("../../../settings");
+class IncyclistRoutesApi {
+    static getInstance() {
+        if (!IncyclistRoutesApi._instance)
+            IncyclistRoutesApi._instance = new IncyclistRoutesApi();
+        return IncyclistRoutesApi._instance;
+    }
+    constructor() {
+        this.logger = new gd_eventlog_1.EventLogger('RouteListApi');
+    }
+    logError(err, fn, logInfo) {
+        const args = logInfo || {};
+        this.logger.logEvent(Object.assign({ message: 'Error', error: err.message, fn }, args));
+        console.log(err);
+    }
+    getApi() {
+        if (!this.api) {
+            this.api = api_1.ApiClient.getClient();
+            return this.api;
+        }
+        return this.api;
+    }
+    getBaseUrl() {
+        return (0, settings_1.useUserSettings)().get(consts_1.ROUTE_API, consts_1.DEFAULT_ROUTE_API);
+    }
+    getRouteDescriptions(query) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { type = 'gpx', category } = query;
+            let url = (type === 'gpx') ? `?private=false` : `/?type=${type}`;
+            if (category)
+                url += "&category=${category}";
+            try {
+                const res = yield this._get(url, consts_1.NO_CACHE);
+                return res.data;
+            }
+            catch (err) {
+                this.logError(err, 'getRouteDescriptions', { query });
+                return undefined;
+            }
+        });
+    }
+    fixMissingRouteDistances(points) {
+        let routeDistance = 0;
+        points.forEach((p) => {
+            if (!p.routeDistance)
+                p.routeDistance = routeDistance;
+            routeDistance = p.routeDistance + p['distance'];
+        });
+    }
+    getRouteDetails(routeId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const res = yield this._get(`/${routeId}`);
+                if (res.data['decoded']) {
+                    res.data.points = res.data['decoded'];
+                    delete res.data['decoded'];
+                    this.fixMissingRouteDistances(res.data.points);
+                }
+                return res.data;
+            }
+            catch (err) {
+                this.logError(err, 'getRouteDetails', { routeId });
+                return undefined;
+            }
+        });
+    }
+    reload() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                this._get(`/reload`);
+            }
+            catch (err) {
+                this.logError(err, 'reload');
+                return undefined;
+            }
+        });
+    }
+    _get(url, ...args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const api = this.getApi();
+            const baseUrl = this.getBaseUrl();
+            return yield api.get(baseUrl + url, ...args);
+        });
+    }
+}
+exports.default = IncyclistRoutesApi;

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

@@ -0,0 +1,46 @@
+import { LocalizedText } from "../../list";
+import { RouteCategory, RoutePoint, RouteProvider, RouteType, VideoDescription } from "../types";
+export type RouteDescriptionQuery = {
+    category?: string;
+    categories?: Array<string>;
+    type: RouteType;
+};
+export type RouteApiDescription = {
+    id: string;
+    routeId?: string;
+    hash?: string;
+    routeHash?: string;
+    title: string;
+    private?: boolean;
+    country?: string;
+    distance?: number;
+    elevation?: number;
+    points?: {
+        id: string;
+    };
+    version?: string;
+    category?: RouteCategory;
+    provider?: RouteProvider;
+    video?: VideoDescription;
+    type?: RouteType;
+    localizedTitle?: LocalizedText;
+};
+export type RouteApiDetail = {
+    id: string;
+    routeId?: string;
+    hash?: string;
+    routeHash?: string;
+    title: string;
+    private?: boolean;
+    country?: string;
+    distance?: number;
+    elevation?: number;
+    points?: Array<RoutePoint>;
+    downloadUrl?: string;
+    downloadType: string;
+    version?: string;
+    category?: RouteCategory;
+    provider?: RouteProvider;
+    video?: VideoDescription;
+    localizedTitle?: LocalizedText;
+};

package/lib/routes/base/api/types.js

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

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

@@ -0,0 +1,44 @@
+export type RouteType = 'gpx' | 'video';
+export type RouteCategory = 'Free' | 'Demo';
+export type RouteState = 'prepared' | 'loading' | 'loaded' | 'error';
+export type RouteProvider = {
+    name: string;
+    url: string;
+    logo: string;
+};
+export type VideoMapping = {
+    videoSpeed: number;
+    time: number;
+    frame: number;
+    distance: number;
+};
+export type RouteInfoText = {
+    distance: number;
+    localizedText: any;
+    text: string;
+};
+export type VideoDescription = {
+    file: string;
+    url: string;
+    framerate: number;
+    width: number;
+    height: number;
+    segments: any;
+    informations: any;
+    mappings: VideoMapping;
+    format: string;
+    selectableSegments: any;
+    infoTexts: RouteInfoText;
+};
+export type RoutePoint = {
+    lat: number;
+    lng: number;
+    routeDistance: number;
+    elevation: number;
+    slope: number;
+};
+export type RouteSegment = {
+    start: number;
+    end: number;
+    name: string;
+};

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

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

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

@@ -0,0 +1,2 @@
+import { RouteInfo } from "../../list/types";
+export declare const getLocalizedData: (data: RouteInfo, language?: string) => RouteInfo;

package/lib/routes/base/utils/localization.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getLocalizedData = void 0;
+const getLocalizedData = (data, language = 'en') => {
+    const updated = Object.assign({}, data);
+    if (language && data.localizedTitle) {
+        updated.title = data.localizedTitle[language];
+        delete updated.localizedTitle;
+    }
+    return updated;
+};
+exports.getLocalizedData = getLocalizedData;

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

@@ -0,0 +1,4 @@
+import { Route } from "../../list";
+import { RouteSegment } from "../types";
+export declare const checkIsLoop: (route: Route) => boolean;
+export declare const getSegments: (route: Route) => Array<RouteSegment>;

package/lib/routes/base/utils/route.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSegments = exports.checkIsLoop = void 0;
+const geo_1 = require("../../../utils/geo");
+const MAX_LAPMODE_DISTANCE = 50;
+const checkIsLoop = (route) => {
+    var _a;
+    const { data, details } = route;
+    if (!((_a = details === null || details === void 0 ? void 0 : details.points) === null || _a === void 0 ? void 0 : _a.length)) {
+        data.isLoop = false;
+        return false;
+    }
+    const points = details.points;
+    const maxDistance = MAX_LAPMODE_DISTANCE;
+    const p1 = points[0];
+    const p2 = points[points.length - 1];
+    if (p1 === undefined || p2 === undefined) {
+        data.isLoop = false;
+        return false;
+    }
+    const dist = Math.abs((0, geo_1.calculateDistance)(p1.lat, p1.lng, p2.lat, p2.lng));
+    data.isLoop = (dist <= maxDistance);
+    return data.isLoop;
+};
+exports.checkIsLoop = checkIsLoop;
+const getSegments = (route) => {
+    var _a;
+    const { data, details } = route;
+    if (data === null || data === void 0 ? void 0 : data.segments) {
+        return data.segments;
+    }
+    if ((_a = details === null || details === void 0 ? void 0 : details.video) === null || _a === void 0 ? void 0 : _a.segments) {
+        const segments = [];
+        details.video.segments.forEach(sx => {
+            if (!sx || typeof sx !== 'object')
+                return;
+            const additional = sx.segment.map(s => {
+                const segment = s['$'];
+                if (segment.start !== undefined)
+                    segment.start = parseInt(segment.start);
+                if (segment.end !== undefined)
+                    segment.end = parseInt(segment.end);
+                return segment;
+            });
+            segments.push(...additional);
+        });
+        if (data)
+            data.segments = segments;
+        return segments;
+    }
+};
+exports.getSegments = getSegments;

package/lib/routes/index.d.ts

@@ -0,0 +1 @@
+export * from './list';