@sports-alliance/sports-lib 7.0.8 → 7.0.9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sports-alliance/sports-lib",
-  "version": "7.0.8",
+  "version": "7.0.9",
   "description": "A Library to for importing / exporting and processing GPX, TCX, FIT and JSON files from services such as Strava, Movescount, Garmin, Polar etc",
   "keywords": [
     "gpx",
@@ -32,7 +32,7 @@
     }
   },
   "scripts": {
-    "build": "npm run clean && tsc --project tsconfig.esm.json && tsc --project tsconfig.cjs.json && echo '{\"type\": \"commonjs\"}' > lib/cjs/package.json && echo '{\"type\": \"module\"}' > lib/esm/package.json",
+    "build": "npm run clean && tsc --emitDeclarationOnly --outDir lib/esm --project tsconfig.esm.json && tsc --project tsconfig.cjs.json && esbuild src/index.ts --bundle --format=esm --outfile=lib/esm/index.js --platform=node --external:fast-xml-parser --external:fit-file-parser --external:geolib --external:gpx-builder --external:kalmanjs --external:lowpassf --external:moving-median --external:xmldom --external:tslib --external:@garmin/fitsdk && echo '{\"type\": \"commonjs\"}' > lib/cjs/package.json && echo '{\"type\": \"module\"}' > lib/esm/package.json",
     "watch": "npm run build -- --watch",
     "clean": "rimraf ./lib/",
     "generate:docs": "npm run build && typedoc --out docs --target es6 --theme minimal --mode file src",

package/lib/esm/activities/activity-parsing-options.js

@@ -1,19 +0,0 @@
-export class ActivityParsingOptions {
-    constructor(options) {
-        var _a, _b, _c;
-        this.streams = (_a = options.streams) !== null && _a !== void 0 ? _a : {
-            smooth: { altitudeSmooth: true, grade: true, gradeSmooth: true },
-            fixAbnormal: { speed: false }
-        };
-        this.maxActivityDurationDays = (_b = options.maxActivityDurationDays) !== null && _b !== void 0 ? _b : 14;
-        this.generateUnitStreams = (_c = options.generateUnitStreams) !== null && _c !== void 0 ? _c : true;
-    }
-}
-ActivityParsingOptions.DEFAULT = new ActivityParsingOptions({
-    streams: {
-        smooth: { altitudeSmooth: true, grade: true, gradeSmooth: true },
-        fixAbnormal: { speed: false }
-    },
-    maxActivityDurationDays: 14,
-    generateUnitStreams: true
-});

package/lib/esm/activities/activity.interface.js

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

package/lib/esm/activities/activity.js

@@ -1,281 +0,0 @@
-import { ActivityTypes } from './activity.types';
-import { DurationClassAbstract } from '../duration/duration.class.abstract';
-import { DataLatitudeDegrees } from '../data/data.latitude-degrees';
-import { DataLongitudeDegrees } from '../data/data.longitude-degrees';
-import { Stream } from '../streams/stream';
-import { isNumber } from '../events/utilities/helpers';
-import { DataPower } from '../data/data.power';
-import { DataStartEvent } from '../data/data.start-event';
-import { DataStopEvent } from '../data/data.stop-event';
-import { DataStopAllEvent } from '../data/data.stop-all-event';
-import { DataTime } from '../data/data.time';
-import { ActivityUtilities } from '../events/utilities/activity.utilities';
-import { DataDistance } from '../data/data.distance';
-import { DataDuration } from '../data/data.duration';
-import { DataRiderPositionChangeEvent } from '../data/data.rider-position-change-event';
-import { ActivityParsingOptions } from './activity-parsing-options';
-import { ParsingEventLibError } from '../errors/parsing-event-lib.error';
-import { DurationExceededEventLibError } from '../errors/duration-exceeded-event-lib.error';
-export class Activity extends DurationClassAbstract {
-    constructor(startDate, endDate, type, creator, options = ActivityParsingOptions.DEFAULT, name = '') {
-        super(startDate, endDate);
-        this.intensityZones = []; // maybe rename
-        this.laps = [];
-        this.streams = [];
-        this.events = [];
-        if (!startDate || !endDate) {
-            throw new ParsingEventLibError('Start and end dates are required');
-        }
-        if (endDate < startDate) {
-            throw new ParsingEventLibError('Activity end date is before the start date and that is not acceptable');
-        }
-        if (+endDate - +startDate > options.maxActivityDurationDays * 24 * 60 * 60 * 1000) {
-            throw new DurationExceededEventLibError(`Activity duration exceeds ${options.maxActivityDurationDays} days. That is not supported`);
-        }
-        this.type = type;
-        this.creator = creator;
-        this.parseOptions = options;
-        this.name = name;
-    }
-    createStream(type) {
-        const stream = new Stream(type, Array(ActivityUtilities.getDataLength(this.startDate, this.endDate)).fill(null));
-        return stream;
-    }
-    addDataToStream(type, date, value) {
-        this.getStreamData(type)[this.getDateIndex(date)] = value;
-        return this;
-    }
-    addStream(stream) {
-        if (this.streams.find(activityStream => activityStream.type === stream.type)) {
-            throw new Error(`Duplicate type of stream when adding ${stream.type} to activity ${this.getID()} `);
-        }
-        this.streams.push(stream);
-        return this;
-    }
-    clearStreams() {
-        this.streams = [];
-        return this;
-    }
-    removeStream(streamType) {
-        const stream = streamType instanceof Stream ? streamType : this.getStream(streamType);
-        this.streams = this.streams.filter(activityStream => stream !== activityStream);
-        return this;
-    }
-    replaceStreamData(streamType, data) {
-        this.removeStream(streamType);
-        this.addStream(this.createStream(streamType).setData(data));
-        return this;
-    }
-    addStreams(streams) {
-        this.streams.push(...streams);
-        return this;
-    }
-    getAllStreams() {
-        return this.streams;
-    }
-    // @todo needs more logic improvement and transparency
-    getAllExportableStreams() {
-        return this.getAllStreams().filter(stream => stream.isExportable());
-    }
-    hasStreamData(streamType, startDate, endDate) {
-        try {
-            this.getStreamData(streamType, startDate, endDate);
-        }
-        catch (e) {
-            return false;
-        }
-        return true;
-    }
-    hasPositionData(startDate, endDate) {
-        return (this.hasStreamData(DataLatitudeDegrees.type, startDate, endDate) &&
-            this.hasStreamData(DataLongitudeDegrees.type, startDate, endDate));
-    }
-    isTrainer() {
-        return Activity.TRAINER_TYPES.indexOf(this.type) !== -1;
-    }
-    hasPowerMeter() {
-        return this.hasStreamData(DataPower.type);
-    }
-    getStream(streamType) {
-        const find = this.streams.find(stream => stream.type === streamType);
-        if (!find) {
-            throw Error(`No stream found with type ${streamType} `);
-        }
-        return find;
-    }
-    getStreamData(streamType, startDate, endDate) {
-        const stream = streamType instanceof Stream ? streamType : this.getStream(streamType);
-        if (!startDate && !endDate) {
-            return stream.getData();
-        }
-        if (startDate && endDate) {
-            return stream
-                .getData()
-                .filter((value, index) => new Date(this.startDate.getTime() + index * 1000) <= endDate)
-                .filter((value, index) => new Date(this.startDate.getTime() + index * 1000) >= startDate);
-        }
-        if (startDate) {
-            return stream.getData().filter((value, index) => new Date(this.startDate.getTime() + index * 1000) > startDate);
-        }
-        if (endDate) {
-            return stream.getData().filter((value, index) => new Date(this.startDate.getTime() + index * 1000) < endDate);
-        }
-        return [];
-    }
-    // @todo see how this fits with the filtering on the stream class
-    /**
-     * Gets the data array of an activity stream excluding the non numeric ones
-     * @todo include strings and all data abstract types
-     * @param streamType
-     * @param startDate
-     * @param endDate
-     */
-    getSquashedStreamData(streamType, startDate, endDate) {
-        return this.getStreamData(streamType, startDate, endDate).filter(data => isNumber(data));
-    }
-    getPositionData(startDate, endDate) {
-        const latitudeStreamData = this.getStreamData(DataLatitudeDegrees.type, startDate, endDate);
-        const longitudeStreamData = this.getStreamData(DataLongitudeDegrees.type, startDate, endDate);
-        return latitudeStreamData.reduce((positionArray, value, index, array) => {
-            const currentLatitude = latitudeStreamData[index];
-            const currentLongitude = longitudeStreamData[index];
-            if (!isNumber(currentLatitude) || !isNumber(currentLongitude)) {
-                positionArray.push(null);
-                return positionArray;
-            }
-            positionArray.push({
-                latitudeDegrees: currentLatitude,
-                longitudeDegrees: currentLongitude
-            });
-            return positionArray;
-        }, []);
-    }
-    getSquashedPositionData(startDate, endDate) {
-        return this.getPositionData(startDate, endDate).filter(data => data !== null);
-    }
-    getStreamDataTypesBasedOnDataType(streamTypeToBaseOn, streamTypes) {
-        return ActivityUtilities.getStreamDataTypesBasedOnDataType(this.getStream(streamTypeToBaseOn), this.getAllStreams()
-            .filter(stream => stream.type !== streamTypeToBaseOn)
-            .filter(stream => streamTypes.indexOf(stream.type) !== -1));
-    }
-    getStreamDataTypesBasedOnTime(streamTypes) {
-        return ActivityUtilities.getStreamDataTypesBasedOnTime(this.startDate, this.endDate, !streamTypes
-            ? this.getAllStreams()
-            : this.getAllStreams().filter(stream => streamTypes.indexOf(stream.type) !== -1));
-    }
-    getStreamDataByTime(streamType, filterNull = false, filterInfinity = false) {
-        return this.getStream(streamType).getStreamDataByTime(this.startDate, filterNull, filterInfinity);
-    }
-    getStreamDataByDuration(streamType, filterNull = false, filterInfinity = false) {
-        return this.getStream(streamType).getStreamDataByDuration(0, filterNull, filterInfinity);
-    }
-    addLap(lap) {
-        this.laps.push(lap);
-        return this;
-    }
-    getLaps(activity) {
-        return this.laps;
-    }
-    hasLaps() {
-        return this.laps.length > 0;
-    }
-    getAllEvents() {
-        return this.events;
-    }
-    getStartEvents() {
-        return this.events.filter(event => event instanceof DataStartEvent);
-    }
-    getStopEvents() {
-        return this.events.filter(event => event instanceof DataStopEvent);
-    }
-    getStopAllEvents() {
-        return this.events.filter(event => event instanceof DataStopAllEvent);
-    }
-    getAllRiderPositionChangeEvents() {
-        return this.events.filter(event => event instanceof DataRiderPositionChangeEvent);
-    }
-    addEvent(event) {
-        this.events.push(event);
-        return this;
-    }
-    setAllEvents(events) {
-        this.events = events;
-        return this;
-    }
-    generateTimeStream(streamTypes = []) {
-        const timeStream = this.createStream(DataTime.type);
-        let streams = this.getAllStreams();
-        if (streamTypes.length) {
-            streams = streams.filter(stream => streamTypes.indexOf(stream.type) !== -1);
-        }
-        streams.forEach(stream => {
-            this.getStreamDataByDuration(stream.type, true, false).forEach((data) => {
-                timeStream.getData()[data.time / 1000] = data.time / 1000;
-            });
-        });
-        return timeStream;
-    }
-    generateDurationStream(streamTypes = []) {
-        const timeStream = this.generateTimeStream(streamTypes);
-        const durationStream = this.createStream(DataDuration.type);
-        durationStream.setData(timeStream.getData());
-        return durationStream;
-    }
-    getDateIndex(date) {
-        // @todo ceil vs floor (still debatable)
-        return Math.round((+date - +this.startDate) / 1000);
-    }
-    toJSON() {
-        const intensityZones = [];
-        this.intensityZones.forEach((value) => {
-            intensityZones.push(value.toJSON());
-        });
-        const stats = {};
-        this.stats.forEach((value, key) => {
-            Object.assign(stats, value.toJSON());
-        });
-        // Fetch streams from activity
-        const streams = this.getAllStreams().reduce((streams, stream) => {
-            streams.push(stream.toJSON());
-            return streams;
-        }, []);
-        // Now append missing time stream to JSON export
-        if (streams === null || streams === void 0 ? void 0 : streams.length) {
-            const stream = streams.find(s => s.type === DataDistance.type) || streams[0];
-            const timeStream = this.generateTimeStream([stream.type]).toJSON();
-            streams.push(timeStream);
-        }
-        return {
-            name: this.name || null,
-            startDate: this.startDate.getTime(),
-            endDate: this.endDate.getTime(),
-            type: this.type,
-            creator: this.creator.toJSON(),
-            intensityZones: intensityZones,
-            powerMeter: this.hasPowerMeter(),
-            trainer: this.isTrainer(),
-            stats: stats,
-            streams: streams,
-            events: this.getAllEvents().reduce((eventsArray, event) => {
-                eventsArray.push(event.toJSON());
-                return eventsArray;
-            }, []),
-            laps: this.getLaps().reduce((jsonLapsArray, lap) => {
-                jsonLapsArray.push(lap.toJSON(this));
-                return jsonLapsArray;
-            }, [])
-        };
-    }
-}
-Activity.TRAINER_TYPES = [
-    ActivityTypes.VirtualRun,
-    ActivityTypes.VirtualCycling,
-    ActivityTypes.Treadmill,
-    ActivityTypes.IndoorCycling,
-    ActivityTypes.IndoorRunning,
-    ActivityTypes.IndoorRowing,
-    ActivityTypes.Crosstrainer,
-    ActivityTypes.EllipticalTrainer,
-    ActivityTypes.FitnessEquipment,
-    ActivityTypes.StairStepper
-];

package/lib/esm/activities/activity.json.interface.js

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

package/lib/esm/activities/activity.spec.js

@@ -1,348 +0,0 @@
-import { Activity } from './activity';
-import { DataHeartRate } from '../data/data.heart-rate';
-import { DataAltitude } from '../data/data.altitude';
-import { ActivityTypes } from './activity.types';
-import { Creator } from '../creators/creator';
-import { Stream } from '../streams/stream';
-import { DataDistance } from '../data/data.distance';
-import { DataStopEvent } from '../data/data.stop-event';
-import { DataStartEvent } from '../data/data.start-event';
-import { DataStopAllEvent } from '../data/data.stop-all-event';
-describe('Activity', () => {
-    let activity;
-    beforeEach(() => {
-        // New activity that ends +6m and is 10s duration from new Date(0)
-        activity = new Activity(new Date(0), new Date(new Date(0).getTime() + 10000), ActivityTypes.Running, new Creator('Test'));
-        activity.setID('123');
-    });
-    it('should get streams based on time', () => {
-        activity.addStream(new Stream(DataAltitude.type, [200, 500, null, 502, null, 600, 700]));
-        activity.addStream(new Stream(DataDistance.type, [0, 10, 20, 30, 40, 50, 60]));
-        expect(activity.getStreamDataTypesBasedOnTime([DataAltitude.type])).toEqual({
-            0: {
-                Altitude: 200
-            },
-            1000: {
-                Altitude: 500
-            },
-            3000: {
-                Altitude: 502
-            },
-            5000: {
-                Altitude: 600
-            },
-            6000: {
-                Altitude: 700
-            }
-        });
-        expect(activity.getStreamDataTypesBasedOnTime([DataDistance.type])).toEqual({
-            0: { Distance: 0 },
-            1000: { Distance: 10 },
-            2000: { Distance: 20 },
-            3000: { Distance: 30 },
-            4000: { Distance: 40 },
-            5000: { Distance: 50 },
-            6000: { Distance: 60 }
-        });
-        expect(activity.getStreamDataTypesBasedOnTime([DataAltitude.type, DataDistance.type])).toEqual({
-            0: {
-                Altitude: 200,
-                Distance: 0
-            },
-            1000: { Altitude: 500, Distance: 10 },
-            2000: { Distance: 20 },
-            3000: { Altitude: 502, Distance: 30 },
-            4000: { Distance: 40 },
-            5000: { Altitude: 600, Distance: 50 },
-            6000: { Altitude: 700, Distance: 60 }
-        });
-    });
-    it('should get streams based on another stream', () => {
-        activity.addStream(new Stream(DataAltitude.type, [200, 500, null, 502, null, 500, 700]));
-        activity.addStream(new Stream(DataHeartRate.type, [60, 70, 80, null, null, null, 120]));
-        activity.addStream(new Stream(DataDistance.type, [0, 10, 20, 30, 40, 50, 60]));
-        expect(activity.getStreamDataTypesBasedOnDataType(DataDistance.type, [DataAltitude.type])).toEqual([
-            {
-                Altitude: 200,
-                Distance: 0
-            },
-            {
-                Altitude: 500,
-                Distance: 10
-            },
-            {
-                Altitude: null,
-                Distance: 20
-            },
-            {
-                Altitude: 502,
-                Distance: 30
-            },
-            {
-                Altitude: null,
-                Distance: 40
-            },
-            {
-                Altitude: 500,
-                Distance: 50
-            },
-            {
-                Altitude: 700,
-                Distance: 60
-            }
-        ]);
-        expect(activity.getStreamDataTypesBasedOnDataType(DataDistance.type, [DataHeartRate.type, DataAltitude.type])).toEqual([
-            {
-                Altitude: 200,
-                Distance: 0,
-                'Heart Rate': 60
-            },
-            {
-                Altitude: 500,
-                Distance: 10,
-                'Heart Rate': 70
-            },
-            {
-                Altitude: null,
-                Distance: 20,
-                'Heart Rate': 80
-            },
-            {
-                Altitude: 502,
-                Distance: 30,
-                'Heart Rate': null
-            },
-            {
-                Altitude: null,
-                Distance: 40,
-                'Heart Rate': null
-            },
-            {
-                Altitude: 500,
-                Distance: 50,
-                'Heart Rate': null
-            },
-            {
-                Altitude: 700,
-                Distance: 60,
-                'Heart Rate': 120
-            }
-        ]);
-        expect(activity.getStreamDataTypesBasedOnDataType(DataAltitude.type, [DataDistance.type, DataHeartRate.type])).toEqual([
-            {
-                Altitude: 200,
-                Distance: 0,
-                'Heart Rate': 60
-            },
-            {
-                Altitude: 500,
-                Distance: 10,
-                'Heart Rate': 70
-            },
-            {
-                Altitude: 502,
-                Distance: 30,
-                'Heart Rate': null
-            },
-            {
-                Altitude: 500,
-                Distance: 50,
-                'Heart Rate': null
-            },
-            {
-                Altitude: 700,
-                Distance: 60,
-                'Heart Rate': 120
-            }
-        ]);
-    });
-    describe('Trainer flagging', () => {
-        it('should flag activities to be performed on a trainer', () => {
-            // Given
-            const types = [
-                ActivityTypes.VirtualRun,
-                ActivityTypes.VirtualCycling,
-                ActivityTypes.Treadmill,
-                ActivityTypes.IndoorCycling,
-                ActivityTypes.IndoorRunning,
-                ActivityTypes.IndoorRowing,
-                ActivityTypes.Crosstrainer,
-                ActivityTypes.EllipticalTrainer,
-                ActivityTypes.FitnessEquipment,
-                ActivityTypes.StairStepper
-            ];
-            // When, Then
-            types.forEach(type => {
-                const fakeActivity = new Activity(new Date(), new Date(), type, new Creator('John doo'));
-                expect(fakeActivity.isTrainer()).toBeTruthy();
-            });
-        });
-        it('should NOT flag activities to be performed on a trainer', () => {
-            // Given
-            const types = [
-                ActivityTypes.Aerobics,
-                ActivityTypes.AlpineSkiing,
-                ActivityTypes.AmericanFootball,
-                ActivityTypes.Aquathlon,
-                ActivityTypes.BackcountrySkiing,
-                ActivityTypes.Badminton,
-                ActivityTypes.Baseball,
-                ActivityTypes.Basketball,
-                ActivityTypes.Boxing,
-                ActivityTypes.Canoeing,
-                ActivityTypes.CardioTraining,
-                ActivityTypes.Climbing,
-                ActivityTypes.Combat,
-                ActivityTypes.Cricket,
-                ActivityTypes.Crossfit,
-                ActivityTypes.CrosscountrySkiing,
-                ActivityTypes.Cycling,
-                ActivityTypes.Dancing,
-                ActivityTypes.Diving,
-                ActivityTypes.DownhillSkiing,
-                ActivityTypes.Driving,
-                ActivityTypes.Duathlon,
-                ActivityTypes.EBikeRide,
-                ActivityTypes.Fishing,
-                ActivityTypes.FlexibilityTraining,
-                ActivityTypes.FloorClimbing,
-                ActivityTypes.Floorball,
-                ActivityTypes.Flying,
-                ActivityTypes.Football,
-                ActivityTypes.FreeDiving,
-                ActivityTypes.Frisbee,
-                ActivityTypes.Generic,
-                ActivityTypes.Golf,
-                ActivityTypes.Gymnastics,
-                ActivityTypes.Handcycle,
-                ActivityTypes.Handball,
-                ActivityTypes.HangGliding,
-                ActivityTypes.Hiking,
-                ActivityTypes.HorsebackRiding,
-                ActivityTypes.IceHockey,
-                ActivityTypes.IceSkating,
-                ActivityTypes.IndoorTraining,
-                ActivityTypes.InlineSkating,
-                ActivityTypes.Kayaking,
-                ActivityTypes.Kettlebell,
-                ActivityTypes.Kitesurfing,
-                ActivityTypes.Motorcycling,
-                ActivityTypes.Motorsports,
-                ActivityTypes.MountainBiking,
-                ActivityTypes.Mountaineering,
-                ActivityTypes.NordicWalking,
-                ActivityTypes.OpenWaterSwimming,
-                ActivityTypes.Orienteering,
-                ActivityTypes.Paddling,
-                ActivityTypes.Paragliding,
-                ActivityTypes.Rafting,
-                ActivityTypes.RockClimbing,
-                ActivityTypes.RollerSki,
-                ActivityTypes.Rowing,
-                ActivityTypes.Rugby,
-                ActivityTypes.Running,
-                ActivityTypes.Sailing,
-                ActivityTypes.ScubaDiving,
-                ActivityTypes.Skating,
-                ActivityTypes.SkiTouring,
-                ActivityTypes.SkyDiving,
-                ActivityTypes.Snorkeling,
-                ActivityTypes.Snowboarding,
-                ActivityTypes.Snowmobiling,
-                ActivityTypes.Snowshoeing,
-                ActivityTypes.Soccer,
-                ActivityTypes.Softball,
-                ActivityTypes.Squash,
-                ActivityTypes.StandUpPaddling,
-                ActivityTypes.StrengthTraining,
-                ActivityTypes.Stretching,
-                ActivityTypes.Surfing,
-                ActivityTypes.Swimming,
-                ActivityTypes.Swimrun,
-                ActivityTypes.TableTennis,
-                ActivityTypes.Tactical,
-                ActivityTypes.TelemarkSkiing,
-                ActivityTypes.Tennis,
-                ActivityTypes.TrackAndField,
-                ActivityTypes.TrailRunning,
-                ActivityTypes.Training,
-                ActivityTypes.Trekking,
-                ActivityTypes.Triathlon,
-                ActivityTypes.UnknownSport,
-                ActivityTypes.Velomobile,
-                ActivityTypes.Volleyball,
-                ActivityTypes.Wakeboarding,
-                ActivityTypes.Walking,
-                ActivityTypes.WaterSkiing,
-                ActivityTypes.WeightTraining,
-                ActivityTypes.Wheelchair,
-                ActivityTypes.Windsurfing,
-                ActivityTypes.Workout,
-                ActivityTypes.Yoga,
-                ActivityTypes.YogaPilates
-            ];
-            // When, Then
-            types.forEach(type => {
-                const fakeActivity = new Activity(new Date(), new Date(), type, new Creator('John doo'));
-                expect(fakeActivity.isTrainer()).toBeFalsy();
-            });
-        });
-    });
-    it('should get the time stream', () => {
-        activity.addStreams([
-            //                                   0     1    2       3       4         5    6     7    8 9 and 10 are not set
-            new Stream(DataAltitude.type, [200, null, 502, Infinity, -Infinity, NaN, 0]),
-            new Stream(DataDistance.type, [0, null, 600, 700, 800, null, NaN, 900, Infinity])
-        ]);
-        expect(activity.generateTimeStream().getData()).toEqual([0, null, 2, 3, 4, null, 6, 7, 8, null, null]);
-        expect(activity.generateTimeStream().getData(true)).toEqual([0, 2, 3, 4, 6, 7, 8]);
-        expect(activity.generateTimeStream().getData(false)).toEqual([0, null, 2, 3, 4, null, 6, 7, 8, null, null]);
-    });
-    it('should set the correct sample sizes', () => {
-        const stream = activity.createStream(DataAltitude.type);
-        expect(stream.getData().length).toBe(11);
-    });
-    it('should get and set the correct sample keys and ', () => {
-        const stream = activity.createStream(DataAltitude.type);
-        activity.addStream(stream);
-        activity.addDataToStream(DataAltitude.type, new Date(0), 0);
-        activity.addDataToStream(DataAltitude.type, new Date(500), 5);
-        activity.addDataToStream(DataAltitude.type, new Date(1040), 10);
-        activity.addDataToStream(DataAltitude.type, new Date(2010), 20);
-        activity.addDataToStream(DataAltitude.type, new Date(2060), 30);
-        activity.addDataToStream(DataAltitude.type, new Date(2080), 35);
-        activity.addDataToStream(DataAltitude.type, new Date(3000), 40);
-        activity.addDataToStream(DataAltitude.type, new Date(4000), 50);
-        activity.addDataToStream(DataAltitude.type, new Date(5000), 60);
-        activity.addDataToStream(DataAltitude.type, new Date(6300), 70);
-        activity.addDataToStream(DataAltitude.type, new Date(7000), 80);
-        activity.addDataToStream(DataAltitude.type, new Date(8000), 90);
-        activity.addDataToStream(DataAltitude.type, new Date(9000), 100);
-        activity.addDataToStream(DataAltitude.type, new Date(10000), 110);
-        expect(stream.getData()).toEqual([0, 10, 35, 40, 50, 60, 70, 80, 90, 100, 110]);
-    });
-    it('should get events correctly', () => {
-        activity.addEvent(new DataStopEvent(1));
-        activity.addEvent(new DataStopEvent(1));
-        activity.addEvent(new DataStartEvent(1));
-        activity.addEvent(new DataStartEvent(1));
-        activity.addEvent(new DataStopAllEvent(1));
-        expect(activity.getAllEvents().length).toBe(5);
-        expect(activity.getStartEvents().length).toBe(2);
-        expect(activity.getStopEvents().length).toBe(2);
-        expect(activity.getStopAllEvents().length).toBe(1);
-    });
-    it('should set all events', () => {
-        activity.setAllEvents([
-            new DataStopEvent(1),
-            new DataStopEvent(1),
-            new DataStartEvent(1),
-            new DataStartEvent(1),
-            new DataStopAllEvent(1)
-        ]);
-        expect(activity.getAllEvents().length).toBe(5);
-        expect(activity.getStartEvents().length).toBe(2);
-        expect(activity.getStopEvents().length).toBe(2);
-        expect(activity.getStopAllEvents().length).toBe(1);
-    });
-});