incyclist-services 1.0.55 → 1.0.57

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/model.d.ts

@@ -52,10 +52,12 @@ export interface InternalPairingState extends PairingState {
     scanTo?: NodeJS.Timeout;
     tsPrevStart?: number;
     check?: {
-        promise: Promise<boolean>;
+        preparing?: number;
+        promise?: Promise<boolean>;
     };
     scan?: {
-        promise: Promise<DeviceSettings[]>;
+        preparing?: number;
+        promise?: Promise<DeviceSettings[]>;
         adapters?: Array<{
             udid: string;
             adapter: IncyclistDeviceAdapter;

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

@@ -12,6 +12,8 @@ export interface Services {
 }
 export declare class DevicePairingService extends IncyclistService {
     protected static _instance: DevicePairingService;
+    protected static checkCounter: number;
+    protected static scanCounter: number;
     protected configuration: DeviceConfigurationService;
     protected access: DeviceAccessService;
     protected rideService: DeviceRideService;

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);
                     });
@@ -431,7 +432,6 @@ class DevicePairingService extends service_2.IncyclistService {
             const current = getInterfaceSettings(ifName, prev);
             const changed = (current.state !== ifDetails.state || current.isScanning !== ifDetails.isScanning || current.enabled !== ifDetails.enabled);
             if (!changed) {
-                console.log('~~~ DEUBUG: if change, no change', ifName, ifDetails);
                 return;
             }
             this.logEvent({ message: 'interface state changed', interface: ifName, state: ifDetails.state });
@@ -765,6 +765,10 @@ class DevicePairingService extends service_2.IncyclistService {
     }
     startPairing(adapters, props) {
         return __awaiter(this, void 0, void 0, function* () {
+            if (this.isPairing())
+                return;
+            const preparing = DevicePairingService.checkCounter++;
+            this.state.check = { preparing };
             this.emit('pairing-start');
             const requiredInterfaces = this.getPairingInterfaces();
             const busyRequired = this.state.interfaces
@@ -773,8 +777,10 @@ class DevicePairingService extends service_2.IncyclistService {
             const isReady = busyRequired === undefined;
             if (!isReady) {
                 setTimeout(() => {
-                    if (!this.isPairing() && !this.isScanning())
+                    if ((!this.isPairing() || this.state.check.preparing === preparing) && !this.isScanning()) {
+                        delete this.state.check;
                         this.run();
+                    }
                 }, 1000);
                 return;
             }
@@ -782,6 +788,9 @@ class DevicePairingService extends service_2.IncyclistService {
             this.processConnectedDevices(adapters);
             const selected = this.state.capabilities.map(c => c.selected);
             const target = adapters.filter(ai => !ai.adapter.isStarted() && selected.includes(ai.udid));
+            if (this.isPairing() && this.state.check.preparing !== preparing) {
+                return;
+            }
             this.initPairingCallbacks();
             const selectedAdapters = target.map(ai => (Object.assign(Object.assign({}, ai), { isStarted: false })));
             const promise = this.rideService.startAdapters(selectedAdapters, 'pair');
@@ -819,18 +828,26 @@ class DevicePairingService extends service_2.IncyclistService {
         return __awaiter(this, void 0, void 0, function* () {
             const interfaces = this.state.interfaces.filter(i => this.isInterfaceEnabled(i) && i.state === 'connected')
                 .map(i => i.name);
+            if (this.isScanning())
+                return;
+            const preparing = DevicePairingService.scanCounter++;
+            this.state.scan = { preparing };
             if (interfaces.length === 0) {
                 if (this.state.scanTo)
                     return;
                 this.state.scanTo = setTimeout(() => {
                     delete this.state.scanTo;
-                    if (!this.isPairing() && !this.isScanning())
+                    if (!this.isPairing() && (!this.isScanning() || this.state.scan.preparing === preparing)) {
+                        delete this.state.scan;
                         this.run();
+                    }
                 }, 1000);
                 return;
             }
             this.emit('scanning-start');
             this.state.tsPrevStart = Date.now();
+            if (this.isScanning() && this.state.scan.preparing !== preparing)
+                return;
             this.logEvent({ message: 'Start Scanning', interfaces: interfaces.join(','), props });
             this.initScanningCallbacks();
             const timeout = props.enforcedScan ? 1000 * 60 * 60 : undefined;
@@ -1139,5 +1156,7 @@ class DevicePairingService extends service_2.IncyclistService {
     }
 }
 exports.DevicePairingService = DevicePairingService;
+DevicePairingService.checkCounter = 0;
+DevicePairingService.scanCounter = 0;
 const useDevicePairing = () => DevicePairingService.getInstance();
 exports.useDevicePairing = useDevicePairing;

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;

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

@@ -1,20 +1,25 @@
-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 } 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 videosRepo: JsonRepository;
+    protected routesRepo: JsonRepository;
     protected api: IncyclistRoutesApi;
-    constructor(binding?: IRouteListBinding);
-    setBinding(binding: IRouteListBinding): void;
+    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>;
+    protected preloadList(list: List, carouselSize?: number, detailsOnly?: boolean): Promise<void>;
     load(props: {
         list?: List;
         loadFrom?: number;
@@ -22,9 +27,12 @@ export declare class RouteListService extends IncyclistService {
         routeId?: string;
     }): Promise<void>;
     openRouteSelection(pageId: string, props: RouteListStartProps): RouteListData;
-    closeRouteSelection(listId: string): void;
+    closeRouteSelection(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;
@@ -54,13 +62,18 @@ 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 stopAllRides(): void;
-    protected addDescriptions(descriptions: Array<RouteApiDescription>): void;
+    protected addDescriptionsFromRepo(descriptions: Array<RouteApiDescription>, repo?: JsonRepository): void;
+    protected addDescriptionsFromServer(descriptions: Array<RouteApiDescription>): void;
     protected updateRouteTitle(data: RouteInfo, route: {
         descr?: RouteApiDescription;
     }): void;
@@ -69,9 +82,12 @@ export declare class RouteListService extends IncyclistService {
     }): void;
     protected getCountryPrefix(title?: string): string | undefined;
     protected removeCountryPrefix(title?: string): string;
+    protected loadRouteDescriptionsFromRepo(): Promise<void>;
+    protected loadRouteDescriptionsFromServer(): Promise<void>;
     protected loadRouteDescriptions(): Promise<void>;
     protected loadRouteDetais(route: Route): Promise<void>;
     protected emitRouteUpdated(route: Route): void;
+    protected getListState(page: Page, list: List): import("./types").RouteListDateEntry;
     private getRouteFromStartProps;
 }
 export declare const useRouteList: () => RouteListService;

package/lib/routes/list/service.js

@@ -18,6 +18,8 @@ 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"));
 class RouteListService extends service_1.IncyclistService {
     static getInstance(binding) {
         if (!RouteListService._instance)
@@ -30,20 +32,33 @@ class RouteListService extends service_1.IncyclistService {
             initialized: false,
             pages: []
         };
-        this.setBinding(binding);
+        if (binding)
+            api_2.JsonRepository.setBinding(binding);
         this.api = api_1.default.getInstance();
         this.initRouteLists();
     }
     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;
+                return;
             const promise = this._preload(carouselSize);
             this.state.loading = { promise };
             yield promise;
@@ -52,17 +67,35 @@ class RouteListService extends service_1.IncyclistService {
     }
     _preload(carouselSize = 5, detailsOnly = false) {
         return __awaiter(this, void 0, void 0, function* () {
-            this.logEvent({ message: 'preloading routes --' });
             if (!detailsOnly) {
                 yield this.loadRouteDescriptions();
             }
+            this.emitPageUpdate();
             const promises = [];
+            const promisesApi = [];
+            const lists = this.getRouteLists().map(li => li.list);
+            lists.forEach((list) => {
+                this.preloadList(list, carouselSize, detailsOnly);
+            });
+            this.logEvent({ message: 'preloading routes finished' });
+        });
+    }
+    preloadList(list, carouselSize = 5, detailsOnly = false) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const promises = [];
+            const promisesApi = [];
+            this.emitPageUpdate();
             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)) {
+                    let cntApi = 0;
+                    rle.routes.forEach((r) => {
+                        if (!r.data.isLocal) {
+                            cntApi++;
+                            return;
+                        }
+                        if (cntApi <= Math.min(carouselSize, rle.routes.length)) {
                             const loader = this.loadRouteDetais(r);
                             promises.push(loader);
                         }
@@ -97,20 +130,23 @@ 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();
+        const page = this.registerPage(pageId, props);
         if (props.visibleCards) {
-            this._preload(props.visibleCards, true);
+            this.preload(props.visibleCards);
+        }
+        else {
+            this.preload(5);
         }
-        const page = this.registerPage(pageId, props);
         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);
         }
@@ -146,6 +182,60 @@ class RouteListService extends service_1.IncyclistService {
             return {};
         }
     }
+    setCardUpdateHandler(pageId, r, list, idx, onRouteStateChanged, onCarouselStateChanged) {
+        const route = this.getRouteFromStartProps(r);
+        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);
+        console.log('~~~ DEBUG:onCarouselInitialied', pageId, list, this.getListState(page, list), startIdx, visibleSize);
+        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 (route.data.title === 'Malaga City Tour')
+                console.log('~~~ DEBUG:Initialized -checked detail', visible, idx, listState.startIdx, listState.endIdx, route.data);
+            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);
+        console.log('~~~ DEBUG:onCarouselUpdated', pageId, list, this.getListState(page, list), startIdx, visibleSize);
+        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 (route.data.title === 'Malaga City Tour')
+                console.log('~~~ DEBUG:Initialized -checked detail', visible, idx, listState.startIdx, listState.endIdx, route.data);
+            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);
@@ -240,8 +330,8 @@ 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() {
@@ -269,7 +359,7 @@ class RouteListService extends service_1.IncyclistService {
     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;
     }
@@ -342,11 +432,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 };
         data.hasVideo = false;
         data.hasGpx = false;
+        data.isLocal = isLocal || false;
         this.updateRouteCountry(data, { descr });
         this.updateRouteTitle(data, { descr });
         if (points)
@@ -366,10 +457,15 @@ 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';
+            console.log('~~~ DEBUG', description.title, description.private, list);
             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';
             }
@@ -384,6 +480,14 @@ class RouteListService extends service_1.IncyclistService {
         var _a;
         return (_a = this.routes.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')
@@ -401,9 +505,38 @@ class RouteListService extends service_1.IncyclistService {
             lists[i].routes.forEach(r => r.startState = 'idle');
         }
     }
-    addDescriptions(descriptions) {
+    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);
+            }
+        });
+    }
+    addDescriptionsFromServer(descriptions) {
         const converted = descriptions.map(this.convertDescription.bind(this));
         converted.forEach((data, idx) => {
+            console.log('~~~ DEBUG:add route from Server', data.title);
+            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 +548,10 @@ class RouteListService extends service_1.IncyclistService {
             }
             else {
                 data.state = 'prepared';
+                data.isLocal = false;
                 const item = { id: data.id, data };
                 this.addRouteToList(list, item);
+                this.emitPageUpdate();
             }
         });
     }
@@ -457,39 +592,104 @@ class RouteListService extends service_1.IncyclistService {
             return title.substring(3);
         }
     }
