@sports-alliance/sports-lib 6.0.4 → 6.1.1

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

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

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

@@ -0,0 +1,227 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const event_1 = require("../event");
+const activity_1 = require("../../activities/activity");
+const data_heart_rate_1 = require("../../data/data.heart-rate");
+const data_altitude_1 = require("../../data/data.altitude");
+const data_distance_1 = require("../../data/data.distance");
+const data_duration_1 = require("../../data/data.duration");
+const creator_1 = require("../../creators/creator");
+const activity_types_1 = require("../../activities/activity.types");
+const stream_1 = require("../../streams/stream");
+const activity_utilities_1 = require("./activity.utilities");
+const data_speed_1 = require("../../data/data.speed");
+const lap_1 = require("../../laps/lap");
+const data_speed_avg_1 = require("../../data/data.speed-avg");
+const lap_types_1 = require("../../laps/lap.types");
+const data_time_1 = require("../../data/data.time");
+const file_type_enum_1 = require("../adapters/file-type.enum");
+const importer_json_1 = require("../adapters/importers/json/importer.json");
+describe('Activity Utilities', () => {
+    let event;
+    beforeEach(() => {
+        event = new event_1.Event('New name', new Date(0), new Date(200), file_type_enum_1.FileType.FIT);
+        const activity = new activity_1.Activity(new Date(0), new Date(new Date(0).getTime() + 10000), activity_types_1.ActivityTypes.Running, new creator_1.Creator('Test'));
+        activity.setDuration(new data_duration_1.DataDuration(10));
+        activity.setDistance(new data_distance_1.DataDistance(10));
+        event.addActivity(activity);
+    });
+    it('should get the correct minimum for a DataType', () => {
+        event.getFirstActivity().addStream(new stream_1.Stream(data_heart_rate_1.DataHeartRate.type, [0, 50, 100]));
+        event.getFirstActivity().addStream(new stream_1.Stream(data_altitude_1.DataAltitude.type, [200, 300, 400]));
+        expect(activity_utilities_1.ActivityUtilities.getDataTypeMin(event.getFirstActivity(), data_heart_rate_1.DataHeartRate.type)).toBe(0);
+        expect(activity_utilities_1.ActivityUtilities.getDataTypeMin(event.getFirstActivity(), data_altitude_1.DataAltitude.type)).toBe(200);
+    });
+    it('should get the correct maximum for a DataType', () => {
+        event.getFirstActivity().addStream(new stream_1.Stream(data_heart_rate_1.DataHeartRate.type, [0, 50, 100]));
+        event.getFirstActivity().addStream(new stream_1.Stream(data_altitude_1.DataAltitude.type, [200, 300, 400]));
+        expect(activity_utilities_1.ActivityUtilities.getDataTypeMax(event.getFirstActivity(), data_heart_rate_1.DataHeartRate.type)).toBe(100);
+        expect(activity_utilities_1.ActivityUtilities.getDataTypeMax(event.getFirstActivity(), data_altitude_1.DataAltitude.type)).toBe(400);
+    });
+    it('should get the correct difference for a DataType', () => {
+        event.getFirstActivity().addStream(new stream_1.Stream(data_heart_rate_1.DataHeartRate.type, [0, 50, 100]));
+        event.getFirstActivity().addStream(new stream_1.Stream(data_altitude_1.DataAltitude.type, [200, 300, 400]));
+        expect(activity_utilities_1.ActivityUtilities.getDataTypeMinToMaxDifference(event.getFirstActivity(), data_heart_rate_1.DataHeartRate.type)).toBe(100);
+        expect(activity_utilities_1.ActivityUtilities.getDataTypeMinToMaxDifference(event.getFirstActivity(), data_altitude_1.DataAltitude.type)).toBe(200);
+    });
+    it('should get the correct average for a DataType', () => {
+        event.getFirstActivity().addStream(new stream_1.Stream(data_heart_rate_1.DataHeartRate.type, [0, 50, 100]));
+        event.getFirstActivity().addStream(new stream_1.Stream(data_altitude_1.DataAltitude.type, [200, 300, 400]));
+        expect(activity_utilities_1.ActivityUtilities.getDataTypeAvg(event.getFirstActivity(), data_heart_rate_1.DataHeartRate.type)).toBe(50);
+        expect(activity_utilities_1.ActivityUtilities.getDataTypeAvg(event.getFirstActivity(), data_altitude_1.DataAltitude.type)).toBe(300);
+    });
+    it('should get the correct gain for a DataType', () => {
+        event.getFirstActivity().addStream(new stream_1.Stream(data_altitude_1.DataAltitude.type, [200, 300, 400]));
+        expect(activity_utilities_1.ActivityUtilities.getActivityDataTypeGain(event.getFirstActivity(), data_altitude_1.DataAltitude.type)).toBe(200);
+        // Add more altitude data but this time descending so it would not affect the gain
+        event.getFirstActivity().getStreamData(data_altitude_1.DataAltitude.type).push(400);
+        event.getFirstActivity().getStreamData(data_altitude_1.DataAltitude.type).push(300);
+        event.getFirstActivity().getStreamData(data_altitude_1.DataAltitude.type).push(200);
+        expect(activity_utilities_1.ActivityUtilities.getActivityDataTypeGain(event.getFirstActivity(), data_altitude_1.DataAltitude.type)).toBe(200);
+        // Add more for gain
+        event.getFirstActivity().getStreamData(data_altitude_1.DataAltitude.type).push(400); // Gain 400 (from prev)
+        event.getFirstActivity().getStreamData(data_altitude_1.DataAltitude.type).push(300);
+        // Gain 400
+        event.getFirstActivity().getStreamData(data_altitude_1.DataAltitude.type).push(400); // Gain 500
+        expect(activity_utilities_1.ActivityUtilities.getActivityDataTypeGain(event.getFirstActivity(), data_altitude_1.DataAltitude.type)).toBe(500);
+    });
+    it('should get the correct gain for a DataType with a changed min difference', () => {
+        event.getFirstActivity().addStream(new stream_1.Stream(data_altitude_1.DataAltitude.type, [200, 300, 400]));
+        // With a diff of 100,200 the gain should be included
+        expect(activity_utilities_1.ActivityUtilities.getActivityDataTypeGain(event.getFirstActivity(), data_altitude_1.DataAltitude.type, void 0, void 0, 100)).toBe(200);
+        expect(activity_utilities_1.ActivityUtilities.getActivityDataTypeGain(event.getFirstActivity(), data_altitude_1.DataAltitude.type, void 0, void 0, 200)).toBe(200);
+        // with a diff of 201 it shouldn't
+        expect(activity_utilities_1.ActivityUtilities.getActivityDataTypeGain(event.getFirstActivity(), data_altitude_1.DataAltitude.type, void 0, void 0, 201)).toBe(0);
+        // Add more
+        event.getFirstActivity().getStreamData(data_altitude_1.DataAltitude.type).push(100);
+        event.getFirstActivity().getStreamData(data_altitude_1.DataAltitude.type).push(101);
+        event.getFirstActivity().getStreamData(data_altitude_1.DataAltitude.type).push(102);
+        // Up to now we have 200m, 300m, 400m, 100m, 101m, 102m
+        expect(activity_utilities_1.ActivityUtilities.getActivityDataTypeGain(event.getFirstActivity(), data_altitude_1.DataAltitude.type, void 0, void 0, 100)).toBe(200);
+        expect(activity_utilities_1.ActivityUtilities.getActivityDataTypeGain(event.getFirstActivity(), data_altitude_1.DataAltitude.type, void 0, void 0, 200)).toBe(200);
+        expect(activity_utilities_1.ActivityUtilities.getActivityDataTypeGain(event.getFirstActivity(), data_altitude_1.DataAltitude.type, void 0, void 0, 300)).toBe(0);
+        expect(activity_utilities_1.ActivityUtilities.getActivityDataTypeGain(event.getFirstActivity(), data_altitude_1.DataAltitude.type, void 0, void 0, 1)).toBe(202);
+        expect(activity_utilities_1.ActivityUtilities.getActivityDataTypeGain(event.getFirstActivity(), data_altitude_1.DataAltitude.type, void 0, void 0, 2)).toBe(202);
+        expect(activity_utilities_1.ActivityUtilities.getActivityDataTypeGain(event.getFirstActivity(), data_altitude_1.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_1.Stream(data_altitude_1.DataAltitude.type, [100, 300, 200, 400]));
+        expect(activity_utilities_1.ActivityUtilities.getActivityDataTypeGain(event.getFirstActivity(), data_altitude_1.DataAltitude.type)).toBe(400);
+    });
+    it('should get the correct loss for a DataType', () => {
+        event.getFirstActivity().addStream(new stream_1.Stream(data_altitude_1.DataAltitude.type, [400, 300, 200]));
+        expect(activity_utilities_1.ActivityUtilities.getActivityDataTypeLoss(event.getFirstActivity(), data_altitude_1.DataAltitude.type)).toBe(200);
+        // Add more altitude data but this time ascenting so it would not affect the Loss
+        event.getFirstActivity().getStreamData(data_altitude_1.DataAltitude.type).push(200); // Loss 0
+        event.getFirstActivity().getStreamData(data_altitude_1.DataAltitude.type).push(300); // Loss 0
+        event.getFirstActivity().getStreamData(data_altitude_1.DataAltitude.type).push(400); // Loss 0
+        expect(activity_utilities_1.ActivityUtilities.getActivityDataTypeLoss(event.getFirstActivity(), data_altitude_1.DataAltitude.type)).toBe(200);
+        event.getFirstActivity().getStreamData(data_altitude_1.DataAltitude.type).push(200); // loss 200
+        event.getFirstActivity().getStreamData(data_altitude_1.DataAltitude.type).push(300); // loss 0
+        event.getFirstActivity().getStreamData(data_altitude_1.DataAltitude.type).push(200); // Gain 100 a total (see above of 500)
+        expect(activity_utilities_1.ActivityUtilities.getActivityDataTypeLoss(event.getFirstActivity(), data_altitude_1.DataAltitude.type)).toBe(500);
+    });
+    it('should get the correct loss for a DataType with a changed min difference', () => {
+        event.getFirstActivity().addStream(new stream_1.Stream(data_altitude_1.DataAltitude.type, [400, 300, 200]));
+        // With a diff of 100,200 the gain should be included
+        expect(activity_utilities_1.ActivityUtilities.getActivityDataTypeLoss(event.getFirstActivity(), data_altitude_1.DataAltitude.type, void 0, void 0, 100)).toBe(200);
+        expect(activity_utilities_1.ActivityUtilities.getActivityDataTypeLoss(event.getFirstActivity(), data_altitude_1.DataAltitude.type, void 0, void 0, 200)).toBe(200);
+        // with a diff of 201 it shouldn't
+        expect(activity_utilities_1.ActivityUtilities.getActivityDataTypeLoss(event.getFirstActivity(), data_altitude_1.DataAltitude.type, void 0, void 0, 201)).toBe(0);
+        // Add more
+        event.getFirstActivity().getStreamData(data_altitude_1.DataAltitude.type).push(500);
+        event.getFirstActivity().getStreamData(data_altitude_1.DataAltitude.type).push(499);
+        event.getFirstActivity().getStreamData(data_altitude_1.DataAltitude.type).push(498);
+        // 200m, 300m, 400m, 100m, 101m, 102m
+        // Up to now we have 400m, 300m, 200m, 500m, 499m, 498m
+        expect(activity_utilities_1.ActivityUtilities.getActivityDataTypeLoss(event.getFirstActivity(), data_altitude_1.DataAltitude.type, void 0, void 0, 100)).toBe(200);
+        expect(activity_utilities_1.ActivityUtilities.getActivityDataTypeLoss(event.getFirstActivity(), data_altitude_1.DataAltitude.type, void 0, void 0, 200)).toBe(200);
+        expect(activity_utilities_1.ActivityUtilities.getActivityDataTypeLoss(event.getFirstActivity(), data_altitude_1.DataAltitude.type, void 0, void 0, 300)).toBe(0);
+        expect(activity_utilities_1.ActivityUtilities.getActivityDataTypeLoss(event.getFirstActivity(), data_altitude_1.DataAltitude.type, void 0, void 0, 1)).toBe(202);
+        expect(activity_utilities_1.ActivityUtilities.getActivityDataTypeLoss(event.getFirstActivity(), data_altitude_1.DataAltitude.type, void 0, void 0, 2)).toBe(202);
+        expect(activity_utilities_1.ActivityUtilities.getActivityDataTypeLoss(event.getFirstActivity(), data_altitude_1.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_1.Stream(data_altitude_1.DataAltitude.type, [400, 200, 300, 100]) // loos 0, 200, 0, 400
+        );
+        expect(activity_utilities_1.ActivityUtilities.getActivityDataTypeLoss(event.getFirstActivity(), data_altitude_1.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(activity_utilities_1.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(activity_utilities_1.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(activity_utilities_1.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_1.Stream(data_distance_1.DataDistance.type, [0, 9, null, 30]));
+        event.getFirstActivity().addStream(new stream_1.Stream(data_speed_1.DataSpeed.type, [0, 10, null, 15]));
+        event.getFirstActivity().addStream(new stream_1.Stream(data_heart_rate_1.DataHeartRate.type, [0, 50, null, 100]));
+        event.getFirstActivity().addStream(new stream_1.Stream(data_altitude_1.DataAltitude.type, [200, 300, null, 400]));
+        const lap1 = new lap_1.Lap(activity.startDate, activity.endDate, 1, lap_types_1.LapTypes.Autolap);
+        lap1.addStat(new data_speed_avg_1.DataSpeedAvg(10));
+        activity.addLap(lap1);
+        const lap2 = new lap_1.Lap(activity.startDate, activity.endDate, 2, lap_types_1.LapTypes.Autolap);
+        lap2.addStat(new data_speed_avg_1.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[data_speed_avg_1.DataSpeedAvg.type]).toEqual(activity.getLaps()[0].getStat(data_speed_avg_1.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 == data_time_1.DataTime.type)) === null || _a === void 0 ? void 0 : _a.data.length).toEqual((_b = activitySerialized.streams.find(s => s.type == data_distance_1.DataDistance.type)) === null || _b === void 0 ? void 0 : _b.data.length);
+        // When deserialize
+        const activityDeserialized = importer_json_1.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(data_speed_avg_1.DataSpeedAvg.type).getValue()).toEqual(activity.getLaps()[0].getStat(data_speed_avg_1.DataSpeedAvg.type).getValue());
+        expect(activityDeserialized.getStream(data_distance_1.DataDistance.type).getData().length).toEqual(activity.getStream(data_distance_1.DataDistance.type).getData().length);
+        expect(activityDeserialized.getStream(data_distance_1.DataDistance.type)).toEqual(activity.getStream(data_distance_1.DataDistance.type));
+        expect(activityDeserialized.getStream(data_speed_1.DataSpeed.type)).toEqual(activity.getStream(data_speed_1.DataSpeed.type));
+        expect(activityDeserialized.getStream(data_heart_rate_1.DataHeartRate.type)).toEqual(activity.getStream(data_heart_rate_1.DataHeartRate.type));
+        expect(activityDeserialized.getStream(data_altitude_1.DataAltitude.type)).toEqual(activity.getStream(data_altitude_1.DataAltitude.type));
+        expect(activityDeserialized.hasStreamData(data_time_1.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_1.Activity(startDate, endDate, activity_types_1.ActivityTypes.Running, new creator_1.Creator('creator'));
+            streams.forEach(stream => {
+                activity.addStream(new stream_1.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: data_distance_1.DataDistance.type, data: distanceData },
+                { type: data_altitude_1.DataAltitude.type, data: altitudeData },
+                { type: data_heart_rate_1.DataHeartRate.type, data: heartRateData }
+            ]);
+            // When
+            activity_utilities_1.ActivityUtilities.addMissingDataToStreams(activity);
+            // Then
+            expect(activity.getStreamData(data_distance_1.DataDistance.type)).toEqual(distanceData);
+            expect(activity.getStreamData(data_altitude_1.DataAltitude.type)).toEqual(expectedAltitudes);
+            expect(activity.getStreamData(data_heart_rate_1.DataHeartRate.type)).toEqual(expectedHeartRates);
+            done();
+        });
+    });
+});

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

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

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

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const grade_calculator_1 = require("./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] = grade_calculator_1.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 = grade_calculator_1.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 = grade_calculator_1.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 = grade_calculator_1.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 = grade_calculator_1.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 = grade_calculator_1.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 = grade_calculator_1.GradeCalculator.estimateAdjustedSpeed(speedMeterSeconds, grade);
+            // Then
+            expect(floor(gradeAdjustedSpeed, 1)).toEqual(29.7);
+        });
+    });
+});

