incyclist-services 1.4.22 → 1.4.23

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

@@ -36,6 +36,7 @@ export interface ActivityAppLink {
 export type ActivityAppLinks = {
     strava?: ActivityAppLink;
     velohero?: ActivityAppLink;
+    intervals?: ActivityAppLink;
 };
 export type ScreenShotInfo = {
     fileName: string;

package/lib/activities/upload/index.d.ts

@@ -1,4 +1,5 @@
 export * from './velohero';
 export * from './strava';
+export * from './intervals';
 export * from './types';
 export * from './factory';

package/lib/activities/upload/index.js

@@ -16,5 +16,6 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./velohero"), exports);
 __exportStar(require("./strava"), exports);
+__exportStar(require("./intervals"), exports);
 __exportStar(require("./types"), exports);
 __exportStar(require("./factory"), exports);

package/lib/activities/upload/intervals.d.ts

@@ -0,0 +1,18 @@
+import { IncyclistService } from "../../base/service";
+import { ActivityDetails } from "../base";
+import { IActivityUpload } from "./types";
+import { IntervalsAppConnection } from "../../apps/intervals/IntervalsAppConnection";
+import { IntervalsFormat } from "../../apps";
+export declare class IntervalsUpload extends IncyclistService implements IActivityUpload {
+    protected isInitialized: any;
+    protected connection: IntervalsAppConnection;
+    constructor();
+    init(): boolean;
+    isConnected(): boolean;
+    upload(activity: ActivityDetails, format?: string): Promise<boolean>;
+    getUrl(activityId: string): string;
+    protected getIntervalsFormat(format: string): IntervalsFormat;
+    protected ensureInitialized(): any;
+    protected getIntervalsAppConnection(): IntervalsAppConnection;
+    protected getApi(): import("../../apps").IntervalsApi;
+}

package/lib/activities/upload/intervals.js

@@ -0,0 +1,160 @@
+"use strict";
+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 __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 __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.IntervalsUpload = void 0;
+const service_1 = require("../../base/service");
+const types_1 = require("../../base/types");
+const Injection_1 = require("../../base/decorators/Injection");
+const factory_1 = require("./factory");
+const IntervalsAppConnection_1 = require("../../apps/intervals/IntervalsAppConnection");
+let IntervalsUpload = (() => {
+    let _classDecorators = [types_1.Singleton];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _classSuper = service_1.IncyclistService;
+    let _instanceExtraInitializers = [];
+    let _getIntervalsAppConnection_decorators;
+    var IntervalsUpload = _classThis = class extends _classSuper {
+        constructor() {
+            super('IntervalsUpload');
+            this.isInitialized = __runInitializers(this, _instanceExtraInitializers);
+            this.connection = new IntervalsAppConnection_1.IntervalsAppConnection();
+            this.isInitialized = false;
+            this.init();
+        }
+        init() {
+            if (this.isInitialized)
+                return true;
+            this.isInitialized = this.getIntervalsAppConnection().init();
+            return this.isInitialized;
+        }
+        isConnected() {
+            return this.getIntervalsAppConnection().isConnected();
+        }
+        upload(activity_1) {
+            return __awaiter(this, arguments, void 0, function* (activity, format = 'TCX') {
+                try {
+                    const ok = this.ensureInitialized();
+                    if (!ok) {
+                        this.logEvent({ message: 'Intervals.icu Upload skipped', reason: 'not initialized' });
+                        return false;
+                    }
+                    if (!this.isConnected())
+                        return false;
+                    const lcFormat = format.toLowerCase();
+                    const ucFormat = format.toUpperCase();
+                    this.logEvent({ message: 'Intervals.icu Upload', format: ucFormat });
+                    if (!activity.links)
+                        activity.links = {};
+                    const fileName = activity[`${lcFormat}FileName`];
+                    const res = yield this.getApi().upload(fileName, {
+                        name: activity.title,
+                        description: '',
+                        format: this.getIntervalsFormat(format)
+                    });
+                    this.logEvent({ message: 'Intervals.icu Upload success', activityId: res.intervalsId });
+                    activity.links.intervals = {
+                        activity_id: res.intervalsId,
+                        url: this.getUrl(res.intervalsId)
+                    };
+                    return true;
+                }
+                catch (err) {
+                    this.logEvent({ message: 'Intervals.icu Upload failure', error: err.message });
+                    activity.links.intervals = {
+                        error: err.message
+                    };
+                    return false;
+                }
+            });
+        }
+        getUrl(activityId) {
+            return `https://intervals.icu/activities/${activityId}`;
+        }
+        getIntervalsFormat(format) {
+            switch (format.toLowerCase()) {
+                case 'tcx':
+                    return 'tcx';
+                case 'fit':
+                    return 'fit';
+                case 'gox':
+                    return 'gpx';
+                default:
+                    return null;
+            }
+        }
+        ensureInitialized() {
+            if (!this.isInitialized)
+                this.init();
+            return this.isInitialized;
+        }
+        getIntervalsAppConnection() {
+            return this.connection;
+        }
+        getApi() {
+            return this.getIntervalsAppConnection().getApi();
+        }
+    };
+    __setFunctionName(_classThis, "IntervalsUpload");
+    (() => {
+        var _a;
+        const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create((_a = _classSuper[Symbol.metadata]) !== null && _a !== void 0 ? _a : null) : void 0;
+        _getIntervalsAppConnection_decorators = [Injection_1.Injectable];
+        __esDecorate(_classThis, null, _getIntervalsAppConnection_decorators, { kind: "method", name: "getIntervalsAppConnection", static: false, private: false, access: { has: obj => "getIntervalsAppConnection" in obj, get: obj => obj.getIntervalsAppConnection }, metadata: _metadata }, null, _instanceExtraInitializers);
+        __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+        IntervalsUpload = _classThis = _classDescriptor.value;
+        if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        __runInitializers(_classThis, _classExtraInitializers);
+    })();
+    return IntervalsUpload = _classThis;
+})();
+exports.IntervalsUpload = IntervalsUpload;
+const factory = new factory_1.ActivityUploadFactory();
+factory.add('intervals', new IntervalsUpload());

package/lib/activities/upload/strava copy.d.ts

@@ -0,0 +1,18 @@
+import { IncyclistService } from "../../base/service";
+import { ActivityDetails } from "../base";
+import { StravaFormat } from "../../apps/base/api/strava";
+import { IActivityUpload } from "./types";
+import { StravaAppConnection } from "../../apps/strava/StravaAppConnection";
+export declare class StravaUpload extends IncyclistService implements IActivityUpload {
+    protected isInitialized: any;
+    protected connection: StravaAppConnection;
+    constructor();
+    init(): boolean;
+    isConnected(): boolean;
+    upload(activity: ActivityDetails, format?: string): Promise<boolean>;
+    getUrl(activityId: string): string;
+    protected getStravaFormat(format: string): StravaFormat;
+    protected ensureInitialized(): any;
+    protected getStravaAppConnection(): StravaAppConnection;
+    protected getApi(): import("../../apps/base/api/strava").StravaApi;
+}

package/lib/activities/upload/strava copy.js

@@ -0,0 +1,170 @@
+"use strict";
+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 __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 __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.StravaUpload = void 0;
+const service_1 = require("../../base/service");
+const types_1 = require("../../base/types");
+const strava_1 = require("../../apps/base/api/strava");
+const Injection_1 = require("../../base/decorators/Injection");
+const factory_1 = require("./factory");
+const StravaAppConnection_1 = require("../../apps/strava/StravaAppConnection");
+let StravaUpload = (() => {
+    let _classDecorators = [types_1.Singleton];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _classSuper = service_1.IncyclistService;
+    let _instanceExtraInitializers = [];
+    let _getStravaAppConnection_decorators;
+    var StravaUpload = _classThis = class extends _classSuper {
+        constructor() {
+            super('StravaUpload');
+            this.isInitialized = __runInitializers(this, _instanceExtraInitializers);
+            this.connection = new StravaAppConnection_1.StravaAppConnection();
+            this.isInitialized = false;
+            this.init();
+        }
+        init() {
+            if (this.isInitialized)
+                return true;
+            this.isInitialized = this.getStravaAppConnection().init();
+            return this.isInitialized;
+        }
+        isConnected() {
+            return this.getStravaAppConnection().isConnected();
+        }
+        upload(activity_1) {
+            return __awaiter(this, arguments, void 0, function* (activity, format = 'TCX') {
+                try {
+                    const ok = this.ensureInitialized();
+                    if (!ok) {
+                        this.logEvent({ message: 'Strava Upload skipped', reason: 'not initialized' });
+                        return false;
+                    }
+                    if (!this.isConnected())
+                        return false;
+                    const lcFormat = format.toLowerCase();
+                    const ucFormat = format.toUpperCase();
+                    this.logEvent({ message: 'Strava Upload', format: ucFormat });
+                    if (!activity.links)
+                        activity.links = {};
+                    const fileName = activity[`${lcFormat}FileName`];
+                    const res = yield this.getApi().upload(fileName, {
+                        name: activity.title,
+                        description: '',
+                        format: this.getStravaFormat(format)
+                    });
+                    this.logEvent({ message: 'Strava Upload success', activityId: res.stravaId });
+                    activity.links.strava = {
+                        activity_id: res.stravaId,
+                        url: this.getUrl(res.stravaId)
+                    };
+                    return true;
+                }
+                catch (err) {
+                    if (err instanceof strava_1.DuplicateError) {
+                        this.logEvent({ message: 'Strava Upload failure', error: 'duplicate', activityId: err.stravaId });
+                        activity.links.strava = {
+                            activity_id: err.stravaId,
+                            url: this.getUrl(err.stravaId)
+                        };
+                    }
+                    else {
+                        this.logEvent({ message: 'Strava Upload failure', error: err.message });
+                        activity.links.strava = {
+                            error: err.message
+                        };
+                    }
+                    return false;
+                }
+            });
+        }
+        getUrl(activityId) {
+            return `https://www.strava.com/activities/${activityId}`;
+        }
+        getStravaFormat(format) {
+            switch (format.toLowerCase()) {
+                case 'tcx':
+                    return 'tcx';
+                case 'fit':
+                    return 'fit';
+                case 'gox':
+                    return 'gpx';
+                default:
+                    return null;
+            }
+        }
+        ensureInitialized() {
+            if (!this.isInitialized)
+                this.init();
+            return this.isInitialized;
+        }
+        getStravaAppConnection() {
+            return this.connection;
+        }
+        getApi() {
+            return this.getStravaAppConnection().getApi();
+        }
+    };
+    __setFunctionName(_classThis, "StravaUpload");
+    (() => {
+        var _a;
+        const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create((_a = _classSuper[Symbol.metadata]) !== null && _a !== void 0 ? _a : null) : void 0;
+        _getStravaAppConnection_decorators = [Injection_1.Injectable];
+        __esDecorate(_classThis, null, _getStravaAppConnection_decorators, { kind: "method", name: "getStravaAppConnection", static: false, private: false, access: { has: obj => "getStravaAppConnection" in obj, get: obj => obj.getStravaAppConnection }, metadata: _metadata }, null, _instanceExtraInitializers);
+        __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+        StravaUpload = _classThis = _classDescriptor.value;
+        if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        __runInitializers(_classThis, _classExtraInitializers);
+    })();
+    return StravaUpload = _classThis;
+})();
+exports.StravaUpload = StravaUpload;
+const factory = new factory_1.ActivityUploadFactory();
+factory.add('strava', new StravaUpload());

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

@@ -1,3 +1,4 @@
 export * from './velohero';
 export * from './strava';
 export * from './komoot';
+export * from './intervals';

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

@@ -17,3 +17,4 @@ Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./velohero"), exports);
 __exportStar(require("./strava"), exports);
 __exportStar(require("./komoot"), exports);
+__exportStar(require("./intervals"), exports);

package/lib/apps/base/api/intervals/api.d.ts

@@ -0,0 +1,21 @@
+import { Observer } from "../../../../base/types/observer";
+import { AppApiBase } from "../base";
+import { EventLogger } from 'gd-eventlog';
+import { AxiosResponse } from "axios";
+import { IntervalsAthlete, IntervalsConfig, IntervalsUploadProps, IntervalsUploadRequest, IntervalsUploadResult } from "./types";
+export declare class IntervalsApi extends AppApiBase {
+    protected config: IntervalsConfig;
+    protected logger: EventLogger;
+    protected observer: Observer;
+    constructor();
+    init(config: IntervalsConfig): Observer;
+    update(config: Partial<IntervalsConfig>): void;
+    isAuthenticated(): boolean;
+    upload(fileName: string, props?: IntervalsUploadProps): Promise<IntervalsUploadResult>;
+    getLoggedInAthlete(): Promise<IntervalsAthlete>;
+    protected verifyAuthentication(): Promise<void>;
+    protected createUpload(request: IntervalsUploadRequest): Promise<IntervalsUploadResult>;
+    protected get(url: string, config?: object): Promise<AxiosResponse>;
+    protected getUploadParams(request: IntervalsUploadRequest): string;
+    protected getBaseUrl(): any;
+}

package/lib/apps/base/api/intervals/api.js

@@ -0,0 +1,117 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IntervalsApi = void 0;
+const observer_1 = require("../../../../base/types/observer");
+const valid_1 = require("../../../../utils/valid");
+const base_1 = require("../base");
+const gd_eventlog_1 = require("gd-eventlog");
+const API_BASE_URL = 'https://intervals.icu/api/v1';
+class IntervalsApi extends base_1.AppApiBase {
+    constructor() {
+        super();
+        this.logger = new gd_eventlog_1.EventLogger('IntervalsApi');
+        this.observer = new observer_1.Observer();
+    }
+    init(config) {
+        this.config = config;
+        return this.observer;
+    }
+    update(config) {
+        if (!this.config)
+            throw new Error('update not allowed before init');
+        this.config = Object.assign(Object.assign({}, this.config), config);
+    }
+    isAuthenticated() {
+        var _a;
+        return (0, valid_1.valid)((_a = this.config) === null || _a === void 0 ? void 0 : _a.accessToken);
+    }
+    upload(fileName, props) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.verifyAuthentication();
+            const request = {
+                file: { type: 'file', fileName },
+                name: props === null || props === void 0 ? void 0 : props.name,
+                description: props === null || props === void 0 ? void 0 : props.description,
+                externalId: props.externalId
+            };
+            return yield this.createUpload(request);
+        });
+    }
+    getLoggedInAthlete() {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const response = yield this.get('/athlete/0/profile');
+            return (_a = response.data) === null || _a === void 0 ? void 0 : _a.athlete;
+        });
+    }
+    verifyAuthentication() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.isAuthenticated())
+                throw new Error('not authenticated');
+        });
+    }
+    createUpload(request) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c, _d, _e, _f, _g, _h;
+            const reqOpts = {
+                headers: {
+                    Authorization: 'Bearer ' + this.config.accessToken
+                }
+            };
+            let url = `/athlete/0/activities${this.getUploadParams(request)}`;
+            const form = yield this.createForm(url, { file: request.file }, reqOpts);
+            const response = yield this.postForm(form);
+            if (response.data && !response.error && !response.data.error) {
+                const result = response.data;
+                return {
+                    externalId: request.externalId,
+                    intervalsId: result.id
+                };
+            }
+            else {
+                const result = response.data;
+                if (result === null || result === void 0 ? void 0 : result.error)
+                    throw new Error(result.error);
+                throw new Error((_h = (_g = (_d = (_c = (_b = (_a = response.error) === null || _a === void 0 ? void 0 : _a.response) === null || _b === void 0 ? void 0 : _b.data) === null || _c === void 0 ? void 0 : _c.error) !== null && _d !== void 0 ? _d : (_f = (_e = response.error) === null || _e === void 0 ? void 0 : _e.response) === null || _f === void 0 ? void 0 : _f.message) !== null && _g !== void 0 ? _g : response.error.message) !== null && _h !== void 0 ? _h : `HTTP error ${response.status}`);
+            }
+        });
+    }
+    get(url, config) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const props = config !== null && config !== void 0 ? config : {};
+            const request = Object.assign({ method: 'get', url: this.getBaseUrl() + url, headers: {
+                    Authorization: 'Bearer ' + this.config.accessToken
+                } }, props);
+            const response = yield this.getApi().request(request);
+            return response;
+        });
+    }
+    getUploadParams(request) {
+        const params = [];
+        if (request.name)
+            params.push(`name=${request.name}`);
+        if (request.description)
+            params.push(`description=${request.description}`);
+        if (params.length === 0)
+            return '';
+        return '?' + params.join('&');
+    }
+    getBaseUrl() {
+        try {
+            return this.getUserSettings().get('INTERVALS_API', API_BASE_URL);
+        }
+        catch (_a) {
+            return API_BASE_URL;
+        }
+    }
+}
+exports.IntervalsApi = IntervalsApi;

