@sports-alliance/sports-lib 6.0.4 → 6.1.0

package/lib/esm/events/adapters/importers/tcx/importer.tcx.mapper.js

@@ -0,0 +1,91 @@
+import { DataLatitudeDegrees } from '../../../../data/data.latitude-degrees';
+import { DataAltitude } from '../../../../data/data.altitude';
+import { DataHeartRate } from '../../../../data/data.heart-rate';
+import { DataCadence } from '../../../../data/data.cadence';
+import { DataDistance } from '../../../../data/data.distance';
+import { DataSpeed } from '../../../../data/data.speed';
+import { DataPace } from '../../../../data/data.pace';
+import { DataPower } from '../../../../data/data.power';
+import { DataLongitudeDegrees } from '../../../../data/data.longitude-degrees';
+import { convertSpeedToPace } from '../../../utilities/helpers';
+import { findChildNode, findChildNodeValue, findTrackPointExtensionValue } from './utils.tcx';
+export const TCXSampleMapper = [
+    {
+        dataType: DataLatitudeDegrees.type,
+        getSampleValue: (trackPointsElement) => {
+            const positionChildNode = findChildNode(trackPointsElement.childNodes, 'Position');
+            if (!positionChildNode) {
+                return null;
+            }
+            return findChildNodeValue(positionChildNode.childNodes, 'LatitudeDegrees');
+        }
+    },
+    {
+        dataType: DataLongitudeDegrees.type,
+        getSampleValue: (trackPointsElement) => {
+            const positionChildNode = findChildNode(trackPointsElement.childNodes, 'Position');
+            if (!positionChildNode) {
+                return null;
+            }
+            return findChildNodeValue(positionChildNode.childNodes, 'LongitudeDegrees');
+        }
+    },
+    {
+        dataType: DataDistance.type,
+        getSampleValue: (trackPointsElement) => {
+            return findChildNodeValue(trackPointsElement.childNodes, 'DistanceMeters');
+        }
+    },
+    {
+        dataType: DataAltitude.type,
+        getSampleValue: (trackPointsElement) => {
+            return findChildNodeValue(trackPointsElement.childNodes, 'AltitudeMeters');
+        }
+    },
+    {
+        dataType: DataCadence.type,
+        getSampleValue: (trackPointsElement) => {
+            return findChildNodeValue(trackPointsElement.childNodes, 'Cadence');
+        }
+    },
+    {
+        dataType: DataHeartRate.type,
+        getSampleValue: (trackPointsElement) => {
+            const heartRateChildNode = findChildNode(trackPointsElement.childNodes, 'HeartRateBpm');
+            if (!heartRateChildNode) {
+                return null;
+            }
+            return findChildNodeValue(heartRateChildNode.childNodes, 'Value');
+        }
+    },
+    {
+        dataType: DataCadence.type,
+        getSampleValue: (trackPointsElement) => {
+            return findTrackPointExtensionValue(trackPointsElement.childNodes, 'RunCadence');
+        }
+    },
+    {
+        dataType: DataSpeed.type,
+        getSampleValue: (trackPointsElement) => {
+            return findTrackPointExtensionValue(trackPointsElement.childNodes, 'Speed');
+        }
+    },
+    {
+        dataType: DataPace.type,
+        getSampleValue: (trackPointsElement) => {
+            const speed = findTrackPointExtensionValue(trackPointsElement.childNodes, 'Speed');
+            return speed !== null ? convertSpeedToPace(speed) : null;
+        }
+    },
+    {
+        dataType: DataPower.type,
+        getSampleValue: (trackPointsElement, sampleInfo) => {
+            // Ensure power stream compliance when in some cases power sample field could be missing even if others samples have it
+            // Just set watts to 0 when this happen
+            // Case example: ride file "7555170032.tcx"  from integration tests
+            return (sampleInfo === null || sampleInfo === void 0 ? void 0 : sampleInfo.hasPowerMeter)
+                ? findTrackPointExtensionValue(trackPointsElement.childNodes, 'Watts') || 0
+                : null;
+        }
+    }
+];

package/lib/esm/events/adapters/importers/tcx/utils.tcx.d.ts

