incyclist-services 1.1.101 → 1.2.0

package/lib/activities/base/loaders/db.d.ts

@@ -0,0 +1,41 @@
+import { EventLogger } from "gd-eventlog";
+import { JsonRepository } from "../../../api";
+import { Observer, PromiseObserver } from "../../../base/types/observer";
+import { ActivityDetails, ActivityInfo, ActivitySummary } from "../model";
+import { ActivitySearchCriteria } from "./types";
+export declare class ActivitiesDbLoader {
+    protected repo: JsonRepository;
+    protected loadObserver: Observer;
+    protected saveObserver: PromiseObserver<void>;
+    protected isDirty: boolean;
+    protected tsLastWrite: number;
+    protected logger: EventLogger;
+    protected activities: Array<ActivityInfo>;
+    protected isDBComplete: boolean;
+    constructor();
+    load(): Observer;
+    stopLoad(): void;
+    save(activity: ActivityInfo, writeDetails?: boolean): Promise<void>;
+    delete(activity: ActivityInfo | string): Promise<void>;
+    get(id: string): ActivityInfo;
+    getWithDetails(id: string): Promise<ActivityInfo>;
+    search(criteria: ActivitySearchCriteria): Array<ActivityInfo>;
+    protected writeRepo(): Promise<void>;
+    protected write(enforce?: boolean): void;
+    protected emitDone(): void;
+    protected emitUpdated(activity: ActivityInfo | Array<ActivityInfo>): void;
+    protected emitAdded(activity: ActivityInfo | Array<ActivityInfo>): void;
+    protected loadSummaries(): Promise<void>;
+    protected buildFromLegacy(): Promise<void>;
+    protected listActivities(): Promise<Array<string>>;
+    protected loadDetailsByName(name: string): Promise<ActivityDetails>;
+    protected loadDetails(name: string, id?: string): Promise<void>;
+    protected writeDetails(activity: ActivityInfo): Promise<void>;
+    protected buildSummary(activity: ActivityDetails, name: string): ActivitySummary;
+    protected scanForActivities(): Promise<Array<ActivitySummary> | null>;
+    protected scanForActivitiesAndMerge(activities: Array<ActivitySummary>): Promise<Array<ActivitySummary>>;
+    protected _load(): Promise<void>;
+    protected getActivity(id: string): ActivityInfo;
+    protected logError(error: Error, fn: string, logProps?: any): void;
+    protected getRepo(): JsonRepository;
+}

package/lib/activities/base/loaders/db.js