package/lib/apps/base/api/intervals/index.d.ts

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

package/lib/apps/base/api/intervals/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("./types"), exports);
+__exportStar(require("./api"), exports);

package/lib/apps/base/api/intervals/types.d.ts

@@ -0,0 +1,49 @@
+export type IntervalsConfig = {
+    accessToken: string;
+};
+export type IntervalsUploadRequest = {
+    file: any;
+    name: string;
+    description: string;
+    externalId?: string;
+};
+export type IntervalsUploadProps = {
+    format: IntervalsFormat;
+    name?: string;
+    description?: string;
+    externalId?: string;
+};
+export type IntervalsActivity = {
+    icu_athlete_id: string;
+    id: string;
+};
+export type IntervalsUploadResponse = {
+    icu_athlete_id?: string;
+    id?: string;
+    status?: number;
+    error?: string;
+    activities?: IntervalsActivity[];
+};
+export type IntervalsUploadResult = {
+    intervalsId?: string;
+    externalId?: string;
+};
+export type IntervalsAthleteResult = {
+    athlete: IntervalsAthlete;
+    sharedFolders: any;
+    customItems: any;
+};
+export type IntervalsAthlete = {
+    id: string;
+    name: string;
+    profile_medium: string;
+    city: string;
+    state: string;
+    country: string;
+    timezone: string;
+    sex: string;
+    bio: string;
+    website: string;
+    email: string;
+};
+export type IntervalsFormat = 'fit' | 'fit.gz' | 'tcx' | 'tcx.gz' | 'gpx' | 'gpx.gz';

