@sports-alliance/sports-lib 6.0.4 → 6.1.0

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

@@ -0,0 +1,1814 @@
+import { DataHeartRate } from '../../data/data.heart-rate';
+import { DataCadence } from '../../data/data.cadence';
+import { DataSpeed } from '../../data/data.speed';
+import { DataVerticalSpeed } from '../../data/data.vertical-speed';
+import { DataTemperature } from '../../data/data.temperature';
+import { DataAltitude } from '../../data/data.altitude';
+import { DataPower } from '../../data/data.power';
+import { DataAltitudeMax } from '../../data/data.altitude-max';
+import { DataAltitudeMin } from '../../data/data.altitude-min';
+import { DataAltitudeAvg } from '../../data/data.altitude-avg';
+import { DataHeartRateMax } from '../../data/data.heart-rate-max';
+import { DataHeartRateMin } from '../../data/data.heart-rate-min';
+import { DataHeartRateAvg } from '../../data/data.heart-rate-avg';
+import { DataCadenceMax } from '../../data/data.cadence-max';
+import { DataCadenceMin } from '../../data/data.cadence-min';
+import { DataCadenceAvg } from '../../data/data.cadence-avg';
+import { DataSpeedMax, DataSpeedMaxFeetPerMinute, DataSpeedMaxFeetPerSecond, DataSpeedMaxKilometersPerHour, DataSpeedMaxKnots, DataSpeedMaxMetersPerMinute, DataSpeedMaxMilesPerHour } from '../../data/data.speed-max';
+import { DataSpeedMin, DataSpeedMinFeetPerMinute, DataSpeedMinFeetPerSecond, DataSpeedMinKilometersPerHour, DataSpeedMinKnots, DataSpeedMinMetersPerMinute, DataSpeedMinMilesPerHour } from '../../data/data.speed-min';
+import { DataSpeedAvg, DataSpeedAvgFeetPerMinute, DataSpeedAvgFeetPerSecond, DataSpeedAvgKilometersPerHour, DataSpeedAvgKnots, DataSpeedAvgMetersPerMinute, DataSpeedAvgMilesPerHour } from '../../data/data.speed-avg';
+import { DataVerticalSpeedMax, DataVerticalSpeedMaxFeetPerHour, DataVerticalSpeedMaxFeetPerMinute, DataVerticalSpeedMaxFeetPerSecond, DataVerticalSpeedMaxKilometerPerHour, DataVerticalSpeedMaxMetersPerHour, DataVerticalSpeedMaxMetersPerMinute, DataVerticalSpeedMaxMilesPerHour } from '../../data/data.vertical-speed-max';
+import { DataVerticalSpeedMin, DataVerticalSpeedMinFeetPerHour, DataVerticalSpeedMinFeetPerMinute, DataVerticalSpeedMinFeetPerSecond, DataVerticalSpeedMinKilometerPerHour, DataVerticalSpeedMinMetersPerHour, DataVerticalSpeedMinMetersPerMinute, DataVerticalSpeedMinMilesPerHour } from '../../data/data.vertical-speed-min';
+import { DataVerticalSpeedAvg, DataVerticalSpeedAvgFeetPerHour, DataVerticalSpeedAvgFeetPerMinute, DataVerticalSpeedAvgFeetPerSecond, DataVerticalSpeedAvgKilometerPerHour, DataVerticalSpeedAvgMetersPerHour, DataVerticalSpeedAvgMetersPerMinute, DataVerticalSpeedAvgMilesPerHour } from '../../data/data.vertical-speed-avg';
+import { DataPowerMax } from '../../data/data.power-max';
+import { DataPowerMin } from '../../data/data.power-min';
+import { DataPowerAvg } from '../../data/data.power-avg';
+import { DataTemperatureMax } from '../../data/data.temperature-max';
+import { DataTemperatureMin } from '../../data/data.temperature-min';
+import { DataTemperatureAvg } from '../../data/data.temperature-avg';
+import { DataDistance } from '../../data/data.distance';
+import { DataDuration } from '../../data/data.duration';
+import { DataPause } from '../../data/data.pause';
+import { DataAscent } from '../../data/data.ascent';
+import { DataDescent } from '../../data/data.descent';
+import { GeoLibAdapter } from '../../geodesy/adapters/geolib.adapter';
+import { DataPaceMax, DataPaceMaxMinutesPerMile } from '../../data/data.pace-max';
+import { DataPace } from '../../data/data.pace';
+import { DataPaceMin, DataPaceMinMinutesPerMile } from '../../data/data.pace-min';
+import { DataPaceAvg, DataPaceAvgMinutesPerMile } from '../../data/data.pace-avg';
+import { DataBatteryCharge } from '../../data/data.battery-charge';
+import { DataBatteryConsumption } from '../../data/data.battery-consumption';
+import { DataBatteryLifeEstimation } from '../../data/data.battery-life-estimation';
+import { DataLatitudeDegrees } from '../../data/data.latitude-degrees';
+import { Stream } from '../../streams/stream';
+import { convertPaceToPaceInMinutesPerMile, convertSpeedToPace, convertSpeedToSpeedInFeetPerHour, convertSpeedToSpeedInFeetPerMinute, convertSpeedToSpeedInFeetPerSecond, convertSpeedToSpeedInKilometersPerHour, convertSpeedToSpeedInKnots, convertSpeedToSpeedInMetersPerHour, convertSpeedToSpeedInMetersPerMinute, convertSpeedToSpeedInMilesPerHour, convertSpeedToSwimPace, convertSwimPaceToSwimPacePer100Yard, isNumber, isNumberOrString, medianFilter, standardDeviation } from './helpers';
+import { DataLongitudeDegrees } from '../../data/data.longitude-degrees';
+import { DataEnergy } from '../../data/data.energy';
+import { DataStartAltitude } from '../../data/data.start-altitude';
+import { DataEndAltitude } from '../../data/data.end-altitude';
+import { DataSwimPaceMax, DataSwimPaceMaxMinutesPer100Yard } from '../../data/data.swim-pace-max';
+import { DataSwimPace } from '../../data/data.swim-pace';
+import { DataSwimPaceMin, DataSwimPaceMinMinutesPer100Yard } from '../../data/data.swim-pace-min';
+import { DataSwimPaceAvg, DataSwimPaceAvgMinutesPer100Yard } from '../../data/data.swim-pace-avg';
+import { DataFeeling } from '../../data/data.feeling';
+import { DataPowerLeft } from '../../data/data.power-left';
+import { DataRightBalance } from '../../data/data.right-balance';
+import { DataLeftBalance } from '../../data/data.left-balance';
+import { DataPowerRight } from '../../data/data.power-right';
+import { DataAirPowerMin } from '../../data/data.air-power-min';
+import { DataAirPower } from '../../data/data.air-power';
+import { DataAirPowerMax } from '../../data/data.air-power-max';
+import { DataAirPowerAvg } from '../../data/data.air-power-avg';
+import { DataRPE } from '../../data/data.rpe';
+import { DataGNSSDistance } from '../../data/data.gnss-distance';
+import { DataHeartRateZoneOneDuration } from '../../data/data.heart-rate-zone-one-duration';
+import { DataHeartRateZoneTwoDuration } from '../../data/data.heart-rate-zone-two-duration';
+import { DataHeartRateZoneThreeDuration } from '../../data/data.heart-rate-zone-three-duration';
+import { DataHeartRateZoneFourDuration } from '../../data/data.heart-rate-zone-four-duration';
+import { DataHeartRateZoneFiveDuration } from '../../data/data.heart-rate-zone-five-duration';
+import { DataPowerZoneOneDuration } from '../../data/data.power-zone-one-duration';
+import { DataPowerZoneTwoDuration } from '../../data/data.power-zone-two-duration';
+import { DataPowerZoneThreeDuration } from '../../data/data.power-zone-three-duration';
+import { DataPowerZoneFourDuration } from '../../data/data.power-zone-four-duration';
+import { DataPowerZoneFiveDuration } from '../../data/data.power-zone-five-duration';
+import { DataSpeedZoneOneDuration } from '../../data/data.speed-zone-one-duration';
+import { DataSpeedZoneTwoDuration } from '../../data/data.speed-zone-two-duration';
+import { DataSpeedZoneThreeDuration } from '../../data/data.speed-zone-three-duration';
+import { DataSpeedZoneFourDuration } from '../../data/data.speed-zone-four-duration';
+import { DataSpeedZoneFiveDuration } from '../../data/data.speed-zone-five-duration';
+import { DynamicDataLoader } from '../../data/data.store';
+import { DataStartPosition } from '../../data/data.start-position';
+import { DataEndPosition } from '../../data/data.end-position';
+import { DataGradeAdjustedSpeedAvg, DataGradeAdjustedSpeedAvgFeetPerMinute, DataGradeAdjustedSpeedAvgFeetPerSecond, DataGradeAdjustedSpeedAvgKilometersPerHour, DataGradeAdjustedSpeedAvgKnots, DataGradeAdjustedSpeedAvgMetersPerMinute, DataGradeAdjustedSpeedAvgMilesPerHour } from '../../data/data.grade-adjusted-speed-avg';
+import { DataGradeAdjustedPaceAvg, DataGradeAdjustedPaceAvgMinutesPerMile } from '../../data/data.grade-adjusted-pace-avg';
+import { DataGradeAdjustedSpeed } from '../../data/data.grade-adjusted-speed';
+import { DataGradeAdjustedPace } from '../../data/data.grade-adjusted-pace';
+import { DataGradeAdjustedSpeedMax, DataGradeAdjustedSpeedMaxFeetPerMinute, DataGradeAdjustedSpeedMaxFeetPerSecond, DataGradeAdjustedSpeedMaxKilometersPerHour, DataGradeAdjustedSpeedMaxKnots, DataGradeAdjustedSpeedMaxMetersPerMinute, DataGradeAdjustedSpeedMaxMilesPerHour } from '../../data/data.grade-adjusted-speed-max';
+import { DataGradeAdjustedSpeedMin, DataGradeAdjustedSpeedMinFeetPerMinute, DataGradeAdjustedSpeedMinFeetPerSecond, DataGradeAdjustedSpeedMinKilometersPerHour, DataGradeAdjustedSpeedMinKnots, DataGradeAdjustedSpeedMinMetersPerMinute, DataGradeAdjustedSpeedMinMilesPerHour } from '../../data/data.grade-adjusted-speed-min';
+import { DataGradeAdjustedPaceMax, DataGradeAdjustedPaceMaxMinutesPerMile } from '../../data/data.grade-adjusted-pace-max';
+import { DataGradeAdjustedPaceMin, DataGradeAdjustedPaceMinMinutesPerMile } from '../../data/data.grade-adjusted-pace-min';
+import { DataGrade } from '../../data/data.grade';
+import { ActivityTypeGroups, ActivityTypes, ActivityTypesHelper, ActivityTypesMoving } from '../../activities/activity.types';
+import { DataMovingTime } from '../../data/data.moving-time';
+import { DataTimerTime } from '../../data/data.timer-time';
+import { DataAltitudeSmooth } from '../../data/data.altitude-smooth';
+import { DataGradeSmooth } from '../../data/data.grade-smooth';
+import { DataSWOLF25m } from '../../data/data.swolf-25m';
+import { DataSWOLF50m } from '../../data/data.swolf-50m';
+import { DataStanceTimeBalanceLeft } from '../../data/data-stance-time-balance-left';
+import { DataStanceTimeBalanceRight } from '../../data/data-stance-time-balance-right';
+import { LowPassFilter } from './grade-calculator/low-pass-filter';
+import { DataPowerNormalized } from '../../data/data.power-normalized';
+import { DataPowerWork } from '../../data/data.power-work';
+import { GradeCalculator } from './grade-calculator/grade-calculator';
+const KalmanFilter = require('kalmanjs');
+/* Configure filtering values */
+// Altitude stream
+const ALTITUDE_SPIKES_FILTER_WIN = 3;
+// Fix abnormal streams
+const SPEED_STREAM_STD_DEV_THRESHOLD_DEFAULT = 25 / 3.6; // Kph to mps
+const SPEED_STREAM_STD_DEV_THRESHOLD_MAP = new Map([
+    [ActivityTypeGroups.Running, 15 / 3.6],
+    [ActivityTypeGroups.Cycling, 27 / 3.6],
+    [ActivityTypeGroups.Swimming, 5 / 3.6] // kph to m/s
+]);
+export class ActivityUtilities {
+    /**
+     * Provide average from laps a given stat type
+     */
+    static getDataTypeAvgFromLaps(activity, statType, filterOver) {
+        const data = activity
+            .getLaps()
+            .map(lap => { var _a; return (_a = lap.getStat(statType)) === null || _a === void 0 ? void 0 : _a.getValue(); })
+            .filter(d => Number.isFinite(d) && (Number.isFinite(filterOver) ? d > filterOver : true));
+        if (data.length > 0) {
+            return this.getAverage(data);
+        }
+        return null;
+    }
+    /**
+     * Provide average of a given stream type
+     */
+    static getDataTypeAvg(activity, streamType, startDate, endDate, filterOver) {
+        const data = (activity
+            .getSquashedStreamData(streamType, startDate, endDate)
+            .filter(streamData => streamData !== Infinity &&
+            streamData !== -Infinity &&
+            (Number.isFinite(filterOver) ? streamData > filterOver : true)));
+        return this.getAverage(data);
+    }
+    static round(value, decimals = 0) {
+        const decimalsFactor = Math.pow(10, decimals);
+        return Math.round(value * decimalsFactor) / decimalsFactor;
+    }
+    static getAverage(data) {
+        return this.getSum(data) / data.length;
+    }
+    static getSum(data) {
+        return data.reduce((sumbuff, value) => {
+            sumbuff += value;
+            return sumbuff;
+        }, 0);
+    }
+    static getDataTypeMax(activity, streamType, startDate, endDate) {
+        return this.getActivityDataTypeMinOrMax(activity, streamType, true, startDate, endDate);
+    }
+    static getDataTypeMin(activity, streamType, startDate, endDate, filterOver) {
+        return this.getActivityDataTypeMinOrMax(activity, streamType, false, startDate, endDate, filterOver);
+    }
+    static getDataTypeMinToMaxDifference(activity, streamType, startDate, endDate) {
+        return (this.getDataTypeMax(activity, streamType, startDate, endDate) -
+            this.getDataTypeMin(activity, streamType, startDate, endDate));
+    }
+    static getDataTypeFirst(activity, streamType, startDate, endDate) {
+        const data = activity.getSquashedStreamData(streamType, startDate, endDate);
+        return data[0];
+    }
+    static getDataTypeLast(activity, streamType, startDate, endDate) {
+        const data = activity.getSquashedStreamData(streamType, startDate, endDate);
+        return data[data.length - 1];
+    }
+    static cropDistance(startDistance, endDistance, activity) {
+        // Short to do the search just in case
+        let startDistanceDate; // Does not sound right
+        let endDistanceDate;
+        // debugger;
+        activity.getStreamData(DataDistance.type).forEach((distanceFromData, index) => {
+            // Find the index with greater dinstnce and convert it to time
+            if (startDistance && !startDistanceDate && distanceFromData && distanceFromData >= startDistance) {
+                startDistanceDate = new Date(activity.startDate.getTime() + index * 1000);
+                return;
+            }
+            // Same for end
+            if (endDistance && !endDistanceDate && distanceFromData && distanceFromData >= endDistance) {
+                endDistanceDate = new Date(activity.startDate.getTime() + index * 1000);
+                return;
+            }
+        });
+        if (!startDistanceDate && !endDistanceDate) {
+            return activity;
+        }
+        activity = this.cropTime(activity, startDistanceDate, endDistanceDate);
+        // Remove because it is invalid, you cannot just offset the distance as a stream I think
+        const distanceStream = activity.getAllStreams().find(s => DataDistance.type === s.type);
+        if (distanceStream) {
+            activity.removeStream(distanceStream);
+        }
+        const gnssDistanceStream = activity.getAllStreams().find(s => DataGNSSDistance.type === s.type);
+        if (gnssDistanceStream) {
+            activity.removeStream(gnssDistanceStream);
+        }
+        return activity;
+    }
+    /**
+     * Crops left,right on time.
+     * Start and end date need to be relative to the activity start / end time
+     * @param activity
+     * @param startDate
+     * @param endDate
+     */
+    static cropTime(activity, startDate, endDate) {
+        activity.getAllStreams().forEach(stream => {
+            // Get the data for the range specified
+            const trimmedStreamData = activity.getStreamData(stream.type, startDate, endDate);
+            activity.removeStream(stream);
+            activity.addStream(new Stream(stream.type, trimmedStreamData));
+        });
+        activity.startDate = startDate || activity.startDate;
+        activity.endDate = endDate || activity.endDate;
+        // debugger
+        return activity;
+    }
+    static getStreamDataTypesBasedOnDataType(streamToBaseOn, streams) {
+        return streamToBaseOn.getData().reduce((accu, streamDataItem, index) => {
+            if (!isNumberOrString(streamDataItem)) {
+                return accu;
+            }
+            const dataItem = {
+                [streamToBaseOn.type]: streamDataItem
+            };
+            streams.forEach(stream => {
+                dataItem[stream.type] = stream.getData()[index];
+            });
+            accu.push(dataItem);
+            return accu;
+        }, []);
+    }
+    static getStreamDataTypesBasedOnTime(startDate, endDate, streams) {
+        const streamDataBasedOnTime = {};
+        for (let i = 0; i < this.getDataLength(startDate, endDate); i++) {
+            // Perhaps this can be optimized with a search function
+            streams.forEach((stream) => {
+                if (isNumber(stream.getData()[i])) {
+                    streamDataBasedOnTime[startDate.getTime() + i * 1000] =
+                        streamDataBasedOnTime[startDate.getTime() + i * 1000] || {};
+                    streamDataBasedOnTime[startDate.getTime() + i * 1000][stream.type] = stream.getData()[i];
+                }
+            });
+        }
+        return streamDataBasedOnTime;
+    }
+    static getDataLength(startDate, endDate) {
+        return Math.ceil((+endDate - +startDate) / 1000) + 1;
+    }
+    static generateMissingStreamsAndStatsForActivity(activity) {
+        this.generateMissingStreams(activity);
+        this.fixAbnormalStreamData(activity);
+        this.generateMissingStatsForActivity(activity);
+        this.generateMissingSpeedDerivedStatsForActivity(activity);
+        this.generateMissingUnitStatsForActivity(activity); // Perhaps this needs to happen on user level so needs to go out of here
+    }
+    static fixAbnormalStreamData(activity) {
+        var _a, _b, _c;
+        // Check if fix abnormal speed option has been enable and if we have stream data and position data (e.g. do not fix for swim pool activities)
+        if (((_c = (_b = (_a = activity.parseOptions) === null || _a === void 0 ? void 0 : _a.streams) === null || _b === void 0 ? void 0 : _b.fixAbnormal) === null || _c === void 0 ? void 0 : _c.speed) &&
+            activity.hasStreamData(DataSpeed.type) &&
+            activity.hasStreamData(DataLatitudeDegrees.type) &&
+            activity.hasStreamData(DataLongitudeDegrees.type)) {
+            // Check for speed data dispersion using standard deviation
+            const speedStdDev = standardDeviation(activity.getSquashedStreamData(DataSpeed.type));
+            // Get speed standard deviation threshold at which we will attempt to fix the stream
+            const stdDevThreshold = SPEED_STREAM_STD_DEV_THRESHOLD_MAP.get(ActivityTypesHelper.getActivityGroupForActivityType(activity.type)) ||
+                SPEED_STREAM_STD_DEV_THRESHOLD_DEFAULT;
+            if (speedStdDev > stdDevThreshold) {
+                // Fix/Predict speed stream through Kalman filtering
+                this.shapeStream(DataSpeed.type, activity, squashedSpeedData => {
+                    // Grade stream
+                    const SPEED_KALMAN_SMOOTHING = {
+                        R: 0.01,
+                        Q: speedStdDev * 2 // We intend to get a measurement error which can be under and over std dev (explaining the double factor)
+                    };
+                    // Apply kalman filter
+                    const kf = new KalmanFilter(SPEED_KALMAN_SMOOTHING);
+                    return squashedSpeedData.map(v => (v === null ? null : kf.filter(v)));
+                });
+            }
+        }
+    }
+    static generateMissingStreams(activity) {
+        // Compute missing streams
+        this.generateMissingStreamsForActivity(activity);
+        activity.addStreams(this.createUnitStreamsFromStreams(activity.getAllStreams(), activity.type));
+    }
+    static getSummaryStatsForActivities(activities) {
+        const stats = [];
+        // If only one
+        if (activities.length === 1) {
+            return activities[0].getStatsAsArray();
+        }
+        let duration = 0;
+        let ascent = 0;
+        let descent = 0;
+        let energy = 0;
+        let distance = 0;
+        let pauseTime = 0;
+        let averageHeartRate = 0;
+        let averagePower = 0;
+        let averageCadence = 0;
+        let averageSpeed = 0;
+        let averageGradeAdjustedSpeed = 0;
+        let averagePace = 0;
+        let averageGradeAdjustedPace = 0;
+        let averageSwimPace = 0;
+        let averageTemperature = 0;
+        let averageFeeling = 0;
+        let averageRPE = 0;
+        // Sum Duration
+        activities.forEach(activity => {
+            duration += activity.getDuration().getValue();
+        });
+        stats.push(new DataDuration(duration));
+        // Sum pause time
+        activities.forEach(activity => {
+            pauseTime += activity.getPause().getValue();
+        });
+        stats.push(new DataPause(pauseTime));
+        // Sum Distance
+        activities.forEach(activity => {
+            distance += activity.getDistance().getValue();
+        });
+        stats.push(new DataDistance(distance));
+        // Sum ascent
+        activities.forEach(activity => {
+            const activityAscent = activity.getStat(DataAscent.type);
+            if (activityAscent) {
+                ascent += activityAscent.getValue();
+            }
+        });
+        stats.push(new DataAscent(ascent));
+        // Sum descent
+        activities.forEach(activity => {
+            const activityDescent = activity.getStat(DataDescent.type);
+            if (activityDescent) {
+                descent += activityDescent.getValue();
+            }
+        });
+        stats.push(new DataDescent(descent));
+        // Sum energy
+        activities.forEach(activity => {
+            const activityEnergy = activity.getStat(DataEnergy.type);
+            if (activityEnergy) {
+                energy += activityEnergy.getValue();
+            }
+        });
+        stats.push(new DataEnergy(energy));
+        // Avg Avg HR
+        activities.forEach(activity => {
+            const activityAvgHeartRate = activity.getStat(DataHeartRateAvg.type);
+            if (activityAvgHeartRate) {
+                // The below will fallback for 0
+                averageHeartRate = averageHeartRate
+                    ? (averageHeartRate + activityAvgHeartRate.getValue()) / 2
+                    : activityAvgHeartRate.getValue();
+            }
+        });
+        if (averageHeartRate) {
+            stats.push(new DataHeartRateAvg(averageHeartRate));
+        }
+        // Avg Avg HR
+        activities.forEach(activity => {
+            const activityAvgHeartRate = activity.getStat(DataHeartRateAvg.type);
+            if (activityAvgHeartRate) {
+                // The below will fallback for 0
+                averageHeartRate = averageHeartRate
+                    ? (averageHeartRate + activityAvgHeartRate.getValue()) / 2
+                    : activityAvgHeartRate.getValue();
+            }
+        });
+        if (averageHeartRate) {
+            stats.push(new DataHeartRateAvg(averageHeartRate));
+        }
+        // Avg Avg Power
+        activities.forEach(activity => {
+            const activityAvgPower = activity.getStat(DataPowerAvg.type);
+            if (activityAvgPower) {
+                // The below will fallback for 0
+                averagePower = averagePower
+                    ? (averagePower + activityAvgPower.getValue()) / 2
+                    : activityAvgPower.getValue();
+            }
+        });
+        if (averagePower) {
+            stats.push(new DataPowerAvg(averagePower));
+        }
+        // Avg Avg Cadence
+        activities.forEach(activity => {
+            const activityAvgCadence = activity.getStat(DataCadenceAvg.type);
+            if (activityAvgCadence) {
+                // The below will fallback for 0
+                averageCadence = averageCadence
+                    ? (averageCadence + activityAvgCadence.getValue()) / 2
+                    : activityAvgCadence.getValue();
+            }
+        });
+        if (averageCadence) {
+            stats.push(new DataCadenceAvg(averageCadence));
+        }
+        // Avg Avg Speed
+        activities.forEach(activity => {
+            const activityAvgSpeed = activity.getStat(DataSpeedAvg.type);
+            if (activityAvgSpeed) {
+                // The below will fallback for 0
+                averageSpeed = averageSpeed
+                    ? (averageSpeed + activityAvgSpeed.getValue()) / 2
+                    : activityAvgSpeed.getValue();
+            }
+        });
+        if (averageSpeed) {
+            stats.push(new DataSpeedAvg(averageSpeed));
+        }
+        // Avg Avg Gap Speed
+        activities.forEach(activity => {
+            const activityAvgGradeAdjustedSpeed = activity.getStat(DataGradeAdjustedSpeedAvg.type);
+            if (activityAvgGradeAdjustedSpeed) {
+                // The below will fallback for 0
+                averageGradeAdjustedSpeed = averageGradeAdjustedSpeed
+                    ? (averageGradeAdjustedSpeed + activityAvgGradeAdjustedSpeed.getValue()) / 2
+                    : activityAvgGradeAdjustedSpeed.getValue();
+            }
+        });
+        if (averageGradeAdjustedSpeed) {
+            stats.push(new DataGradeAdjustedSpeedAvg(averageGradeAdjustedSpeed));
+        }
+        // Avg Avg Pace
+        activities.forEach(activity => {
+            const activityAvgPace = activity.getStat(DataPaceAvg.type);
+            if (activityAvgPace) {
+                // The below will fallback for 0
+                averagePace = averagePace
+                    ? (averagePace + activityAvgPace.getValue()) / 2
+                    : activityAvgPace.getValue();
+            }
+        });
+        if (averagePace) {
+            stats.push(new DataPaceAvg(averagePace));
+        }
+        // Avg Avg GAP Pace
+        activities.forEach(activity => {
+            const activityAvgGradeAdjustedPace = activity.getStat(DataGradeAdjustedPaceAvg.type);
+            if (activityAvgGradeAdjustedPace) {
+                // The below will fallback for 0
+                averageGradeAdjustedPace = averageGradeAdjustedPace
+                    ? (averageGradeAdjustedPace + activityAvgGradeAdjustedPace.getValue()) / 2
+                    : activityAvgGradeAdjustedPace.getValue();
+            }
+        });
+        if (averageGradeAdjustedPace) {
+            stats.push(new DataGradeAdjustedPaceAvg(averageGradeAdjustedPace));
+        }
+        // Avg Avg SwimPace
+        activities.forEach(activity => {
+            const activityAvgSwimPace = activity.getStat(DataSwimPaceAvg.type);
+            if (activityAvgSwimPace) {
+                // The below will fallback for 0
+                averageSwimPace = averageSwimPace
+                    ? (averageSwimPace + activityAvgSwimPace.getValue()) / 2
+                    : activityAvgSwimPace.getValue();
+            }
+        });
+        if (averageSwimPace) {
+            stats.push(new DataSwimPaceAvg(averageSwimPace));
+        }
+        // Avg Avg Temperature
+        activities.forEach(activity => {
+            const activityAvgTemperature = activity.getStat(DataTemperatureAvg.type);
+            if (activityAvgTemperature) {
+                // The below will fallback for 0
+                averageTemperature = averageTemperature
+                    ? (averageTemperature + activityAvgTemperature.getValue()) / 2
+                    : activityAvgTemperature.getValue();
+            }
+        });
+        if (averageTemperature) {
+            stats.push(new DataTemperatureAvg(averageTemperature));
+        }
+        // Avg Feeling
+        activities.forEach(activity => {
+            const activityAvgFeeling = activity.getStat(DataFeeling.type);
+            if (activityAvgFeeling) {
+                // The below will fallback for 0
+                averageFeeling = averageFeeling
+                    ? Math.ceil((averageFeeling + activityAvgFeeling.getValue()) / 2)
+                    : activityAvgFeeling.getValue();
+            }
+        });
+        if (averageFeeling) {
+            stats.push(new DataFeeling(averageFeeling));
+        }
+        // Avg RPE
+        activities.forEach(activity => {
+            const activityAvgRPE = activity.getStat(DataFeeling.type);
+            if (activityAvgRPE) {
+                // The below will fallback for 0
+                averageRPE = averageRPE
+                    ? Math.ceil((averageRPE + activityAvgRPE.getValue()) / 2)
+                    : activityAvgRPE.getValue();
+            }
+        });
+        if (averageRPE) {
+            stats.push(new DataRPE(averageRPE));
+        }
+        stats.push(...this.getIntensityZonesStatsAggregated(activities));
+        // Add start and end position
+        // This expects the to be sorted
+        const activitiesWithStartPosition = activities.filter(activity => activity.getStat(DataStartPosition.type));
+        const activitiesWithEndPosition = activities.filter(activity => activity.getStat(DataEndPosition.type));
+        if (activitiesWithStartPosition && activitiesWithStartPosition.length) {
+            const startPositionStat = activitiesWithStartPosition[0].getStat(DataStartPosition.type);
+            stats.push(new DataStartPosition(startPositionStat.getValue()));
+        }
+        if (activitiesWithEndPosition && activitiesWithEndPosition.length) {
+            const endPositionStat = (activitiesWithEndPosition[activitiesWithEndPosition.length - 1].getStat(DataEndPosition.type));
+            stats.push(new DataEndPosition(endPositionStat.getValue()));
+        }
+        // debugger;
+        return stats;
+    }
+    static getIntensityZonesStatsAggregated(statClassInstances) {
+        return [
+            DataHeartRateZoneOneDuration.type,
+            DataHeartRateZoneTwoDuration.type,
+            DataHeartRateZoneThreeDuration.type,
+            DataHeartRateZoneFourDuration.type,
+            DataHeartRateZoneFiveDuration.type,
+            DataPowerZoneOneDuration.type,
+            DataPowerZoneTwoDuration.type,
+            DataPowerZoneThreeDuration.type,
+            DataPowerZoneFourDuration.type,
+            DataPowerZoneFiveDuration.type,
+            DataSpeedZoneOneDuration.type,
+            DataSpeedZoneTwoDuration.type,
+            DataSpeedZoneThreeDuration.type,
+            DataSpeedZoneFourDuration.type,
+            DataSpeedZoneFiveDuration.type
+        ].reduce((statsArray, zone) => {
+            const zoneDuration = statClassInstances.reduce((duration, statClassInstance) => {
+                const durationStat = statClassInstance.getStat(zone);
+                if (durationStat) {
+                    duration = duration || 0;
+                    duration += durationStat.getValue();
+                }
+                return duration;
+            }, null);
+            if (isNumber(zoneDuration)) {
+                statsArray.push(DynamicDataLoader.getDataInstanceFromDataType(zone, zoneDuration));
+            }
+            return statsArray;
+        }, []);
+    }
+    static getActivityDataTypeGain(activity, streamType, starDate, endDate, minDiff) {
+        return this.getActivityDataTypeGainOrLoss(activity, streamType, true, starDate, endDate, minDiff);
+    }
+    static getActivityDataTypeLoss(activity, streamType, starDate, endDate, minDiff) {
+        return this.getActivityDataTypeGainOrLoss(activity, streamType, false, starDate, endDate, minDiff);
+    }
+    static getGainOrLoss(data, gain, minDiff = 2) {
+        let gainOrLoss = 0;
+        if (!(data === null || data === void 0 ? void 0 : data.length)) {
+            return null;
+        }
+        data.reduce((previousValue, nextValue) => {
+            // For gain
+            if (gain) {
+                // Increase the gain if eligible first check to be greater plus diff  [200, 300, 400, 100, 101, 102]
+                if (previousValue + minDiff <= nextValue) {
+                    gainOrLoss += nextValue - previousValue;
+                    return nextValue;
+                }
+                // if not eligible check if smaller without the diff and if yes do not register it and send it back as the last to check against
+                if (previousValue < nextValue) {
+                    return previousValue;
+                }
+                return nextValue;
+            }
+            // For Loss
+            if (previousValue - minDiff >= nextValue) {
+                gainOrLoss += previousValue - nextValue;
+                return nextValue;
+            }
+            // if not eligible check if smaller without the diff and if yes do not register it and send it back as the last to check against
+            if (previousValue > nextValue) {
+                return previousValue;
+            }
+            return nextValue;
+        }, data[0]);
+        return gainOrLoss;
+    }
+    static getMax(data) {
+        return data.reduce((previousValue, currentValue) => Math.max(previousValue, currentValue), -Infinity);
+    }
+    static getMin(data) {
+        return data.reduce((previousValue, currentValue) => Math.min(previousValue, currentValue), Infinity);
+    }
+    static calculateTotalDistanceForActivity(activity, startDate, endDate) {
+        return this.geoLibAdapter.getDistance(activity.getPositionData(startDate, endDate).filter(position => position !== null));
+    }
+    /**
+     * Returns streams that derive from speed based on the activity type
+     * @param speedStream
+     * @param activityType
+     */
+    static createByActivityTypeSpeedBasedStreams(speedStream, activityType) {
+        return ActivityTypesHelper.speedDerivedDataTypesToUseForActivityType(activityType).reduce((array, dataType) => {
+            switch (dataType) {
+                case DataPace.type:
+                    return array.concat([
+                        new Stream(DataPace.type, speedStream.getData().map(dataValue => {
+                            if (!isNumber(dataValue)) {
+                                return null;
+                            }
+                            return convertSpeedToPace(dataValue);
+                        }))
+                    ]);
+                case DataSwimPace.type:
+                    return array.concat([
+                        new Stream(DataSwimPace.type, speedStream.getData().map(dataValue => {
+                            if (!isNumber(dataValue)) {
+                                return null;
+                            }
+                            return convertSpeedToSwimPace(dataValue);
+                        }))
+                    ]);
+                case DataSpeed.type:
+                    return array.concat(speedStream);
+                default:
+                    return array;
+            }
+        }, []);
+    }
+    /**
+     * Returns streams that derive from grade adjusted speed based on the activity type
+     * @param gradeAdjustedSpeedStream
+     * @param activityType
+     */
+    static createByActivityTypeAltiDistanceSpeedBasedStreams(gradeAdjustedSpeedStream, activityType) {
+        return ActivityTypesHelper.altiDistanceSpeedDerivedDataTypesToUseForActivityType(activityType).reduce((array, dataType) => {
+            switch (dataType) {
+                case DataGradeAdjustedPace.type:
+                    return array.concat([
+                        new Stream(DataGradeAdjustedPace.type, gradeAdjustedSpeedStream.getData().map(dataValue => {
+                            if (!isNumber(dataValue)) {
+                                return null;
+                            }
+                            return convertSpeedToPace(dataValue);
+                        }))
+                    ]);
+                case DataGradeAdjustedSpeed.type:
+                    return array.concat(gradeAdjustedSpeedStream);
+                default:
+                    return array;
+            }
+        }, []);
+    }
+    /**
+     * @todo unit test (get the pun?)
+     * This creates streams that are deriving as unit based streams
+     * For example it will create pace from speed, swim pace from speed but also speed in km/h as a unitstream
+     * @param streams
+     * @param activityType
+     * @param unitStreamTypes DynamicDataLoader.allUnitDerivedDataTypes this acts like a whitelist for the unit derived units ONLY!
+     */
+    static createUnitStreamsFromStreams(streams, activityType, unitStreamTypes) {
+        // @todo perhaps check input to be unitStreamTypesStrictly
+        const unitStreamTypesToCreate = unitStreamTypes || DynamicDataLoader.allUnitDerivedDataTypes;
+        let baseUnitStreams = [];
+        const speedStream = streams.find(stream => stream.type === DataSpeed.type);
+        if (speedStream) {
+            baseUnitStreams = baseUnitStreams.concat(this.createByActivityTypeSpeedBasedStreams(speedStream, activityType));
+        }
+        const gradeAdjustedSpeedStream = streams.find(stream => stream.type === DataGradeAdjustedSpeed.type);
+        if (gradeAdjustedSpeedStream) {
+            baseUnitStreams = baseUnitStreams.concat(this.createByActivityTypeAltiDistanceSpeedBasedStreams(gradeAdjustedSpeedStream, activityType));
+        }
+        const verticalSpeedStream = streams.find(stream => stream.type === DataVerticalSpeed.type);
+        if (verticalSpeedStream) {
+            // For vertical speed (yet) we dont need a seperate function so just add the base that is the "derived" one
+            baseUnitStreams = ActivityTypesHelper.verticalSpeedDerivedDataTypesToUseForActivityType(activityType).length
+                ? baseUnitStreams.concat(verticalSpeedStream)
+                : baseUnitStreams;
+        }
+        // @todo add distance ?
+        const startWith = baseUnitStreams.filter(baseUnitStream => unitStreamTypesToCreate.indexOf(baseUnitStream.type) !== -1 && streams.indexOf(baseUnitStream) === -1);
+        return Object.keys(DynamicDataLoader.dataTypeUnitGroups).reduce((array, baseDataType) => {
+            const baseStream = baseUnitStreams.find(stream => stream.type === baseDataType);
+            if (!baseStream) {
+                return array;
+            }
+            const unitStreams = Object.keys(DynamicDataLoader.dataTypeUnitGroups[baseDataType])
+                .filter(unitBasedDataType => unitStreamTypesToCreate.indexOf(unitBasedDataType) !== -1) // @todo perhaps dont filter
+                .map(unitBasedDataType => {
+                return new Stream(unitBasedDataType, baseStream.getData().map(dataValue => {
+                    if (!isNumber(dataValue)) {
+                        return null;
+                    }
+                    return DynamicDataLoader.dataTypeUnitGroups[baseDataType][unitBasedDataType](dataValue);
+                }));
+            });
+            return array.concat(unitStreams);
+        }, startWith);
+    }
+    /**
+     * Generates missing streams for an activity such as distance etc if they are missing
+     * This will always create a steam even if the distance is 0
+     * @param activity
+     */
+    static generateMissingStreamsForActivity(activity) {
+        var _a, _b, _c, _d, _e, _f;
+        // Create derived primitive streams which will be needed for others streams & stats computations
+        this.createDerivedStreams(activity);
+        // First add any missing data to the streams via interpolating and extrapolating
+        this.addMissingDataToStreams(activity);
+        if (activity.hasStreamData(DataLatitudeDegrees.type) &&
+            activity.hasStreamData(DataLongitudeDegrees.type) &&
+            (!activity.hasStreamData(DataDistance.type) || !activity.hasStreamData(DataGNSSDistance.type))) {
+            const streamData = activity.createStream(DataDistance.type).getData(); // Creating does not add it to activity just presets the resolution to 1s
+            let distance = 0;
+            streamData[0] = distance; // Force first distance sample to be equal to 0 instead of null
+            activity
+                .getPositionData()
+                .reduce((prevPosition, position, index) => {
+                if (!position) {
+                    return prevPosition;
+                }
+                if (prevPosition && position) {
+                    distance += this.round(this.geoLibAdapter.getDistance([prevPosition, position]), 2);
+                }
+                streamData[index] = distance;
+                return position;
+            });
+            if (!activity.hasStreamData(DataDistance.type)) {
+                activity.addStream(new Stream(DataDistance.type, streamData));
+            }
+            if (!activity.hasStreamData(DataGNSSDistance.type)) {
+                activity.addStream(new Stream(DataGNSSDistance.type, streamData));
+            }
+            if (!activity.hasStreamData(DataSpeed.type)) {
+                const speedStreamData = activity.createStream(DataSpeed.type).getData();
+                const distanceStream = activity.getStreamDataByDuration(DataDistance.type);
+                let previousDistanceItem;
+                distanceStream.forEach((distanceItem, index) => {
+                    // Use the first distance item value if previous distance is unknown
+                    if (!previousDistanceItem) {
+                        previousDistanceItem = distanceItem;
+                    }
+                    // If know distance then compute speed from last known distance item
+                    if (Number.isFinite(distanceItem.value)) {
+                        const deltaTime = (distanceItem.time - previousDistanceItem.time) / 1000;
+                        const deltaDistance = (distanceItem === null || distanceItem === void 0 ? void 0 : distanceItem.value) ? distanceItem.value - ((previousDistanceItem === null || previousDistanceItem === void 0 ? void 0 : previousDistanceItem.value) || 0) : 0;
+                        speedStreamData[index] = this.round(deltaTime > 0 ? deltaDistance / deltaTime : 0, 3);
+                        // Keep tracking of last know distance item
+                        previousDistanceItem = distanceItem;
+                    }
+                    else {
+                        speedStreamData[index] = null;
+                    }
+                });
+                activity.addStream(new Stream(DataSpeed.type, speedStreamData));
+            }
+        }
+        // Check if we can get a grade stream
+        if (((_c = (_b = (_a = activity.parseOptions) === null || _a === void 0 ? void 0 : _a.streams) === null || _b === void 0 ? void 0 : _b.smooth) === null || _c === void 0 ? void 0 : _c.grade) &&
+            !activity.hasStreamData(DataGrade.type) &&
+            activity.hasStreamData(DataDistance.type) &&
+            (activity.hasStreamData(DataAltitudeSmooth.type) || activity.hasStreamData(DataAltitude.type))) {
+            const distanceData = activity.getStreamData(DataDistance.type);
+            const altitudeData = activity.getStreamData(activity.hasStreamData(DataAltitudeSmooth.type) ? DataAltitudeSmooth.type : DataAltitude.type);
+            // Create the grade stream from time, distance and altitude non-squashed streams
+            const timeData = activity.generateTimeStream([DataDistance.type]);
+            const gradeStreamData = GradeCalculator.computeGradeStream(timeData.getData(), distanceData, altitudeData);
+            // Append new grade stream to activity
+            activity.addStream(new Stream(DataGrade.type, gradeStreamData));
+            if ((_f = (_e = (_d = activity.parseOptions) === null || _d === void 0 ? void 0 : _d.streams) === null || _e === void 0 ? void 0 : _e.smooth) === null || _f === void 0 ? void 0 : _f.gradeSmooth) {
+                // Duplicate and create an altitude smooth stream (we want to keep original altitude stream available)
+                // Activity stats and grade adjusted speed will be computed on the smoothed altitude stream
+                this.cloneStream(activity, DataGrade.type, DataGradeSmooth.type);
+                // Smooth grade computed stream
+                this.shapeStream(DataGradeSmooth.type, activity, squashedGradeData => {
+                    // Grade stream
+                    const GRADE_KALMAN_SMOOTHING = {
+                        R: 0.01,
+                        Q: 0.5 // Grade measurement error which can be expected
+                    };
+                    // Predict proper grade values
+                    const kf = new KalmanFilter(GRADE_KALMAN_SMOOTHING);
+                    return squashedGradeData.map(v => (v === null ? null : kf.filter(v)));
+                });
+            }
+        }
+        // Get a grade adjusted speed (the model applies to running only)
+        if ((ActivityTypesHelper.getActivityGroupForActivityType(activity.type) === ActivityTypeGroups.Running ||
+            ActivityTypesHelper.getActivityGroupForActivityType(activity.type) === ActivityTypeGroups.TrailRunning) &&
+            !activity.hasStreamData(DataGradeAdjustedSpeed.type) &&
+            activity.hasStreamData(DataGradeSmooth.type) &&
+            activity.hasStreamData(DataSpeed.type)) {
+            const speedStreamData = activity.getStreamData(DataSpeed.type);
+            const gradeStreamData = activity.getStreamData(DataGradeSmooth.type);
+            const gradeAdjustedSpeedData = speedStreamData.map((value, index) => value === null ? null : this.round(GradeCalculator.estimateAdjustedSpeed(value, gradeStreamData[index] || 0), 2));
+            // Ensure first grade adjusted pace dont start with 0 (it's common) meaning infinity
+            if (!gradeAdjustedSpeedData[0]) {
+                const firstKnownValue = gradeAdjustedSpeedData.find(v => v > 0);
+                gradeAdjustedSpeedData[0] = firstKnownValue ? firstKnownValue : gradeAdjustedSpeedData[0];
+            }
+            activity.addStream(new Stream(DataGradeAdjustedSpeed.type, gradeAdjustedSpeedData));
+        }
+        if (activity.hasStreamData(DataPower.type) &&
+            activity.hasStreamData(DataRightBalance.type) &&
+            !activity.hasStreamData(DataPowerRight.type)) {
+            const rightPowerStream = activity.createStream(DataPowerRight.type);
+            const powerStreamData = activity.getStreamData(DataPower.type);
+            const rightBalanceStreamData = activity.getStreamData(DataRightBalance.type);
+            rightPowerStream.setData(rightBalanceStreamData.reduce((accu, streamData, index) => {
+                const powerStreamDataItem = powerStreamData[index];
+                if (streamData === null || !powerStreamData || powerStreamDataItem === null) {
+                    return accu;
+                }
+                accu[index] = (streamData / 100) * powerStreamDataItem;
+                return accu;
+            }, []));
+            activity.addStream(rightPowerStream);
+        }
+        if (activity.hasStreamData(DataPower.type) &&
+            activity.hasStreamData(DataLeftBalance.type) &&
+            !activity.hasStreamData(DataPowerLeft.type)) {
+            const leftPowerStream = activity.createStream(DataPowerLeft.type);
+            const powerStreamData = activity.getStreamData(DataPower.type);
+            const leftBalanceStreamData = activity.getStreamData(DataLeftBalance.type);
+            leftPowerStream.setData(leftBalanceStreamData.reduce((accu, streamData, index) => {
+                const powerStreamDataItem = powerStreamData[index];
+                if (streamData === null || !powerStreamData || powerStreamDataItem === null) {
+                    return accu;
+                }
+                accu[index] = (streamData / 100) * powerStreamDataItem;
+                return accu;
+            }, []));
+            activity.addStream(leftPowerStream);
+        }
+        // If left stance time stream available, then add the right balance stream too
+        if (activity.hasStreamData(DataStanceTimeBalanceLeft.type)) {
+            const rightStanceBalanceTimeStream = activity.createStream(DataStanceTimeBalanceRight.type);
+            const leftStanceBalanceTimeStream = activity.getStreamData(DataStanceTimeBalanceLeft.type);
+            const rightStanceBalanceTimeData = leftStanceBalanceTimeStream.map(leftBalance => {
+                return Number.isFinite(leftBalance) ? 100 - leftBalance : null;
+            });
+            rightStanceBalanceTimeStream.setData(rightStanceBalanceTimeData);
+            activity.addStream(rightStanceBalanceTimeStream);
+        }
+        return activity;
+    }
+    /**
+     * Provides squashed stream data through callback for data manipulation.
+     * Then rebuild the stream based on duration including the missing values (null, Infinity, ...) like the source stream
+     * @param streamType
+     * @param activity
+     * @param shapeStreamData
+     */
+    static shapeStream(streamType, activity, shapeStreamData) {
+        let streamDataByDuration = activity.getStreamDataByDuration(streamType, true, true);
+        // Shape data along function param
+        const streamData = shapeStreamData(streamDataByDuration.map(item => item.value));
+        // Update streamDataByDuration with shaped data
+        streamDataByDuration = streamDataByDuration.map((item, index) => {
+            item.value = streamData[index];
+            return item;
+        });
+        // Rebuild/replace stream with new shaped value
+        activity.removeStream(streamType);
+        activity.addStream(activity.createStream(streamType));
+        const activityStartTime = activity.startDate.getTime();
+        streamDataByDuration.forEach(item => {
+            activity.addDataToStream(streamType, new Date(activityStartTime + item.time), item.value);
+        });
+    }
+    static cloneStream(activity, sourceStreamType, targetStreamType) {
+        const sourceStream = activity.getStream(sourceStreamType);
+        const targetStream = activity.createStream(targetStreamType);
+        targetStream.setData(Array.from(sourceStream.getData())); // Shallow copy data to new stream
+        activity.addStream(targetStream);
+    }
+    /**
+     * Create derived primitive streams which will be needed for others streams & stats computations
+     * @param activity
+     */
+    static createDerivedStreams(activity) {
+        var _a, _b, _c;
+        if (((_c = (_b = (_a = activity.parseOptions) === null || _a === void 0 ? void 0 : _a.streams) === null || _b === void 0 ? void 0 : _b.smooth) === null || _c === void 0 ? void 0 : _c.altitudeSmooth) &&
+            activity.hasStreamData(DataAltitude.type) &&
+            !activity.hasStreamData(DataAltitudeSmooth.type)) {
+            // Duplicate and create an altitude smooth stream (we want to keep original altitude stream available)
+            // Activity stats will be computed on the smoothed altitude stream
+            this.cloneStream(activity, DataAltitude.type, DataAltitudeSmooth.type);
+            // Remove spiky data altitudes
+            this.shapeStream(DataAltitudeSmooth.type, activity, squashedAltData => {
+                squashedAltData = medianFilter(squashedAltData, ALTITUDE_SPIKES_FILTER_WIN); // Remove data spikes
+                squashedAltData = LowPassFilter.smooth(squashedAltData); // Remove too high altitude frequencies
+                return squashedAltData;
+            });
+        }
+        return activity;
+    }
+    /**
+     * Back and forth fills an activity's stream data so they can be more "tree" like
+     * It does this for:
+     *
+     *  [DataAltitude.type,
+     * DataHeartRate.type,
+     * DataCadence.type,
+     * DataDistance.type]
+     *
+     * Example
+     *
+     * Distance[0, 10, 30, 40, 50,null,60] #null here is legit eg missing record
+     * Altitude[100, 101, null, 103, null, null, 106]
+     * Should be
+     * Altitude[100,101,101,103,103,103,106]
+     *
+     * @param activity
+     */
+    static addMissingDataToStreams(activity) {
+        /**
+         * This tries to align data with Strava.
+         * Strava fills HR alti cadence with the last value.
+         * For Power and temperature it doesn't but keeps nulls.
+         * However, if you keep nulls for paused portions then strava doens't give back null
+         * that typically indicates a sensor disconnect I suppose.
+         */
+        const streamTypesToBackAndForthFill = [
+            DataAltitude.type,
+            DataHeartRate.type,
+            DataCadence.type,
+            DataDistance.type
+            // DataSpeed.type, @todo should we be backfilling speed?
+        ];
+        // First generate the time stream
+        const timeStream = activity.generateTimeStream();
+        /**
+         * We do a second pass here and we add missing data on crossing time indexes
+         * for example:
+         * Time[0,1,2,3,4,5,7]
+         * Distance[0, 10, 30, 40, 50,null,60] #null here is legit eg missing record
+         * Altitude[100, 101, null, 103, null, null, 106]
+         * Should be
+         * Altitude[100,101,101,103,103,103,106]
+         */
+        activity
+            .getAllStreams()
+            .filter(stream => streamTypesToBackAndForthFill.indexOf(stream.type) !== -1)
+            .forEach(stream => {
+            // Find the first sample value
+            let currentValue = stream.getData(true, true)[0];
+            // The time stream will always have more length than each stream when not back/forthfilled
+            const timeStreamData = timeStream.getData();
+            stream.setData(timeStreamData.reduce((data, time, timeIndex) => {
+                // If there is no timeslot put whatever was
+                if (!isNumber(time)) {
+                    data.push(stream.getData()[timeIndex]);
+                    return data;
+                }
+                // We have a time slot here on ...  (for the first run, old is the very first next)
+                // If it's a number set the current , else leave it to old to forth fill
+                if (isNumber(stream.getData()[time])) {
+                    currentValue = stream.getData()[time];
+                }
+                // Fill the current or old...
+                data.push(currentValue);
+                return data;
+            }, []));
+        });
+        /**
+         * @todo
+         * Linear fill distance where:
+         * a) There is not distance but it's not paused
+         * b) There is no corespoding lat/long but there is distace (aka distance = not trusted)
+         * About B I am not sure. That is because if there is for example an internal accelerometer
+         * that reports better this can help with pace and other things. Even for GAP
+         */
+        // Fix activity having broken start lat/lng
+        // Case: "fixtures/others/broken-start-latlng.fit"
+        if (activity.hasStreamData(DataLongitudeDegrees.type)) {
+            this.shapeStream(DataLongitudeDegrees.type, activity, (squashedData) => {
+                const firstKnownCoord = squashedData.find(l => l != 0);
+                if (firstKnownCoord != null) {
+                    let index = 0;
+                    while (squashedData[index] === 0) {
+                        squashedData[index] = firstKnownCoord;
+                        index++;
+                    }
+                }
+                return squashedData;
+            });
+        }
+        if (activity.hasStreamData(DataLatitudeDegrees.type)) {
+            this.shapeStream(DataLatitudeDegrees.type, activity, (squashedData) => {
+                const firstKnownCoord = squashedData.find(l => l != 0);
+                if (firstKnownCoord != null) {
+                    let index = 0;
+                    while (squashedData[index] === 0) {
+                        squashedData[index] = firstKnownCoord;
+                        index++;
+                    }
+                }
+                return squashedData;
+            });
+        }
+    }
+    /**
+     *
+     * @param secondsPer100m
+     * @param avgStrokesPerMin
+     * @param poolLength
+     */
+    static computeSwimSwolf(secondsPer100m, avgStrokesPerMin, poolLength) {
+        const minutesPer100m = secondsPer100m / 60;
+        const avgStrokePer100m = avgStrokesPerMin * minutesPer100m;
+        const strokesPerMeter = avgStrokePer100m / 100;
+        const secondsPerMeter = secondsPer100m / 100;
+        return this.round((secondsPerMeter + strokesPerMeter) * poolLength, 1);
+    }
+    /**
+     * Andrew Coggan weighted power compute method
+     * 1) starting at the 30s mark, calculate a rolling 30 s average (of the preceding time points, obviously).
+     * 2) raise all the values obtained in step #1 to the 4th power.
+     * 3) take the average of all of the values obtained in step #2.
+     * 4) take the 4th root of the value obtained in step #3.
+     * (And when you get tired of exporting every file to, e.g., Excel to perform such calculations, help develop a program
+     * like WKO+ to do the work for you <g>.)
+     */
+    static computeNormalizedPower(powerArray, timeArray) {
+        const WEIGHTED_WATTS_TIME_BUFFER = 30; // Seconds
+        const poweredWeightedWatts = [];
+        let accumulatedTimeInBuffer = 0; // seconds
+        let wattsInBuffer = [];
+        for (const [index, current] of timeArray.entries()) {
+            if (index === 0) {
+                continue;
+            }
+            wattsInBuffer.push(powerArray[index]);
+            if (accumulatedTimeInBuffer >= WEIGHTED_WATTS_TIME_BUFFER) {
+                const meanWatts = this.getAverage(wattsInBuffer);
+                if (Number.isFinite(meanWatts)) {
+                    poweredWeightedWatts.push(Math.pow(meanWatts, 4));
+                }
+                // Reset
+                accumulatedTimeInBuffer = 0;
+                wattsInBuffer = [];
+            }
+            accumulatedTimeInBuffer += current - timeArray[index - 1];
+        }
+        return Math.sqrt(Math.sqrt(this.getAverage(poweredWeightedWatts)));
+    }
+    static getActivityDataTypeGainOrLoss(activity, streamType, gain, startDate, endDate, minDiff) {
+        return this.getGainOrLoss(activity.getSquashedStreamData(streamType, startDate, endDate), gain, minDiff);
+    }
+    static getActivityDataTypeMinOrMax(activity, streamType, max, startDate, endDate, filterOver) {
+        const data = activity
+            .getSquashedStreamData(streamType, startDate, endDate)
+            .filter(streamData => streamData !== Infinity &&
+            streamData !== -Infinity &&
+            (Number.isFinite(filterOver) ? streamData > filterOver : true));
+        if (max) {
+            return this.getMax(data);
+        }
+        return this.getMin(data);
+    }
+    /**
+     * Generates the stats for an activity
+     * @todo move to factory with next version
+     * @param activity
+     */
+    static generateMissingStatsForActivity(activity) {
+        // If there is no distance or distance for some reason is 0
+        const activityDistanceStat = activity.getStat(DataDistance.type);
+        if (!activityDistanceStat || activityDistanceStat.getValue() === 0) {
+            let distance = 0;
+            if (activity.hasStreamData(DataDistance.type)) {
+                const distanceData = activity.getSquashedStreamData(DataDistance.type);
+                distance = distanceData[distanceData.length - 1] - distanceData[0] || 0;
+            }
+            else if (activity.hasStreamData(DataLongitudeDegrees.type) &&
+                activity.hasStreamData(DataLatitudeDegrees.type)) {
+                distance = this.calculateTotalDistanceForActivity(activity, activity.startDate, activity.endDate);
+            }
+            activity.addStat(new DataDistance(distance));
+        }
+        if (!activity.getStat(DataGNSSDistance.type) && activity.hasStreamData(DataGNSSDistance.type)) {
+            activity.addStat(new DataGNSSDistance(activity.getSquashedStreamData(DataGNSSDistance.type)[activity.getSquashedStreamData(DataGNSSDistance.type).length - 1]));
+        }
+        // Ascent (altitude gain)
+        if (!activity.getStat(DataAscent.type) &&
+            (activity.hasStreamData(DataAltitudeSmooth.type) || activity.hasStreamData(DataAltitude.type))) {
+            const gain = this.getActivityDataTypeGain(activity, activity.hasStreamData(DataAltitudeSmooth.type) ? DataAltitudeSmooth.type : DataAltitude.type);
+            if (gain !== null) {
+                activity.addStat(new DataAscent(gain));
+            }
+        }
+        // Descent (altitude loss)
+        if (!activity.getStat(DataDescent.type) &&
+            (activity.hasStreamData(DataAltitudeSmooth.type) || activity.hasStreamData(DataAltitude.type))) {
+            const loss = this.getActivityDataTypeLoss(activity, activity.hasStreamData(DataAltitudeSmooth.type) ? DataAltitudeSmooth.type : DataAltitude.type);
+            if (loss !== null) {
+                activity.addStat(new DataDescent(loss));
+            }
+        }
+        // Altitude Max
+        if (!activity.getStat(DataAltitudeMax.type) &&
+            (activity.hasStreamData(DataAltitudeSmooth.type) || activity.hasStreamData(DataAltitude.type))) {
+            activity.addStat(new DataAltitudeMax(this.getDataTypeMax(activity, activity.hasStreamData(DataAltitudeSmooth.type) ? DataAltitudeSmooth.type : DataAltitude.type)));
+        }
+        // Altitude Min
+        if (!activity.getStat(DataAltitudeMin.type) &&
+            (activity.hasStreamData(DataAltitudeSmooth.type) || activity.hasStreamData(DataAltitude.type))) {
+            activity.addStat(new DataAltitudeMin(this.getDataTypeMin(activity, activity.hasStreamData(DataAltitudeSmooth.type) ? DataAltitudeSmooth.type : DataAltitude.type)));
+        }
+        // Altitude Avg
+        if (!activity.getStat(DataAltitudeAvg.type) &&
+            (activity.hasStreamData(DataAltitudeSmooth.type) || activity.hasStreamData(DataAltitude.type))) {
+            activity.addStat(new DataAltitudeAvg(this.getDataTypeAvg(activity, activity.hasStreamData(DataAltitudeSmooth.type) ? DataAltitudeSmooth.type : DataAltitude.type)));
+        }
+        // Altitude start
+        if (!activity.getStat(DataStartAltitude.type) &&
+            (activity.hasStreamData(DataAltitudeSmooth.type) || activity.hasStreamData(DataAltitude.type)) &&
+            this.getDataTypeFirst(activity, activity.hasStreamData(DataAltitudeSmooth.type) ? DataAltitudeSmooth.type : DataAltitude.type)) {
+            activity.addStat(new DataStartAltitude(this.getDataTypeFirst(activity, activity.hasStreamData(DataAltitudeSmooth.type) ? DataAltitudeSmooth.type : DataAltitude.type)));
+        }
+        // Altitude end
+        if (!activity.getStat(DataEndAltitude.type) &&
+            (activity.hasStreamData(DataAltitudeSmooth.type) || activity.hasStreamData(DataAltitude.type)) &&
+            this.getDataTypeLast(activity, activity.hasStreamData(DataAltitudeSmooth.type) ? DataAltitudeSmooth.type : DataAltitude.type)) {
+            activity.addStat(new DataEndAltitude(this.getDataTypeLast(activity, activity.hasStreamData(DataAltitudeSmooth.type) ? DataAltitudeSmooth.type : DataAltitude.type)));
+        }
+        // Heart Rate  Max
+        if (!activity.getStat(DataHeartRateMax.type) && activity.hasStreamData(DataHeartRate.type)) {
+            activity.addStat(new DataHeartRateMax(this.getDataTypeMax(activity, DataHeartRate.type)));
+        }
+        // Heart Rate Min
+        if (!activity.getStat(DataHeartRateMin.type) && activity.hasStreamData(DataHeartRate.type)) {
+            activity.addStat(new DataHeartRateMin(this.getDataTypeMin(activity, DataHeartRate.type)));
+        }
+        // Heart Rate Avg
+        if (!activity.getStat(DataHeartRateAvg.type) && activity.hasStreamData(DataHeartRate.type)) {
+            activity.addStat(new DataHeartRateAvg(this.round(this.getDataTypeAvg(activity, DataHeartRate.type))));
+        }
+        // Cadence Max
+        if (!activity.getStat(DataCadenceMax.type) && activity.hasStreamData(DataCadence.type)) {
+            activity.addStat(new DataCadenceMax(this.getDataTypeMax(activity, DataCadence.type)));
+        }
+        // Cadence Min
+        if (!activity.getStat(DataCadenceMin.type) && activity.hasStreamData(DataCadence.type)) {
+            // Get min cadence except 0. A 0 cadence is not meaningful.
+            const minCadenceOver = 0;
+            activity.addStat(new DataCadenceMin(this.getDataTypeMin(activity, DataCadence.type, undefined, undefined, minCadenceOver)));
+        }
+        // Cadence Avg
+        if (!activity.getStat(DataCadenceAvg.type) && activity.hasStreamData(DataCadence.type)) {
+            // Get avg cadence except 0 values. Platforms like garmin/strava don't include 0 cadences in their averages.
+            const avgCadenceOver = 0;
+            const avgCadence = this.getDataTypeAvg(activity, DataCadence.type, undefined, undefined, avgCadenceOver);
+            activity.addStat(new DataCadenceAvg(this.round(avgCadence)));
+        }
+        // Speed Max
+        if (!activity.getStat(DataSpeedMax.type) && activity.hasStreamData(DataSpeed.type)) {
+            activity.addStat(new DataSpeedMax(this.getDataTypeMax(activity, DataSpeed.type)));
+        }
+        // Speed Min
+        if (!activity.getStat(DataSpeedMin.type) && activity.hasStreamData(DataSpeed.type)) {
+            activity.addStat(new DataSpeedMin(this.getDataTypeMin(activity, DataSpeed.type)));
+        }
+        // Speed Avg
+        if (!activity.getStat(DataSpeedAvg.type) && activity.hasStreamData(DataSpeed.type)) {
+            activity.addStat(new DataSpeedAvg(this.getDataTypeAvg(activity, DataSpeed.type)));
+        }
+        // Grade Adjusted Speed Max
+        if (!activity.getStat(DataGradeAdjustedSpeedMax.type) && activity.hasStreamData(DataGradeAdjustedSpeed.type)) {
+            activity.addStat(new DataGradeAdjustedSpeedMax(this.getDataTypeMax(activity, DataGradeAdjustedSpeed.type)));
+        }
+        // Grade Adjusted Speed Min
+        if (!activity.getStat(DataGradeAdjustedSpeedMin.type) && activity.hasStreamData(DataGradeAdjustedSpeed.type)) {
+            activity.addStat(new DataGradeAdjustedSpeedMin(this.getDataTypeMin(activity, DataGradeAdjustedSpeed.type)));
+        }
+        // Grade Adjusted Speed Avg
+        if (!activity.getStat(DataGradeAdjustedSpeedAvg.type) && activity.hasStreamData(DataGradeAdjustedSpeed.type)) {
+            activity.addStat(new DataGradeAdjustedSpeedAvg(this.getDataTypeAvg(activity, DataGradeAdjustedSpeed.type)));
+        }
+        // Vertical Speed Max
+        if (!activity.getStat(DataVerticalSpeedMax.type) && activity.hasStreamData(DataVerticalSpeed.type)) {
+            activity.addStat(new DataVerticalSpeedMax(this.getDataTypeMax(activity, DataVerticalSpeed.type)));
+        }
+        // Vertical Speed Min
+        if (!activity.getStat(DataVerticalSpeedMin.type) && activity.hasStreamData(DataVerticalSpeed.type)) {
+            activity.addStat(new DataVerticalSpeedMin(this.getDataTypeMin(activity, DataVerticalSpeed.type)));
+        }
+        // Vertical Speed Avg
+        if (!activity.getStat(DataVerticalSpeedAvg.type) && activity.hasStreamData(DataVerticalSpeed.type)) {
+            activity.addStat(new DataVerticalSpeedAvg(this.getDataTypeAvg(activity, DataVerticalSpeed.type)));
+        }
+        // Power Max
+        if (!activity.getStat(DataPowerMax.type) && activity.hasStreamData(DataPower.type)) {
+            activity.addStat(new DataPowerMax(this.getDataTypeMax(activity, DataPower.type)));
+        }
+        // Power Min
+        if (!activity.getStat(DataPowerMin.type) && activity.hasStreamData(DataPower.type)) {
+            activity.addStat(new DataPowerMin(this.getDataTypeMin(activity, DataPower.type)));
+        }
+        // Power AVG
+        if (!activity.getStat(DataPowerAvg.type) && activity.hasStreamData(DataPower.type)) {
+            activity.addStat(new DataPowerAvg(this.getDataTypeAvg(activity, DataPower.type)));
+        }
+        // Power Normalized
+        if (!activity.getStat(DataPowerNormalized.type) && activity.hasStreamData(DataPower.type)) {
+            const powerDurationStream = activity.getStreamDataByDuration(DataPower.type, true, true);
+            const timeStream = powerDurationStream.map(item => item.time / 1000);
+            const powerStream = powerDurationStream.map(item => item.value);
+            const normalizedPower = this.computeNormalizedPower(powerStream, timeStream);
+            activity.addStat(new DataPowerNormalized(normalizedPower));
+        }
+        // Air AirPower Max
+        if (!activity.getStat(DataAirPowerMax.type) && activity.hasStreamData(DataAirPower.type)) {
+            activity.addStat(new DataAirPowerMax(this.getDataTypeMax(activity, DataAirPower.type)));
+        }
+        // Air AirPower Min
+        if (!activity.getStat(DataAirPowerMin.type) && activity.hasStreamData(DataAirPower.type)) {
+            activity.addStat(new DataAirPowerMin(this.getDataTypeMin(activity, DataAirPower.type)));
+        }
+        // Air AirPower AVG
+        if (!activity.getStat(DataAirPowerAvg.type) && activity.hasStreamData(DataAirPower.type)) {
+            activity.addStat(new DataAirPowerAvg(this.getDataTypeAvg(activity, DataAirPower.type)));
+        }
+        // Temperature Max
+        if (!activity.getStat(DataTemperatureMax.type) && activity.hasStreamData(DataTemperature.type)) {
+            activity.addStat(new DataTemperatureMax(this.getDataTypeMax(activity, DataTemperature.type)));
+        }
+        // Temperature Min
+        if (!activity.getStat(DataTemperatureMin.type) && activity.hasStreamData(DataTemperature.type)) {
+            activity.addStat(new DataTemperatureMin(this.getDataTypeMin(activity, DataTemperature.type)));
+        }
+        // Temperature Avg
+        if (!activity.getStat(DataTemperatureAvg.type) && activity.hasStreamData(DataTemperature.type)) {
+            activity.addStat(new DataTemperatureAvg(this.getDataTypeAvg(activity, DataTemperature.type)));
+        }
+        // Battery Consumption Avg
+        if (!activity.getStat(DataBatteryConsumption.type) && activity.hasStreamData(DataBatteryCharge.type)) {
+            activity.addStat(new DataBatteryConsumption(this.getDataTypeMinToMaxDifference(activity, DataBatteryCharge.type)));
+        }
+        // Battery Life Estimation based on Consumption
+        if (!activity.getStat(DataBatteryLifeEstimation.type)) {
+            const consumption = activity.getStat(DataBatteryConsumption.type);
+            if (consumption && consumption.getValue()) {
+                activity.addStat(new DataBatteryLifeEstimation(Number(((+activity.endDate - +activity.startDate) / 1000) * 100) / Number(consumption.getValue())));
+            }
+        }
+        // Start and end position
+        if ((!activity.getStat(DataStartPosition.type) || !activity.getStat(DataEndPosition.type)) &&
+            activity.hasPositionData()) {
+            const activityPositionData = activity.getPositionData().filter(data => data !== null);
+            const startPosition = activityPositionData[0];
+            const endPosition = activityPositionData[activityPositionData.length - 1];
+            if (startPosition && !activity.getStat(DataStartPosition.type)) {
+                activity.addStat(new DataStartPosition(startPosition));
+            }
+            if (endPosition && !activity.getStat(DataEndPosition.type)) {
+                activity.addStat(new DataEndPosition(endPosition));
+            }
+        }
+        // Assign L/R balance from streams if exists
+        if (!activity.getStat(DataRightBalance.type) && activity.hasStreamData(DataRightBalance.type)) {
+            const avgRightBalance = this.round(this.getDataTypeAvg(activity, DataRightBalance.type), 2);
+            activity.addStat(new DataRightBalance(avgRightBalance));
+            activity.addStat(new DataLeftBalance(100 - avgRightBalance));
+        }
+        // Assign L/R balance stance time from streams if exists
+        if (!activity.getStat(DataStanceTimeBalanceLeft.type) && activity.hasStreamData(DataStanceTimeBalanceLeft.type)) {
+            const avgStanceTimeLeftBalance = this.round(this.getDataTypeAvg(activity, DataStanceTimeBalanceLeft.type), 2);
+            activity.addStat(new DataStanceTimeBalanceLeft(avgStanceTimeLeftBalance));
+            activity.addStat(new DataStanceTimeBalanceRight(100 - avgStanceTimeLeftBalance));
+        }
+    }
+    static generateMissingSpeedDerivedStatsForActivity(activity) {
+        // Pace
+        const speedMax = activity.getStat(DataSpeedMax.type);
+        if (speedMax && !activity.getStat(DataPaceMax.type)) {
+            activity.addStat(new DataPaceMax(convertSpeedToPace(speedMax.getValue())));
+        }
+        const speedMin = activity.getStat(DataSpeedMin.type);
+        if (speedMin && !activity.getStat(DataPaceMin.type)) {
+            activity.addStat(new DataPaceMin(convertSpeedToPace(speedMin.getValue())));
+        }
+        const speedAvg = activity.getStat(DataSpeedAvg.type);
+        if (speedAvg && !activity.getStat(DataPaceAvg.type)) {
+            activity.addStat(new DataPaceAvg(convertSpeedToPace(speedAvg.getValue())));
+        }
+        // GAP
+        const gradeAdjustedSpeedMax = activity.getStat(DataGradeAdjustedSpeedMax.type);
+        if (gradeAdjustedSpeedMax && !activity.getStat(DataGradeAdjustedPaceMax.type)) {
+            const targetAdjustedSpeed = gradeAdjustedSpeedMax.getValue() < speedMax.getValue()
+                ? speedMax.getValue()
+                : gradeAdjustedSpeedMax.getValue();
+            activity.addStat(new DataGradeAdjustedPaceMax(convertSpeedToPace(targetAdjustedSpeed)));
+        }
+        const gradeAdjustedSpeedMin = activity.getStat(DataGradeAdjustedSpeedMin.type);
+        if (gradeAdjustedSpeedMin && !activity.getStat(DataGradeAdjustedPaceMin.type)) {
+            const targetAdjustedSpeed = gradeAdjustedSpeedMin.getValue() < speedMin.getValue()
+                ? speedMin.getValue()
+                : gradeAdjustedSpeedMin.getValue();
+            activity.addStat(new DataGradeAdjustedPaceMin(convertSpeedToPace(targetAdjustedSpeed)));
+        }
+        const gradeAdjustedSpeedAvg = activity.getStat(DataGradeAdjustedSpeedAvg.type);
+        if (gradeAdjustedSpeedAvg && !activity.getStat(DataGradeAdjustedPaceAvg.type)) {
+            const targetAdjustedSpeed = gradeAdjustedSpeedAvg.getValue() < speedAvg.getValue()
+                ? speedAvg.getValue()
+                : gradeAdjustedSpeedAvg.getValue();
+            activity.addStat(new DataGradeAdjustedPaceAvg(convertSpeedToPace(targetAdjustedSpeed)));
+        }
+        // Swim Pace
+        if (speedMax && !activity.getStat(DataSwimPaceMax.type)) {
+            activity.addStat(new DataSwimPaceMax(convertSpeedToSwimPace(speedMax.getValue())));
+        }
+        if (speedMin && !activity.getStat(DataSwimPaceMin.type)) {
+            activity.addStat(new DataSwimPaceMin(convertSpeedToSwimPace(speedMin.getValue())));
+        }
+        if (speedAvg && !activity.getStat(DataSwimPaceAvg.type)) {
+            activity.addStat(new DataSwimPaceAvg(convertSpeedToSwimPace(speedAvg.getValue())));
+        }
+    }
+    // @todo move to factory
+    static generateMissingUnitStatsForActivity(activity) {
+        var _a, _b, _c;
+        // Pace
+        if (!activity.getStat(DataPaceMaxMinutesPerMile.type)) {
+            const paceMax = activity.getStat(DataPaceMax.type);
+            if (paceMax) {
+                activity.addStat(new DataPaceMaxMinutesPerMile(convertPaceToPaceInMinutesPerMile(paceMax.getValue())));
+            }
+        }
+        if (!activity.getStat(DataPaceMinMinutesPerMile.type)) {
+            const paceMin = activity.getStat(DataPaceMin.type);
+            if (paceMin) {
+                activity.addStat(new DataPaceMinMinutesPerMile(convertPaceToPaceInMinutesPerMile(paceMin.getValue())));
+            }
+        }
+        if (!activity.getStat(DataPaceAvgMinutesPerMile.type)) {
+            const paceAvg = activity.getStat(DataPaceAvg.type);
+            if (paceAvg) {
+                activity.addStat(new DataPaceAvgMinutesPerMile(convertPaceToPaceInMinutesPerMile(paceAvg.getValue())));
+            }
+        }
+        // Grade Adjusted Pace
+        if (!activity.getStat(DataGradeAdjustedPaceMaxMinutesPerMile.type)) {
+            const gradeAdjustedPaceMax = activity.getStat(DataGradeAdjustedPaceMax.type);
+            if (gradeAdjustedPaceMax) {
+                activity.addStat(new DataGradeAdjustedPaceMaxMinutesPerMile(convertPaceToPaceInMinutesPerMile(gradeAdjustedPaceMax.getValue())));
+            }
+        }
+        if (!activity.getStat(DataGradeAdjustedPaceMinMinutesPerMile.type)) {
+            const gradeAdjustedPaceMin = activity.getStat(DataGradeAdjustedPaceMin.type);
+            if (gradeAdjustedPaceMin) {
+                activity.addStat(new DataGradeAdjustedPaceMinMinutesPerMile(convertPaceToPaceInMinutesPerMile(gradeAdjustedPaceMin.getValue())));
+            }
+        }
+        if (!activity.getStat(DataGradeAdjustedPaceAvgMinutesPerMile.type)) {
+            const gradeAdjustedPaceAvg = activity.getStat(DataGradeAdjustedPaceAvg.type);
+            if (gradeAdjustedPaceAvg) {
+                activity.addStat(new DataGradeAdjustedPaceAvgMinutesPerMile(convertPaceToPaceInMinutesPerMile(gradeAdjustedPaceAvg.getValue())));
+            }
+        }
+        // Swim Pace
+        if (!activity.getStat(DataSwimPaceMaxMinutesPer100Yard.type)) {
+            const swimPaceMax = activity.getStat(DataSwimPaceMax.type);
+            if (swimPaceMax) {
+                activity.addStat(new DataSwimPaceMaxMinutesPer100Yard(convertSwimPaceToSwimPacePer100Yard(swimPaceMax.getValue())));
+            }
+        }
+        if (!activity.getStat(DataSwimPaceMinMinutesPer100Yard.type)) {
+            const swimPaceMin = activity.getStat(DataSwimPaceMin.type);
+            if (swimPaceMin) {
+                activity.addStat(new DataSwimPaceMinMinutesPer100Yard(convertSwimPaceToSwimPacePer100Yard(swimPaceMin.getValue())));
+            }
+        }
+        if (!activity.getStat(DataSwimPaceAvgMinutesPer100Yard.type)) {
+            const swimPaceAvg = activity.getStat(DataPaceAvg.type);
+            if (swimPaceAvg) {
+                activity.addStat(new DataSwimPaceAvgMinutesPer100Yard(convertSwimPaceToSwimPacePer100Yard(swimPaceAvg.getValue())));
+            }
+        }
+        // Speed
+        if (!activity.getStat(DataSpeedMaxKilometersPerHour.type)) {
+            const speedMax = activity.getStat(DataSpeedMax.type);
+            if (speedMax) {
+                activity.addStat(new DataSpeedMaxKilometersPerHour(convertSpeedToSpeedInKilometersPerHour(speedMax.getValue())));
+            }
+        }
+        if (!activity.getStat(DataSpeedMaxMilesPerHour.type)) {
+            const speedMax = activity.getStat(DataSpeedMax.type);
+            if (speedMax) {
+                activity.addStat(new DataSpeedMaxMilesPerHour(convertSpeedToSpeedInMilesPerHour(speedMax.getValue())));
+            }
+        }
+        if (!activity.getStat(DataSpeedMaxFeetPerSecond.type)) {
+            const speedMax = activity.getStat(DataSpeedMax.type);
+            if (speedMax) {
+                activity.addStat(new DataSpeedMaxFeetPerSecond(convertSpeedToSpeedInFeetPerSecond(speedMax.getValue())));
+            }
+        }
+        if (!activity.getStat(DataSpeedMaxFeetPerMinute.type)) {
+            const speedMax = activity.getStat(DataSpeedMax.type);
+            if (speedMax) {
+                activity.addStat(new DataSpeedMaxFeetPerMinute(convertSpeedToSpeedInFeetPerMinute(speedMax.getValue())));
+            }
+        }
+        if (!activity.getStat(DataSpeedMaxMetersPerMinute.type)) {
+            const speedMax = activity.getStat(DataSpeedMax.type);
+            if (speedMax) {
+                activity.addStat(new DataSpeedMaxMetersPerMinute(convertSpeedToSpeedInMetersPerMinute(speedMax.getValue())));
+            }
+        }
+        if (!activity.getStat(DataSpeedMaxKnots.type)) {
+            const speedMax = activity.getStat(DataSpeedMax.type);
+            if (speedMax) {
+                activity.addStat(new DataSpeedMaxKnots(convertSpeedToSpeedInKnots(speedMax.getValue())));
+            }
+        }
+        if (!activity.getStat(DataSpeedMinKilometersPerHour.type)) {
+            const speedMin = activity.getStat(DataSpeedMin.type);
+            if (speedMin) {
+                activity.addStat(new DataSpeedMinKilometersPerHour(convertSpeedToSpeedInKilometersPerHour(speedMin.getValue())));
+            }
+        }
+        if (!activity.getStat(DataSpeedMinMilesPerHour.type)) {
+            const speedMin = activity.getStat(DataSpeedMin.type);
+            if (speedMin) {
+                activity.addStat(new DataSpeedMinMilesPerHour(convertSpeedToSpeedInMilesPerHour(speedMin.getValue())));
+            }
+        }
+        if (!activity.getStat(DataSpeedMinFeetPerSecond.type)) {
+            const speedMin = activity.getStat(DataSpeedMin.type);
+            if (speedMin) {
+                activity.addStat(new DataSpeedMinFeetPerSecond(convertSpeedToSpeedInFeetPerSecond(speedMin.getValue())));
+            }
+        }
+        if (!activity.getStat(DataSpeedMinFeetPerMinute.type)) {
+            const speedMin = activity.getStat(DataSpeedMin.type);
+            if (speedMin) {
+                activity.addStat(new DataSpeedMinFeetPerMinute(convertSpeedToSpeedInFeetPerMinute(speedMin.getValue())));
+            }
+        }
+        if (!activity.getStat(DataSpeedMinMetersPerMinute.type)) {
+            const speedMin = activity.getStat(DataSpeedMin.type);
+            if (speedMin) {
+                activity.addStat(new DataSpeedMinMetersPerMinute(convertSpeedToSpeedInMetersPerMinute(speedMin.getValue())));
+            }
+        }
+        if (!activity.getStat(DataSpeedMinKnots.type)) {
+            const speedMin = activity.getStat(DataSpeedMin.type);
+            if (speedMin) {
+                activity.addStat(new DataSpeedMinKnots(convertSpeedToSpeedInKnots(speedMin.getValue())));
+            }
+        }
+        if (!activity.getStat(DataSpeedAvgKilometersPerHour.type)) {
+            const speedAvg = activity.getStat(DataSpeedAvg.type);
+            if (speedAvg) {
+                activity.addStat(new DataSpeedAvgKilometersPerHour(convertSpeedToSpeedInKilometersPerHour(speedAvg.getValue())));
+            }
+        }
+        if (!activity.getStat(DataSpeedAvgMilesPerHour.type)) {
+            const speedAvg = activity.getStat(DataSpeedAvg.type);
+            if (speedAvg) {
+                activity.addStat(new DataSpeedAvgMilesPerHour(convertSpeedToSpeedInMilesPerHour(speedAvg.getValue())));
+            }
+        }
+        if (!activity.getStat(DataSpeedAvgFeetPerSecond.type)) {
+            const speedAvg = activity.getStat(DataSpeedAvg.type);
+            if (speedAvg) {
+                activity.addStat(new DataSpeedAvgFeetPerSecond(convertSpeedToSpeedInFeetPerSecond(speedAvg.getValue())));
+            }
+        }
+        if (!activity.getStat(DataSpeedAvgFeetPerMinute.type)) {
+            const speedAvg = activity.getStat(DataSpeedAvg.type);
+            if (speedAvg) {
+                activity.addStat(new DataSpeedAvgFeetPerMinute(convertSpeedToSpeedInFeetPerMinute(speedAvg.getValue())));
+            }
+        }
+        if (!activity.getStat(DataSpeedAvgMetersPerMinute.type)) {
+            const speedAvg = activity.getStat(DataSpeedAvg.type);
+            if (speedAvg) {
+                activity.addStat(new DataSpeedAvgMetersPerMinute(convertSpeedToSpeedInMetersPerMinute(speedAvg.getValue())));
+            }
+        }
+        if (!activity.getStat(DataSpeedAvgKnots.type)) {
+            const speedAvg = activity.getStat(DataSpeedAvg.type);
+            if (speedAvg) {
+                activity.addStat(new DataSpeedAvgKnots(convertSpeedToSpeedInKnots(speedAvg.getValue())));
+            }
+        }
+        // Grade Adjusted Speed
+        if (!activity.getStat(DataGradeAdjustedSpeedMaxKilometersPerHour.type)) {
+            const speedMax = activity.getStat(DataGradeAdjustedSpeedMax.type);
+            if (speedMax) {
+                activity.addStat(new DataGradeAdjustedSpeedMaxKilometersPerHour(convertSpeedToSpeedInKilometersPerHour(speedMax.getValue())));
+            }
+        }
+        if (!activity.getStat(DataGradeAdjustedSpeedMaxMilesPerHour.type)) {
+            const speedMax = activity.getStat(DataGradeAdjustedSpeedMax.type);
+            if (speedMax) {
+                activity.addStat(new DataGradeAdjustedSpeedMaxMilesPerHour(convertSpeedToSpeedInMilesPerHour(speedMax.getValue())));
+            }
+        }
+        if (!activity.getStat(DataGradeAdjustedSpeedMaxFeetPerSecond.type)) {
+            const speedMax = activity.getStat(DataGradeAdjustedSpeedMax.type);
+            if (speedMax) {
+                activity.addStat(new DataGradeAdjustedSpeedMaxFeetPerSecond(convertSpeedToSpeedInFeetPerSecond(speedMax.getValue())));
+            }
+        }
+        if (!activity.getStat(DataGradeAdjustedSpeedMaxFeetPerMinute.type)) {
+            const speedMax = activity.getStat(DataGradeAdjustedSpeedMax.type);
+            if (speedMax) {
+                activity.addStat(new DataGradeAdjustedSpeedMaxFeetPerMinute(convertSpeedToSpeedInFeetPerMinute(speedMax.getValue())));
+            }
+        }
+        if (!activity.getStat(DataGradeAdjustedSpeedMaxMetersPerMinute.type)) {
+            const speedMax = activity.getStat(DataGradeAdjustedSpeedMax.type);
+            if (speedMax) {
+                activity.addStat(new DataGradeAdjustedSpeedMaxMetersPerMinute(convertSpeedToSpeedInMetersPerMinute(speedMax.getValue())));
+            }
+        }
+        if (!activity.getStat(DataGradeAdjustedSpeedMaxKnots.type)) {
+            const speedMax = activity.getStat(DataGradeAdjustedSpeedMax.type);
+            if (speedMax) {
+                activity.addStat(new DataGradeAdjustedSpeedMaxKnots(convertSpeedToSpeedInKnots(speedMax.getValue())));
+            }
+        }
+        if (!activity.getStat(DataGradeAdjustedSpeedMinKilometersPerHour.type)) {
+            const speedMin = activity.getStat(DataGradeAdjustedSpeedMin.type);
+            if (speedMin) {
+                activity.addStat(new DataGradeAdjustedSpeedMinKilometersPerHour(convertSpeedToSpeedInKilometersPerHour(speedMin.getValue())));
+            }
+        }
+        if (!activity.getStat(DataGradeAdjustedSpeedMinMilesPerHour.type)) {
+            const speedMin = activity.getStat(DataGradeAdjustedSpeedMin.type);
+            if (speedMin) {
+                activity.addStat(new DataGradeAdjustedSpeedMinMilesPerHour(convertSpeedToSpeedInMilesPerHour(speedMin.getValue())));
+            }
+        }
+        if (!activity.getStat(DataGradeAdjustedSpeedMinFeetPerSecond.type)) {
+            const speedMin = activity.getStat(DataGradeAdjustedSpeedMin.type);
+            if (speedMin) {
+                activity.addStat(new DataGradeAdjustedSpeedMinFeetPerSecond(convertSpeedToSpeedInFeetPerSecond(speedMin.getValue())));
+            }
+        }
+        if (!activity.getStat(DataGradeAdjustedSpeedMinFeetPerMinute.type)) {
+            const speedMin = activity.getStat(DataGradeAdjustedSpeedMin.type);
+            if (speedMin) {
+                activity.addStat(new DataGradeAdjustedSpeedMinFeetPerMinute(convertSpeedToSpeedInFeetPerMinute(speedMin.getValue())));
+            }
+        }
+        if (!activity.getStat(DataGradeAdjustedSpeedMinMetersPerMinute.type)) {
+            const speedMin = activity.getStat(DataGradeAdjustedSpeedMin.type);
+            if (speedMin) {
+                activity.addStat(new DataGradeAdjustedSpeedMinMetersPerMinute(convertSpeedToSpeedInMetersPerMinute(speedMin.getValue())));
+            }
+        }
+        if (!activity.getStat(DataGradeAdjustedSpeedMinKnots.type)) {
+            const speedMin = activity.getStat(DataGradeAdjustedSpeedMin.type);
+            if (speedMin) {
+                activity.addStat(new DataGradeAdjustedSpeedMinKnots(convertSpeedToSpeedInKnots(speedMin.getValue())));
+            }
+        }
+        if (!activity.getStat(DataGradeAdjustedSpeedAvgKilometersPerHour.type)) {
+            const speedAvg = activity.getStat(DataGradeAdjustedSpeedAvg.type);
+            if (speedAvg) {
+                activity.addStat(new DataGradeAdjustedSpeedAvgKilometersPerHour(convertSpeedToSpeedInKilometersPerHour(speedAvg.getValue())));
+            }
+        }
+        if (!activity.getStat(DataGradeAdjustedSpeedAvgMilesPerHour.type)) {
+            const speedAvg = activity.getStat(DataGradeAdjustedSpeedAvg.type);
+            if (speedAvg) {
+                activity.addStat(new DataGradeAdjustedSpeedAvgMilesPerHour(convertSpeedToSpeedInMilesPerHour(speedAvg.getValue())));
+            }
+        }
+        if (!activity.getStat(DataGradeAdjustedSpeedAvgFeetPerSecond.type)) {
+            const speedAvg = activity.getStat(DataGradeAdjustedSpeedAvg.type);
+            if (speedAvg) {
+                activity.addStat(new DataGradeAdjustedSpeedAvgFeetPerSecond(convertSpeedToSpeedInFeetPerSecond(speedAvg.getValue())));
+            }
+        }
+        if (!activity.getStat(DataGradeAdjustedSpeedAvgFeetPerMinute.type)) {
+            const speedAvg = activity.getStat(DataGradeAdjustedSpeedAvg.type);
+            if (speedAvg) {
+                activity.addStat(new DataGradeAdjustedSpeedAvgFeetPerMinute(convertSpeedToSpeedInFeetPerMinute(speedAvg.getValue())));
+            }
+        }
+        if (!activity.getStat(DataGradeAdjustedSpeedAvgMetersPerMinute.type)) {
+            const speedAvg = activity.getStat(DataGradeAdjustedSpeedAvg.type);
+            if (speedAvg) {
+                activity.addStat(new DataGradeAdjustedSpeedAvgMetersPerMinute(convertSpeedToSpeedInMetersPerMinute(speedAvg.getValue())));
+            }
+        }
+        if (!activity.getStat(DataGradeAdjustedSpeedAvgKnots.type)) {
+            const speedAvg = activity.getStat(DataGradeAdjustedSpeedAvg.type);
+            if (speedAvg) {
+                activity.addStat(new DataGradeAdjustedSpeedAvgKnots(convertSpeedToSpeedInKnots(speedAvg.getValue())));
+            }
+        }
+        // Vertical speed
+        if (!activity.getStat(DataVerticalSpeedAvgFeetPerSecond.type)) {
+            const verticalSpeedAvg = activity.getStat(DataVerticalSpeedAvg.type);
+            if (verticalSpeedAvg) {
+                activity.addStat(new DataVerticalSpeedAvgFeetPerSecond(convertSpeedToSpeedInFeetPerSecond(verticalSpeedAvg.getValue())));
+            }
+        }
+        if (!activity.getStat(DataVerticalSpeedAvgMetersPerMinute.type)) {
+            const verticalSpeedAvg = activity.getStat(DataVerticalSpeedAvg.type);
+            if (verticalSpeedAvg) {
+                activity.addStat(new DataVerticalSpeedAvgMetersPerMinute(convertSpeedToSpeedInMetersPerMinute(verticalSpeedAvg.getValue())));
+            }
+        }
+        if (!activity.getStat(DataVerticalSpeedAvgFeetPerMinute.type)) {
+            const verticalSpeedAvg = activity.getStat(DataVerticalSpeedAvg.type);
+            if (verticalSpeedAvg) {
+                activity.addStat(new DataVerticalSpeedAvgFeetPerMinute(convertSpeedToSpeedInFeetPerMinute(verticalSpeedAvg.getValue())));
+            }
+        }
+        if (!activity.getStat(DataVerticalSpeedAvgMetersPerHour.type)) {
+            const verticalSpeedAvg = activity.getStat(DataVerticalSpeedAvg.type);
+            if (verticalSpeedAvg) {
+                activity.addStat(new DataVerticalSpeedAvgMetersPerHour(convertSpeedToSpeedInMetersPerHour(verticalSpeedAvg.getValue())));
+            }
+        }
+        if (!activity.getStat(DataVerticalSpeedAvgFeetPerHour.type)) {
+            const verticalSpeedAvg = activity.getStat(DataVerticalSpeedAvg.type);
+            if (verticalSpeedAvg) {
+                activity.addStat(new DataVerticalSpeedAvgFeetPerHour(convertSpeedToSpeedInFeetPerHour(verticalSpeedAvg.getValue())));
+            }
+        }
+        if (!activity.getStat(DataVerticalSpeedAvgKilometerPerHour.type)) {
+            const verticalSpeedAvg = activity.getStat(DataVerticalSpeedAvg.type);
+            if (verticalSpeedAvg) {
+                activity.addStat(new DataVerticalSpeedAvgKilometerPerHour(convertSpeedToSpeedInKilometersPerHour(verticalSpeedAvg.getValue())));
+            }
+        }
+        if (!activity.getStat(DataVerticalSpeedAvgMilesPerHour.type)) {
+            const verticalSpeedAvg = activity.getStat(DataVerticalSpeedAvg.type);
+            if (verticalSpeedAvg) {
+                activity.addStat(new DataVerticalSpeedAvgMilesPerHour(convertSpeedToSpeedInMilesPerHour(verticalSpeedAvg.getValue())));
+            }
+        }
+        if (!activity.getStat(DataVerticalSpeedMaxFeetPerSecond.type)) {
+            const verticalSpeedMax = activity.getStat(DataVerticalSpeedMax.type);
+            if (verticalSpeedMax) {
+                activity.addStat(new DataVerticalSpeedMaxFeetPerSecond(convertSpeedToSpeedInFeetPerSecond(verticalSpeedMax.getValue())));
+            }
+        }
+        if (!activity.getStat(DataVerticalSpeedMaxMetersPerMinute.type)) {
+            const verticalSpeedMax = activity.getStat(DataVerticalSpeedMax.type);
+            if (verticalSpeedMax) {
+                activity.addStat(new DataVerticalSpeedMaxMetersPerMinute(convertSpeedToSpeedInMetersPerMinute(verticalSpeedMax.getValue())));
+            }
+        }
+        if (!activity.getStat(DataVerticalSpeedMaxFeetPerMinute.type)) {
+            const verticalSpeedMax = activity.getStat(DataVerticalSpeedMax.type);
+            if (verticalSpeedMax) {
+                activity.addStat(new DataVerticalSpeedMaxFeetPerMinute(convertSpeedToSpeedInFeetPerMinute(verticalSpeedMax.getValue())));
+            }
+        }
+        if (!activity.getStat(DataVerticalSpeedMaxMetersPerHour.type)) {
+            const verticalSpeedMax = activity.getStat(DataVerticalSpeedMax.type);
+            if (verticalSpeedMax) {
+                activity.addStat(new DataVerticalSpeedMaxMetersPerHour(convertSpeedToSpeedInMetersPerHour(verticalSpeedMax.getValue())));
+            }
+        }
+        if (!activity.getStat(DataVerticalSpeedMaxFeetPerHour.type)) {
+            const verticalSpeedMax = activity.getStat(DataVerticalSpeedMax.type);
+            if (verticalSpeedMax) {
+                activity.addStat(new DataVerticalSpeedMaxFeetPerHour(convertSpeedToSpeedInFeetPerHour(verticalSpeedMax.getValue())));
+            }
+        }
+        if (!activity.getStat(DataVerticalSpeedMaxKilometerPerHour.type)) {
+            const verticalSpeedMax = activity.getStat(DataVerticalSpeedMax.type);
+            if (verticalSpeedMax) {
+                activity.addStat(new DataVerticalSpeedMaxKilometerPerHour(convertSpeedToSpeedInKilometersPerHour(verticalSpeedMax.getValue())));
+            }
+        }
+        if (!activity.getStat(DataVerticalSpeedMaxMilesPerHour.type)) {
+            const verticalSpeedMax = activity.getStat(DataVerticalSpeedMax.type);
+            if (verticalSpeedMax) {
+                activity.addStat(new DataVerticalSpeedMaxMilesPerHour(convertSpeedToSpeedInMilesPerHour(verticalSpeedMax.getValue())));
+            }
+        }
+        if (!activity.getStat(DataVerticalSpeedMinFeetPerSecond.type)) {
+            const verticalSpeedMin = activity.getStat(DataVerticalSpeedMin.type);
+            if (verticalSpeedMin) {
+                activity.addStat(new DataVerticalSpeedMinFeetPerSecond(convertSpeedToSpeedInFeetPerSecond(verticalSpeedMin.getValue())));
+            }
+        }
+        if (!activity.getStat(DataVerticalSpeedMinMetersPerMinute.type)) {
+            const verticalSpeedMin = activity.getStat(DataVerticalSpeedMin.type);
+            if (verticalSpeedMin) {
+                activity.addStat(new DataVerticalSpeedMinMetersPerMinute(convertSpeedToSpeedInMetersPerMinute(verticalSpeedMin.getValue())));
+            }
+        }
+        if (!activity.getStat(DataVerticalSpeedMinFeetPerMinute.type)) {
+            const verticalSpeedMin = activity.getStat(DataVerticalSpeedMin.type);
+            if (verticalSpeedMin) {
+                activity.addStat(new DataVerticalSpeedMinFeetPerMinute(convertSpeedToSpeedInFeetPerMinute(verticalSpeedMin.getValue())));
+            }
+        }
+        if (!activity.getStat(DataVerticalSpeedMinMetersPerHour.type)) {
+            const verticalSpeedMin = activity.getStat(DataVerticalSpeedMin.type);
+            if (verticalSpeedMin) {
+                activity.addStat(new DataVerticalSpeedMinMetersPerHour(convertSpeedToSpeedInMetersPerHour(verticalSpeedMin.getValue())));
+            }
+        }
+        if (!activity.getStat(DataVerticalSpeedMinFeetPerHour.type)) {
+            const verticalSpeedMin = activity.getStat(DataVerticalSpeedMin.type);
+            if (verticalSpeedMin) {
+                activity.addStat(new DataVerticalSpeedMinFeetPerHour(convertSpeedToSpeedInFeetPerHour(verticalSpeedMin.getValue())));
+            }
+        }
+        if (!activity.getStat(DataVerticalSpeedMinKilometerPerHour.type)) {
+            const verticalSpeedMin = activity.getStat(DataVerticalSpeedMin.type);
+            if (verticalSpeedMin) {
+                activity.addStat(new DataVerticalSpeedMinKilometerPerHour(convertSpeedToSpeedInKilometersPerHour(verticalSpeedMin.getValue())));
+            }
+        }
+        if (!activity.getStat(DataVerticalSpeedMinMilesPerHour.type)) {
+            const verticalSpeedMin = activity.getStat(DataVerticalSpeedMin.type);
+            if (verticalSpeedMin) {
+                activity.addStat(new DataVerticalSpeedMinMilesPerHour(convertSpeedToSpeedInMilesPerHour(verticalSpeedMin.getValue())));
+            }
+        }
+        // Test SWOLF existence for swimming activities
+        if ((activity.type === ActivityTypes.Swimming || activity.type === ActivityTypes.OpenWaterSwimming) &&
+            (!activity.getStat(DataSWOLF25m.type) || !activity.getStat(DataSWOLF50m.type)) &&
+            ((_a = activity.getStat(DataSpeedAvg.type)) === null || _a === void 0 ? void 0 : _a.getValue()) &&
+            ((_b = activity.getStat(DataCadenceAvg.type)) === null || _b === void 0 ? void 0 : _b.getValue())) {
+            const avgPace100m = 100 / activity.getStat(DataSpeedAvg.type).getValue();
+            const avgCadence = activity.getStat(DataCadenceAvg.type).getValue();
+            if (!activity.getStat(DataSWOLF25m.type)) {
+                const swolf25m = ActivityUtilities.computeSwimSwolf(avgPace100m, avgCadence, 25);
+                activity.addStat(new DataSWOLF25m(swolf25m));
+            }
+            if (!activity.getStat(DataSWOLF50m.type)) {
+                const swolf50m = ActivityUtilities.computeSwimSwolf(avgPace100m, avgCadence, 50);
+                activity.addStat(new DataSWOLF50m(swolf50m));
+            }
+        }
+        if (!activity.getStat(DataDuration.type)) {
+            activity.addStat(new DataDuration((activity.endDate.getTime() - activity.startDate.getTime()) / 1000));
+        }
+        // If timer time not set, then assign elapsed time by default (e.g. GPX file dont support timer time)
+        if (!activity.getStat(DataTimerTime.type)) {
+            activity.addStat(new DataTimerTime(this.round(activity.getDuration().getValue(), 2)));
+        }
+        // If missing moving time
+        // Or moving time equals duration, then try to build real moving from laps if available
+        if (!activity.getStat(DataMovingTime.type)) {
+            let movingTime = 0;
+            // First try to compute moving time from laps
+            const laps = activity.getLaps();
+            if (laps && laps.length > 0) {
+                activity.getLaps().forEach(lap => {
+                    const stat = lap.getStat(DataMovingTime.type);
+                    if (stat) {
+                        movingTime += stat.getValue();
+                    }
+                });
+            }
+            // Get timer time...
+            const timerTime = (_c = activity.getStat(DataTimerTime.type)) === null || _c === void 0 ? void 0 : _c.getValue();
+            // ... and compare with moving time and determine if moving time is like "moving time"
+            const isMovingTimeAlike = movingTime > 0 && movingTime < timerTime;
+            // If moving time from laps is not valid
+            if (!isMovingTimeAlike && activity.hasStreamData(DataSpeed.type)) {
+                // ...then re-compute moving time but using global records.
+                movingTime = 0;
+                const speedByDurationStream = activity.getStreamDataByDuration(DataSpeed.type, true, true);
+                const speedThreshold = ActivityTypesMoving.getSpeedThreshold(activity.type);
+                speedByDurationStream.forEach((speedItem, index) => {
+                    var _a;
+                    if (speedItem.value !== null && speedItem.value > speedThreshold) {
+                        movingTime += (speedByDurationStream[index].time - (((_a = speedByDurationStream[index - 1]) === null || _a === void 0 ? void 0 : _a.time) || 0)) / 1000;
+                    }
+                });
+            }
+            // In case moving time would be invalid, set it to timer time "at max"
+            if (!movingTime || movingTime > timerTime) {
+                movingTime = timerTime;
+            }
+            activity.addStat(new DataMovingTime(movingTime));
+        }
+        // Add Power Work if missing when avg power and moving time are available
+        if (!activity.getStat(DataPowerWork.type) &&
+            activity.getStat(DataPowerAvg.type) &&
+            activity.getStat(DataMovingTime.type)) {
+            const movingTime = activity.getStat(DataMovingTime.type).getValue();
+            const avgPower = activity.getStat(DataPowerAvg.type).getValue();
+            const powerWork = Math.round((avgPower * movingTime) / 1000);
+            activity.addStat(new DataPowerWork(powerWork));
+        }
+        // If there is no pause defined then get it from duration and moving time (if available)
+        if (!activity.getStat(DataPause.type) || !activity.getStat(DataPause.type).getValue()) {
+            const movingTimeStat = activity.getStat(DataMovingTime.type);
+            const pauseTime = movingTimeStat && movingTimeStat.getValue() ? activity.getDuration().getValue() - movingTimeStat.getValue() : 0;
+            activity.addStat(new DataPause(this.round(pauseTime, 2)));
+        }
+    }
+}
+ActivityUtilities.geoLibAdapter = new GeoLibAdapter();