@@ -0,0 +1,5 @@
+export declare const findChildNode: (fromNodeList: NodeListOf<ChildNode>, childNodeName: string | RegExp) => ChildNode | null;
+export declare const findChildNodeValue: (fromNodeList: NodeListOf<ChildNode>, childNodeName: string | RegExp) => number | null;
+export declare const findTrackPointExtensionValue: (childNodes: NodeListOf<ChildNode>, extensionName: string) => number | null;
+export declare const findLapExtensionValue: (childNodes: NodeListOf<ChildNode>, extensionName: string) => number | null;
+export declare const findExtensionValue: (childNodes: NodeListOf<ChildNode>, extensionName: string, namespace: string) => number | null;

package/lib/esm/events/adapters/importers/tcx/utils.tcx.js

@@ -0,0 +1,33 @@
+export const findChildNode = (fromNodeList, childNodeName) => {
+    const childNodeFound = Array.from(fromNodeList).find((childNode) => {
+        return childNode.nodeName === childNodeName || childNode.nodeName.match(childNodeName) !== null;
+    });
+    return childNodeFound ? childNodeFound : null;
+};
+export const findChildNodeValue = (fromNodeList, childNodeName) => {
+    var _a, _b;
+    const predicate = (childNode) => childNode.nodeName === childNodeName || childNode.nodeName.match(childNodeName) !== null;
+    let value = (_b = (_a = Array.from(fromNodeList).find(predicate)) === null || _a === void 0 ? void 0 : _a.firstChild) === null || _b === void 0 ? void 0 : _b.nodeValue;
+    value = value !== undefined ? value : null;
+    return value === null ? value : Number(value);
+};
+// Fetch activity track point extensions according https://www8.garmin.com/xmlschemas/ActivityExtensionv2.xsd schema
+export const findTrackPointExtensionValue = (childNodes, extensionName) => {
+    return findExtensionValue(childNodes, extensionName, 'TPX');
+};
+// Fetch activity lap extensions according https://www8.garmin.com/xmlschemas/ActivityExtensionv2.xsd schema
+export const findLapExtensionValue = (childNodes, extensionName) => {
+    return findExtensionValue(childNodes, extensionName, 'LX');
+};
+export const findExtensionValue = (childNodes, extensionName, namespace) => {
+    const trackPointsChild = findChildNode(childNodes, 'Extensions');
+    if (!trackPointsChild) {
+        return null;
+    }
+    const tpxChildNode = findChildNode(trackPointsChild.childNodes, new RegExp(`${namespace}$`, 'gi'));
+    if (tpxChildNode) {
+        const value = findChildNodeValue(tpxChildNode.childNodes, new RegExp(extensionName + '$'));
+        return value !== null ? Number(value) : null;
+    }
+    return null;
+};

package/lib/esm/events/event.d.ts

@@ -0,0 +1,29 @@
+import { EventInterface } from './event.interface';
+import { ActivityInterface } from '../activities/activity.interface';
+import { DurationClassAbstract } from '../duration/duration.class.abstract';
+import { EventJSONInterface } from './event.json.interface';
+import { Privacy } from '../privacy/privacy.class.interface';
+import { FileType } from './adapters/file-type.enum';
+export declare class Event extends DurationClassAbstract implements EventInterface {
+    name: string;
+    srcFileType: FileType;
+    description?: string;
+    privacy: Privacy;
+    isMerge: boolean;
+    private activities;
+    constructor(name: string, startDate: Date, endDate: Date, srcFileType: FileType, privacy?: Privacy, description?: string, isMerge?: boolean);
+    addActivity(activity: ActivityInterface): void;
+    addActivities(activities: ActivityInterface[]): void;
+    clearActivities(): void;
+    removeActivity(activityToRemove: ActivityInterface): void;
+    getActivities(): ActivityInterface[];
+    getFirstActivity(): ActivityInterface;
+    getLastActivity(): ActivityInterface;
+    getActivityTypesAsArray(): string[];
+    getActivityTypesAsString(): string;
+    getDeviceNamesAsString(): string;
+    private sortActivities;
+    private getUniqueStringWithMultiplier;
+    isMultiSport(): boolean;
+    toJSON(): EventJSONInterface;
+}