package/lib/apps/base/api/intervals/types.js

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

package/lib/apps/intervals/IntervalsAppConnection.d.ts

@@ -0,0 +1,23 @@
+import { IntervalsApi, IntervalsConfig } from "../base/api";
+import { ConnectedAppService } from "../base/app";
+import { IntervalsCredentials } from "./types";
+export declare class IntervalsAppConnection extends ConnectedAppService<IntervalsCredentials> {
+    protected config: IntervalsConfig;
+    protected api: IntervalsApi;
+    constructor();
+    connect(credentials: IntervalsCredentials): Promise<boolean>;
+    isConnecting(): boolean;
+    disconnect(): void;
+    isConnected(): boolean;
+    getCredentials(): IntervalsCredentials;
+    getApi(): IntervalsApi;
+    protected initAuth(): boolean;
+    protected updateConfig(config: IntervalsConfig): void;
+    protected saveCredentials(config?: IntervalsConfig): void;
+    protected getSecret(key: string): string;
+    protected buildConfigFromCredentials(credentials: IntervalsCredentials): {
+        accessToken: string;
+    };
+    protected initApi(config: IntervalsConfig): void;
+    protected getSecretBindings(): import("../../api/bindings/secret").ISecretBinding;
+}

package/lib/apps/intervals/IntervalsAppConnection.js