-    loadRouteDescriptions() {
+    loadRouteDescriptionsFromRepo() {
+        return __awaiter(this, void 0, void 0, function* () {
+            console.log('~~~ DEBUG:loadRouteDescriptionsFromRepo');
+            const enrichRepo = (v, type) => {
+                const data = v;
+                return Object.assign({ type }, data);
+            };
+            const videos = ((yield this.getVideosRepo().read('routes')) || []);
+            console.log('~~~ DEBUG,videos:', videos);
+            this.addDescriptionsFromRepo(videos, this.getVideosRepo());
+            const routes = ((yield this.getRoutesRepo().read('routes')) || []);
+            console.log('~~~ DEBUG,routes:', routes);
+            this.addDescriptionsFromRepo(routes, this.getVideosRepo());
+        });
+    }
+    loadRouteDescriptionsFromServer() {
         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')))
+            console.log('~~~ DEBUG:loadRouteDescriptionsFromServer');
+            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);
+            console.log('~~~ DEBUG:loadRouteDescriptionsFromServer done', (new Date()).toISOString(), res);
+            this.emitPageUpdate();
             res.forEach(p => {
                 if (p.status === 'fulfilled') {
-                    this.addDescriptions(p.value);
+                    this.addDescriptionsFromServer(p.value);
                 }
             });
         });
     }