@@ -0,0 +1,378 @@
+"use strict";
+var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
+    function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
+    var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
+    var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
+    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+    var _, done = false;
+    for (var i = decorators.length - 1; i >= 0; i--) {
+        var context = {};
+        for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
+        for (var p in contextIn.access) context.access[p] = contextIn.access[p];
+        context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
+        var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
+        if (kind === "accessor") {
+            if (result === void 0) continue;
+            if (result === null || typeof result !== "object") throw new TypeError("Object expected");
+            if (_ = accept(result.get)) descriptor.get = _;
+            if (_ = accept(result.set)) descriptor.set = _;
+            if (_ = accept(result.init)) initializers.unshift(_);
+        }
+        else if (_ = accept(result)) {
+            if (kind === "field") initializers.unshift(_);
+            else descriptor[key] = _;
+        }
+    }
+    if (target) Object.defineProperty(target, contextIn.name, descriptor);
+    done = true;
+};
+var __runInitializers = (this && this.__runInitializers) || function (thisArg, initializers, value) {
+    var useValue = arguments.length > 2;
+    for (var i = 0; i < initializers.length; i++) {
+        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
+    }
+    return useValue ? value : void 0;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __setFunctionName = (this && this.__setFunctionName) || function (f, name, prefix) {
+    if (typeof name === "symbol") name = name.description ? "[".concat(name.description, "]") : "";
+    return Object.defineProperty(f, "name", { configurable: true, value: prefix ? "".concat(prefix, " ", name) : name });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ActivitiesDbLoader = void 0;
+const gd_eventlog_1 = require("gd-eventlog");
+const api_1 = require("../../../api");
+const types_1 = require("../../../base/types");
+const observer_1 = require("../../../base/types/observer");
+const utils_1 = require("../../../utils");
+const DB_VERSION = '1';
+let ActivitiesDbLoader = (() => {
+    let _classDecorators = [types_1.Singleton];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    var ActivitiesDbLoader = _classThis = class {
+        constructor() {
+            this.logger = new gd_eventlog_1.EventLogger('ActivitiesDB');
+        }
+        load() {
+            if (this.loadObserver)
+                return this.loadObserver;
+            this.loadObserver = new observer_1.Observer();
+            this._load();
+            return this.loadObserver;
+        }
+        stopLoad() {
+            this.emitDone();
+        }
+        save(activity, writeDetails = true) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const stringify = (json) => { try {
+                    JSON.stringify(json);
+                }
+                catch (_a) { } };
+                let prev;
+                const idx = this.activities.findIndex(ai => ai.summary.id === activity.summary.id);
+                if (idx === -1) {
+                    this.activities.push(activity);
+                }
+                else {
+                    prev = stringify(this.activities[idx]);
+                    this.activities[idx] = activity;
+                }
+                const changed = !prev || stringify(activity) !== prev;
+                if (changed) {
+                    this.isDirty = true;
+                    this.write();
+                    if (writeDetails) {
+                        this.writeDetails(activity);
+                    }
+                }
+            });
+        }
+        delete(activity) {
+            return __awaiter(this, void 0, void 0, function* () {
+                let target = activity;
+                if (typeof (activity) === 'string') {
+                    target = this.getActivity(activity);
+                }
+                if (!target)
+                    return;
+                const id = target.summary.id;
+                const idx = this.activities.findIndex(ai => ai.summary.id === id);
+                if (idx) {
+                    this.activities.splice(idx, 1);
+                    this.write(true);
+                }
+                const name = target.summary.name;
+                yield this.getRepo().delete(name);
+            });
+        }
+        get(id) {
+            const info = this.getActivity(id);
+            if (!info)
+                return;
+            return info;
+        }
+        getWithDetails(id) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const info = this.getActivity(id);
+                if (!info)
+                    return;
+                if (!info.details) {
+                    yield this.loadDetails(info.summary.name, id);
+                }
+                return info;
+            });
+        }
+        search(criteria) {
+            let result = this.activities;
+            if ((result === null || result === void 0 ? void 0 : result.length) > 0 && (criteria === null || criteria === void 0 ? void 0 : criteria.routeId)) {
+                result = result.filter(ai => ai.summary.routeId === criteria.routeId);
+            }
+            if ((result === null || result === void 0 ? void 0 : result.length) > 0 && (criteria === null || criteria === void 0 ? void 0 : criteria.startPos) !== undefined) {
+                result = result.filter(ai => ai.summary.startPos === criteria.startPos);
+            }
+            if ((result === null || result === void 0 ? void 0 : result.length) > 0 && (criteria === null || criteria === void 0 ? void 0 : criteria.realityFactor) !== undefined) {
+                result = result.filter(ai => { var _a; return ((_a = ai.summary.realityFactor) !== null && _a !== void 0 ? _a : 100) === criteria.realityFactor; });
+            }
+            if ((result === null || result === void 0 ? void 0 : result.length) > 0 && (criteria === null || criteria === void 0 ? void 0 : criteria.isSaved) !== undefined) {
+                result = result.filter(ai => ai.summary.isSaved === criteria.isSaved);
+            }
+            if ((result === null || result === void 0 ? void 0 : result.length) > 0 && (criteria === null || criteria === void 0 ? void 0 : criteria.uploadStatus) !== undefined) {
+                if (Array.isArray(criteria.uploadStatus)) {
+                    result = result.filter(ai => {
+                        const requested = criteria.uploadStatus;
+                        const actual = ai.summary.uploadStatus;
+                        const r = requested.sort().map(us => `${us.service}:${us.status}`).join(';');
+                        const a = actual.sort().map(us => `${us.service}:${us.status}`).join(';');
+                        return r === a;
+                    });
+                }
+                else {
+                    const status = criteria.uploadStatus;
+                    result = result.filter(ai => {
+                        const serviceInfo = ai.summary.uploadStatus.find(asi => asi.service === status.service);
+                        if (!serviceInfo)
+                            return false;
+                        return serviceInfo.status === status.status;
+                    });
+                }
+            }
+            return result;
+        }
+        writeRepo() {
+            return __awaiter(this, void 0, void 0, function* () {
+                if (this.saveObserver)
+                    yield this.saveObserver.wait();
+                const save = () => __awaiter(this, void 0, void 0, function* () {
+                    const isComplete = this.isDBComplete;
+                    try {
+                        const dbData = {
+                            version: DB_VERSION,
+                            isComplete,
+                            activties: this.activities.map(ai => ai.summary)
+                        };
+                        yield this.getRepo().write('db', dbData);
+                    }
+                    catch (err) {
+                        this.logger.logEvent({ message: 'could not safe repo', error: err.message });
+                    }
+                });
+                this.saveObserver = new observer_1.PromiseObserver(save());
+                yield this.saveObserver.start();
+                process.nextTick(() => { delete this.saveObserver; });
+            });
+        }
+        write(enforce = false) {
+            if (enforce)
+                this.isDirty = true;
+            if (this.isDirty && (this.tsLastWrite === undefined || Date.now() - this.tsLastWrite >= 1000)) {
+                this.isDirty = false;
+                this.tsLastWrite = Date.now();
+                this.writeRepo();
+            }
+            if (this.isDirty && Date.now() - this.tsLastWrite < 1000) {
+                setTimeout(() => { this.write(); }, this.tsLastWrite + 1000 - Date.now());
+            }
+        }
+        emitDone() {
+            if (this.loadObserver)
+                this.loadObserver.emit('done');
+            (0, utils_1.waitNextTick)().then(() => {
+                this.loadObserver.reset();
+                delete this.loadObserver;
+            });
+        }
+        emitUpdated(activity) {
+            if (this.loadObserver)
+                this.loadObserver.emit('updated', activity);
+        }
+        emitAdded(activity) {
+            if (this.loadObserver)
+                this.loadObserver.emit('added', activity);
+        }
+        loadSummaries() {
+            return __awaiter(this, void 0, void 0, function* () {
+                const dbData = yield this.getRepo().read('db');
+                if (dbData) {
+                    const { activities, isComplete } = dbData;
+                    this.activities = activities.map(summary => ({ summary }));
+                    this.emitAdded(this.activities);
+                    this.isDBComplete = isComplete;
+                    if (!isComplete) {
+                        const cnt = activities.length;
+                        const update = yield this.scanForActivitiesAndMerge(activities);
+                        if (cnt !== update.length) {
+                            yield this.write(true);
+                        }
+                        return;
+                    }
+                }
+                yield this.buildFromLegacy();
+                return;
+            });
+        }
+        buildFromLegacy() {
+            return __awaiter(this, void 0, void 0, function* () {
+                const activities = yield this.scanForActivities();
+                if (activities !== null) {
+                    this.activities = activities.map(summary => ({ summary }));
+                }
+                yield this.write(true);
+            });
+        }
+        listActivities() {
+            return __awaiter(this, void 0, void 0, function* () {
+                return this.getRepo().list();
+            });
+        }
+        loadDetailsByName(name) {
+            return __awaiter(this, void 0, void 0, function* () {
+                let details;
+                try {
+                    details = yield this.getRepo().read(name);
+                }
+                catch (err) {
+                    this.logger.logEvent({ message: 'could not load activity details', name, reason: err.message, stack: err.stack });
+                }
+                return details;
+            });
+        }
+        loadDetails(name, id) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const details = yield this.loadDetailsByName(name);
+                const aid = id !== null && id !== void 0 ? id : details.id;
+                const activity = this.getActivity(aid);
+                if (activity) {
+                    activity.details = details;
+                    this.emitUpdated(activity);
+                }
+            });
+        }
+        writeDetails(activity) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const name = activity.summary.name;
+                this.getRepo().write(name, activity.details);
+            });
+        }
+        buildSummary(activity, name) {
+            var _a;
+            const { id, title, route, screenshots, startTime: startTimeUTC, time: rideTime, distance, startPos, realityFactor = 100, links, laps } = activity;
+            const routeId = route === null || route === void 0 ? void 0 : route.id;
+            const shots = screenshots !== null && screenshots !== void 0 ? screenshots : [];
+            const preview = (_a = shots.find(s => s.isHighlight)) !== null && _a !== void 0 ? _a : shots[0];
+            const previewImage = preview === null || preview === void 0 ? void 0 : preview.fileName;
+            let startTime;
+            if (startTimeUTC)
+                startTime = (new Date(startTimeUTC)).getTime();
+            const uploadStatus = [];
+            if (links === null || links === void 0 ? void 0 : links.strava) {
+                uploadStatus.push({ service: 'strava', status: 'success' });
+            }
+            return {
+                id, title, name, routeId, previewImage, startTime, rideTime, distance, startPos, realityFactor, uploadStatus, laps
+            };
+        }
+        scanForActivities() {
+            var _a, _b;
+            return __awaiter(this, void 0, void 0, function* () {
+                try {
+                    this.isDBComplete = (_a = this.isDBComplete) !== null && _a !== void 0 ? _a : false;
+                    const names = yield this.listActivities();
+                    if (!names)
+                        return null;
+                    const promises = [];
+                    names.forEach(name => promises.push(this.loadDetailsByName(name).then((details) => ({ name, details }))));
+                    const result = yield Promise.allSettled(promises);
+                    const activities = [];
+                    let isComplete = true;
+                    result.forEach(result => {
+                        var _a;
+                        if (result.status === "rejected")
+                            isComplete = false;
+                        else {
+                            const details = (_a = result.value) === null || _a === void 0 ? void 0 : _a.details;
+                            const name = result.value.name;
+                            const summary = this.buildSummary(details, name);
+                            activities.push(summary);
+                        }
+                    });
+                    this.isDBComplete = (_b = this.isDBComplete) !== null && _b !== void 0 ? _b : isComplete;
+                    return activities;
+                }
+                catch (err) {
+                    return null;
+                }
+            });
+        }
+        scanForActivitiesAndMerge(activities) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const total = yield this.scanForActivities();
+                if (total === null)
+                    return activities;
+                total.forEach(activity => {
+                    if (!activities.map(a => a.id).includes(activity.id))
+                        activities.push(activity);
+                });
+                return activities;
+            });
+        }
+        _load() {
+            return __awaiter(this, void 0, void 0, function* () {
+                yield this.loadSummaries();
+                this.emitDone();
+            });
+        }
+        getActivity(id) {
+            return this.activities.find(ai => ai.summary.id === id);
+        }
+        logError(error, fn, logProps) {
+            const props = logProps !== null && logProps !== void 0 ? logProps : {};
+            this.logger.logEvent(Object.assign({ message: 'error', error, fn }, props));
+        }
+        getRepo() {
+            if (!this.repo)
+                this.repo = api_1.JsonRepository.create('activities');
+            return this.repo;
+        }
+    };
+    __setFunctionName(_classThis, "ActivitiesDbLoader");
+    (() => {
+        const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(null) : void 0;
+        __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+        ActivitiesDbLoader = _classThis = _classDescriptor.value;
+        if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        __runInitializers(_classThis, _classExtraInitializers);
+    })();
+    return ActivitiesDbLoader = _classThis;
+})();
+exports.ActivitiesDbLoader = ActivitiesDbLoader;