package/lib/cjs/id/id.class.spec.d.ts

@@ -0,0 +1,3 @@
+import { IDClass } from './id.abstract.class';
+export declare class IdClass extends IDClass {
+}

package/lib/cjs/id/id.class.spec.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IdClass = void 0;
+const id_abstract_class_1 = require("./id.abstract.class");
+describe('IDClass', () => {
+    let idClass;
+    beforeEach(() => {
+        idClass = new IdClass();
+    });
+    it('should correctly set an ID', () => {
+        idClass.setID('123');
+        expect(idClass.getID()).toBe('123');
+    });
+});
+class IdClass extends id_abstract_class_1.IDClass {
+}
+exports.IdClass = IdClass;

package/lib/cjs/index.d.ts

@@ -0,0 +1,149 @@
+import { EventInterface } from './events/event.interface';
+import { EventJSONInterface } from './events/event.json.interface';
+import { ActivityParsingOptions } from './activities/activity-parsing-options';
+export declare class SportsLib {
+    /**
+     * Parses and returns an event using GPX format
+     * @param gpxString
+     * @param options
+     * @param domParser custom DOMParser (case of NodeJs usage)
+     */
+    static importFromGPX(gpxString: string, domParser?: any, options?: ActivityParsingOptions): Promise<EventInterface>;
+    /**
+     * Parses and returns an event using TCX format
+     * @param xmlDocument
+     * @param options
+     */
+    static importFromTCX(xmlDocument: XMLDocument, options?: ActivityParsingOptions): Promise<EventInterface>;
+    /**
+     * Parses and returns an event using FIT format
+     * @param arrayBuffer
+     * @param options
+     */
+    static importFromFit(arrayBuffer: ArrayBuffer, options?: ActivityParsingOptions): Promise<EventInterface>;
+    /**
+     * Parses and returns an event using Suunto format
+     * @param jsonString
+     * @param options
+     */
+    static importFromSuunto(jsonString: string, options?: ActivityParsingOptions): Promise<EventInterface>;
+    /**
+     * Parses and returns an event using native format (SportsLib exported format)
+     * @param json EventJSONInterface
+     */
+    static importFromJSON(json: EventJSONInterface): EventInterface;
+}
+export * from './activities/activity.interface';
+export * from './activities/activity.json.interface';
+export * from './activities/activity.types';
+export * from './constants/constants';
+export * from './data/data-aerobic-training-effect';
+export * from './data/data.absolute-pressure';
+export * from './data/data.accumulated-power';
+export * from './data/data.activity-types';
+export * from './data/data.air-power';
+export * from './data/data.altitude';
+export * from './data/data.altitude-avg';
+export * from './data/data.altitude-gps';
+export * from './data/data.altitude-max';
+export * from './data/data.altitude-min';
+export * from './data/data.ascent';
+export * from './data/data.cadence-avg';
+export * from './data/data.cadence-max';
+export * from './data/data.cadence-min';
+export * from './data/data.descent';
+export * from './data/data.description';
+export * from './data/data.device-names';
+export * from './data/data.distance';
+export * from './data/data.duration';
+export * from './data/data.ehpe';
+export * from './data/data.energy';
+export * from './data/data.epoc';
+export * from './data/data.evpe';
+export * from './data/data.feeling';
+export * from './data/data.grade-adjusted-pace';
+export * from './data/data.grade-adjusted-pace-avg';
+export * from './data/data.grade-adjusted-speed';
+export * from './data/data.grade-adjusted-speed-avg';
+export * from './data/data.heart-rate';
+export * from './data/data.heart-rate-avg';
+export * from './data/data.heart-rate-max';
+export * from './data/data.heart-rate-min';
+export * from './data/data.ibi';
+export * from './data/data.interface';
+export * from './data/data.latitude-degrees';
+export * from './data/data.left-balance';
+export * from './data/data.longitude-degrees';
+export * from './data/data.moving-time';
+export * from './data/data.pace';
+export * from './data/data.pace-avg';
+export * from './data/data.peak-epoc';
+export * from './data/data.peak-training-effect';
+export * from './data/data.position.interface';
+export * from './data/data.power';
+export * from './data/data.power-avg';
+export * from './data/data.power-left';
+export * from './data/data.power-max';
+export * from './data/data.power-min';
+export * from './data/data.power-right';
+export * from './data/data.recovery-time';
+export * from './data/data.right-balance';
+export * from './data/data.rpe';
+export * from './data/data.sea-level-pressure';
+export * from './data/data.speed';
+export * from './data/data.speed-avg';
+export * from './data/data.speed-max';
+export * from './data/data.speed-min';
+export * from './data/data.start-position';
+export * from './data/data.store';
+export * from './data/data.stryd-altitude';
+export * from './data/data.stryd-distance';
+export * from './data/data.stryd-speed';
+export * from './data/data.swim-pace';
+export * from './data/data.swim-pace-avg';
+export * from './data/data.swim-pace-max';
+export * from './data/data.temperature';
+export * from './data/data.temperature-avg';
+export * from './data/data.temperature-max';
+export * from './data/data.temperature-min';
+export * from './data/data.vertical-speed';
+export * from './data/data.vertical-speed-avg';
+export * from './data/data.vo2-max';
+export * from './data/ibi/data.ibi';
+export * from './events/adapters/exporters/exporter.gpx';
+export * from './events/adapters/exporters/exporter.json';
+export * from './events/adapters/importers/fit/importer.fit';
+export * from './events/adapters/importers/gpx/importer.gpx';
+export * from './events/adapters/importers/json/importer.json';
+export * from './events/adapters/importers/suunto/importer.suunto.json';
+export * from './events/adapters/importers/suunto/importer.suunto.sml';
+export * from './events/adapters/importers/tcx/importer.tcx';
+export * from './events/event.interface';
+export * from './events/event.json.interface';
+export * from './events/utilities/activity.utilities';
+export * from './events/utilities/event.utilities';
+export * from './events/utilities/helpers';
+export * from './geodesy/adapters/geolib.adapter';
+export * from './laps/lap.interface';
+export * from './laps/lap.types';
+export * from './meta-data/event-meta-data.interface';
+export * from './meta-data/meta-data';
+export * from './privacy/privacy.class.interface';
+export * from './service-tokens/oauth1-service-token.interface';
+export * from './service-tokens/oauth2-service-token.interface';
+export * from './stats/stats.class.interface';
+export * from './streams/compressed.stream.interface';
+export * from './streams/stream';
+export * from './streams/stream.interface';
+export * from './tiles/tile.settings.interface';
+export * from './users/settings/dashboard/user.dashboard.settings.interface';
+export * from './users/settings/user.app.settings.interface';
+export * from './users/settings/user.chart.settings.interface';
+export * from './users/settings/user.map.settings.interface';
+export * from './users/settings/user.my-tracks.settings.interface';
+export * from './users/settings/user.settings.interface';
+export * from './users/settings/user.summaries.settings.interface';
+export * from './users/settings/user.unit.settings.interface';
+export * from './users/user';
+export * from './users/user.export-to-csv.settings.interface';
+export * from './users/user.service.meta.interface';