+    loadRouteDescriptions() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.loadRouteDescriptionsFromRepo();
+            console.log('~~~ DEBUG, routes after Repo', this.routes);
+            this.emitPageUpdate();
+            this.loadRouteDescriptionsFromServer().then(() => {
+                console.log('~~~ DEBUG, routes after API', this.routes);
+            });
+        });
+    }
     loadRouteDetais(route) {
         return __awaiter(this, void 0, void 0, function* () {
+            console.log('~~~ DEBUG:loadDetails()', (0, clone_1.default)(route.data));
             if (route.data.state === 'loaded')
                 return;
             try {
                 route.data.state = 'loading';
-                route.details = yield this.api.getRouteDetails(route.id);
+                this.emitRouteUpdated(route);
+                if (route.data.isLocal) {
+                    route.details = route.data.hasVideo ?
+                        yield this.videosRepo.read(route.id)
+                        :
+                            yield this.routesRepo.read(route.id);
+                    api_1.default.verify(route.details);
+                }
+                else {
+                    route.details = yield this.api.getRouteDetails(route.id);
+                }
+                if (route.data.title === 'Arnbach')
+                    console.log('~~~ DEBUG: loaded details', route.details);
+                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);
             }
             catch (e) {
+                console.log('~~~ DEBUG:Error', e);
                 route.data.state = 'error';
+                this.emitRouteUpdated(route);
             }
         });
     }
     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) {
+        console.log('~~~ DEBUG.getListState', list, page === null || page === void 0 ? void 0 : page.state, this.state);
+        return page === null || page === void 0 ? void 0 : page.state.lists.find(pl => pl.list === list);
     }
     getRouteFromStartProps(r) {
         try {

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

@@ -23,6 +23,7 @@ export type RouteInfo = {
     elevation?: number;
     category?: RouteCategory;
     provider?: RouteProvider;
+    isLocal?: boolean;
     hasGpx?: boolean;
     hasVideo?: boolean;
     isDemo?: boolean;
@@ -37,7 +38,14 @@ 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 +67,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;

package/package.json

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