package/lib/esm/events/event.interface.d.ts

@@ -0,0 +1,26 @@
+import { SerializableClassInterface } from '../serializable/serializable.class.interface';
+import { StatsClassInterface } from '../stats/stats.class.interface';
+import { ActivityInterface } from '../activities/activity.interface';
+import { DurationClassInterface } from '../duration/duration.class.interface';
+import { EventJSONInterface } from './event.json.interface';
+import { IDClassInterface } from '../id/id.class.interface';
+import { PrivacyClassInterface } from '../privacy/privacy.class.interface';
+import { FileType } from './adapters/file-type.enum';
+export interface EventInterface extends StatsClassInterface, DurationClassInterface, PrivacyClassInterface, SerializableClassInterface, IDClassInterface {
+    name: string;
+    srcFileType: FileType;
+    description?: string;
+    isMerge: boolean;
+    addActivity(activity: ActivityInterface): void;
+    addActivities(activities: ActivityInterface[]): void;
+    removeActivity(activity: ActivityInterface): void;
+    getActivities(): ActivityInterface[];
+    getActivityTypesAsArray(): string[];
+    getActivityTypesAsString(): string;
+    getDeviceNamesAsString(): string;
+    clearActivities(): void;
+    getFirstActivity(): ActivityInterface;
+    getLastActivity(): ActivityInterface;
+    isMultiSport(): boolean;
+    toJSON(): EventJSONInterface;
+}

package/lib/esm/events/event.interface.js

@@ -0,0 +1 @@
+export {};

package/lib/esm/events/event.js

@@ -0,0 +1,123 @@
+import { DurationClassAbstract } from '../duration/duration.class.abstract';
+import { Privacy } from '../privacy/privacy.class.interface';
+import { ActivityTypes } from '../activities/activity.types';
+import { DataActivityTypes } from '../data/data.activity-types';
+import { DataDeviceNames } from '../data/data.device-names';
+export class Event extends DurationClassAbstract {
+    constructor(name, startDate, endDate, srcFileType, privacy, description, isMerge = false) {
+        super(startDate, endDate);
+        this.privacy = Privacy.Private;
+        this.activities = [];
+        this.name = name;
+        this.srcFileType = srcFileType;
+        if (privacy) {
+            this.privacy = privacy;
+        }
+        if (description) {
+            this.description = description;
+        }
+        this.isMerge = isMerge;
+    }
+    addActivity(activity) {
+        this.activities.push(activity);
+    }
+    addActivities(activities) {
+        activities.forEach(activity => this.addActivity(activity));
+    }
+    clearActivities() {
+        this.activities = [];
+    }
+    removeActivity(activityToRemove) {
+        this.activities = this.activities.filter(activity => activityToRemove.getID() !== activity.getID());
+    }
+    getActivities() {
+        this.sortActivities(); // PErhaps move on adding ? Lets check performance
+        return this.activities;
+    }
+    getFirstActivity() {
+        return this.getActivities().reduce((activityA, activityB) => {
+            return activityA.startDate < activityB.startDate ? activityA : activityB;
+        });
+    }
+    getLastActivity() {
+        return this.getActivities().reduce((activityA, activityB) => {
+            return activityA.startDate < activityB.startDate ? activityB : activityA;
+        });
+    }
+    getActivityTypesAsArray() {
+        const activityTypesStat = this.getStat(DataActivityTypes.type);
+        if (!activityTypesStat) {
+            throw new Error(`Event with id ${this.getID()} has no activity types`);
+        }
+        return activityTypesStat.getValue();
+    }
+    getActivityTypesAsString() {
+        const activityTypesStat = this.getStat(DataActivityTypes.type);
+        if (!activityTypesStat) {
+            throw new Error(`Event with id ${this.getID()} has no activity types`);
+        }
+        return activityTypesStat.getValue().length > 1
+            ? `${this.getUniqueStringWithMultiplier(activityTypesStat
+                .getValue()
+                .map((activityType) => ActivityTypes[activityType]))}`
+            : ActivityTypes[activityTypesStat.getDisplayValue()];
+    }
+    getDeviceNamesAsString() {
+        const deviceNamesStat = this.getStat(DataDeviceNames.type);
+        if (!deviceNamesStat) {
+            throw new Error(`Event with id ${this.getID()} has no device names`);
+        }
+        return `${this.getUniqueStringWithMultiplier(deviceNamesStat.getValue())}`;
+    }
+    sortActivities() {
+        this.activities.sort((activityA, activityB) => {
+            return +activityA.startDate - +activityB.startDate;
+        });
+    }
+    getUniqueStringWithMultiplier(arrayOfStrings) {
+        const uniqueObject = arrayOfStrings.reduce((uniqueObj, type, index) => {
+            if (!uniqueObj[type]) {
+                uniqueObj[type] = 1;
+            }
+            else {
+                uniqueObj[type] += 1;
+            }
+            return uniqueObj;
+        }, {});
+        return Object.keys(uniqueObject)
+            .reduce((uniqueArray, key, index, object) => {
+            if (uniqueObject[key] === 1) {
+                uniqueArray.push(key);
+            }
+            else {
+                uniqueArray.push(uniqueObject[key] + 'x ' + key);
+            }
+            return uniqueArray;
+        }, [])
+            .join(', ');
+    }
+    isMultiSport() {
+        return !this.isMerge && this.getActivities().length > 1;
+    }
+    toJSON() {
+        const stats = {};
+        this.stats.forEach((value, key) => {
+            Object.assign(stats, value.toJSON());
+        });
+        return {
+            name: this.name,
+            srcFileType: this.srcFileType,
+            description: this.description || null,
+            privacy: this.privacy,
+            startDate: this.startDate.getTime(),
+            endDate: this.endDate.getTime(),
+            stats: stats,
+            isMerge: this.isMerge,
+            activities: this.getActivities().reduce((activities, activity) => {
+                const jsonActivity = activity.toJSON();
+                activities.push(jsonActivity);
+                return activities;
+            }, [])
+        };
+    }
+}

