incyclist-services 1.0.56 → 1.0.58

package/lib/api/index.d.ts

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

package/lib/api/index.js

@@ -16,3 +16,4 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./rest/index"), exports);
 __exportStar(require("./rest/types"), exports);
+__exportStar(require("./repository"), exports);

package/lib/api/repository/json/index.d.ts

@@ -1,19 +1,21 @@
 import { EventLogger } from "gd-eventlog";
-import { IRepositoryBinding, JSONObject } from "../types";
+import { IJsonRepositoryBinding, JSONObject, JsonAccess } from "../types";
 export declare class JsonRepository {
     protected static _instances: {
         [x: string]: JsonRepository;
     };
-    protected static _defaultBinding: IRepositoryBinding;
+    protected static _defaultBinding: IJsonRepositoryBinding;
     static create(repoName: string): JsonRepository;
-    static setBinding(binding: IRepositoryBinding): void;
-    protected binding: IRepositoryBinding;
+    static setBinding(binding: IJsonRepositoryBinding): void;
+    protected binding: IJsonRepositoryBinding;
     protected name: string;
     protected db: string;
     protected logger: EventLogger;
-    constructor(repoName: string, binding?: IRepositoryBinding);
+    protected access: JsonAccess;
+    constructor(repoName: string, binding?: IJsonRepositoryBinding);
+    getName(): string;
+    write(objectName: string, data: JSONObject): Promise<boolean>;
+    read(objectName: string): Promise<JSONObject>;
     protected open(): Promise<boolean>;
     protected close(): Promise<boolean>;
-    protected write(objectName: string, data: JSONObject): Promise<boolean>;
-    protected read(objectName: string): Promise<JSONObject>;
 }

package/lib/api/repository/json/index.js

@@ -26,16 +26,48 @@ class JsonRepository {
         this.binding = binding || JsonRepository._defaultBinding;
         this.logger = new gd_eventlog_1.EventLogger(`Repo-${this.name}`);
     }