@@ -0,0 +1,203 @@
+"use strict";
+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 __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 __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.IntervalsAppConnection = void 0;
+const api_1 = require("../../api");
+const decorators_1 = require("../../base/decorators");
+const valid_1 = require("../../utils/valid");
+const api_2 = require("../base/api");
+const app_1 = require("../base/app");
+let IntervalsAppConnection = (() => {
+    let _classDecorators = [decorators_1.Singleton];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _classSuper = app_1.ConnectedAppService;
+    let _instanceExtraInitializers = [];
+    let _getSecretBindings_decorators;
+    var IntervalsAppConnection = _classThis = class extends _classSuper {
+        constructor() {
+            super('IntervalsAppConnection', 'intervals');
+            this.config = __runInitializers(this, _instanceExtraInitializers);
+        }
+        connect(credentials) {
+            return __awaiter(this, void 0, void 0, function* () {
+                this.ensureInitialized();
+                this.logEvent({ message: 'Connect with Intervals.icu' });
+                try {
+                    const isConnected = this.isConnected();
+                    const config = this.buildConfigFromCredentials(credentials);
+                    if (isConnected) {
+                        this.getApi().update(config);
+                    }
+                    else {
+                        this.initApi(config);
+                        this.saveCredentials(config);
+                    }
+                    this.logEvent({ message: 'Connect with Intervals.icu success' });
+                    return true;
+                }
+                catch (err) {
+                    this.logError(err, 'connect');
+                    throw err;
+                }
+            });
+        }
+        isConnecting() {
+            return false;
+        }
+        disconnect() {
+            try {
+                this.config = undefined;
+                this.saveCredentials();
+                this.getApi().init(undefined);
+            }
+            catch (err) {
+                this.logError(err, 'disconnect');
+            }
+        }
+        isConnected() {
+            if (!this.isInitialized) {
+                this.init();
+            }
+            if (this.getApi().isAuthenticated() && !this.config) {
+                this.initAuth();
+            }
+            return ((0, valid_1.valid)(this.config));
+        }
+        getCredentials() {
+            const userSettings = this.getUserSettings();
+            try {
+                return userSettings.get('user.auth.intervals', null);
+            }
+            catch (_a) {
+                return null;
+            }
+        }
+        getApi() {
+            if (!this.api)
+                this.api = new api_2.IntervalsApi();
+            return this.api;
+        }
+        initAuth() {
+            let isInitialized = false;
+            try {
+                const auth = this.getCredentials();
+                if (auth) {
+                    this.logEvent({ message: 'Intervals.icu init done', hasCredentials: true });
+                    this.config = this.buildConfigFromCredentials(auth);
+                    this.initApi(this.config);
+                }
+                else {
+                    this.logEvent({ message: 'Intervals.icu init done', hasCredentials: false });
+                }
+                isInitialized = true;
+            }
+            catch (err) {
+                this.logEvent({ message: 'error', error: err.message, fn: 'init', stack: err.stack });
+                isInitialized = false;
+                delete this.config;
+            }
+            return isInitialized;
+        }
+        updateConfig(config) {
+            const { accessToken } = config;
+            this.config = Object.assign(Object.assign({}, this.config), { accessToken });
+            this.saveCredentials();
+        }
+        saveCredentials(config) {
+            if (config)
+                this.config = config;
+            try {
+                if (!this.isConnected()) {
+                    this.logEvent({ message: 'Intervals.icu Delete Credentials' });
+                    this.getUserSettings().set('user.auth.intervals', null);
+                    return;
+                }
+                this.logEvent({ message: 'Intervals.icu Save Credentials' });
+                this.getUserSettings().set('user.auth.intervals', {
+                    accesstoken: this.config.accessToken
+                });
+            }
+            catch (err) {
+                this.logEvent({ message: 'error', fn: 'saveCredentials', error: err.message, stack: err.stack });
+            }
+            this.logEvent({ message: 'Intervals.icu Save Credentials done' });
+        }
+        getSecret(key) {
+            var _a;
+            return (_a = this.getSecretBindings()) === null || _a === void 0 ? void 0 : _a.getSecret(key);
+        }
+        buildConfigFromCredentials(credentials) {
+            return {
+                accessToken: credentials === null || credentials === void 0 ? void 0 : credentials.accesstoken
+            };
+        }
+        initApi(config) {
+            this.getApi().init(config);
+        }
+        getSecretBindings() {
+            var _a;
+            return (_a = (0, api_1.getBindings)()) === null || _a === void 0 ? void 0 : _a.secret;
+        }
+    };
+    __setFunctionName(_classThis, "IntervalsAppConnection");
+    (() => {
+        var _a;
+        const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create((_a = _classSuper[Symbol.metadata]) !== null && _a !== void 0 ? _a : null) : void 0;
+        _getSecretBindings_decorators = [decorators_1.Injectable];
+        __esDecorate(_classThis, null, _getSecretBindings_decorators, { kind: "method", name: "getSecretBindings", static: false, private: false, access: { has: obj => "getSecretBindings" in obj, get: obj => obj.getSecretBindings }, metadata: _metadata }, null, _instanceExtraInitializers);
+        __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+        IntervalsAppConnection = _classThis = _classDescriptor.value;
+        if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        __runInitializers(_classThis, _classExtraInitializers);
+    })();
+    return IntervalsAppConnection = _classThis;
+})();
+exports.IntervalsAppConnection = IntervalsAppConnection;

