@sports-alliance/sports-lib 6.0.4 → 6.1.1

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

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

package/lib/esm/events/utilities/activity.utilities.spec.js

@@ -0,0 +1,225 @@
+import { Event } from '../event';
+import { Activity } from '../../activities/activity';
+import { DataHeartRate } from '../../data/data.heart-rate';
+import { DataAltitude } from '../../data/data.altitude';
+import { DataDistance } from '../../data/data.distance';
+import { DataDuration } from '../../data/data.duration';
+import { Creator } from '../../creators/creator';
+import { ActivityTypes } from '../../activities/activity.types';
+import { Stream } from '../../streams/stream';
+import { ActivityUtilities } from './activity.utilities';
+import { DataSpeed } from '../../data/data.speed';
+import { Lap } from '../../laps/lap';
+import { DataSpeedAvg } from '../../data/data.speed-avg';
+import { LapTypes } from '../../laps/lap.types';
+import { DataTime } from '../../data/data.time';
+import { FileType } from '../adapters/file-type.enum';
+import { EventImporterJSON } from '../adapters/importers/json/importer.json';
+describe('Activity Utilities', () => {
+    let event;
+    beforeEach(() => {
+        event = new Event('New name', new Date(0), new Date(200), FileType.FIT);
+        const activity = new Activity(new Date(0), new Date(new Date(0).getTime() + 10000), ActivityTypes.Running, new Creator('Test'));
+        activity.setDuration(new DataDuration(10));
+        activity.setDistance(new DataDistance(10));
+        event.addActivity(activity);
+    });
+    it('should get the correct minimum for a DataType', () => {
+        event.getFirstActivity().addStream(new Stream(DataHeartRate.type, [0, 50, 100]));
+        event.getFirstActivity().addStream(new Stream(DataAltitude.type, [200, 300, 400]));
+        expect(ActivityUtilities.getDataTypeMin(event.getFirstActivity(), DataHeartRate.type)).toBe(0);
+        expect(ActivityUtilities.getDataTypeMin(event.getFirstActivity(), DataAltitude.type)).toBe(200);
+    });
+    it('should get the correct maximum for a DataType', () => {
+        event.getFirstActivity().addStream(new Stream(DataHeartRate.type, [0, 50, 100]));
+        event.getFirstActivity().addStream(new Stream(DataAltitude.type, [200, 300, 400]));
+        expect(ActivityUtilities.getDataTypeMax(event.getFirstActivity(), DataHeartRate.type)).toBe(100);
+        expect(ActivityUtilities.getDataTypeMax(event.getFirstActivity(), DataAltitude.type)).toBe(400);
+    });
+    it('should get the correct difference for a DataType', () => {
+        event.getFirstActivity().addStream(new Stream(DataHeartRate.type, [0, 50, 100]));
+        event.getFirstActivity().addStream(new Stream(DataAltitude.type, [200, 300, 400]));
+        expect(ActivityUtilities.getDataTypeMinToMaxDifference(event.getFirstActivity(), DataHeartRate.type)).toBe(100);
+        expect(ActivityUtilities.getDataTypeMinToMaxDifference(event.getFirstActivity(), DataAltitude.type)).toBe(200);
+    });
+    it('should get the correct average for a DataType', () => {
+        event.getFirstActivity().addStream(new Stream(DataHeartRate.type, [0, 50, 100]));
+        event.getFirstActivity().addStream(new Stream(DataAltitude.type, [200, 300, 400]));
+        expect(ActivityUtilities.getDataTypeAvg(event.getFirstActivity(), DataHeartRate.type)).toBe(50);
+        expect(ActivityUtilities.getDataTypeAvg(event.getFirstActivity(), DataAltitude.type)).toBe(300);
+    });
+    it('should get the correct gain for a DataType', () => {
+        event.getFirstActivity().addStream(new Stream(DataAltitude.type, [200, 300, 400]));
+        expect(ActivityUtilities.getActivityDataTypeGain(event.getFirstActivity(), DataAltitude.type)).toBe(200);
+        // Add more altitude data but this time descending so it would not affect the gain
+        event.getFirstActivity().getStreamData(DataAltitude.type).push(400);
+        event.getFirstActivity().getStreamData(DataAltitude.type).push(300);
+        event.getFirstActivity().getStreamData(DataAltitude.type).push(200);
+        expect(ActivityUtilities.getActivityDataTypeGain(event.getFirstActivity(), DataAltitude.type)).toBe(200);
+        // Add more for gain
+        event.getFirstActivity().getStreamData(DataAltitude.type).push(400); // Gain 400 (from prev)
+        event.getFirstActivity().getStreamData(DataAltitude.type).push(300);
+        // Gain 400
+        event.getFirstActivity().getStreamData(DataAltitude.type).push(400); // Gain 500
+        expect(ActivityUtilities.getActivityDataTypeGain(event.getFirstActivity(), DataAltitude.type)).toBe(500);
+    });
+    it('should get the correct gain for a DataType with a changed min difference', () => {
+        event.getFirstActivity().addStream(new Stream(DataAltitude.type, [200, 300, 400]));
+        // With a diff of 100,200 the gain should be included
+        expect(ActivityUtilities.getActivityDataTypeGain(event.getFirstActivity(), DataAltitude.type, void 0, void 0, 100)).toBe(200);
+        expect(ActivityUtilities.getActivityDataTypeGain(event.getFirstActivity(), DataAltitude.type, void 0, void 0, 200)).toBe(200);
+        // with a diff of 201 it shouldn't
+        expect(ActivityUtilities.getActivityDataTypeGain(event.getFirstActivity(), DataAltitude.type, void 0, void 0, 201)).toBe(0);
+        // Add more
+        event.getFirstActivity().getStreamData(DataAltitude.type).push(100);
+        event.getFirstActivity().getStreamData(DataAltitude.type).push(101);
+        event.getFirstActivity().getStreamData(DataAltitude.type).push(102);
+        // Up to now we have 200m, 300m, 400m, 100m, 101m, 102m
+        expect(ActivityUtilities.getActivityDataTypeGain(event.getFirstActivity(), DataAltitude.type, void 0, void 0, 100)).toBe(200);
+        expect(ActivityUtilities.getActivityDataTypeGain(event.getFirstActivity(), DataAltitude.type, void 0, void 0, 200)).toBe(200);
+        expect(ActivityUtilities.getActivityDataTypeGain(event.getFirstActivity(), DataAltitude.type, void 0, void 0, 300)).toBe(0);
+        expect(ActivityUtilities.getActivityDataTypeGain(event.getFirstActivity(), DataAltitude.type, void 0, void 0, 1)).toBe(202);
+        expect(ActivityUtilities.getActivityDataTypeGain(event.getFirstActivity(), DataAltitude.type, void 0, void 0, 2)).toBe(202);
+        expect(ActivityUtilities.getActivityDataTypeGain(event.getFirstActivity(), DataAltitude.type, void 0, void 0, 3)).toBe(200);
+    });
+    it('should get the correct gain for a DataType with a set of points of non data', () => {
+        event.getFirstActivity().addStream(new Stream(DataAltitude.type, [100, 300, 200, 400]));
+        expect(ActivityUtilities.getActivityDataTypeGain(event.getFirstActivity(), DataAltitude.type)).toBe(400);
+    });
+    it('should get the correct loss for a DataType', () => {
+        event.getFirstActivity().addStream(new Stream(DataAltitude.type, [400, 300, 200]));
+        expect(ActivityUtilities.getActivityDataTypeLoss(event.getFirstActivity(), DataAltitude.type)).toBe(200);
+        // Add more altitude data but this time ascenting so it would not affect the Loss
+        event.getFirstActivity().getStreamData(DataAltitude.type).push(200); // Loss 0
+        event.getFirstActivity().getStreamData(DataAltitude.type).push(300); // Loss 0
+        event.getFirstActivity().getStreamData(DataAltitude.type).push(400); // Loss 0
+        expect(ActivityUtilities.getActivityDataTypeLoss(event.getFirstActivity(), DataAltitude.type)).toBe(200);
+        event.getFirstActivity().getStreamData(DataAltitude.type).push(200); // loss 200
+        event.getFirstActivity().getStreamData(DataAltitude.type).push(300); // loss 0
+        event.getFirstActivity().getStreamData(DataAltitude.type).push(200); // Gain 100 a total (see above of 500)
+        expect(ActivityUtilities.getActivityDataTypeLoss(event.getFirstActivity(), DataAltitude.type)).toBe(500);
+    });
+    it('should get the correct loss for a DataType with a changed min difference', () => {
+        event.getFirstActivity().addStream(new Stream(DataAltitude.type, [400, 300, 200]));
+        // With a diff of 100,200 the gain should be included
+        expect(ActivityUtilities.getActivityDataTypeLoss(event.getFirstActivity(), DataAltitude.type, void 0, void 0, 100)).toBe(200);
+        expect(ActivityUtilities.getActivityDataTypeLoss(event.getFirstActivity(), DataAltitude.type, void 0, void 0, 200)).toBe(200);
+        // with a diff of 201 it shouldn't
+        expect(ActivityUtilities.getActivityDataTypeLoss(event.getFirstActivity(), DataAltitude.type, void 0, void 0, 201)).toBe(0);
+        // Add more
+        event.getFirstActivity().getStreamData(DataAltitude.type).push(500);
+        event.getFirstActivity().getStreamData(DataAltitude.type).push(499);
+        event.getFirstActivity().getStreamData(DataAltitude.type).push(498);
+        // 200m, 300m, 400m, 100m, 101m, 102m
+        // Up to now we have 400m, 300m, 200m, 500m, 499m, 498m
+        expect(ActivityUtilities.getActivityDataTypeLoss(event.getFirstActivity(), DataAltitude.type, void 0, void 0, 100)).toBe(200);
+        expect(ActivityUtilities.getActivityDataTypeLoss(event.getFirstActivity(), DataAltitude.type, void 0, void 0, 200)).toBe(200);
+        expect(ActivityUtilities.getActivityDataTypeLoss(event.getFirstActivity(), DataAltitude.type, void 0, void 0, 300)).toBe(0);
+        expect(ActivityUtilities.getActivityDataTypeLoss(event.getFirstActivity(), DataAltitude.type, void 0, void 0, 1)).toBe(202);
+        expect(ActivityUtilities.getActivityDataTypeLoss(event.getFirstActivity(), DataAltitude.type, void 0, void 0, 2)).toBe(202);
+        expect(ActivityUtilities.getActivityDataTypeLoss(event.getFirstActivity(), DataAltitude.type, void 0, void 0, 3)).toBe(200);
+    });
+    it('should get the correct loss for a DataType with a set of points of non data', () => {
+        event
+            .getFirstActivity()
+            .getAllStreams()
+            .push(new Stream(DataAltitude.type, [400, 200, 300, 100]) // loos 0, 200, 0, 400
+        );
+        expect(ActivityUtilities.getActivityDataTypeLoss(event.getFirstActivity(), DataAltitude.type)).toBe(400);
+    });
+    it('should get the correct data length', () => {
+        const activity = event.getFirstActivity(); // 10s
+        // 10 seconds = 11 slugs; from second 1 eg
+        // [1,2,3,4,5,6,7,8,9,10] ->
+        // [0, 1, 2,3,4,5,6,7,8,9,10]
+        expect(ActivityUtilities.getDataLength(activity.startDate, activity.endDate)).toBe(11);
+        // Change start / end date to <1s
+        activity.startDate = new Date(0);
+        activity.endDate = new Date(50); // 50ms
+        // More than 0 = 1 slug
+        expect(ActivityUtilities.getDataLength(activity.startDate, activity.endDate)).toBe(2);
+        // Change start / end date to >9999ms and <100000s
+        activity.startDate = new Date(0);
+        activity.endDate = new Date(9999); // 9.9 seconds
+        // more than 9 is 10 slugs
+        expect(ActivityUtilities.getDataLength(activity.startDate, activity.endDate)).toBe(11);
+    });
+    it('should provide serialization/deserialization through toJSON', () => {
+        var _a, _b;
+        // Given
+        const activity = event.getFirstActivity();
+        activity.startDate = new Date();
+        activity.endDate = new Date(activity.startDate.getTime() + 3000);
+        event.getFirstActivity().addStream(new Stream(DataDistance.type, [0, 9, null, 30]));
+        event.getFirstActivity().addStream(new Stream(DataSpeed.type, [0, 10, null, 15]));
+        event.getFirstActivity().addStream(new Stream(DataHeartRate.type, [0, 50, null, 100]));
+        event.getFirstActivity().addStream(new Stream(DataAltitude.type, [200, 300, null, 400]));
+        const lap1 = new Lap(activity.startDate, activity.endDate, 1, LapTypes.Autolap);
+        lap1.addStat(new DataSpeedAvg(10));
+        activity.addLap(lap1);
+        const lap2 = new Lap(activity.startDate, activity.endDate, 2, LapTypes.Autolap);
+        lap2.addStat(new DataSpeedAvg(15));
+        activity.addLap(lap2);
+        // When serialize
+        const activitySerialized = activity.toJSON();
+        // Then
+        expect(activitySerialized.name).toBeNull();
+        expect(activitySerialized.startDate).toEqual(activity.startDate.getTime());
+        expect(activitySerialized.endDate).toEqual(activity.endDate.getTime());
+        expect(activitySerialized.powerMeter).toBeFalsy();
+        expect(activitySerialized.trainer).toBeFalsy();
+        expect(activitySerialized.laps.length).toEqual(activity.getLaps().length);
+        expect(activitySerialized.laps[0].startIndex).toEqual(0);
+        expect(activitySerialized.laps[0].endIndex).toEqual(3);
+        expect(activitySerialized.laps[0].stats[DataSpeedAvg.type]).toEqual(activity.getLaps()[0].getStat(DataSpeedAvg.type).getValue());
+        expect(activitySerialized.streams.length).toEqual(activity.getAllStreams().length + 1); // +1 because we add time stream
+        expect((_a = activitySerialized.streams.find(s => s.type == DataTime.type)) === null || _a === void 0 ? void 0 : _a.data.length).toEqual((_b = activitySerialized.streams.find(s => s.type == DataDistance.type)) === null || _b === void 0 ? void 0 : _b.data.length);
+        // When deserialize
+        const activityDeserialized = EventImporterJSON.getActivityFromJSON(activitySerialized);
+        // Then
+        expect(activityDeserialized.startDate).toEqual(activity.startDate);
+        expect(activityDeserialized.endDate).toEqual(activity.endDate);
+        expect(activityDeserialized.hasPowerMeter()).toEqual(activity.hasPowerMeter());
+        expect(activityDeserialized.getLaps().length).toEqual(activity.getLaps().length);
+        expect(activityDeserialized.getLaps()[0].getStat(DataSpeedAvg.type).getValue()).toEqual(activity.getLaps()[0].getStat(DataSpeedAvg.type).getValue());
+        expect(activityDeserialized.getStream(DataDistance.type).getData().length).toEqual(activity.getStream(DataDistance.type).getData().length);
+        expect(activityDeserialized.getStream(DataDistance.type)).toEqual(activity.getStream(DataDistance.type));
+        expect(activityDeserialized.getStream(DataSpeed.type)).toEqual(activity.getStream(DataSpeed.type));
+        expect(activityDeserialized.getStream(DataHeartRate.type)).toEqual(activity.getStream(DataHeartRate.type));
+        expect(activityDeserialized.getStream(DataAltitude.type)).toEqual(activity.getStream(DataAltitude.type));
+        expect(activityDeserialized.hasStreamData(DataTime.type)).toBeFalsy();
+    });
+    describe('Fill streams', () => {
+        const createFakeActivityWithStreams = (lengthInSeconds, streams) => {
+            const startDate = new Date();
+            const endDate = new Date(startDate.getTime() + lengthInSeconds * 1000);
+            const activity = new Activity(startDate, endDate, ActivityTypes.Running, new Creator('creator'));
+            streams.forEach(stream => {
+                activity.addStream(new Stream(stream.type).setData(stream.data));
+            });
+            return activity;
+        };
+        it('should add missing data to streams (1)', done => {
+            // Given
+            const timeData = [0, 1, 2, 3, 4, 5, 6]; // 6 seconds
+            const seconds = timeData.length - 1;
+            const distanceData = [0, 10, 20, 25, 40, 45, 55];
+            const altitudeData = [null, 13, 10, null, 8, 7, null];
+            const heartRateData = [123, 135, null, null, null, null, null];
+            const expectedAltitudes = [13, 13, 10, 10, 8, 7, 7];
+            const expectedHeartRates = [123, 135, 135, 135, 135, 135, 135];
+            const activity = createFakeActivityWithStreams(seconds, [
+                { type: DataDistance.type, data: distanceData },
+                { type: DataAltitude.type, data: altitudeData },
+                { type: DataHeartRate.type, data: heartRateData }
+            ]);
+            // When
+            ActivityUtilities.addMissingDataToStreams(activity);
+            // Then
+            expect(activity.getStreamData(DataDistance.type)).toEqual(distanceData);
+            expect(activity.getStreamData(DataAltitude.type)).toEqual(expectedAltitudes);
+            expect(activity.getStreamData(DataHeartRate.type)).toEqual(expectedHeartRates);
+            done();
+        });
+    });
+});

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