package/lib/activities/base/loaders/index.d.ts

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

package/lib/activities/base/loaders/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./db"), exports);
+__exportStar(require("./types"), exports);

package/lib/activities/base/loaders/types.d.ts

@@ -0,0 +1,8 @@
+import { UploadInfo } from "../model";
+export interface ActivitySearchCriteria {
+    routeId?: string;
+    startPos?: number;
+    realityFactor?: number;
+    uploadStatus?: UploadInfo | Array<UploadInfo>;
+    isSaved?: boolean;
+}

package/lib/activities/base/loaders/types.js

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

package/lib/activities/base/model/index.d.ts

@@ -0,0 +1,116 @@
+import { RoutePoint } from "../../../routes/base/types";
+export type ActivityUser = {
+    uuid?: string;
+    weight: number;
+    ftp: number;
+};
+export type ActivityRoute = {
+    id?: string;
+    hash: string;
+    name: string;
+};
+export type ActivityStatsRecord = {
+    min: number;
+    max: number;
+    avg: number;
+    cntVal: number;
+    sum: number;
+    minAllowed: number;
+};
+export type ActivityLogRecord = {
+    time: number;
+    timeDelta: number;
+    speed: number;
+    slope: number;
+    cadence: number;
+    heartrate: number;
+    distance: number;
+    power: number;
+    lat?: number;
+    lon?: number;
+    elevation?: number;
+};
+export type ActivityStats = {
+    hrm?: ActivityStatsRecord;
+    cadence?: ActivityStatsRecord;
+    speed: ActivityStatsRecord;
+    slope?: ActivityStatsRecord;
+    power: ActivityStatsRecord;
+};
+export type StravaAppLink = {
+    upload_id: number;
+    activity_id: number;
+};
+export type ActivityAppLinks = {
+    strava?: StravaAppLink;
+};
+export type ScreenShotInfo = {
+    fileName: string;
+    position: RoutePoint;
+    isHighlight?: boolean;
+};
+export type ActivityType = 'IncyclistActivity';
+export type UploadStatus = 'success' | 'failure';
+export type UploadInfo = {
+    service: string;
+    status: UploadStatus;
+};
+export type ActivityDB = {
+    version: string;
+    activities: Array<ActivitySummary>;
+    isComplete: boolean;
+};
+export type ActivitySummary = {
+    id: string;
+    title: string;
+    name: string;
+    routeId: string;
+    previewImage?: string;
+    startTime: number;
+    rideTime: number;
+    distance: number;
+    startPos: number;
+    realityFactor: number;
+    uploadStatus: Array<UploadInfo>;
+    isCompleted?: boolean;
+    isSaved?: boolean;
+    saveRideTime?: number;
+    laps?: Array<LapSummary>;
+};
+export type LapSummary = {
+    num: number;
+    startPos: number;
+    distance: number;
+    startTime: number;
+    rideTime: number;
+};
+export type ActivityDetails = {
+    type?: ActivityType;
+    version?: string;
+    title: string;
+    id: string;
+    user: ActivityUser;
+    route: ActivityRoute;
+    startTime: string;
+    time: number;
+    timeTotal: number;
+    timePause: number;
+    distance: number;
+    startPos: number;
+    startpos: number;
+    endpos: number;
+    totalElevation: number;
+    stats: ActivityStats;
+    logs: Array<ActivityLogRecord>;
+    screenshots: Array<ScreenShotInfo>;
+    fileName?: string;
+    tcxFileName?: string;
+    fitFileName?: string;
+    links?: ActivityAppLinks;
+    realityFactor: number;
+    laps?: Array<LapSummary>;
+};
+export type ActivityInfo = {
+    summary: ActivitySummary;
+    details?: ActivityDetails;
+};