package/lib/esm/events/event.json.interface.d.ts

@@ -0,0 +1,16 @@
+import { DataJSONInterface } from '../data/data.json.interface';
+import { Privacy } from '../privacy/privacy.class.interface';
+import { ActivityJSONInterface } from '../activities/activity.json.interface';
+import { FileType } from './adapters/file-type.enum';
+export interface EventJSONInterface {
+    id?: string;
+    name: string;
+    srcFileType: FileType;
+    description: string | null;
+    isMerge: boolean;
+    privacy: Privacy;
+    startDate: number;
+    endDate: number;
+    stats: DataJSONInterface;
+    activities: ActivityJSONInterface[];
+}

package/lib/esm/events/event.json.interface.js

@@ -0,0 +1 @@
+export {};

package/lib/esm/events/event.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/esm/events/event.spec.js

@@ -0,0 +1,51 @@
+import { Event } from './event';
+import { Activity } from '../activities/activity';
+import { Creator } from '../creators/creator';
+import { ActivityTypes } from '../activities/activity.types';
+import { FileType } from './adapters/file-type.enum';
+describe('Event', () => {
+    let event;
+    beforeEach(() => {
+        event = new Event('Test', new Date(0), new Date(200), FileType.FIT);
+        event.description = 'Test';
+    });
+    it('should add an activity', () => {
+        expect(event.getActivities().length).toBe(0);
+        event.addActivity(new Activity(new Date(0), new Date(new Date(0).getTime() + 10), ActivityTypes.Running, new Creator('Test')));
+        expect(event.getActivities().length).toBe(1);
+    });
+    it('should remove an activity', () => {
+        const activity = new Activity(new Date(0), new Date(new Date(0).getTime() + 10), ActivityTypes.Running, new Creator('Test'));
+        event.addActivity(activity);
+        expect(event.getActivities().length).toBe(1);
+        event.removeActivity(activity);
+        expect(event.getActivities().length).toBe(0);
+    });
+    it('should get the first and the last activity', () => {
+        const activityA = new Activity(new Date(20), new Date(30), ActivityTypes.Running, new Creator('Test'));
+        const activityB = new Activity(new Date(0), new Date(10), ActivityTypes.Running, new Creator('Test'));
+        event.addActivity(activityA);
+        event.addActivity(activityB);
+        // Should get them sorted by date
+        expect(event.getFirstActivity()).toEqual(activityB);
+        expect(event.getLastActivity()).toEqual(activityA);
+    });
+    it('should export correctly to JSON', () => {
+        const d1 = new Date(0);
+        const d2 = new Date(new Date(0).getTime() + 200);
+        const activity = new Activity(d1, d2, ActivityTypes.Running, new Creator('Test'));
+        event.addActivity(activity);
+        event.setID('123');
+        expect(event.toJSON()).toEqual({
+            name: 'Test',
+            description: 'Test',
+            isMerge: false,
+            privacy: 'private',
+            srcFileType: FileType.FIT,
+            stats: {},
+            activities: [activity.toJSON()],
+            startDate: d1.getTime(),
+            endDate: d2.getTime()
+        });
+    });
+});