package/lib/apps/intervals/StravaAppConnection.d.ts

@@ -0,0 +1,28 @@
+import { StravaApi, StravaConfig } from "../base/api";
+import { ConnectedAppService } from "../base/app";
+import { StravaCredentials } from "./types";
+export declare class StravaAppConnection extends ConnectedAppService<StravaCredentials> {
+    protected config: StravaConfig;
+    protected api: StravaApi;
+    protected tokenUpdateHandler: any;
+    constructor();
+    connect(credentials: StravaCredentials): Promise<boolean>;
+    isConnecting(): boolean;
+    disconnect(): void;
+    isConnected(): boolean;
+    getCredentials(): StravaCredentials;
+    getApi(): StravaApi;
+    protected initAuth(): boolean;
+    protected updateConfig(config: StravaConfig): void;
+    protected saveCredentials(config?: StravaConfig): void;
+    protected getSecret(key: string): string;
+    protected buildConfigFromCredentials(credentials: StravaCredentials): {
+        clientId: string;
+        clientSecret: string;
+        accessToken: any;
+        refreshToken: any;
+        expiration: Date;
+    };
+    protected initApi(config: StravaConfig): void;
+    protected getSecretBindings(): import("../../api/bindings/secret").ISecretBinding;
+}

package/lib/apps/intervals/StravaAppConnection.js