package/lib/activities/base/model/index.js

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

package/lib/activities/index.d.ts

@@ -0,0 +1,2 @@
+export * from './base/model';
+export * from './base/loaders';

package/lib/activities/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./base/model"), exports);
+__exportStar(require("./base/loaders"), exports);

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

@@ -15,5 +15,6 @@ export declare class JsonRepository {
     read(objectName: string): Promise<JSONObject>;
     delete(objectName: string): Promise<boolean>;
     protected open(): Promise<boolean>;
+    list(exclude?: string | Array<string>): Promise<Array<string>>;
     protected close(): Promise<boolean>;
 }

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

@@ -75,6 +75,25 @@ class JsonRepository {
             }
         });
     }
+    list(exclude) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                let names = yield this.access.list();
+                if (!names)
+                    return null;
+                names = names.filter(name => name.toLowerCase().endsWith('.json'));
+                names = names.map(name => name.substring(0, name.length - 5));
+                if (exclude) {
+                    const excludes = (typeof (exclude) === 'string') ? [exclude] : exclude;
+                    names = names.filter(name => !excludes.includes(name));
+                }
+                return names;
+            }
+            catch (_a) {
+                return null;
+            }
+        });
+    }
     close() {
         return __awaiter(this, void 0, void 0, function* () {
             const db = (0, bindings_1.getBindings)().db;

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

@@ -5,6 +5,7 @@ export type JsonAccess = {
     read(resourceName: string): Promise<JSONObject>;
     write(resourceName: string, data: JSONObject): Promise<boolean>;
     delete(resourceName: string): Promise<boolean>;
+    list(): Promise<Array<string>>;
 };
 export interface IJsonRepositoryBinding {
     create(name: string): Promise<JsonAccess | null>;

package/lib/index.d.ts

@@ -4,4 +4,5 @@ export * from './api';
 export * from './routes';
 export * from './workouts';
 export * from './coaches';
+export * from './activities';
 export { useUserSettings, initUserSettings, UserSettingsService, UserSettingsBinding, IUserSettingsBinding } from './settings';

package/lib/index.js

@@ -21,6 +21,7 @@ __exportStar(require("./api"), exports);
 __exportStar(require("./routes"), exports);
 __exportStar(require("./workouts"), exports);
 __exportStar(require("./coaches"), exports);
+__exportStar(require("./activities"), exports);
 var settings_1 = require("./settings");
 Object.defineProperty(exports, "useUserSettings", { enumerable: true, get: function () { return settings_1.useUserSettings; } });
 Object.defineProperty(exports, "initUserSettings", { enumerable: true, get: function () { return settings_1.initUserSettings; } });

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

@@ -7,7 +7,7 @@ exports.getPosition = exports.getNextPosition = exports.getRouteHash = exports.g
 const utils_1 = require("../../../utils");
 const geo_1 = require("../../../utils/geo");
 const valid_1 = require("../../../utils/valid");
-const md5_1 = __importDefault(require("md5"));
+const crypto_1 = __importDefault(require("crypto"));
 const MAX_LAPMODE_DISTANCE = 50;
 const checkIsLoop = (_route) => {
     var _a;
@@ -155,7 +155,7 @@ const getRouteHash = (route) => {
     else {
         json = { decoded: route.points.map(p => ({ lat: p.lat, lng: p.lng })) };
     }
-    const routeHash = (0, md5_1.default)(JSON.stringify(json));
+    const routeHash = crypto_1.default.createHash('md5').update(JSON.stringify(json)).digest('hex');
     return routeHash;
 };
 exports.getRouteHash = getRouteHash;

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

@@ -7,7 +7,7 @@ exports.Plan = exports.Workout = void 0;
 const Step_1 = require("./Step");
 const Segment_1 = require("./Segment");
 const valid_1 = require("../../../utils/valid");
-const md5_1 = __importDefault(require("md5"));
+const crypto_1 = __importDefault(require("crypto"));
 class Workout extends Segment_1.Segment {
     constructor(opts) {
         var _a;
@@ -36,7 +36,7 @@ class Workout extends Segment_1.Segment {
         if (this._hash)
             return this.hash;
         const { name, description, steps, repeat } = this;
-        this._hash = (0, md5_1.default)(JSON.stringify({ name, description, steps, repeat }));
+        this._hash = crypto_1.default.createHash('md5').update(JSON.stringify({ name, description, steps, repeat })).digest('hex');
         return this._hash;
     }
     getSegment(time) {
@@ -85,7 +85,8 @@ class Plan {
         if (this._hash)
             return this.hash;
         const { name, description, workouts } = this;
-        this._hash = (0, md5_1.default)(JSON.stringify({ name, description, workouts }));
+        const data = JSON.stringify({ name, description, workouts });
+        this._hash = crypto_1.default.createHash('md5').update(data).digest('hex');
         return this._hash;
     }
     addWorkoutSchedule(week, day, workoutId) {

package/lib/workouts/list/cards/WorkoutCard.d.ts

@@ -19,7 +19,7 @@ export declare class WorkoutCard extends BaseCard implements Card<Workout> {
     select(settings?: WorkoutSettings): void;
     unselect(): void;
     move(targetListName: string): void;
-    save(): Promise<void>;
+    save(enforce?: boolean): Promise<void>;
     delete(): PromiseObserver<boolean>;
     getId(): string;
     getTitle(): string;

package/lib/workouts/list/cards/WorkoutCard.js

@@ -71,12 +71,12 @@ class WorkoutCard extends base_1.BaseCard {
             this.list = newList;
         }
         this.workout.category = { name: targetListName, index: newList === null || newList === void 0 ? void 0 : newList.length };
-        this.save();
+        this.save(true);
     }
-    save() {
+    save(enforce = false) {
         return __awaiter(this, void 0, void 0, function* () {
             try {
-                return yield this.getRepo().save(this.workout);
+                return yield this.getRepo().save(this.workout, enforce);
             }
             catch (err) {
                 this.logError(err, 'save');

package/lib/workouts/list/loaders/db.d.ts

@@ -16,7 +16,7 @@ export declare class WorkoutsDbLoader extends Loader {
     constructor();
     load(): Observer;
     stopLoad(): void;
-    save(workout: Workout | Plan): Promise<void>;
+    save(workout: Workout | Plan, enforceWrite?: boolean): Promise<void>;
     delete(workout: Workout | Plan): Promise<void>;
     protected getRepo(): JsonRepository;
     protected _load(): Promise<void>;

package/lib/workouts/list/loaders/db.js

@@ -85,7 +85,7 @@ let WorkoutsDbLoader = (() => {
                 });
             }
         }
-        save(workout) {
+        save(workout, enforceWrite = false) {
             return __awaiter(this, void 0, void 0, function* () {
                 if (!(0, valid_1.valid)(workout))
                     return;
@@ -106,9 +106,9 @@ let WorkoutsDbLoader = (() => {
                 else {
                     prev = stringify(Object.assign({}, this.workouts[idx]));
                     this.workouts[idx] = workout;
-                    changed = stringify(Object.assign({}, this.workouts[idx])) !== prev;
+                    changed = stringify(Object.assign({}, workout)) !== prev;
                 }
-                if (changed) {
+                if (changed || enforceWrite) {
                     this.isDirty = true;
                     this.write();
                 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "incyclist-services",
-  "version": "1.1.101",
+  "version": "1.2.0",
   "peerDependencies": {
     "gd-eventlog": "^0.1.26"
   },
@@ -39,8 +39,7 @@
   },
   "dependencies": {
     "axios": "^1.6.1",
-    "incyclist-devices": "^2.1.41",
-    "md5": "^2.3.0",
+    "incyclist-devices": "^2.2.0",
     "promise.any": "^2.0.6",
     "uuid": "^9.0.0",
     "xml2js": "^0.6.2"