@@ -0,0 +1,6 @@
+import { EventInterface } from '../event.interface';
+export declare class EventUtilities {
+    static mergeEvents(events: EventInterface[]): EventInterface;
+    static generateStatsForAll(event: EventInterface): void;
+    static reGenerateStatsForEvent(event: EventInterface): void;
+}

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

@@ -0,0 +1,57 @@
+import { Event } from '../event';
+import { DataActivityTypes } from '../../data/data.activity-types';
+import { DataDeviceNames } from '../../data/data.device-names';
+import { Privacy } from '../../privacy/privacy.class.interface';
+import { DataDescription } from '../../data/data.description';
+import { ActivityUtilities } from './activity.utilities';
+export class EventUtilities {
+    static mergeEvents(events) {
+        events.sort((eventA, eventB) => {
+            return +eventA.getFirstActivity().startDate - +eventB.getFirstActivity().startDate;
+        });
+        const activities = events
+            .reduce((activitiesArray, event) => {
+            activitiesArray.push(...event.getActivities());
+            return activitiesArray;
+        }, [])
+            .map(activity => {
+            return activity.setID(null);
+        });
+        const event = new Event(`Merged at ${new Date().toISOString()}`, activities[0].startDate, activities[activities.length - 1].endDate, events[0].srcFileType, Privacy.Private, `A merge of 2 or more activities `, true);
+        event.addActivities(activities);
+        this.generateStatsForAll(event);
+        return event;
+    }
+    static generateStatsForAll(event) {
+        // First generate that stats on the activity it self
+        event.getActivities().forEach((activity) => {
+            ActivityUtilities.generateMissingStreamsAndStatsForActivity(activity);
+        });
+        this.reGenerateStatsForEvent(event);
+    }
+    static reGenerateStatsForEvent(event) {
+        event.clearStats();
+        event.startDate = event.getFirstActivity().startDate;
+        event.endDate = event.getLastActivity().endDate;
+        event.addStat(new DataActivityTypes(event.getActivities().map(activity => activity.type)));
+        event.addStat(new DataDeviceNames(event.getActivities().map(activity => activity.creator.name)));
+        // If only one
+        if (event.getActivities().length === 1) {
+            event
+                .getFirstActivity()
+                .getStats()
+                .forEach(stat => {
+                event.addStat(stat);
+            });
+            // Add the description
+            const description = event.getStat(DataDescription.type);
+            if (description && description.getValue()) {
+                event.description = description.getValue();
+            }
+            return;
+        }
+        event.startDate = event.getFirstActivity().startDate;
+        event.endDate = event.getLastActivity().endDate;
+        ActivityUtilities.getSummaryStatsForActivities(event.getActivities()).forEach(stat => event.addStat(stat));
+    }
+}