@@ -0,0 +1,211 @@
+"use strict";
+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 __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 __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.StravaAppConnection = void 0;
+const api_1 = require("../../api");
+const decorators_1 = require("../../base/decorators");
+const valid_1 = require("../../utils/valid");
+const api_2 = require("../base/api");
+const app_1 = require("../base/app");
+let StravaAppConnection = (() => {
+    let _classDecorators = [decorators_1.Singleton];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _classSuper = app_1.ConnectedAppService;
+    let _instanceExtraInitializers = [];
+    let _getSecretBindings_decorators;
+    var StravaAppConnection = _classThis = class extends _classSuper {
+        constructor() {
+            super('StravaAppConnection', 'strava');
+            this.config = __runInitializers(this, _instanceExtraInitializers);
+            this.tokenUpdateHandler = this.updateConfig.bind(this);
+        }
+        connect(credentials) {
+            return __awaiter(this, void 0, void 0, function* () {
+                this.ensureInitialized();
+                this.logEvent({ message: 'Connect with Strava' });
+                try {
+                    const isConnected = this.isConnected();
+                    const config = this.buildConfigFromCredentials(credentials);
+                    if (isConnected) {
+                        this.getApi().update(config);
+                    }
+                    else {
+                        this.initApi(config);
+                        this.saveCredentials(config);
+                    }
+                    this.logEvent({ message: 'Connect with Strava success' });
+                    return true;
+                }
+                catch (err) {
+                    this.logError(err, 'connect');
+                    throw err;
+                }
+            });
+        }
+        isConnecting() {
+            return false;
+        }
+        disconnect() {
+            try {
+                this.config = undefined;
+                this.saveCredentials();
+                this.getApi().init(undefined);
+            }
+            catch (err) {
+                this.logError(err, 'disconnect');
+            }
+        }
+        isConnected() {
+            if (!this.isInitialized) {
+                this.init();
+            }
+            return ((0, valid_1.valid)(this.config));
+        }
+        getCredentials() {
+            const userSettings = this.getUserSettings();
+            try {
+                return userSettings.get('user.auth.strava', null);
+            }
+            catch (_a) {
+                return null;
+            }
+        }
+        getApi() {
+            if (!this.api)
+                this.api = new api_2.StravaApi();
+            return this.api;
+        }
+        initAuth() {
+            let isInitialized = false;
+            try {
+                const auth = this.getCredentials();
+                const clientId = this.getSecret('STRAVA_CLIENT_ID');
+                const clientSecret = this.getSecret('STRAVA_CLIENT_SECRET');
+                if (clientId && clientSecret && auth) {
+                    this.logEvent({ message: 'Strava init done', hasCredentials: true });
+                    this.config = this.buildConfigFromCredentials(auth);
+                    this.initApi(this.config);
+                }
+                else {
+                    this.logEvent({ message: 'Strava init done', hasCredentials: false });
+                }
+                isInitialized = true;
+            }
+            catch (err) {
+                this.logEvent({ message: 'error', error: err.message, fn: 'init', stack: err.stack });
+                isInitialized = false;
+                delete this.config;
+            }
+            return isInitialized;
+        }
+        updateConfig(config) {
+            const { accessToken, refreshToken, expiration } = config;
+            this.config = Object.assign(Object.assign({}, this.config), { accessToken, refreshToken, expiration });
+            this.saveCredentials();
+        }
+        saveCredentials(config) {
+            var _a;
+            if (config)
+                this.config = config;
+            try {
+                if (!this.isConnected()) {
+                    this.logEvent({ message: 'Strava Delete Credentials' });
+                    this.getUserSettings().set('user.auth.strava', null);
+                    return;
+                }
+                this.logEvent({ message: 'Strava Save Credentials' });
+                this.getUserSettings().set('user.auth.strava', {
+                    accesstoken: this.config.accessToken,
+                    refreshtoken: this.config.refreshToken,
+                    expiration: (_a = this.config.expiration) === null || _a === void 0 ? void 0 : _a.toISOString()
+                });
+            }
+            catch (err) {
+                this.logEvent({ message: 'error', fn: 'saveCredentials', error: err.message, stack: err.stack });
+            }
+            this.logEvent({ message: 'Strava Save Credentials done' });
+        }
+        getSecret(key) {
+            var _a;
+            return (_a = this.getSecretBindings()) === null || _a === void 0 ? void 0 : _a.getSecret(key);
+        }
+        buildConfigFromCredentials(credentials) {
+            return {
+                clientId: this.getSecret('STRAVA_CLIENT_ID'),
+                clientSecret: this.getSecret('STRAVA_CLIENT_SECRET'),
+                accessToken: credentials === null || credentials === void 0 ? void 0 : credentials.accesstoken,
+                refreshToken: credentials === null || credentials === void 0 ? void 0 : credentials.refreshtoken,
+                expiration: (credentials === null || credentials === void 0 ? void 0 : credentials.expiration) ? new Date(credentials.expiration) : undefined
+            };
+        }
+        initApi(config) {
+            const observer = this.getApi().init(config);
+            observer.on('token.updated', this.tokenUpdateHandler);
+        }
+        getSecretBindings() {
+            var _a;
+            return (_a = (0, api_1.getBindings)()) === null || _a === void 0 ? void 0 : _a.secret;
+        }
+    };
+    __setFunctionName(_classThis, "StravaAppConnection");
+    (() => {
+        var _a;
+        const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create((_a = _classSuper[Symbol.metadata]) !== null && _a !== void 0 ? _a : null) : void 0;
+        _getSecretBindings_decorators = [decorators_1.Injectable];
+        __esDecorate(_classThis, null, _getSecretBindings_decorators, { kind: "method", name: "getSecretBindings", static: false, private: false, access: { has: obj => "getSecretBindings" in obj, get: obj => obj.getSecretBindings }, metadata: _metadata }, null, _instanceExtraInitializers);
+        __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+        StravaAppConnection = _classThis = _classDescriptor.value;
+        if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        __runInitializers(_classThis, _classExtraInitializers);
+    })();
+    return StravaAppConnection = _classThis;
+})();
+exports.StravaAppConnection = StravaAppConnection;

