@sports-alliance/sports-lib 7.0.8 → 7.0.9

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

@@ -1,373 +0,0 @@
-import { Event } from '../event';
-import { DataSpeedMaxKilometersPerHour } from '../../data/data.speed-max';
-import { Activity } from '../../activities/activity';
-import { ActivityParsingOptions } from '../../activities/activity-parsing-options';
-import { DataHeartRate } from '../../data/data.heart-rate';
-import { DataAltitude } from '../../data/data.altitude';
-import { DataDistance, DataDistanceMiles } 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';
-import { DataPace, DataPaceMinutesPerMile } from '../../data/data.pace';
-import { DataSpeedKilometersPerHour } from '../../data/data.speed';
-import { DataSwimPace } from '../../data/data.swim-pace';
-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();
-        });
-    });
-    describe('createUnitStreamsFromStreams', () => {
-        it('should include derived types and unit variants by default', () => {
-            const streams = [new Stream(DataSpeed.type, [10, 20])];
-            const result = ActivityUtilities.createUnitStreamsFromStreams(streams, ActivityTypes.Running);
-            const paceStream = result.find(s => s.type === DataPaceMinutesPerMile.type);
-            const kmhStream = result.find(s => s.type === DataSpeedKilometersPerHour.type);
-            expect(paceStream).toBeDefined();
-            expect(kmhStream).toBeDefined();
-        });
-        it('should exclude derived types when includeDerivedTypes is false', () => {
-            const streams = [new Stream(DataSpeed.type, [10, 20])];
-            const result = ActivityUtilities.createUnitStreamsFromStreams(streams, ActivityTypes.Running, undefined, {
-                includeDerivedTypes: false,
-                includeUnitVariants: true
-            });
-            const paceStream = result.find(s => s.type === DataPaceMinutesPerMile.type);
-            const kmhStream = result.find(s => s.type === DataSpeedKilometersPerHour.type);
-            expect(paceStream).toBeUndefined();
-            expect(kmhStream).toBeDefined();
-        });
-        it('should exclude unit variants when includeUnitVariants is false', () => {
-            const streams = [new Stream(DataSpeed.type, [10, 20])];
-            // We pass DataPace.type in unitStreamTypes so we can check if the derived base stream is present
-            const result = ActivityUtilities.createUnitStreamsFromStreams(streams, ActivityTypes.Running, [DataPace.type], {
-                includeDerivedTypes: true,
-                includeUnitVariants: false
-            });
-            const paceStream = result.find(s => s.type === DataPace.type);
-            const paceUnitStream = result.find(s => s.type === DataPaceMinutesPerMile.type);
-            expect(paceStream).toBeDefined(); // Derived type should be there
-            expect(paceUnitStream).toBeUndefined(); // Unit variant should be gone
-        });
-        it('should exclude both derived types and unit variants', () => {
-            const streams = [new Stream(DataSpeed.type, [10, 20])];
-            const result = ActivityUtilities.createUnitStreamsFromStreams(streams, ActivityTypes.Running, [DataPace.type], {
-                includeDerivedTypes: false,
-                includeUnitVariants: false
-            });
-            const paceStream = result.find(s => s.type === DataPace.type);
-            const paceUnitStream = result.find(s => s.type === DataPaceMinutesPerMile.type);
-            expect(paceStream).toBeUndefined();
-            expect(paceUnitStream).toBeUndefined();
-        });
-    });
-    describe('generateMissingStreams', () => {
-        it('should generate unit streams when generateUnitStreams = true', () => {
-            const activity = new Activity(new Date(), new Date(), ActivityTypes.Running, new Creator('test'), new ActivityParsingOptions({ generateUnitStreams: true }));
-            // Add a speed stream
-            activity.addStream(new Stream(DataSpeed.type, [10, 20]));
-            ActivityUtilities.generateMissingStreams(activity);
-            // Should have generated "sister" types (e.g. Pace) and unit variants (e.g. Speed km/h)
-            expect(activity.hasStreamData(DataSpeedKilometersPerHour.type)).toBe(true);
-            expect(activity.hasStreamData(DataPaceMinutesPerMile.type)).toBe(true);
-        });
-        it('should NOT generate unit streams when generateUnitStreams = false', () => {
-            const activity = new Activity(new Date(), new Date(), ActivityTypes.Running, new Creator('test'));
-            // Mock parsing options
-            activity.parseOptions = {
-                streams: { smooth: {}, fixAbnormal: {} },
-                maxActivityDurationDays: 14,
-                generateUnitStreams: false
-            };
-            // Add a speed stream
-            activity.addStream(new Stream(DataSpeed.type, [10, 20]));
-            ActivityUtilities.generateMissingStreams(activity);
-            // Should NOT have generated unit variants
-            expect(activity.hasStreamData(DataSpeedKilometersPerHour.type)).toBe(false);
-            // It might still generate some "derived" streams depending on other flags, but our specific unit loop should be skipped
-            // The Pace stream comes from createUnitStreamsFromStreams too, so it should also be missing
-            expect(activity.hasStreamData(DataPaceMinutesPerMile.type)).toBe(false);
-        });
-    });
-    describe('generateMissingStreamsAndStatsForActivity', () => {
-        it('should generate unit STATS even if unit STREAMS are disabled', () => {
-            const activity = new Activity(new Date(), new Date(), ActivityTypes.Running, new Creator('test'));
-            activity.parseOptions = {
-                streams: { smooth: {}, fixAbnormal: {} },
-                maxActivityDurationDays: 14,
-                generateUnitStreams: false // DISABLE streams
-            };
-            // Add a speed stream [10 m/s, 20 m/s]
-            // Max speed = 20 m/s
-            activity.addStream(new Stream(DataSpeed.type, [10, 20]));
-            ActivityUtilities.generateMissingStreamsAndStatsForActivity(activity);
-            // 1. Verify Unit Streams are missing (as requested)
-            expect(activity.hasStreamData(DataSpeedKilometersPerHour.type)).toBe(false);
-            // 2. Verify Derived Base Streams are PRESENT (The fix)
-            expect(activity.hasStreamData(DataPace.type)).toBe(true);
-            // 3. Verify Stats are PRESENT (Safety Check)
-            // 20 m/s = 72 km/h
-            const allStats = Array.from(activity.getStats().values());
-            const speedMaxKmh = allStats.find(s => s.getType() === DataSpeedMaxKilometersPerHour.type);
-            expect(speedMaxKmh).toBeDefined();
-            expect(speedMaxKmh === null || speedMaxKmh === void 0 ? void 0 : speedMaxKmh.getValue()).toBe(72);
-        });
-        it('should generate DataSwimPace when generateUnitStreams = false for swimming', () => {
-            const activity = new Activity(new Date(), new Date(), ActivityTypes.Swimming, new Creator('test'));
-            activity.parseOptions = {
-                streams: { smooth: {}, fixAbnormal: {} },
-                maxActivityDurationDays: 14,
-                generateUnitStreams: false
-            };
-            activity.addStream(new Stream(DataSpeed.type, [1, 2])); // m/s
-            ActivityUtilities.generateMissingStreamsAndStatsForActivity(activity);
-            // Verify Unit Streams missing
-            expect(activity.hasStreamData(DataSpeedKilometersPerHour.type)).toBe(false);
-            // Verify Derived Base Stream (Swim Pace) IS present
-            expect(activity.hasStreamData(DataSwimPace.type)).toBe(true);
-        });
-        it('should generate DataDistanceMiles when generateUnitStreams = true', () => {
-            const activity = new Activity(new Date(), new Date(), ActivityTypes.Running, new Creator('test'), new ActivityParsingOptions({ generateUnitStreams: true }));
-            activity.addStream(new Stream(DataDistance.type, [1000, 2000]));
-            ActivityUtilities.generateMissingStreamsAndStatsForActivity(activity);
-            // Should generate miles
-            expect(activity.hasStreamData(DataDistanceMiles.type)).toBe(true);
-        });
-        it('should NOT generate DataDistanceMiles when generateUnitStreams = false', () => {
-            const activity = new Activity(new Date(), new Date(), ActivityTypes.Running, new Creator('test'));
-            activity.parseOptions = {
-                streams: { smooth: {}, fixAbnormal: {} },
-                maxActivityDurationDays: 14,
-                generateUnitStreams: false
-            };
-            activity.addStream(new Stream(DataDistance.type, [1000, 2000]));
-            ActivityUtilities.generateMissingStreamsAndStatsForActivity(activity);
-            // Should NOT generate miles
-            expect(activity.hasStreamData(DataDistanceMiles.type)).toBe(false);
-            // But base Distance should still be there (it was added manually)
-            expect(activity.hasStreamData(DataDistance.type)).toBe(true);
-        });
-        it('should generate unit streams for Mountain Biking using DataSpeed', () => {
-            const speedData = [10, 20, 30]; // m/s
-            const speedStream = new Stream(DataSpeed.type, speedData);
-            // Mountain Biking (defaults to Cycling group)
-            const unitStreams = ActivityUtilities.createUnitStreamsFromStreams([speedStream], ActivityTypes.MountainBiking, undefined, // Auto-detect all known unit types
-            { includeDerivedTypes: true, includeUnitVariants: true });
-            const kmhStream = unitStreams.find(s => s.type === 'Speed in kilometers per hour');
-            expect(kmhStream).toBeDefined();
-            if (kmhStream) {
-                expect(kmhStream.getData()[0]).toBeCloseTo(36, 1); // 10 m/s = 36 km/h
-            }
-        });
-    });
-});

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

@@ -1,57 +0,0 @@
-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.js

@@ -1,121 +0,0 @@
-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.js

@@ -1,93 +0,0 @@
-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);
-        });
-    });
-});