+    getName() {
+        return this.name;
+    }
+    write(objectName, data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.open();
+            const success = yield this.access.write(objectName, data);
+            if (!success) {
+            }
+            return success;
+        });
+    }
+    read(objectName) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.open();
+            try {
+                const data = yield this.access.read(objectName);
+                if (!data) {
+                }
+                return data;
+            }
+            catch (err) {
+            }
+        });
+    }
     open() {
         return __awaiter(this, void 0, void 0, function* () {
+            if (this.access)
+                return true;
             if (!this.binding)
                 throw new Error('no binding specified');
             try {
                 const existing = yield this.binding.get(this.name);
                 if (existing) {
+                    this.access = existing;
                     return true;
                 }
-                return yield this.binding.create(this.name);
+                const access = yield this.binding.create(this.name);
+                if (!access)
+                    return false;
+                this.access = access;
+                return true;
             }
             catch (err) {
                 return false;
@@ -47,29 +79,10 @@ class JsonRepository {
             if (!this.binding)
                 throw new Error('no binding specified');
             this.binding.release(this.name);
+            this.access = null;
             return true;
         });
     }
-    write(objectName, data) {
-        if (!this.binding)
-            throw new Error('no binding specified');
-        const success = this.binding.write(objectName, data);
-        if (!success) {
-        }
-        return success;
-    }
-    read(objectName) {
-        if (!this.binding)
-            throw new Error('no binding specified');
-        try {
-            const data = this.binding.read(objectName);
-            if (!data) {
-            }
-            return data;
-        }
-        catch (err) {
-        }
-    }
 }
 exports.JsonRepository = JsonRepository;
 JsonRepository._instances = {};

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

@@ -1,10 +1,18 @@
 export type JSONObject = string | number | boolean | {
     [x: string]: JSONObject;
 } | Array<JSONObject>;
-export interface IRepositoryBinding {
-    create(name: string): Promise<boolean>;
-    get(name: string): Promise<boolean>;
-    release(name: string): Promise<boolean>;
+export type JsonAccess = {
     read(resourceName: string): Promise<JSONObject>;
     write(resourceName: string, data: JSONObject): Promise<boolean>;
+    delete(resourceName: string): Promise<boolean>;
+};
+export interface IJsonRepositoryBinding {
+    create(name: string): Promise<JsonAccess | null>;
+    get(name: string): Promise<JsonAccess | null>;
+    release(name: string): Promise<boolean>;
+}
+export declare abstract class AbstractJsonRepositoryBinding implements IJsonRepositoryBinding {
+    abstract create(name: string): Promise<JsonAccess | null>;
+    abstract get(name: string): Promise<JsonAccess | null>;
+    abstract release(name: string): Promise<boolean>;
 }

package/lib/api/repository/types.js

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

package/lib/devices/pairing/service.js

@@ -198,12 +198,13 @@ class DevicePairingService extends service_2.IncyclistService {
                 const c = this.getCapability(capability);
                 if (cntSelected === 1 && c.selected === udid) {
                     const adapter = this.getDeviceAdapter(udid);
-                    adapter.stop();
+                    if (adapter)
+                        adapter.stop();
                 }
                 if (deleteAll) {
                     const adapter = this.getDeviceAdapter(udid);
                     const capabilities = adapter.getCapabilities();
-                    capabilities.forEach((c, idx) => {
+                    capabilities === null || capabilities === void 0 ? void 0 : capabilities.forEach((c, idx) => {
                         const shouldEmit = (idx === capabilities.length - 1);
                         this.deleteCapabilityDevice(c, udid, shouldEmit);
                     });
@@ -732,7 +733,7 @@ class DevicePairingService extends service_2.IncyclistService {
     run(props = {}) {
         return __awaiter(this, void 0, void 0, function* () {
             this.emit('run');
-            if (this.isPairing() || this.isScanning() || !this.state.waiting) {
+            if ((this.isPairing() || this.isScanning()) && !this.state.waiting) {
                 yield this._stop();
             }
             if (this.state.stopRequested || this.state.stopped) {
@@ -847,6 +848,10 @@ class DevicePairingService extends service_2.IncyclistService {
             this.state.tsPrevStart = Date.now();
             if (this.isScanning() && this.state.scan.preparing !== preparing)
                 return;
+            this.logEvent({ message: 'Stopping Adapters', interfaces: interfaces.join(','), props });
+            const stopPromises = [];
+            interfaces.forEach(i => stopPromises.push(this.stopAdaptersOnInterface(i)));
+            yield Promise.allSettled(stopPromises);
             this.logEvent({ message: 'Start Scanning', interfaces: interfaces.join(','), props });
             this.initScanningCallbacks();
             const timeout = props.enforcedScan ? 1000 * 60 * 60 : undefined;
@@ -1016,6 +1021,8 @@ class DevicePairingService extends service_2.IncyclistService {
     stopAdaptersWithCapability(capability, udid) {
         return __awaiter(this, void 0, void 0, function* () {
             const c = this.getCapability(capability);
+            if (!c)
+                return;
             const { adapters = [], capabilities } = this.state;
             const maxRetries = 3;
             let target = udid ?

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

@@ -32,6 +32,10 @@ export declare class DeviceRideService extends EventEmitter {
     startCheck(filter: RideServiceCheckFilter): Promise<void>;
     getAdapters(filter: RideServiceCheckFilter): AdapterRideInfo[];
     setSerialPortInUse(adapter: IncyclistDeviceAdapter): void;
+    protected checkAntSameDeviceID(adapters: AdapterRideInfo[]): Array<{
+        udid: string;
+        info: AdapterInfo;
+    }>;
     startAdapters(adapters: AdapterRideInfo[], startType: 'start' | 'check' | 'pair', props?: RideServiceDeviceProperties): Promise<boolean>;
     start(props: RideServiceDeviceProperties): Promise<boolean>;
     startRetry(props: RideServiceDeviceProperties): Promise<boolean>;

package/lib/devices/ride/service.js

@@ -336,11 +336,39 @@ class DeviceRideService extends events_1.default {
             serial.setInUse(device.getPort());
         }
     }
+    checkAntSameDeviceID(adapters) {
+        const antDevices = adapters.map((ai, idx) => (Object.assign(Object.assign({}, ai), { idx })))
+            .filter(ai => ai.adapter.getInterface() === 'ant')
+            .map(ai => ({ idx: ai.idx, deviceID: ai.adapter.getID(), capabilities: ai.capabilities, udid: ai.udid }));
+        const antDeviceIds = antDevices.map(di => di.deviceID);
+        const duplicateIds = antDeviceIds.filter((item, index) => antDeviceIds.indexOf(item) !== index);
+        const score = (capabilities) => {
+            let value = 0;
+            if (capabilities.includes(incyclist_devices_1.IncyclistCapability.Control))
+                value += 100;
+            if (capabilities.includes(incyclist_devices_1.IncyclistCapability.Power))
+                value += 50;
+            value += capabilities.length;
+            return value;
+        };
+        const duplicateDevices = antDevices.filter(di => duplicateIds.includes(di.deviceID)).sort((a, b) => score(b.capabilities) - score(a.capabilities));
+        const leading = duplicateDevices[0];
+        const duplicateAdapters = [];
+        duplicateDevices.forEach((di, i) => {
+            if (i == 0)
+                return;
+            duplicateAdapters.push({ udid: leading.udid, info: adapters[di.idx] });
+        });
+        return duplicateAdapters;
+    }
     startAdapters(adapters, startType, props) {
         return __awaiter(this, void 0, void 0, function* () {
             const { forceErgMode, startPos, realityFactor, rideMode, route } = props || {};
+            const duplicates = this.checkAntSameDeviceID(adapters);
             this.startPromises = adapters === null || adapters === void 0 ? void 0 : adapters.map((ai) => __awaiter(this, void 0, void 0, function* () {
                 var _a;
+                if (duplicates.find(dai => dai.info.udid === ai.udid))
+                    return;
                 const startProps = (0, clone_1.default)(props || {});
                 if (startType === 'check' || startType === 'pair') {
                     startProps.timeout = 10000;
@@ -389,6 +417,9 @@ class DeviceRideService extends events_1.default {
                     .then((success) => __awaiter(this, void 0, void 0, function* () {
                     if (success) {
                         this.emit(`${startType}-success`, this.getAdapterStateInfo(ai));
+                        if (duplicates.find(dai => dai.udid === ai.udid)) {
+                            duplicates.forEach(dai => { this.emit(`${startType}-success`, this.getAdapterStateInfo(dai.info)); });
+                        }
                         this.logEvent(Object.assign({ message: `${startType} ${sType} request finished` }, logProps));
                         if (startType === 'check')
                             yield ai.adapter.pause().catch(console.log);
@@ -400,6 +431,9 @@ class DeviceRideService extends events_1.default {
                     }
                     else {
                         this.emit(`${startType}-error`, this.getAdapterStateInfo(ai));
+                        if (duplicates.find(dai => dai.udid === ai.udid)) {
+                            duplicates.forEach(dai => { this.emit(`${startType}-error`, this.getAdapterStateInfo(dai.info)); });
+                        }
                         this.logEvent(Object.assign({ message: `${startType} ${sType} request failed` }, logProps));
                         if (startType === 'check' || startType === 'pair')
                             yield ai.adapter.stop().catch(console.log);
@@ -411,6 +445,9 @@ class DeviceRideService extends events_1.default {
                     ai.isStarted = false;
                     this.logEvent(Object.assign(Object.assign({ message: `${startType} ${sType} request failed` }, logProps), { reason: err.message }));
                     this.emit(`${startType}-error`, this.getAdapterStateInfo(ai), err);
+                    if (duplicates.find(dai => dai.udid === ai.udid)) {
+                        duplicates.forEach(dai => { this.emit(`${startType}-error`, this.getAdapterStateInfo(dai.info)); });
+                    }
                     if (startType === 'check' || startType === 'pair') {
                         yield ai.adapter.stop().catch(console.log);
                     }
@@ -529,10 +566,29 @@ class DeviceRideService extends events_1.default {
         this.verifySelected(selectedDevices, incyclist_devices_1.IncyclistCapability.Speed);
         this.verifySelected(selectedDevices, incyclist_devices_1.IncyclistCapability.Cadence);
         this.verifySelected(selectedDevices, incyclist_devices_1.IncyclistCapability.Power);
-        const enabledCapabilities = this.enforceSimulator ?
-            [incyclist_devices_1.IncyclistCapability.Control, incyclist_devices_1.IncyclistCapability.Power, incyclist_devices_1.IncyclistCapability.Speed, incyclist_devices_1.IncyclistCapability.HeartRate, incyclist_devices_1.IncyclistCapability.Cadence]
-            :
-                selectedDevices.filter(sd => sd.selected === adapterInfo.udid).map(c => c.capability);
+        const duplicates = this.checkAntSameDeviceID(adapters);
+        const toBeReplaced = duplicates.filter(dai => dai.udid === adapterInfo.udid).map(dai => dai.info.udid);
+        let enabledCapabilities = [];
+        if (this.simulatorEnforced) {
+            enabledCapabilities = [incyclist_devices_1.IncyclistCapability.Control, incyclist_devices_1.IncyclistCapability.Power, incyclist_devices_1.IncyclistCapability.Speed, incyclist_devices_1.IncyclistCapability.HeartRate, incyclist_devices_1.IncyclistCapability.Cadence];
+        }
+        else if (duplicates.length > 0 && duplicates.find(d => d.udid === adapterInfo.udid)) {
+            const selected = (0, clone_1.default)(selectedDevices);
+            selected.forEach(cd => {
+                if (toBeReplaced.includes(cd.selected))
+                    cd.selected = adapterInfo.udid;
+            });
+            selected.forEach;
+            selected.forEach(sd => {
+                const duplicate = duplicates.find(dai => dai.info.udid === sd.selected);
+                if (duplicate)
+                    sd.selected = duplicate.udid;
+            });
+            enabledCapabilities = selected.map(c => c.capability);
+        }
+        else {
+            enabledCapabilities = selectedDevices.filter(sd => sd.selected === adapterInfo.udid).map(c => c.capability);
+        }
         this.logEvent({ message: 'Data Update', device: adapterInfo.adapter.getName(), data, enabledCapabilities });
         enabledCapabilities.forEach(capability => {
             switch (capability) {
@@ -559,6 +615,11 @@ class DeviceRideService extends events_1.default {
             }
         });
         this.emit('data', this.data, adapterInfo.udid);
+        if (toBeReplaced) {
+            toBeReplaced.forEach(udid => {
+                this.emit('data', this.data, udid);
+            });
+        }
     }
     sendUpdate(request) {
         const adapters = this.getAdapterList();

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

@@ -12,7 +12,8 @@ export default class IncyclistRoutesApi {
     protected getApi(): AxiosInstance;
     protected getBaseUrl(): any;
     getRouteDescriptions(query: RouteDescriptionQuery): Promise<Array<RouteApiDescription>>;
-    fixMissingRouteDistances(points: Array<RoutePoint>): void;
+    static verify(route: any): void;
+    protected static 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

@@ -25,7 +25,6 @@ class IncyclistRoutesApi {
     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) {
@@ -53,7 +52,14 @@ class IncyclistRoutesApi {
             }
         });
     }
-    fixMissingRouteDistances(points) {
+    static verify(route) {
+        if (route['decoded']) {
+            route.points = route['decoded'];
+            delete route['decoded'];
+            IncyclistRoutesApi.fixMissingRouteDistances(route.points);
+        }
+    }
+    static fixMissingRouteDistances(points) {
         let routeDistance = 0;
         points.forEach((p) => {
             if (!p.routeDistance)
@@ -65,11 +71,7 @@ class IncyclistRoutesApi {
         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);
-                }
+                IncyclistRoutesApi.verify(res.data);
                 return res.data;
             }
             catch (err) {

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

@@ -25,6 +25,23 @@ export type RouteApiDescription = {
     type?: RouteType;
     localizedTitle?: LocalizedText;
 };
+export type LegacyRouteGpxRepoDescription = {
+    id: string;
+    hash?: string;
+    routeHash?: string;
+    title: string;
+    private?: boolean;
+    distance?: number;
+    elevation?: number;
+    author?: {
+        id: string;
+    };
+    points?: {
+        id: string;
+    };
+    __v: number;
+    category?: RouteCategory;
+};
 export type RouteApiDetail = {
     id: string;
     routeId?: string;

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

@@ -1,5 +1,5 @@
 export type RouteType = 'gpx' | 'video';
-export type RouteCategory = 'Free' | 'Demo';
+export type RouteCategory = 'Free' | 'Demo' | 'personal';
 export type RouteState = 'prepared' | 'loading' | 'loaded' | 'error';
 export type RouteProvider = {
     name: string;
@@ -35,7 +35,7 @@ export type RoutePoint = {
     lng: number;
     routeDistance: number;
     elevation: number;
-    slope: number;
+    slope?: number;
 };
 export type RouteSegment = {
     start: number;

package/lib/routes/list/FreeRideCard.d.ts

@@ -0,0 +1,8 @@
+import { RouteState } from "../base/types";
+import { CardInfo, CardType } from "./types";
+export declare class FreeRideCard implements CardInfo {
+    type: CardType;
+    state: RouteState;
+    title?: string;
+    constructor(state: any, title?: any);
+}

package/lib/routes/list/FreeRideCard.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FreeRideCard = void 0;
+class FreeRideCard {
+    constructor(state, title) {
+        this.type = 'free-ride';
+        this.state = state;
+        this.title = title || 'Free Ride';
+    }
+}
+exports.FreeRideCard = FreeRideCard;

package/lib/routes/list/service.d.ts

@@ -1,20 +1,24 @@
-import { Page, IRouteListBinding, InternalRouteListState, List, RouteInfo, Route, RouteListEntry, RouteListStartProps, RouteListData, RouteStartSettings } from "./types";
+import { Page, InternalRouteListState, List, RouteInfo, Route, RouteListEntry, RouteListStartProps, RouteListData, RouteStartSettings, onRouteStatusUpdateCallback, onCarouselStateChangedCallback, RoutesDB } from "./types";
 import IncyclistRoutesApi from "../base/api";
 import { RouteApiDescription, RouteApiDetail } from "../base/api/types";
 import { IncyclistService } from "../../base/service";
+import { IJsonRepositoryBinding, JsonRepository } from "../../api";
 type filterFn = (route: Route, idx: number, obj: Route[]) => boolean;
 export declare class RouteListService extends IncyclistService {
     protected static _instance: any;
-    static getInstance(binding?: IRouteListBinding): RouteListService;
+    static getInstance(binding?: IJsonRepositoryBinding): RouteListService;
     protected baseDir: string;
     protected state: InternalRouteListState;
-    protected binding: IRouteListBinding;
-    protected routes: Array<RouteListEntry>;
+    protected lists: Array<RouteListEntry>;
+    protected videosRepo: JsonRepository;
+    protected routesRepo: JsonRepository;
     protected api: IncyclistRoutesApi;
-    constructor(binding?: IRouteListBinding);
-    setBinding(binding: IRouteListBinding): void;
+    protected routeDescriptions: RoutesDB;
+    constructor(binding?: IJsonRepositoryBinding);
+    setBinding(binding: IJsonRepositoryBinding): void;
+    protected getVideosRepo(): JsonRepository;
+    protected getRoutesRepo(): JsonRepository;
     preload(carouselSize?: number): Promise<void>;
-    protected _preload(carouselSize?: number, detailsOnly?: boolean): Promise<void>;
     load(props: {
         list?: List;
         loadFrom?: number;
@@ -22,9 +26,13 @@ export declare class RouteListService extends IncyclistService {
         routeId?: string;
     }): Promise<void>;
     openRouteSelection(pageId: string, props: RouteListStartProps): RouteListData;
-    closeRouteSelection(listId: string): void;
+    closeRouteSelection(pageId: string): void;
+    onResize(pageId: string): void;
     openStartSettings(r: RouteInfo | string): RouteStartSettings;
     cancelStartSettings(r: RouteInfo | string): {};
+    setCardUpdateHandler(pageId: string, r: RouteInfo | string, list: List, idx: number, onRouteStateChanged: onRouteStatusUpdateCallback, onCarouselStateChanged: onCarouselStateChangedCallback): void;
+    onCarouselInitialized(pageId: string, list: List, startIdx: number, visibleSize: number): void;
+    onCarouselUpdated(pageId: string, list: List, startIdx: number, visibleSize: number): void;
     acceptStartSettings(r: RouteInfo | string, startSettings: RouteStartSettings): {};
     getSelectedRoute(): RouteApiDetail;
     getStartSettings(routeId?: string): RouteStartSettings;
@@ -32,6 +40,8 @@ export declare class RouteListService extends IncyclistService {
     stopRide(r?: RouteInfo | string): {};
     startDownload(routeId: any, onStatusUpdate: any): void;
     cancelDownload(routeId: any): void;
+    protected _preload(carouselSize?: number, detailsOnly?: boolean): Promise<void>;
+    protected preloadList(list: List, carouselSize?: number): Promise<void>;
     protected loadStartSettingsFromUserSettings(route: Route): {
         startPos: number;
         realityFactor: number;
@@ -54,13 +64,20 @@ export declare class RouteListService extends IncyclistService {
     protected getRouteDescription(list: List, id: string): RouteInfo;
     protected mergeDescription(local: RouteInfo, fromApi: RouteInfo): void;
     protected mergeWithDetails(route: Route): void;
-    protected convertDescription(descr: RouteApiDescription): RouteInfo;
+    protected convertDescription(descr: RouteApiDescription, isLocal?: boolean): RouteInfo;
     protected getListFromApiDesciption(description: RouteApiDescription): "selected" | "myRoutes" | "alternatives";
     protected addRouteToList(list: List, route: Route): void;
     protected getRouteList(list: List): Array<Route>;
+    protected getRouteLists(): Array<{
+        list: List;
+        title: string;
+    }>;
     protected getRoute(criteria: string | filterFn): Route;
+    protected getAllRoutes(): Array<Route>;
     protected stopAllRides(): void;
-    protected addDescriptions(descriptions: Array<RouteApiDescription>): void;
+    protected addDescriptionsFromDB(descriptions: RoutesDB): void;
+    protected addDescriptionsFromRepo(descriptions: Array<RouteApiDescription>, repo?: JsonRepository): void;
+    protected addDescriptionsFromServer(descriptions: Array<RouteApiDescription>): void;
     protected updateRouteTitle(data: RouteInfo, route: {
         descr?: RouteApiDescription;
     }): void;
@@ -69,10 +86,18 @@ export declare class RouteListService extends IncyclistService {
     }): void;
     protected getCountryPrefix(title?: string): string | undefined;
     protected removeCountryPrefix(title?: string): string;
+    protected loadRouteDescriptionsFromRepo(): Promise<void>;
+    protected saveRouteDescriptions(): Promise<void>;
+    protected loadRouteDescriptionsFromServer(): Promise<void>;
     protected loadRouteDescriptions(): Promise<void>;
-    protected loadRouteDetais(route: Route): Promise<void>;
+    protected loadRouteDetais(route: Route): Promise<RouteInfo>;
+    saveRouteDetails(route: any): Promise<void>;
     protected emitRouteUpdated(route: Route): void;
+    protected getListState(page: Page, list: List): import("./types").RouteListDateEntry;
     private getRouteFromStartProps;
+    private isDescriptionsLoaded;
+    private decodePoints;
+    private encodePoints;
 }
 export declare const useRouteList: () => RouteListService;
 export {};

package/lib/routes/list/service.js

@@ -18,6 +18,9 @@ const localization_1 = require("../base/utils/localization");
 const service_1 = require("../../base/service");
 const route_1 = require("../base/utils/route");
 const settings_1 = require("../../settings");
+const api_2 = require("../../api");
+const clone_1 = __importDefault(require("../../utils/clone"));
+const FreeRideCard_1 = require("./FreeRideCard");
 class RouteListService extends service_1.IncyclistService {
     static getInstance(binding) {
         if (!RouteListService._instance)
@@ -28,52 +31,44 @@ class RouteListService extends service_1.IncyclistService {
         super('RouteList');
         this.state = {
             initialized: false,
-            pages: []
+            pages: [],
+            preloadDone: false
         };
-        this.setBinding(binding);
+        if (binding)
+            api_2.JsonRepository.setBinding(binding);
         this.api = api_1.default.getInstance();
         this.initRouteLists();
+        this.routeDescriptions = {};
     }
     setBinding(binding) {
         if (!binding)
             return;
-        this.binding = binding;
+        api_2.JsonRepository.setBinding(binding);
         this.state.initialized = true;
     }
+    getVideosRepo() {
+        if (this.videosRepo)
+            return this.videosRepo;
+        this.videosRepo = api_2.JsonRepository.create('videos');
+        return this.videosRepo;
+    }
+    getRoutesRepo() {
+        if (this.routesRepo)
+            return this.routesRepo;
+        this.routesRepo = api_2.JsonRepository.create('routes');
+        return this.routesRepo;
+    }
     preload(carouselSize = 5) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (this.state.loading)
-                yield this.state.loading.promise;
+            if (this.state.loading || this.state.preloadDone)
+                return;
             const promise = this._preload(carouselSize);
             this.state.loading = { promise };
             yield promise;
+            this.state.preloadDone = true;
             this.state.loading = null;
         });
     }
-    _preload(carouselSize = 5, detailsOnly = false) {
-        return __awaiter(this, void 0, void 0, function* () {
-            this.logEvent({ message: 'preloading routes --' });
-            if (!detailsOnly) {
-                yield this.loadRouteDescriptions();
-            }
-            const promises = [];
-            this.routes.forEach(rle => {
-                var _a;
-                if (((_a = rle.routes) === null || _a === void 0 ? void 0 : _a.length) > 0) {
-                    this.sort(rle.routes);
-                    rle.routes.forEach((r, idx) => {
-                        if (idx < Math.min(carouselSize, rle.routes.length)) {
-                            const loader = this.loadRouteDetais(r);
-                            promises.push(loader);
-                        }
-                    });
-                }
-            });
-            yield Promise.allSettled(promises);
-            this.emitPageUpdate();
-            this.logEvent({ message: 'preloading routes finished' });
-        });
-    }
     load(props) {
         return __awaiter(this, void 0, void 0, function* () {
             const { routeId, list, loadFrom, loadTo } = props;
@@ -86,7 +81,7 @@ class RouteListService extends service_1.IncyclistService {
             if (list)
                 lists.push(list);
             else
-                lists = this.routes.map(rle => rle.list);
+                lists = this.lists.map(rle => rle.list);
             lists.forEach(l => {
                 const routes = this.getRouteList(l);
                 for (let i = loadFrom; i < loadTo; i++) {
@@ -97,24 +92,39 @@ class RouteListService extends service_1.IncyclistService {
     }
     openRouteSelection(pageId, props) {
         const { language, visibleCards, visibleLists } = props;
-        this.logEvent({ message: 'start', pageId, language, visibleCards, visibleLists });
+        this.logEvent({ message: 'openRouteSelection', pageId, language, visibleCards, visibleLists });
         const existing = this.getPage(pageId);
         if (existing) {
             this.closeRouteSelection(pageId);
         }
         this.stopAllRides();
-        if (props.visibleCards) {
-            this._preload(props.visibleCards, true);
-        }
         const page = this.registerPage(pageId, props);
+        if (!this.state.preloadDone)
+            this.preload(props.visibleCards || 5);
+        else
+            this.onResize(pageId);
         return page.state;
     }
-    closeRouteSelection(listId) {
-        const idx = this.getPage(listId, true);
+    closeRouteSelection(pageId) {
+        const idx = this.getPage(pageId, true);
         if (idx !== -1) {
             this.state.pages.splice(idx, 1);
         }
     }
+    onResize(pageId) {
+        const page = this.getPage(pageId);
+        const routeIds = Object.keys(page.onCarouselStateChanged);
+        routeIds.forEach(id => {
+            var _a;
+            const route = this.getRoute(id);
+            const stateChange = (_a = page.onCarouselStateChanged[id]) === null || _a === void 0 ? void 0 : _a.onCarouselStateChanged;
+            if (stateChange)
+                stateChange({ initialized: true, visible: false });
+            const update = page.onRouteUpdate[id].onRouteStateChanged;
+            if (update)
+                update(route.data);
+        });
+    }
     openStartSettings(r) {
         var _a;
         const route = this.getRouteFromStartProps(r);
@@ -146,6 +156,56 @@ class RouteListService extends service_1.IncyclistService {
             return {};
         }
     }
+    setCardUpdateHandler(pageId, r, list, idx, onRouteStateChanged, onCarouselStateChanged) {
+        const route = this.getRouteFromStartProps(r);
+        if (!route)
+            return;
+        const page = this.getPage(pageId);
+        if (!page)
+            return;
+        page.onRouteUpdate[route.id] = { idx, onRouteStateChanged };
+        page.onCarouselStateChanged[route.id] = { idx, onCarouselStateChanged };
+    }
+    onCarouselInitialized(pageId, list, startIdx, visibleSize) {
+        const page = this.getPage(pageId);
+        if (!page)
+            return;
+        const listState = this.getListState(page, list);
+        if (listState) {
+            listState.startIdx = startIdx;
+            listState.endIdx = startIdx + visibleSize - 1;
+        }
+        const routes = this.getRouteList(list);
+        routes.forEach((route) => {
+            const { idx, onCarouselStateChanged } = page.onCarouselStateChanged[route.id] || {};
+            const visible = listState !== undefined ? idx >= listState.startIdx && idx <= listState.endIdx : undefined;
+            if (onCarouselStateChanged)
+                onCarouselStateChanged({ initialized: true, visible });
+            if (visible && (route.data.state === 'prepared' || route.data.state === 'error')) {
+                this.loadRouteDetais(route);
+            }
+        });
+    }
+    onCarouselUpdated(pageId, list, startIdx, visibleSize) {
+        const page = this.getPage(pageId);
+        if (!page)
+            return;
+        const listState = this.getListState(page, list);
+        if (listState) {
+            listState.startIdx = startIdx;
+            listState.endIdx = startIdx + visibleSize - 1;
+        }
+        const routes = this.getRouteList(list);
+        routes.forEach((route) => {
+            const { idx, onCarouselStateChanged } = page.onCarouselStateChanged[route.id] || {};
+            const visible = listState !== undefined ? idx >= listState.startIdx && idx <= listState.endIdx : undefined;
+            if (onCarouselStateChanged)
+                onCarouselStateChanged({ initialized: true, visible });
+            if (visible && route.data.state === 'prepared' || route.data.state === 'error') {
+                this.loadRouteDetais(route);
+            }
+        });
+    }
     acceptStartSettings(r, startSettings) {
         var _a;
         const route = this.getRouteFromStartProps(r);
@@ -192,6 +252,44 @@ class RouteListService extends service_1.IncyclistService {
     }
     cancelDownload(routeId) {
     }
+    _preload(carouselSize = 5, detailsOnly = false) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!detailsOnly) {
+                yield this.loadRouteDescriptions();
+            }
+            this.emitPageUpdate();
+            const lists = this.getRouteLists().map(li => li.list);
+            lists.forEach((list) => {
+                this.preloadList(list, carouselSize);
+            });
+            this.logEvent({ message: 'preloading routes finished' });
+        });
+    }
+    preloadList(list, carouselSize = 5) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            this.emitPageUpdate();
+            const promises = [];
+            const rle = this.lists.find(l => l.list === list);
+            if (((_a = rle.routes) === null || _a === void 0 ? void 0 : _a.length) > 0) {
+                this.sort(rle.routes);
+                let cntApi = 0;
+                rle.routes.forEach((r) => {
+                    if (!r.data.isLocal) {
+                        cntApi++;
+                    }
+                    if (r.data.isLocal || cntApi <= Math.min(carouselSize, rle.routes.length)) {
+                        promises.push(this.loadRouteDetais(r));
+                    }
+                });
+            }
+            console.log('~~~ DEBUG: during preload', promises.length);
+            Promise.allSettled(promises).then((res) => {
+                console.log('~~~ DEBUG: after preload', (0, clone_1.default)(this.state), (0, clone_1.default)(this.routeDescriptions), res);
+                this.saveRouteDescriptions();
+            });
+        });
+    }
     loadStartSettingsFromUserSettings(route) {
         let startPos = 0, realityFactor = 100, segment;
         const { data } = route;
@@ -211,6 +309,10 @@ class RouteListService extends service_1.IncyclistService {
         if (prevRoutePosition !== null) {
             startPos = prevRoutePosition;
         }
+        if (data.videoFormat === 'avi') {
+            startPos = 0;
+            segment = undefined;
+        }
         return { startPos, realityFactor, segment };
     }
     writeStartSettingsToUserSettings(route, startSettings) {
@@ -240,15 +342,15 @@ class RouteListService extends service_1.IncyclistService {
     }
     emitPageUpdate() {
         this.state.pages.forEach(p => {
-            const state = this.getPageState(p.id);
-            p.onStatusUpdate(state);
+            p.state = this.getPageState(p.id);
+            p.onStatusUpdate(p.state);
         });
     }
     initRouteLists() {
-        this.routes = [];
-        this.routes.push({ list: "myRoutes", routes: [] });
-        this.routes.push({ list: "selected", routes: [] });
-        this.routes.push({ list: "alternatives", routes: [] });
+        this.lists = [];
+        this.lists.push({ list: "myRoutes", routes: [] });
+        this.lists.push({ list: "selected", routes: [] });
+        this.lists.push({ list: "alternatives", routes: [] });
     }
     getPageState(pageId, lang) {
         var _a;
@@ -257,6 +359,11 @@ class RouteListService extends service_1.IncyclistService {
         const language = lang || ((_a = this.getPage(pageId)) === null || _a === void 0 ? void 0 : _a.language) || 'en';
         const add = (list, listHeader) => {
             const data = this.getRouteList(list);
+            if (list === 'myRoutes' && !data.find(r => r.data.type === 'free-ride')) {
+                const card = new FreeRideCard_1.FreeRideCard('loaded');
+                const route = { data: card, id: 'free-ride', };
+                data.unshift(route);
+            }
             if ((data === null || data === void 0 ? void 0 : data.length) > 0) {
                 lists.push(this.getRouteListDataEntry(list, data, language, listHeader));
             }
@@ -264,12 +371,13 @@ class RouteListService extends service_1.IncyclistService {
         add('myRoutes', 'My Routes');
         add('selected', 'Selected For Me');
         add('alternatives', 'Alternatives');
+        console.log('~~~ DEBUG:getPageState', state);
         return state;
     }
     registerPage(pageId, props) {
         const { onStatusUpdate, language = 'en' } = props;
         const state = this.getPageState(pageId, language);
-        const page = { id: pageId, onStatusUpdate, language, state };
+        const page = { id: pageId, onStatusUpdate, onRouteUpdate: {}, onCarouselStateChanged: {}, language, state };
         this.state.pages.push(page);
         return page;
     }
@@ -317,7 +425,9 @@ class RouteListService extends service_1.IncyclistService {
         local.distance = local.distance || details.distance;
         local.elevation = local.elevation || details.elevation;
         local.localizedTitle = local.localizedTitle || details.localizedTitle;
-        local.points = details.points;
+        if (!local.points) {
+            local.points = details.points;
+        }
         if (!local.hasGpx && details.points) {
             local.hasGpx = true;
         }
@@ -342,11 +452,12 @@ class RouteListService extends service_1.IncyclistService {
         }
         route.data = local;
     }
-    convertDescription(descr) {
+    convertDescription(descr, isLocal) {
         const { id, title, localizedTitle, country, distance, elevation, category, provider, video, points } = descr;
-        const data = { state: 'prepared', id, title, localizedTitle, country, distance, elevation, provider, category };
+        const data = { type: 'route', state: 'prepared', id, title, localizedTitle, country, distance, elevation, provider, category };
         data.hasVideo = false;
         data.hasGpx = false;
+        data.isLocal = isLocal || false;
         this.updateRouteCountry(data, { descr });
         this.updateRouteTitle(data, { descr });
         if (points)
@@ -366,10 +477,14 @@ class RouteListService extends service_1.IncyclistService {
         var _a;
         let list;
         if (description.type === 'gpx') {
-            list = description.private ? 'myRoutes' : 'selected';
+            if (description.category === 'personal')
+                return 'myRoutes';
+            list = description.category ? 'alternatives' : 'selected';
             return list;
         }
         if (description.type === 'video') {
+            if (description.category === undefined || description.category === 'personal')
+                return 'myRoutes';
             if ((_a = description.video) === null || _a === void 0 ? void 0 : _a.url) {
                 return 'selected';
             }
@@ -382,28 +497,82 @@ class RouteListService extends service_1.IncyclistService {
     }
     getRouteList(list) {
         var _a;
-        return (_a = this.routes.find(rle => rle.list === list)) === null || _a === void 0 ? void 0 : _a.routes;
+        return (_a = this.lists.find(rle => rle.list === list)) === null || _a === void 0 ? void 0 : _a.routes;
+    }
+    getRouteLists() {
+        const lists = [
+            { list: 'myRoutes', title: 'My Routes' },
+            { list: 'selected', title: 'Selected For Me' },
+            { list: 'alternatives', title: 'Alternatives' }
+        ];
+        return lists;
     }
     getRoute(criteria) {
         let compareFn = criteria;
         if (typeof criteria === 'string')
             compareFn = v => v.id === criteria;
-        const lists = this.routes;
+        const lists = this.lists;
         let route = null;
         for (let i = 0; i < lists.length && !route; i++) {
             route = lists[i].routes.find(compareFn);
         }
         return route;
     }
+    getAllRoutes() {
+        const lists = this.lists;
+        const routes = [];
+        for (let i = 0; i < lists.length; i++) {
+            routes.push(...lists[i].routes);
+        }
+        return routes;
+    }
     stopAllRides() {
-        const lists = this.routes;
+        const lists = this.lists;
         for (let i = 0; i < lists.length; i++) {
             lists[i].routes.forEach(r => r.startState = 'idle');
         }
     }
-    addDescriptions(descriptions) {
+    addDescriptionsFromDB(descriptions) {
+        const ids = Object.keys(descriptions);
+        const routes = ids.map(id => descriptions[id]);
+        this.routeDescriptions = descriptions;
+        routes.forEach((data) => {
+            data.state = "prepared";
+            this.addRouteToList(data.list, { data, id: data.id });
+        });
+    }
+    addDescriptionsFromRepo(descriptions, repo) {
+        const routes = descriptions;
+        if (repo) {
+            const type = repo.getName() === 'videos' ? 'video' : 'gpx';
+            routes.forEach(r => {
+                r.type = type;
+            });
+        }
+        const converted = routes
+            .map(this.convertDescription.bind(this));
+        converted.forEach((data, idx) => {
+            const list = this.getListFromApiDesciption(descriptions[idx]);
+            const existing = this.getRouteDescription(list, data.id);
+            if (existing) {
+                this.mergeDescription(existing, data);
+            }
+            else {
+                data.state = 'prepared';
+                data.isLocal = true;
+                const item = { id: data.id, data };
+                this.addRouteToList(list, item);
+                this.routeDescriptions[data.id] = Object.assign(Object.assign({}, data), { list });
+            }
+        });
+    }
+    addDescriptionsFromServer(descriptions) {
         const converted = descriptions.map(this.convertDescription.bind(this));
         converted.forEach((data, idx) => {
+            const existing = this.getRoute(data.id);
+            if (existing) {
+                return;
+            }
             const list = this.getListFromApiDesciption(descriptions[idx]);
             if (!list) {
                 this.logEvent({ message: 'Error', error: 'no list found for route', id: data.id, title: data.title });
@@ -415,8 +584,11 @@ class RouteListService extends service_1.IncyclistService {
             }
             else {
                 data.state = 'prepared';
+                data.isLocal = false;
                 const item = { id: data.id, data };
                 this.addRouteToList(list, item);
+                this.routeDescriptions[data.id] = Object.assign(Object.assign({}, data), { list });
+                this.emitPageUpdate();
             }
         });
     }
@@ -457,39 +629,153 @@ class RouteListService extends service_1.IncyclistService {
             return title.substring(3);
         }
     }
-    loadRouteDescriptions() {
+    loadRouteDescriptionsFromRepo() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (Object.keys(this.routeDescriptions).length > 0) {
+                this.emitPageUpdate();
+                return;
+            }
+            const all = yield this.getRoutesRepo().read('settings');
+            if (!all) {
+                const videos = ((yield this.getVideosRepo().read('routes')) || []);
+                this.addDescriptionsFromRepo(videos, this.getVideosRepo());
+                const routes = ((yield this.getRoutesRepo().read('routes')) || []);
+                this.addDescriptionsFromRepo(routes, this.getRoutesRepo());
+            }
+            else {
+                const ids = Object.keys(all);
+                ids.forEach(id => {
+                    const r = all[id];
+                    if (typeof r.points === 'string') {
+                        this.decodePoints(r);
+                    }
+                    if (!Array.isArray(r.points))
+                        delete r.points;
+                });
+                console.log('~~~ DEBUG:', all);
+                this.addDescriptionsFromDB(all);
+            }
+            this.saveRouteDescriptions();
+        });
+    }
+    saveRouteDescriptions() {
         return __awaiter(this, void 0, void 0, function* () {
-            const enrich = (v, type) => (Object.assign({ type }, v));
-            const promises = [
-                this.api.getRouteDescriptions({ type: 'gpx' }).then(v => v.map(e => enrich(e, 'gpx'))),
-                this.api.getRouteDescriptions({ type: 'video' }).then(v => v.map(e => enrich(e, 'video')))
+            const ids = Object.keys(this.routeDescriptions);
+            const data = ids.map(id => {
+                const r = this.routeDescriptions[id];
+                if (r.points)
+                    this.encodePoints(r);
+                return Object.assign({}, r);
+            });
+            yield this.getRoutesRepo().write('settings', data);
+        });
+    }
+    loadRouteDescriptionsFromServer() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const enrichApi = (v, type) => (Object.assign({ type }, v));
+            const api = [
+                this.api.getRouteDescriptions({ type: 'gpx' }).then(v => v.map(e => enrichApi(e, 'gpx'))),
+                this.api.getRouteDescriptions({ type: 'video' }).then(v => v.map(e => enrichApi(e, 'video')))
             ];
-            const res = yield Promise.allSettled(promises);
+            const res = yield Promise.allSettled(api);
             res.forEach(p => {
                 if (p.status === 'fulfilled') {
-                    this.addDescriptions(p.value);
+                    this.addDescriptionsFromServer(p.value);
                 }
             });
         });
     }
+    loadRouteDescriptions() {
+        return __awaiter(this, void 0, void 0, function* () {
+            console.log('~~~ DEBUG:loadRouteDescriptions', Object.keys(this.routeDescriptions));
+            yield this.loadRouteDescriptionsFromRepo();
+            this.emitPageUpdate();
+            if (this.isDescriptionsLoaded()) {
+                yield this.loadRouteDescriptionsFromServer();
+                this.emitPageUpdate();
+                this.saveRouteDescriptions();
+            }
+            else {
+                this.loadRouteDescriptionsFromServer().then(() => {
+                    this.emitPageUpdate();
+                });
+            }
+        });
+    }
     loadRouteDetais(route) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (route.data.state === 'loaded')
+            if (route.data.state === 'loaded' || route.data.state === 'loading')
                 return;
             try {
                 route.data.state = 'loading';
-                route.details = yield this.api.getRouteDetails(route.id);
+                this.emitRouteUpdated(route);
+                try {
+                    route.details = route.data.hasVideo ?
+                        yield this.getVideosRepo().read(route.id)
+                        :
+                            yield this.getRoutesRepo().read(route.id);
+                    api_1.default.verify(route.details);
+                }
+                catch (err) {
+                    console.log('~~~ DEBUG:error', route.data.title, route.data.isLocal, err);
+                    if (route.data.isLocal)
+                        throw err;
+                }
+                if (!route.details) {
+                    route.details = yield this.api.getRouteDetails(route.id);
+                    api_1.default.verify(route.details);
+                    this.saveRouteDetails(route);
+                }
+                if (route.details.id !== route.data.id) {
+                    route.data.state = 'error';
+                    delete route.details;
+                    return;
+                }
                 this.mergeWithDetails(route);
-                route.data.state = 'loading';
+                route.data.state = 'loaded';
                 this.emitRouteUpdated(route);
+                const { list } = this.routeDescriptions[route.id];
+                this.routeDescriptions[route.id] = Object.assign(Object.assign({}, route.data), { list });
+                return route.data;
             }
             catch (e) {
                 route.data.state = 'error';
+                this.emitRouteUpdated(route);
+            }
+        });
+    }
+    saveRouteDetails(route) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                route.details = route.data.hasVideo ?
+                    yield this.videosRepo.write(route.id, route.details)
+                    :
+                        yield this.routesRepo.write(route.id, route.details);
+            }
+            catch (err) {
+                if (route.data.isLocal)
+                    throw err;
             }
         });
     }
     emitRouteUpdated(route) {
         this.emit('route-update', route.id, route.data);
+        this.state.pages.forEach(page => {
+            try {
+                const { onRouteStateChanged } = page.onRouteUpdate[route.id] || {};
+                const { language } = page;
+                if (onRouteStateChanged) {
+                    const data = (0, localization_1.getLocalizedData)(route.data, language);
+                    onRouteStateChanged(data);
+                }
+            }
+            catch (err) {
+                console.log('~~~ DEBUG:Error', err);
+            }
+        });
+    }
+    getListState(page, list) {
+        return page === null || page === void 0 ? void 0 : page.state.lists.find(pl => pl.list === list);
     }
     getRouteFromStartProps(r) {
         try {
@@ -507,6 +793,15 @@ class RouteListService extends service_1.IncyclistService {
             return;
         }
     }
+    isDescriptionsLoaded() {
+        return Object.keys(this.routeDescriptions).length === 0;
+    }
+    decodePoints(r) {
+        return;
+    }
+    encodePoints(r) {
+        return;
+    }
 }
 exports.RouteListService = RouteListService;
 const useRouteList = () => RouteListService.getInstance();

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

@@ -12,10 +12,14 @@ export type RouteListStartProps = {
 export type LocalizedText = {
     [index: string]: string;
 };
-export type RouteInfo = {
+export type CardType = 'route' | 'free-ride' | 'import';
+export interface CardInfo {
+    type: CardType;
     state: RouteState;
-    id?: string;
     title?: string;
+}
+export interface RouteInfo extends CardInfo {
+    id?: string;
     localizedTitle?: LocalizedText;
     country?: string;
     isLoop?: boolean;
@@ -23,6 +27,7 @@ export type RouteInfo = {
     elevation?: number;
     category?: RouteCategory;
     provider?: RouteProvider;
+    isLocal?: boolean;
     hasGpx?: boolean;
     hasVideo?: boolean;
     isDemo?: boolean;
@@ -30,14 +35,34 @@ export type RouteInfo = {
     videoFormat?: string;
     videoUrl?: string;
     previewUrl?: string;
-    points?: Array<RoutePoint>;
+    points?: Array<RoutePoint> | string;
     segments?: Array<RouteSegment>;
+}
+export interface RouteDBEntry extends RouteInfo {
+    list: List;
+    settings?: {
+        position?: number;
+        segment?: string;
+        realityFactor?: number;
+    };
+    cntStarts?: number;
+    lastStart?: number;
+}
+export type RoutesDB = {
+    [index: string]: RouteDBEntry;
 };
 export type RouteListDateEntry = {
     list: List;
     listHeader: string;
     routes: Array<RouteInfo>;
+    startIdx?: number;
+    endIdx?: number;
 };
+export type onRouteStatusUpdateCallback = (route: RouteInfo) => void;
+export type onCarouselStateChangedCallback = (state: {
+    initialized: boolean;
+    visible: boolean;
+}) => void;
 export type RouteListData = {
     pageId: string;
     lists: Array<RouteListDateEntry>;
@@ -59,6 +84,18 @@ export type Page = {
     settingsState?: RouteSettingsState;
     language: string;
     onStatusUpdate: RouteListStatusUpdateCallback;
+    onRouteUpdate: {
+        [index: string]: {
+            idx: number;
+            onRouteStateChanged: onRouteStatusUpdateCallback;
+        };
+    };
+    onCarouselStateChanged: {
+        [index: string]: {
+            idx: number;
+            onCarouselStateChanged: onCarouselStateChangedCallback;
+        };
+    };
 };
 export interface LoadingState {
     promise: any;
@@ -67,17 +104,20 @@ export interface InternalRouteListState {
     initialized: boolean;
     pages: Array<Page>;
     loading?: LoadingState;
+    preloadDone: boolean;
 }
 export type RouteStartState = 'idle' | 'preparing' | 'selected' | 'started';
-export type Route = {
+export type Card<T> = {
     id: string;
-    data: RouteInfo;
+    data: T;
     details?: RouteApiDetail;
     startSettings?: RouteStartSettings;
     startState?: RouteStartState;
 };
-export type RouteListEntry = {
+export type CardListEntry<T> = {
     list: List;
-    routes: Array<Route>;
+    routes: Array<Card<T>>;
 };
+export type Route = Card<RouteInfo>;
+export type RouteListEntry = CardListEntry<RouteInfo>;
 export type List = 'myRoutes' | 'alternatives' | 'selected';

package/lib/utils/geo.js

@@ -47,9 +47,11 @@ const getPointAfter = (p1, p2, offset) => {
 };
 exports.getPointAfter = getPointAfter;
 const getLatLng = (position) => {
-    if (Array.isArray(position))
+    if (Array.isArray(position)) {
         return { lat: position[0], lng: position[1] };
-    if (position.lat !== undefined && position.lng !== undefined)
+    }
+    if (position.lat !== undefined && position.lng !== undefined) {
         return position;
+    }
 };
 exports.getLatLng = getLatLng;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "incyclist-services",
-  "version": "1.0.56",
+  "version": "1.0.58",
   "peerDependencies": {
     "gd-eventlog": "^0.1.26"
   },
@@ -39,7 +39,7 @@
   },
   "dependencies": {
     "axios": "^1.6.1",
-    "incyclist-devices": "^2.1.23",
+    "incyclist-devices": "^2.1.24",
     "uuid": "^9.0.0"
   }
 }