package/lib/apps/intervals/types.d.ts

@@ -0,0 +1,6 @@
+import { AppCredentials } from "../base/types";
+export interface IntervalsCredentials extends AppCredentials {
+    accesstoken: string;
+    refreshtoken: string;
+    expiration?: string;
+}

package/lib/apps/intervals/types.js

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

package/lib/apps/service.js

@@ -54,6 +54,7 @@ const service_1 = require("../base/service");
 const types_1 = require("../base/types");
 const settings_1 = require("../settings");
 const base_1 = require("./base");
+const IntervalsAppConnection_1 = require("./intervals/IntervalsAppConnection");
 const komoot_1 = require("./komoot");
 const VeloHeroAppConnection_1 = require("./velohero/VeloHeroAppConnection");
 let AppsService = (() => {
@@ -69,7 +70,7 @@ let AppsService = (() => {
         constructor() {
             super('AppsService');
             this.services = (__runInitializers(this, _instanceExtraInitializers), {
-                ActivityUpload: ['strava', 'velohero', 'intervals.icu'],
+                ActivityUpload: ['strava', 'velohero', 'intervals'],
                 WorkoutUpload: [],
                 WorkoutDownload: [],
                 ActivityDownload: [],
@@ -79,6 +80,7 @@ let AppsService = (() => {
                 { name: 'Strava', key: 'strava', iconUrl: 'https://static.cdnlogo.com/logos/s/42/strava-wordmark.svg', connection: new base_1.StravaAppConnection() },
                 { name: 'VeloHero', key: 'velohero', iconUrl: 'images/velo-white.png', connection: new VeloHeroAppConnection_1.VeloHeroAppConnection() },
                 { name: 'Komoot', key: 'komoot', iconUrl: 'https://www.komoot.com/assets/4d8ae313eec53e6e.svg', connection: new komoot_1.KomootAppConnection() },
+                { name: 'Intervals.icu', key: 'intervals', iconUrl: 'images/intervals.png', connection: new IntervalsAppConnection_1.IntervalsAppConnection() },
             ];
         }
         openSettings() {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "incyclist-services",
-  "version": "1.4.22",
+  "version": "1.4.23",
   "peerDependencies": {
     "gd-eventlog": "^0.1.26"
   },