package/lib/esm/events/utilities/grade-calculator/grade-calculator.d.ts

@@ -0,0 +1,36 @@
+export declare const CLAMP = 50;
+export declare const LOOK_AHEAD_IN_METERS = 10;
+export declare class GradeCalculator {
+    static computeGradeStream(timeStream: (number | null)[], distanceStream: (number | null)[], altitudeStream: (number | null)[], aheadMeters?: number, clamp?: number): (number | null)[];
+    /**
+     * Repair distance and altitude streams based on time streams
+     * @param timeData
+     * @param distanceData
+     * @param altitudeData
+     */
+    static squashAlignStreams(timeData: (number | null)[], distanceData: (number | null)[], altitudeData: (number | null)[]): number[][];
+    /**
+     * Contains a 5th order equation which models the Strava GAP behavior described on picture "./strava_gap_modelization.png"
+     * ------------------------------------------------------------------------------------
+     * Get Real Strava Premium Grade Adjusted Pace on every strava activities with below gist
+     * https://gist.github.com/thomaschampagne/2781dce212d12cd048728e70ae791a30
+     * ------------------------------------------------------------------------------------
+     *
+     * This Strava GAP behavior is described by the below data
+     * [{ grade: -34, speedFactor: 1.7 }, { grade: -32, speedFactor: 1.6 }, { grade: -30, speedFactor: 1.5 },
+     * { grade: -28, speedFactor: 1.4 }, { grade: -26, speedFactor: 1.3 }, { grade: -24, speedFactor: 1.235 },
+     * { grade: -22, speedFactor: 1.15 }, { grade: -20, speedFactor: 1.09 }, { grade: -18, speedFactor: 1.02 },
+     * { grade: -16, speedFactor: 0.95 }, { grade: -14, speedFactor: 0.91 }, { grade: -12, speedFactor: 0.89 },
+     * { grade: -10, speedFactor: 0.88 }, { grade: -8, speedFactor: 0.88 }, { grade: -6, speedFactor: 0.89 },
+     * { grade: -4, speedFactor: 0.91 }, { grade: -2, speedFactor: 0.95 }, { grade: 0, speedFactor: 1 },
+     * { grade: 2, speedFactor: 1.05 }, { grade: 4, speedFactor: 1.14 }, { grade: 6, speedFactor: 1.24 },
+     * { grade: 8, speedFactor: 1.34 }, { grade: 10, speedFactor: 1.47 }, { grade: 12, speedFactor: 1.5 },
+     * { grade: 14, speedFactor: 1.76 }, { grade: 16, speedFactor: 1.94 }, { grade: 18, speedFactor: 2.11 },
+     * { grade: 20, speedFactor: 2.3 }, { grade: 22, speedFactor: 2.4 }, { grade: 24, speedFactor: 2.48 },
+     * { grade: 26, speedFactor: 2.81 }, { grade: 28, speedFactor: 3 }, { grade: 30, speedFactor: 3.16 },
+     * { grade: 32, speedFactor: 3.31 }, { grade: 34, speedFactor: 3.49 } ]
+     *
+     * The 5th order equation has been curve fitted using plot.ly
+     */
+    static estimateAdjustedSpeed(speedMeterSeconds: number, grade: number): number;
+}