package/lib/esm/events/utilities/activity.utilities.d.ts

@@ -0,0 +1,140 @@
+import { ActivityInterface } from '../../activities/activity.interface';
+import { StreamInterface } from '../../streams/stream.interface';
+import { DataInterface } from '../../data/data.interface';
+import { ActivityTypes } from '../../activities/activity.types';
+import { StatsClassInterface } from '../../stats/stats.class.interface';
+export declare class ActivityUtilities {
+    private static geoLibAdapter;
+    /**
+     * Provide average from laps a given stat type
+     */
+    static getDataTypeAvgFromLaps(activity: ActivityInterface, statType: string, filterOver?: number): number | null;
+    /**
+     * Provide average of a given stream type
+     */
+    static getDataTypeAvg(activity: ActivityInterface, streamType: string, startDate?: Date, endDate?: Date, filterOver?: number): number;
+    static round(value: number, decimals?: number): number;
+    static getAverage(data: number[]): number;
+    static getSum(data: number[]): number;
+    static getDataTypeMax(activity: ActivityInterface, streamType: string, startDate?: Date, endDate?: Date): number;
+    static getDataTypeMin(activity: ActivityInterface, streamType: string, startDate?: Date, endDate?: Date, filterOver?: number): number;
+    static getDataTypeMinToMaxDifference(activity: ActivityInterface, streamType: string, startDate?: Date, endDate?: Date): number;
+    static getDataTypeFirst(activity: ActivityInterface, streamType: string, startDate?: Date, endDate?: Date): number;
+    static getDataTypeLast(activity: ActivityInterface, streamType: string, startDate?: Date, endDate?: Date): number;
+    static cropDistance(startDistance: number, endDistance: number, activity: ActivityInterface): ActivityInterface;
+    /**
+     * Crops left,right on time.
+     * Start and end date need to be relative to the activity start / end time
+     * @param activity
+     * @param startDate
+     * @param endDate
+     */
+    static cropTime(activity: ActivityInterface, startDate?: Date, endDate?: Date): ActivityInterface;
+    static getStreamDataTypesBasedOnDataType(streamToBaseOn: StreamInterface, streams: StreamInterface[]): {
+        [type: string]: number | null;
+    }[];
+    static getStreamDataTypesBasedOnTime(startDate: Date, endDate: Date, streams: StreamInterface[]): {
+        [type: number]: {
+            [type: string]: number | null;
+        };
+    };
+    static getDataLength(startDate: Date, endDate: Date): number;
+    static generateMissingStreamsAndStatsForActivity(activity: ActivityInterface): void;
+    static fixAbnormalStreamData(activity: ActivityInterface): void;
+    static generateMissingStreams(activity: ActivityInterface): void;
+    static getSummaryStatsForActivities(activities: ActivityInterface[]): DataInterface[];
+    static getIntensityZonesStatsAggregated(statClassInstances: StatsClassInterface[]): DataInterface[];
+    static getActivityDataTypeGain(activity: ActivityInterface, streamType: string, starDate?: Date, endDate?: Date, minDiff?: number): number | null;
+    static getActivityDataTypeLoss(activity: ActivityInterface, streamType: string, starDate?: Date, endDate?: Date, minDiff?: number): number | null;
+    static getGainOrLoss(data: number[], gain: boolean, minDiff?: number): number | null;
+    static getMax(data: number[]): number;
+    static getMin(data: number[]): number;
+    static calculateTotalDistanceForActivity(activity: ActivityInterface, startDate?: Date, endDate?: Date): number;
+    /**
+     * Returns streams that derive from speed based on the activity type
+     * @param speedStream
+     * @param activityType
+     */
+    private static createByActivityTypeSpeedBasedStreams;
+    /**
+     * Returns streams that derive from grade adjusted speed based on the activity type
+     * @param gradeAdjustedSpeedStream
+     * @param activityType
+     */
+    private static createByActivityTypeAltiDistanceSpeedBasedStreams;
+    /**
+     * @todo unit test (get the pun?)
+     * This creates streams that are deriving as unit based streams
+     * For example it will create pace from speed, swim pace from speed but also speed in km/h as a unitstream
+     * @param streams
+     * @param activityType
+     * @param unitStreamTypes DynamicDataLoader.allUnitDerivedDataTypes this acts like a whitelist for the unit derived units ONLY!
+     */
+    static createUnitStreamsFromStreams(streams: StreamInterface[], activityType: ActivityTypes, unitStreamTypes?: string[]): StreamInterface[];
+    /**
+     * Generates missing streams for an activity such as distance etc if they are missing
+     * This will always create a steam even if the distance is 0
+     * @param activity
+     */
+    static generateMissingStreamsForActivity(activity: ActivityInterface): ActivityInterface;
+    /**
+     * Provides squashed stream data through callback for data manipulation.
+     * Then rebuild the stream based on duration including the missing values (null, Infinity, ...) like the source stream
+     * @param streamType
+     * @param activity
+     * @param shapeStreamData
+     */
+    static shapeStream(streamType: string, activity: ActivityInterface, shapeStreamData: (squashedStreamData: number[]) => number[]): void;
+    static cloneStream(activity: ActivityInterface, sourceStreamType: string, targetStreamType: string): void;
+    /**
+     * Create derived primitive streams which will be needed for others streams & stats computations
+     * @param activity
+     */
+    static createDerivedStreams(activity: ActivityInterface): ActivityInterface;
+    /**
+     * Back and forth fills an activity's stream data so they can be more "tree" like
+     * It does this for:
+     *
+     *  [DataAltitude.type,
+     * DataHeartRate.type,
+     * DataCadence.type,
+     * DataDistance.type]
+     *
+     * Example
+     *
+     * Distance[0, 10, 30, 40, 50,null,60] #null here is legit eg missing record
+     * Altitude[100, 101, null, 103, null, null, 106]
+     * Should be
+     * Altitude[100,101,101,103,103,103,106]
+     *
+     * @param activity
+     */
+    static addMissingDataToStreams(activity: ActivityInterface): void;
+    /**
+     *
+     * @param secondsPer100m
+     * @param avgStrokesPerMin
+     * @param poolLength
+     */
+    static computeSwimSwolf(secondsPer100m: number, avgStrokesPerMin: number, poolLength: number): number;
+    /**
+     * Andrew Coggan weighted power compute method
+     * 1) starting at the 30s mark, calculate a rolling 30 s average (of the preceding time points, obviously).
+     * 2) raise all the values obtained in step #1 to the 4th power.
+     * 3) take the average of all of the values obtained in step #2.
+     * 4) take the 4th root of the value obtained in step #3.
+     * (And when you get tired of exporting every file to, e.g., Excel to perform such calculations, help develop a program
+     * like WKO+ to do the work for you <g>.)
+     */
+    private static computeNormalizedPower;
+    private static getActivityDataTypeGainOrLoss;
+    private static getActivityDataTypeMinOrMax;
+    /**
+     * Generates the stats for an activity
+     * @todo move to factory with next version
+     * @param activity
+     */
+    private static generateMissingStatsForActivity;
+    private static generateMissingSpeedDerivedStatsForActivity;
+    private static generateMissingUnitStatsForActivity;
+}