incyclist-services 1.1.85 → 1.1.87

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

@@ -120,3 +120,6 @@ export interface Parser<In, Out extends RouteBase> {
     supportsContent(data: In): boolean;
     getData(info: FileInfo, data?: In): Promise<In>;
 }
+export interface AppStatus {
+    isOnline?: boolean;
+}

package/lib/routes/list/cards/ActiveImportCard.d.ts

@@ -4,7 +4,8 @@ import { ImportFilter } from "../../../base/cardlist/types";
 import { PromiseObserver } from "../../../base/types/observer";
 import { Route } from "../../base/model/route";
 import { BaseCard } from "./base";
-import { AppStatus, RouteCardType, ActiveImportProps } from "./types";
+import { RouteCardType, ActiveImportProps } from "./types";
+import { AppStatus } from "../../base/types";
 export declare class ActiveImportCard extends BaseCard implements Card<Route> {
     protected file: FileInfo;
     protected error: Error;

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

@@ -1,10 +1,12 @@
+import { EventLogger } from "gd-eventlog";
 import { Card } from "../../../base/cardlist";
 import { PromiseObserver } from "../../../base/types/observer";
 import { LatLng } from "../../../utils/geo";
 import { Route } from "../../base/model/route";
 import { FreeRideOption } from "../types";
 import { BaseCard } from "./base";
-import { AppStatus, RouteCardType } from "./types";
+import { RouteCardType } from "./types";
+import { AppStatus } from "../../base/types";
 export type FreeRideSettings = {
     position?: LatLng;
     options?: any;
@@ -15,6 +17,8 @@ export interface FreeRideDisplayProps extends LatLng {
 export declare class FreeRideCard extends BaseCard implements Card<Route> {
     protected position: LatLng;
     protected options: [];
+    protected logger: EventLogger;
+    constructor();
     delete(): PromiseObserver<boolean>;
     canStart(status: AppStatus): boolean;
     setVisible(): void;
@@ -34,4 +38,5 @@ export declare class FreeRideCard extends BaseCard implements Card<Route> {
     cancel(): void;
     protected loadSettings(): void;
     protected saveSettings(): void;
+    protected logError(err: Error, fn: string): void;
 }

package/lib/routes/list/cards/FreeRideCard.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FreeRideCard = void 0;
+const gd_eventlog_1 = require("gd-eventlog");
 const observer_1 = require("../../../base/types/observer");
 const settings_1 = require("../../../settings");
 const utils_1 = require("../../../utils");
@@ -9,6 +10,10 @@ const route_1 = require("../../base/model/route");
 const service_1 = require("../service");
 const base_1 = require("./base");
 class FreeRideCard extends base_1.BaseCard {
+    constructor() {
+        super();
+        this.logger = new gd_eventlog_1.EventLogger('FreeRideCard');
+    }
     delete() {
         return observer_1.PromiseObserver.alwaysReturning(false);
     }
@@ -29,7 +34,12 @@ class FreeRideCard extends base_1.BaseCard {
         return 'Free-Ride';
     }
     getDisplayProperties() {
-        return Object.assign(Object.assign({}, this.position), { visible: true });
+        try {
+            return Object.assign(Object.assign({}, this.position), { visible: true });
+        }
+        catch (err) {
+            this.logError(err, 'getDisplayProperties');
+        }
     }
     getPosition() {
         return this.position;
@@ -46,29 +56,46 @@ class FreeRideCard extends base_1.BaseCard {
     setData(_data) {
     }
     openSettings() {
-        (0, service_1.getRouteList)().unselect();
-        if (!this.position)
-            this.loadSettings();
-        const position = this.position;
-        return { position };
+        try {
+            (0, service_1.getRouteList)().unselect();
+            if (!this.position)
+                this.loadSettings();
+            const position = this.position;
+            return { position };
+        }
+        catch (err) {
+            this.logError(err, 'openSettings');
+            return {};
+        }
     }
     changeSettings(props) {
-        const { position: pos } = props;
-        this.position = utils_1.geo.getLatLng(pos);
-        this.saveSettings();
+        try {
+            const { position: pos } = props;
+            this.position = utils_1.geo.getLatLng(pos);
+            this.saveSettings();
+        }
+        catch (err) {
+            this.logError(err, 'changeSettings');
+        }
     }
     accept(option) {
-        option.path = option.path.map(p => ({ lat: p.lat, lng: p.lng, ways: p.ways, tag: p.tag }));
-        const settings = {
-            type: this.getCardType(),
-            position: this.position,
-            option
-        };
-        (0, service_1.getRouteList)().setStartSettings(settings);
+        try {
+            option.path = option.path.map(p => ({ lat: p.lat, lng: p.lng, ways: p.ways, tag: p.tag }));
+            const settings = {
+                type: this.getCardType(),
+                position: this.position,
+                option
+            };
+            (0, service_1.getRouteList)().setStartSettings(settings);
+        }
+        catch (err) {
+            this.logError(err, 'accept');
+        }
     }
     cancel() {
     }
     loadSettings() {
+        var _a, _b;
         const prevSetting = this.getUserSetting(`routeSelection.freeRide`, null);
         if (prevSetting) {
             this.position = prevSetting.position;
@@ -76,7 +103,7 @@ class FreeRideCard extends base_1.BaseCard {
         else {
             this.position = this.getUserSetting(`position`, null);
         }
-        if (!(0, valid_1.valid)(this.position.lat) || !(0, valid_1.valid)(this.position.lng))
+        if (!(0, valid_1.valid)((_a = this.position) === null || _a === void 0 ? void 0 : _a.lat) || !(0, valid_1.valid)((_b = this.position) === null || _b === void 0 ? void 0 : _b.lng))
             this.position = undefined;
     }
     saveSettings() {
@@ -85,5 +112,8 @@ class FreeRideCard extends base_1.BaseCard {
         const userSettings = (0, settings_1.useUserSettings)();
         userSettings.set('routeSelection.freeRide', { position: this.position });
     }
+    logError(err, fn) {
+        this.logger.logEvent({ message: 'error', error: err.message, fn, stack: err.stack });
+    }
 }
 exports.FreeRideCard = FreeRideCard;

package/lib/routes/list/cards/RouteCard.d.ts

@@ -2,9 +2,10 @@ import { Card, CardList } from "../../../base/cardlist";
 import { Observer, PromiseObserver } from "../../../base/types/observer";
 import { RouteApiDetail } from "../../base/api/types";
 import { Route } from "../../base/model/route";
-import { RouteInfo } from "../../base/types";
+import { RouteInfo, RoutePoint } from "../../base/types";
 import { BaseCard } from "./base";
-import { AppStatus, RouteCardType } from "./types";
+import { RouteCardType } from "./types";
+import { AppStatus } from "../../base/types";
 import { RouteStartSettings } from "../types";
 import { RoutesDbLoader } from "../loaders/db";
 import { DownloadObserver } from "../../download/types";
@@ -28,8 +29,15 @@ export interface StartSettings {
     realityFactor: number;
     downloadProgress?: number;
     convertProgress?: number;
+    loopOverwrite?: boolean;
+    nextOverwrite?: boolean;
 }
 export type RouteSettings = StartSettings & RouteStartSettings;
+export type RouteCardProps = {
+    settings: RouteSettings;
+    showLoopOverwrite: boolean;
+    showNextOverwrite: boolean;
+};
 declare class ConvertObserver extends Observer {
     protected conversion: Observer;
     constructor();
@@ -65,10 +73,11 @@ export declare class RouteCard extends BaseCard implements Card<Route> {
     getCardType(): RouteCardType;
     getTitle(): string;
     getDisplayProperties(): SummaryCardDisplayProps;
+    getMarkers(settings?: RouteSettings): Array<RoutePoint>;
     getId(): string;
     enableDelete(enabled?: boolean): void;
     canDelete(): boolean;
-    openSettings(): RouteSettings;
+    openSettings(): RouteCardProps;
     changeSettings(props: RouteSettings): void;
     save(): Promise<void>;
     delete(): PromiseObserver<boolean>;
@@ -102,5 +111,6 @@ export declare class RouteCard extends BaseCard implements Card<Route> {
     protected resetDownload(): Promise<void>;
     protected deleteRoute(): Promise<void>;
     protected logError(err: Error, fn: string): void;
+    protected getSettings(): RouteSettings;
 }
 export {};

package/lib/routes/list/cards/RouteCard.js

@@ -22,6 +22,7 @@ const utils_1 = require("../../../utils");
 const service_2 = require("../../download/service");
 const localization_1 = require("../../base/utils/localization");
 const gd_eventlog_1 = require("gd-eventlog");
+const route_1 = require("../../base/utils/route");
 class ConvertObserver extends observer_1.Observer {
     constructor() {
         super();
@@ -162,6 +163,19 @@ class RouteCard extends base_1.BaseCard {
             this.logError(err, 'getDisplayProperties');
         }
     }
+    getMarkers(settings) {
+        const markers = [];
+        try {
+            const startSettings = settings || this.getSettings();
+            const startDistance = startSettings.startPos || 0;
+            const startPos = (0, route_1.getPosition)(this.route, { distance: startDistance, nearest: true });
+            markers.push(startPos);
+        }
+        catch (err) {
+            this.logError(err, 'getMarkers');
+        }
+        return markers;
+    }
     getId() {
         var _a, _b;
         return (_b = (_a = this.route) === null || _a === void 0 ? void 0 : _a.description) === null || _b === void 0 ? void 0 : _b.id;
@@ -173,32 +187,29 @@ class RouteCard extends base_1.BaseCard {
         return this.deleteable;
     }
     openSettings() {
-        this.startSettings = { startPos: 0, realityFactor: 100, type: this.getCardType() };
+        var _a, _b, _c, _d, _e, _f;
+        const settings = this.getSettings();
+        let showLoopOverwrite, showNextOverwrite;
         try {
-            let migrate = false;
-            const legacy = this.buildSettingsKey(true);
-            const legacySettings = (0, settings_1.useUserSettings)().get(legacy, null);
-            if (legacySettings) {
-                this.startSettings = legacySettings;
-                migrate = true;
-            }
-            const key = this.buildSettingsKey();
-            const startSettings = (0, settings_1.useUserSettings)().get(key, null);
-            if (startSettings) {
-                this.startSettings = startSettings;
-            }
-            if (migrate) {
-                (0, settings_1.useUserSettings)().set(key, this.startSettings);
+            showLoopOverwrite = (_b = (_a = this.route) === null || _a === void 0 ? void 0 : _a.description) === null || _b === void 0 ? void 0 : _b.isLoop;
+            showNextOverwrite = (0, valid_1.valid)((_d = (_c = this.route) === null || _c === void 0 ? void 0 : _c.description) === null || _d === void 0 ? void 0 : _d.next);
+            if (showNextOverwrite) {
+                const card = (0, service_1.getRouteList)().getCard((_f = (_e = this.route) === null || _e === void 0 ? void 0 : _e.description) === null || _f === void 0 ? void 0 : _f.next);
+                const route = card === null || card === void 0 ? void 0 : card.getData();
+                if (!route || (route.description.requiresDownload && !route.description.isDownloaded)) {
+                    showNextOverwrite = false;
+                }
+                console.log('~~~ NEXT', route);
             }
         }
         catch (err) {
             this.logError(err, 'openSettings');
         }
-        return this.startSettings;
+        return { settings, showLoopOverwrite, showNextOverwrite };
     }
     changeSettings(props) {
         try {
-            this.startSettings = props;
+            this.startSettings = Object.assign({}, props);
             const userSettings = (0, settings_1.useUserSettings)();
             const key = this.buildSettingsKey();
             userSettings.set(key, props, true);
@@ -275,6 +286,7 @@ class RouteCard extends base_1.BaseCard {
     start() {
         try {
             const service = (0, service_1.getRouteList)();
+            console.log('~~~ start', this.startSettings);
             service.select(this.route);
             service.setStartSettings(Object.assign({ type: this.getCardType() }, this.startSettings));
             this.route.description.tsLastStart = Date.now();
@@ -519,5 +531,29 @@ class RouteCard extends base_1.BaseCard {
     logError(err, fn) {
         this.logger.logEvent({ message: 'error', error: err.message, fn, stack: err.stack });
     }
+    getSettings() {
+        this.startSettings = { startPos: 0, realityFactor: 100, type: this.getCardType() };
+        try {
+            let migrate = false;
+            const legacy = this.buildSettingsKey(true);
+            const legacySettings = (0, settings_1.useUserSettings)().get(legacy, null);
+            if (legacySettings) {
+                this.startSettings = legacySettings;
+                migrate = true;
+            }
+            const key = this.buildSettingsKey();
+            const startSettings = (0, settings_1.useUserSettings)().get(key, null);
+            if (startSettings) {
+                this.startSettings = startSettings;
+            }
+            if (migrate) {
+                (0, settings_1.useUserSettings)().set(key, this.startSettings);
+            }
+        }
+        catch (err) {
+            this.logError(err, 'getSettings');
+        }
+        return this.startSettings;
+    }
 }
 exports.RouteCard = RouteCard;

package/lib/routes/list/cards/RouteImportCard.d.ts

@@ -3,7 +3,8 @@ import { ImportFilter } from "../../../base/cardlist/types";
 import { PromiseObserver } from "../../../base/types/observer";
 import { Route } from "../../base/model/route";
 import { BaseCard } from "./base";
-import { AppStatus, RouteCardType, RouteImportProps } from "./types";
+import { RouteCardType, RouteImportProps } from "./types";
+import { AppStatus } from "../../base/types";
 export declare class RouteImportCard extends BaseCard implements Card<Route> {
     setVisible(): void;
     canStart(status: AppStatus): boolean;

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

@@ -17,6 +17,3 @@ export interface ActiveImportProps {
     visible: boolean;
     observer: Observer;
 }
-export interface AppStatus {
-    isOnline?: boolean;
-}

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

@@ -61,7 +61,7 @@ export declare class RouteListService extends IncyclistService {
     onCarouselUpdated(list: any, item: any, itemsInSlide: any): void;
     preload(): PromiseObserver<void>;
     getLists(forUi?: boolean): Array<CardList<Route>>;
-    getRouteDetails(id: string): Promise<RouteApiDetail>;
+    getRouteDetails(id: string, expectLocal?: boolean): Promise<RouteApiDetail>;
     getSelectedRouteDetails(): Promise<RouteApiDetail>;
     unselect(): void;
     select(route: Route): void;

package/lib/routes/list/service.js

@@ -300,11 +300,13 @@ let RouteListService = (() => {
                 return [this.myRoutes];
             }
         }
-        getRouteDetails(id) {
+        getRouteDetails(id, expectLocal = false) {
             return __awaiter(this, void 0, void 0, function* () {
                 try {
                     const route = this.routes.find(r => r.description.id === id);
                     if (route) {
+                        if (expectLocal && route.description.requiresDownload && !route.description.isDownloaded)
+                            return;
                         if (route.details)
                             return route.details;
                         route.details = yield this.db.getDetails(id);

package/lib/workouts/base/model/Segment.d.ts

@@ -0,0 +1,18 @@
+import Step from './Step';
+import { CurrentStep, SegmentDefinition, StepDefinition } from './types';
+export default class Segment extends Step implements SegmentDefinition {
+    steps: Array<Step>;
+    repeat: number;
+    constructor(opts?: SegmentDefinition, ignoreValidate?: boolean);
+    protected init(opts: SegmentDefinition, ignoreValidate: boolean): void;
+    validate(): void;
+    validateTiming(): boolean;
+    prepareNext(json: StepDefinition | SegmentDefinition): void;
+    push(s: any): void;
+    getDuration(): number;
+    getSingleDuration(): number;
+    getStart(): number;
+    getEnd(): number;
+    getStep(ts: number): Step;
+    getLimits(ts: any, includeStepInfo?: boolean): CurrentStep;
+}

package/lib/workouts/base/model/Segment.js

@@ -0,0 +1,139 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const valid_1 = require("../../../utils/valid");
+const Step_1 = __importDefault(require("./Step"));
+class Segment extends Step_1.default {
+    constructor(opts = null, ignoreValidate) {
+        super(opts, true);
+        this.steps = [];
+        this.repeat = 1;
+        this.type = 'segment';
+        if ((0, valid_1.valid)(opts)) {
+            this.init(opts, ignoreValidate);
+            if (ignoreValidate === undefined || ignoreValidate === false)
+                this.validate();
+        }
+    }
+    init(opts, ignoreValidate) {
+        const start = opts.start || 0;
+        this.start = start;
+        let stepStart = start;
+        if (opts instanceof Step_1.default) {
+            this.steps = [new Step_1.default(opts)];
+        }
+        else if (opts.steps !== undefined) {
+            if (Array.isArray(opts.steps)) {
+                opts.steps.forEach(step => {
+                    if (step.start === undefined) {
+                        step.start = stepStart;
+                    }
+                    const s = new Step_1.default(step);
+                    stepStart = s.end;
+                    this.steps.push(s);
+                });
+            }
+            else {
+                if (ignoreValidate !== true)
+                    throw new Error(`Invalid Segment description, no steps defined`);
+            }
+        }
+        else {
+            if (ignoreValidate === undefined || ignoreValidate === false)
+                throw new Error(`Invalid Segment description, no steps defined`);
+        }
+        if (opts.repeat !== undefined)
+            this.repeat = opts.repeat;
+        this.duration = this.getDuration();
+        this.end = this.start + this.duration;
+    }
+    validate() {
+        this.validateTiming();
+    }
+    validateTiming() {
+        let prev;
+        this.steps.forEach(s => {
+            s.validateTiming();
+            if (prev !== undefined) {
+                const delta1 = Math.abs(prev.end - s.start);
+                if (delta1 > 0)
+                    throw new Error(`Invalid Segment description, start & prev end not matching`);
+            }
+            prev = s;
+        });
+        return true;
+    }
+    prepareNext(json) {
+        if (json === undefined)
+            return;
+        const empty = this.steps.length === 0;
+        if (json.start === undefined && json.end === undefined) {
+            json.start = !empty ? this.steps[this.steps.length - 1].end : 0;
+        }
+        if (empty) {
+            this.start = 0;
+        }
+    }
+    push(s) {
+        if (s === undefined)
+            return;
+        this.prepareNext(s);
+        let step;
+        if (s instanceof Step_1.default || s instanceof Segment)
+            step = s;
+        else
+            step = new Step_1.default(s);
+        this.steps.push(step);
+        this.duration += step.getDuration();
+        this.end = this.start + this.duration;
+        this.validate();
+    }
+    getDuration() {
+        return this.getSingleDuration() * this.repeat;
+    }
+    getSingleDuration() {
+        if (this.steps.length === 0)
+            return 0;
+        return this.steps.map(s => s.duration).reduce((a, b) => a + b);
+    }
+    getStart() {
+        if (this.start !== undefined)
+            return this.start;
+        else {
+            if (this.steps.length > 0)
+                return this.steps[0].start;
+            else
+                return undefined;
+        }
+    }
+    getEnd() {
+        return this.getStart() + this.getDuration();
+    }
+    getStep(ts) {
+        if (ts >= this.getStart() && ts <= this.getEnd()) {
+            const segTime = ts - this.getStart();
+            let part = (segTime % this.getSingleDuration());
+            part += this.getStart();
+            if (part === this.getStart() && segTime > 0)
+                part += this.getSingleDuration();
+            const found = this.steps.find(s => {
+                return (part >= s.start && part <= s.end);
+            });
+            return found;
+        }
+    }
+    getLimits(ts, includeStepInfo = false) {
+        const step = this.getStep(ts);
+        if (step === undefined)
+            return undefined;
+        const segTime = ts - this.getStart();
+        let part = (segTime % this.getSingleDuration());
+        part += this.getStart();
+        if (part === this.getStart() && segTime > 0)
+            part += this.getSingleDuration();
+        return step.getLimits(part, includeStepInfo);
+    }
+}
+exports.default = Segment;

package/lib/workouts/base/model/Step.d.ts

@@ -0,0 +1,35 @@
+import { CurrentStep, Limit, PowerLimit, StepDefinition } from "./types";
+export declare const STEP_TYPE: {
+    STEP: string;
+    SEGMENT: string;
+};
+export declare const POWER_TYPE: {
+    WATT: string;
+    PCT: string;
+};
+export default class Step implements StepDefinition {
+    type: 'step' | 'segment';
+    start?: number;
+    end?: number;
+    duration: number;
+    power?: PowerLimit;
+    cadence?: Limit;
+    hrm?: Limit;
+    text: string;
+    work: boolean;
+    steady: boolean;
+    cooldown: boolean;
+    constructor(opts?: any, ignoreValidate?: boolean);
+    validate(): void;
+    getDuration(): number;
+    getStart(): number;
+    getEnd(): number;
+    validateTiming(): boolean;
+    validateLimit(p: Limit, name: string): boolean;
+    validatePower(): boolean;
+    validateCadence(): boolean;
+    validateHrm(): boolean;
+    getLimits(ts: number, includeStepInfo?: boolean): CurrentStep;
+    getRemainder(limits: CurrentStep, includeStepInfo?: boolean): CurrentStep;
+    calc(ts: any, limit: any, includeStepInfo: boolean, isPower?: boolean): {};
+}