package/lib/esm/events/utilities/grade-calculator/grade-calculator.js

@@ -0,0 +1,121 @@
+export const CLAMP = 50;
+export const LOOK_AHEAD_IN_METERS = 10;
+export class GradeCalculator {
+    static computeGradeStream(timeStream, distanceStream, altitudeStream, aheadMeters = LOOK_AHEAD_IN_METERS, clamp = CLAMP) {
+        const [squashedAlignedTime, squashedAlignedDist, squashedAlignedAlt] = GradeCalculator.squashAlignStreams(timeStream, distanceStream, altitudeStream);
+        const squashedAlignedGrade = [];
+        let indexNow = 0;
+        do {
+            // Remove first index of distances & altitudes stream at every loop
+            const aheadDistances = squashedAlignedDist.slice(indexNow);
+            const aheadAltitudes = squashedAlignedAlt.slice(indexNow);
+            // Take our current distance travelled & altitude
+            const distanceNow = aheadDistances[0];
+            const altitudeNow = aheadAltitudes[0];
+            // Find ahead index matching minimal distance travelled
+            let aheadIndex = aheadDistances.findIndex(dist => distanceNow + aheadMeters <= dist);
+            // Validate we find an index with distance ahead for sure, else use last index of ahead distances
+            aheadIndex = aheadIndex >= 0 ? aheadIndex : aheadDistances.length - 1;
+            // Compute deltas & grade
+            const aheadDeltaDistance = aheadDistances[aheadIndex] - distanceNow;
+            const aheadDeltaAltitude = aheadAltitudes[aheadIndex] - altitudeNow;
+            const aheadGrade = aheadDeltaDistance > 0 ? Math.min(Math.max((aheadDeltaAltitude / aheadDeltaDistance) * 100, -clamp), clamp) : 0;
+            squashedAlignedGrade.push(Math.round(aheadGrade * 10) / 10);
+            indexNow++;
+        } while (indexNow < squashedAlignedTime.length);
+        // Rebuild grade stream with empty values using computed squashed/aligned time & grade streams
+        const gradeStream = Array(altitudeStream.length).fill(null);
+        for (const [index, seconds] of squashedAlignedTime.entries()) {
+            gradeStream[seconds] = squashedAlignedGrade[index];
+        }
+        return gradeStream;
+    }
+    /**
+     * Repair distance and altitude streams based on time streams
+     * @param timeData
+     * @param distanceData
+     * @param altitudeData
+     */
+    static squashAlignStreams(timeData, distanceData, altitudeData) {
+        const squashedAlignedTime = [];
+        const squashedAlignedDist = [];
+        const squashedAlignedAlt = [];
+        let lastKnownDistance = distanceData.find(dist => Number.isFinite(dist));
+        let lastKnownAlt = altitudeData.find(alt => Number.isFinite(alt));
+        timeData.forEach((seconds, index) => {
+            // If we have time data
+            if (Number.isFinite(seconds)) {
+                if (Number.isFinite(distanceData[index]) && Number.isFinite(altitudeData[index])) {
+                    // If we have finite distance and altitude, store values
+                    squashedAlignedTime.push(seconds);
+                    squashedAlignedDist.push(distanceData[index]);
+                    squashedAlignedAlt.push(altitudeData[index]);
+                    // Then track last known dist and alt
+                    lastKnownDistance = distanceData[index];
+                    lastKnownAlt = altitudeData[index];
+                }
+                else if (!Number.isFinite(distanceData[index]) && Number.isFinite(altitudeData[index])) {
+                    // If only altitude is finite, then store altitude, and use last known distance instead of empty distance
+                    squashedAlignedTime.push(seconds);
+                    squashedAlignedDist.push(lastKnownDistance);
+                    squashedAlignedAlt.push(altitudeData[index]);
+                    // Then track last known alt
+                    lastKnownAlt = altitudeData[index];
+                }
+                else if (Number.isFinite(distanceData[index]) && !Number.isFinite(altitudeData[index])) {
+                    // If only distance is finite, then store distance, and use last known altitude instead of empty altitude
+                    squashedAlignedTime.push(seconds);
+                    squashedAlignedDist.push(distanceData[index]);
+                    squashedAlignedAlt.push(lastKnownAlt);
+                    // Then track last known distance
+                    lastKnownDistance = distanceData[index];
+                }
+                else {
+                    // Do nothing. Don't store any time or distance data
+                }
+            }
+            else {
+                // Do nothing. Don't store any time or distance data
+            }
+        });
+        return [squashedAlignedTime, squashedAlignedDist, squashedAlignedAlt];
+    }
+    /**
+     * Contains a 5th order equation which models the Strava GAP behavior described on picture "./strava_gap_modelization.png"
+     * ------------------------------------------------------------------------------------
+     * Get Real Strava Premium Grade Adjusted Pace on every strava activities with below gist
+     * https://gist.github.com/thomaschampagne/2781dce212d12cd048728e70ae791a30
+     * ------------------------------------------------------------------------------------
+     *
+     * This Strava GAP behavior is described by the below data
+     * [{ grade: -34, speedFactor: 1.7 }, { grade: -32, speedFactor: 1.6 }, { grade: -30, speedFactor: 1.5 },
+     * { grade: -28, speedFactor: 1.4 }, { grade: -26, speedFactor: 1.3 }, { grade: -24, speedFactor: 1.235 },
+     * { grade: -22, speedFactor: 1.15 }, { grade: -20, speedFactor: 1.09 }, { grade: -18, speedFactor: 1.02 },
+     * { grade: -16, speedFactor: 0.95 }, { grade: -14, speedFactor: 0.91 }, { grade: -12, speedFactor: 0.89 },
+     * { grade: -10, speedFactor: 0.88 }, { grade: -8, speedFactor: 0.88 }, { grade: -6, speedFactor: 0.89 },
+     * { grade: -4, speedFactor: 0.91 }, { grade: -2, speedFactor: 0.95 }, { grade: 0, speedFactor: 1 },
+     * { grade: 2, speedFactor: 1.05 }, { grade: 4, speedFactor: 1.14 }, { grade: 6, speedFactor: 1.24 },
+     * { grade: 8, speedFactor: 1.34 }, { grade: 10, speedFactor: 1.47 }, { grade: 12, speedFactor: 1.5 },
+     * { grade: 14, speedFactor: 1.76 }, { grade: 16, speedFactor: 1.94 }, { grade: 18, speedFactor: 2.11 },
+     * { grade: 20, speedFactor: 2.3 }, { grade: 22, speedFactor: 2.4 }, { grade: 24, speedFactor: 2.48 },
+     * { grade: 26, speedFactor: 2.81 }, { grade: 28, speedFactor: 3 }, { grade: 30, speedFactor: 3.16 },
+     * { grade: 32, speedFactor: 3.31 }, { grade: 34, speedFactor: 3.49 } ]
+     *
+     * The 5th order equation has been curve fitted using plot.ly
+     */
+    static estimateAdjustedSpeed(speedMeterSeconds, grade) {
+        const kA = 1;
+        const kB = 0.029290920646623777;
+        const kC = 0.0018083953212790634;
+        const kD = 4.0662425671715924e-7;
+        const kE = -3.686186584867523e-7;
+        const kF = -2.6628107325930747e-9;
+        const speedAdjust = kA +
+            kB * grade +
+            kC * Math.pow(grade, 2) +
+            kD * Math.pow(grade, 3) +
+            kE * Math.pow(grade, 4) +
+            kF * Math.pow(grade, 5);
+        return speedMeterSeconds * speedAdjust;
+    }
+}

package/lib/esm/events/utilities/grade-calculator/grade-calculator.spec.d.ts

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

package/lib/esm/events/utilities/grade-calculator/grade-calculator.spec.js

@@ -0,0 +1,93 @@
+import { GradeCalculator } from './grade-calculator';
+const floor = (value, decimals) => {
+    const pow = Math.pow(10, decimals);
+    return Math.floor(value * pow) / pow;
+};
+describe('GradeCalculator', () => {
+    it('should align and squash distance & altitude along time', done => {
+        // Given
+        const timeData = [0, null, 2, 3, 4, 5, 6, 7, 8, 9];
+        const distanceData = [0, null, 20, null, 40, 56, null, 73, 85, 99];
+        const altitudeData = [100, null, 102, 303, null, 205, null, 207, 308, 109];
+        const expectedSquashedAlignTime = [0, 2, 3, 4, 5, 7, 8, 9];
+        const expectedSquashedAlignDistance = [0, 20, 20, 40, 56, 73, 85, 99];
+        const expectedSquashedAlignAltitude = [100, 102, 303, 303, 205, 207, 308, 109];
+        // When
+        const [squashedAlignedTime, squashedAlignedDist, squashedAlignedAlt] = GradeCalculator.squashAlignStreams(timeData, distanceData, altitudeData);
+        // Then
+        expect(squashedAlignedDist.length).toEqual(squashedAlignedTime.length);
+        expect(squashedAlignedAlt.length).toEqual(squashedAlignedTime.length);
+        expect(squashedAlignedTime).toEqual(expectedSquashedAlignTime);
+        expect(squashedAlignedDist).toEqual(expectedSquashedAlignDistance);
+        expect(squashedAlignedAlt).toEqual(expectedSquashedAlignAltitude);
+        done();
+    });
+    describe('Grade compute', () => {
+        it('should calculate grade on flat terrain', done => {
+            // Given
+            const timeData = [0, null, 2, 3, 4, 5, 6, 7, 8, 9];
+            const distanceData = [10, null, 20, null, 30, 35, null, 45, 50, 55];
+            const altitudeData = [10, null, 10, 10, 10, 10, null, 10, 10, 10];
+            const gradeData = [0, null, 0, 0, 0, 0, null, 0, 0, 0];
+            // When
+            const gradeStream = GradeCalculator.computeGradeStream(timeData, distanceData, altitudeData);
+            // Then
+            expect(gradeStream.length).toEqual(timeData.length);
+            expect(gradeStream.length).toEqual(gradeData.length);
+            expect(gradeStream).toEqual(gradeData);
+            done();
+        });
+        it('should calculate grade on hilly terrain', done => {
+            // Given
+            const timeData = [0, null, 2, 3, 4, 5, 6, 7, 8, 9];
+            const distanceData = [10, null, 20, null, 30, 35, null, 45, 50, 55];
+            const altitudeData = [10, null, 10, 11, 13, 16, null, 15, 14, 13];
+            const expectedGradeData = [0, null, 30, 20, 13.3, -10, null, -20, -20, 0];
+            // When
+            const gradeStream = GradeCalculator.computeGradeStream(timeData, distanceData, altitudeData, 10, 50);
+            // Then
+            expect(gradeStream.length).toEqual(timeData.length);
+            expect(gradeStream.length).toEqual(expectedGradeData.length);
+            expect(gradeStream).toEqual(expectedGradeData);
+            done();
+        });
+    });
+    describe('Grade adjusted speed', () => {
+        it('should model grade adjusted pace at grade of -32', () => {
+            // Given
+            const speedMeterSeconds = 10;
+            const grade = -30;
+            // When
+            const gradeAdjustedSpeed = GradeCalculator.estimateAdjustedSpeed(speedMeterSeconds, grade);
+            // Then
+            expect(floor(gradeAdjustedSpeed, 1)).toEqual(15);
+        });
+        it('should model grade adjusted pace at grade of 0', () => {
+            // Given
+            const speedMeterSeconds = 10;
+            const grade = 0;
+            // When
+            const gradeAdjustedSpeed = GradeCalculator.estimateAdjustedSpeed(speedMeterSeconds, grade);
+            // Then
+            expect(floor(gradeAdjustedSpeed, 1)).toEqual(10);
+        });
+        it('should model grade adjusted pace at grade of 6', () => {
+            // Given
+            const speedMeterSeconds = 10;
+            const grade = 6;
+            // When
+            const gradeAdjustedSpeed = GradeCalculator.estimateAdjustedSpeed(speedMeterSeconds, grade);
+            // Then
+            expect(floor(gradeAdjustedSpeed, 1)).toEqual(12.4);
+        });
+        it('should model grade adjusted pace at grade of 28', () => {
+            // Given
+            const speedMeterSeconds = 10;
+            const grade = 28;
+            // When
+            const gradeAdjustedSpeed = GradeCalculator.estimateAdjustedSpeed(speedMeterSeconds, grade);
+            // Then
+            expect(floor(gradeAdjustedSpeed, 1)).toEqual(29.7);
+        });
+    });
+});

package/lib/esm/events/utilities/grade-calculator/low-pass-filter.d.ts

@@ -0,0 +1,38 @@
+export declare class LowPassFilter {
+    private _bufferMaxSize;
+    private _buffer;
+    private _smoothing;
+    static smooth(values: number[], smoothing?: number): (number | null)[];
+    constructor(smoothing?: number);
+    /**
+     * Init buffer with array of values
+     * @param {number[]} values
+     * @returns {number[]}
+     */
+    init(values: number[]): number[];
+    /**
+     * Add new value to buffer (FIFO queue)
+     * @param {number} value
+     * @returns {number}
+     * @private
+     */
+    __push(value: number): number;
+    /**
+     * Smooth value from stream
+     * @param {number} nextValue
+     * @returns {number}
+     */
+    next(nextValue: number): number;
+    /**
+     * Smooth array of values
+     * @param {number[]} values
+     * @returns {number[]}
+     */
+    smoothArray(values: (number | null)[]): (number | null)[];
+    get bufferMaxSize(): number;
+    set bufferMaxSize(value: number);
+    get buffer(): number[];
+    set buffer(value: number[]);
+    get smoothing(): number;
+    set smoothing(value: number);
+}