@sports-alliance/sports-lib 6.1.10 → 6.1.12

package/babel.config.js

@@ -1,3 +1,3 @@
 module.exports = {
-    presets: [['@babel/preset-env', { targets: { node: 'current' } }]],
+  presets: [['@babel/preset-env', { targets: { node: 'current' } }]]
 };

package/jest.config.js

@@ -18,5 +18,6 @@ module.exports = {
     'ts-jest': {
       babelConfig: true
     }
-  }
+  },
+  setupFilesAfterEnv: ['<rootDir>/jest.setup.ts']
 };

package/jest.setup.ts

@@ -0,0 +1,9 @@
+
+import { ActivityParsingOptions } from './src/activities/activity-parsing-options';
+
+// Disable unit stream generation by default for tests to improve performance
+// This creates separate arrays for km/h, mph, etc. which are expensive and rarely needed in tests
+// unless specifically testing the charting logic or unit conversion.
+ActivityParsingOptions.DEFAULT.generateUnitStreams = false;
+
+console.log('Jest Setup: Disabled ActivityParsingOptions.generateUnitStreams for faster tests.');

package/lib/cjs/activities/activity.types.js

@@ -48,6 +48,7 @@ class ActivityTypesHelper {
             case ActivityTypeGroups.TrailRunning:
                 return [data_pace_avg_1.DataPaceAvg.type, data_grade_adjusted_pace_avg_1.DataGradeAdjustedPaceAvg.type, data_speed_avg_1.DataSpeedAvg.type, data_grade_adjusted_speed_avg_1.DataGradeAdjustedSpeedAvg.type];
             case ActivityTypeGroups.WaterSports:
+            case ActivityTypeGroups.Swimming:
                 return [data_speed_avg_1.DataSpeedAvg.type, data_swim_pace_avg_1.DataSwimPaceAvg.type];
             default:
                 return [data_speed_avg_1.DataSpeedAvg.type];
@@ -60,6 +61,7 @@ class ActivityTypesHelper {
             case ActivityTypeGroups.TrailRunning:
                 return [data_pace_1.DataPace.type, data_speed_1.DataSpeed.type];
             case ActivityTypeGroups.WaterSports:
+            case ActivityTypeGroups.Swimming:
                 return [data_speed_1.DataSpeed.type, data_swim_pace_1.DataSwimPace.type];
             default:
                 return [data_speed_1.DataSpeed.type];

package/lib/cjs/data/data-store.spec.js

@@ -70,7 +70,9 @@ describe('DataStore', () => {
                 temperatureUnits: [],
                 weightUnits: []
             };
-            const result = data_store_1.DynamicDataLoader.getUnitBasedDataTypesFromDataTypes([data_speed_1.DataSpeed.type], settings, { includeDerivedTypes: false });
+            const result = data_store_1.DynamicDataLoader.getUnitBasedDataTypesFromDataTypes([data_speed_1.DataSpeed.type], settings, {
+                includeDerivedTypes: false
+            });
             expect(result).toContain(data_speed_1.DataSpeedKilometersPerHour.type);
             expect(result).not.toContain(data_pace_1.DataPaceMinutesPerMile.type);
         });

package/lib/cjs/events/adapters/importers/fit/importer.fit.js

@@ -627,10 +627,20 @@ class EventImporterFIT {
         // Pause TIME on Object (activity, lap...)
         const pause = elapsedTime > movingTime && movingTime > 0 ? Math.round((elapsedTime - movingTime) * 100) / 100 : 0;
         stats.push(new data_pause_1.DataPause(pause));
+        const getStatValue = (obj, keys) => {
+            for (const key of keys) {
+                if ((0, helpers_1.isNumberOrString)(obj[key])) {
+                    return obj[key];
+                }
+            }
+            return null;
+        };
+        const avgSpeed = getStatValue(object, ['enhanced_avg_speed', 'EnhancedAvgSpeed', 'avg_speed', 'AvgSpeed']);
+        const totalDistance = getStatValue(object, ['total_distance', 'TotalDistance']);
         // Assign is active lap status
-        stats.push(new data_active_lap_1.DataActiveLap(!!(object.total_distance || object.avg_speed)));
-        if ((0, helpers_1.isNumberOrString)(object.total_distance)) {
-            stats.push(new data_distance_1.DataDistance(object.total_distance));
+        stats.push(new data_active_lap_1.DataActiveLap(!!(totalDistance || avgSpeed)));
+        if (totalDistance !== null) {
+            stats.push(new data_distance_1.DataDistance(totalDistance));
         }
         else {
             stats.push(new data_distance_1.DataDistance(0));
@@ -690,24 +700,16 @@ class EventImporterFIT {
             stats.push(new data_power_pedal_smoothness_right_1.DataPowerPedalSmoothnessRight(object.avg_right_pedal_smoothness));
         }
         // Speed
-        if ((0, helpers_1.isNumberOrString)(object.avg_speed)) {
-            stats.push(new data_speed_avg_1.DataSpeedAvg(object.avg_speed));
-        }
-        if ((0, helpers_1.isNumberOrString)(object.min_speed)) {
-            stats.push(new data_speed_min_1.DataSpeedMin(object.min_speed));
-        }
-        if ((0, helpers_1.isNumberOrString)(object.max_speed)) {
-            stats.push(new data_speed_max_1.DataSpeedMax(object.max_speed));
-        }
-        // Keep latest , enhanced @todo this can create a bug
-        if ((0, helpers_1.isNumberOrString)(object.enhanced_avg_speed)) {
-            stats.push(new data_speed_avg_1.DataSpeedAvg(object.enhanced_avg_speed));
+        if (avgSpeed !== null) {
+            stats.push(new data_speed_avg_1.DataSpeedAvg(avgSpeed));
         }
-        if ((0, helpers_1.isNumberOrString)(object.enhanced_min_speed)) {
-            stats.push(new data_speed_min_1.DataSpeedMin(object.enhanced_min_speed));
+        const minSpeed = getStatValue(object, ['enhanced_min_speed', 'EnhancedMinSpeed', 'min_speed', 'MinSpeed']);
+        if (minSpeed !== null) {
+            stats.push(new data_speed_min_1.DataSpeedMin(minSpeed));
         }
-        if ((0, helpers_1.isNumberOrString)(object.enhanced_max_speed)) {
-            stats.push(new data_speed_max_1.DataSpeedMax(object.enhanced_max_speed));
+        const maxSpeed = getStatValue(object, ['enhanced_max_speed', 'EnhancedMaxSpeed', 'max_speed', 'MaxSpeed']);
+        if (maxSpeed !== null) {
+            stats.push(new data_speed_max_1.DataSpeedMax(maxSpeed));
         }
         // Temperature
         if ((0, helpers_1.isNumberOrString)(object.avg_temperature)) {
@@ -720,12 +722,14 @@ class EventImporterFIT {
             stats.push(new data_temperature_max_1.DataTemperatureMax(object.max_temperature));
         }
         // Ascent
-        if ((0, helpers_1.isNumberOrString)(object.total_ascent)) {
-            stats.push(new data_ascent_1.DataAscent(object.total_ascent));
+        const ascent = getStatValue(object, ['total_ascent', 'TotalAscent']);
+        if (ascent !== null) {
+            stats.push(new data_ascent_1.DataAscent(ascent));
         }
         // Descent
-        if ((0, helpers_1.isNumberOrString)(object.total_descent)) {
-            stats.push(new data_descent_1.DataDescent(object.total_descent));
+        const descent = getStatValue(object, ['total_descent', 'TotalDescent']);
+        if (descent !== null) {
+            stats.push(new data_descent_1.DataDescent(descent));
         }
         // Calories
         if ((0, helpers_1.isNumberOrString)(object.total_calories)) {

package/lib/cjs/events/adapters/importers/fit/importer.fit.mapper.js

@@ -50,7 +50,7 @@ exports.FITSampleMapper = [
     {
         dataType: data_distance_1.DataDistance.type,
         getSampleValue: (sample) => {
-            return sample.distance;
+            return (0, helpers_1.isNumber)(sample.distance) ? sample.distance : sample.Distance;
         }
     },
     {
@@ -62,13 +62,19 @@ exports.FITSampleMapper = [
     {
         dataType: data_altitude_1.DataAltitude.type,
         getSampleValue: (sample) => {
-            return (0, helpers_1.isNumber)(sample.enhanced_altitude)
-                ? Math.round(sample.enhanced_altitude * Math.pow(10, constants_1.ALTITUDE_PRECISION_NUMBER_OF_DECIMAL_PLACES)) /
+            const altitude = (0, helpers_1.isNumber)(sample.enhanced_altitude)
+                ? sample.enhanced_altitude
+                : (0, helpers_1.isNumber)(sample.EnhancedAltitude)
+                    ? sample.EnhancedAltitude
+                    : (0, helpers_1.isNumber)(sample.altitude)
+                        ? sample.altitude
+                        : (0, helpers_1.isNumber)(sample.Altitude)
+                            ? sample.Altitude
+                            : null;
+            return (0, helpers_1.isNumber)(altitude)
+                ? Math.round(altitude * Math.pow(10, constants_1.ALTITUDE_PRECISION_NUMBER_OF_DECIMAL_PLACES)) /
                     Math.pow(10, constants_1.ALTITUDE_PRECISION_NUMBER_OF_DECIMAL_PLACES)
-                : (0, helpers_1.isNumber)(sample.altitude)
-                    ? Math.round(sample.altitude * Math.pow(10, constants_1.ALTITUDE_PRECISION_NUMBER_OF_DECIMAL_PLACES)) /
-                        Math.pow(10, constants_1.ALTITUDE_PRECISION_NUMBER_OF_DECIMAL_PLACES)
-                    : sample.altitude;
+                : altitude;
         }
     },
     {
@@ -105,12 +111,18 @@ exports.FITSampleMapper = [
     {
         dataType: data_speed_1.DataSpeed.type,
         getSampleValue: (sample) => {
-            if (Number.isFinite(sample.enhanced_speed)) {
+            if ((0, helpers_1.isNumber)(sample.enhanced_speed)) {
                 return sample.enhanced_speed;
             }
-            if (Number.isFinite(sample.speed)) {
+            if ((0, helpers_1.isNumber)(sample.EnhancedSpeed)) {
+                return sample.EnhancedSpeed;
+            }
+            if ((0, helpers_1.isNumber)(sample.speed)) {
                 return sample.speed;
             }
+            if ((0, helpers_1.isNumber)(sample.Speed)) {
+                return sample.Speed;
+            }
             return null;
         }
     },

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

@@ -291,9 +291,12 @@ class ActivityUtilities {
     static generateMissingStreams(activity) {
         // Compute missing streams
         this.generateMissingStreamsForActivity(activity);
-        if (!activity.parseOptions || activity.parseOptions.generateUnitStreams) {
-            activity.addStreams(this.createUnitStreamsFromStreams(activity.getAllStreams(), activity.type));
-        }
+        // Always include derived base streams (like Pace), but conditionally include unit variants
+        const includeUnitVariants = !activity.parseOptions || activity.parseOptions.generateUnitStreams;
+        activity.addStreams(this.createUnitStreamsFromStreams(activity.getAllStreams(), activity.type, undefined, {
+            includeDerivedTypes: true,
+            includeUnitVariants
+        }));
     }
     static getSummaryStatsForActivities(activities) {
         const stats = [];
@@ -680,34 +683,37 @@ class ActivityUtilities {
         includeUnitVariants: true
     }) {
         // @todo perhaps check input to be unitStreamTypesStrictly
-        const unitStreamTypesToCreate = unitStreamTypes || data_store_1.DynamicDataLoader.allUnitDerivedDataTypes;
+        const unitStreamTypesToCreate = unitStreamTypes || [
+            ...data_store_1.DynamicDataLoader.allUnitDerivedDataTypes,
+            ...data_store_1.DynamicDataLoader.speedDerivedDataTypes
+        ];
         let baseUnitStreams = [];
-        const speedStream = streams.find(stream => stream.type === data_speed_1.DataSpeed.type);
-        if (speedStream) {
-            if (options.includeDerivedTypes) {
-                baseUnitStreams = baseUnitStreams.concat(this.createByActivityTypeSpeedBasedStreams(speedStream, activityType));
+        // Iterate over all possible base types that can have unit variants
+        // This allows us to dynamically include ALL base streams (like Distance, Power, etc.) that need unit conversion
+        Object.keys(data_store_1.DynamicDataLoader.dataTypeUnitGroups).forEach(baseDataType => {
+            const stream = streams.find(s => s.type === baseDataType);
+            if (!stream) {
+                return;
             }
-            else {
-                baseUnitStreams.push(speedStream);
+            // Special handling for derived types (Pace from Speed, etc.)
+            if (baseDataType === data_speed_1.DataSpeed.type && options.includeDerivedTypes) {
+                baseUnitStreams = baseUnitStreams.concat(this.createByActivityTypeSpeedBasedStreams(stream, activityType));
+                return;
             }
-        }
-        const gradeAdjustedSpeedStream = streams.find(stream => stream.type === data_grade_adjusted_speed_1.DataGradeAdjustedSpeed.type);
-        if (gradeAdjustedSpeedStream) {
-            if (options.includeDerivedTypes) {
-                baseUnitStreams = baseUnitStreams.concat(this.createByActivityTypeAltiDistanceSpeedBasedStreams(gradeAdjustedSpeedStream, activityType));
+            if (baseDataType === data_grade_adjusted_speed_1.DataGradeAdjustedSpeed.type && options.includeDerivedTypes) {
+                baseUnitStreams = baseUnitStreams.concat(this.createByActivityTypeAltiDistanceSpeedBasedStreams(stream, activityType));
+                return;
             }
-            else {
-                baseUnitStreams.push(gradeAdjustedSpeedStream);
+            if (baseDataType === data_vertical_speed_1.DataVerticalSpeed.type) {
+                // Vertical speed handling
+                if (activity_types_1.ActivityTypesHelper.verticalSpeedDerivedDataTypesToUseForActivityType(activityType).length) {
+                    baseUnitStreams.push(stream);
+                }
+                return;
             }
-        }
-        const verticalSpeedStream = streams.find(stream => stream.type === data_vertical_speed_1.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 = activity_types_1.ActivityTypesHelper.verticalSpeedDerivedDataTypesToUseForActivityType(activityType).length
-                ? baseUnitStreams.concat(verticalSpeedStream)
-                : baseUnitStreams;
-        }
-        // @todo add distance ?
+            // For everything else (like Distance), just add the base stream so it can be used for unit generation
+            baseUnitStreams.push(stream);
+        });
         const startWith = baseUnitStreams.filter(baseUnitStream => unitStreamTypesToCreate.indexOf(baseUnitStream.type) !== -1 && streams.indexOf(baseUnitStream) === -1);
         if (options.includeUnitVariants === false) {
             return startWith;
@@ -867,7 +873,8 @@ class ActivityUtilities {
             activity.addStream(leftPowerStream);
         }
         // If left stance time stream available, then add the right balance stream too
-        if (activity.hasStreamData(data_stance_time_balance_left_1.DataStanceTimeBalanceLeft.type) && !activity.hasStreamData(data_stance_time_balance_right_1.DataStanceTimeBalanceRight.type)) {
+        if (activity.hasStreamData(data_stance_time_balance_left_1.DataStanceTimeBalanceLeft.type) &&
+            !activity.hasStreamData(data_stance_time_balance_right_1.DataStanceTimeBalanceRight.type)) {
             const rightStanceBalanceTimeStream = activity.createStream(data_stance_time_balance_right_1.DataStanceTimeBalanceRight.type);
             const leftStanceBalanceTimeStream = activity.getStreamData(data_stance_time_balance_left_1.DataStanceTimeBalanceLeft.type);
             const rightStanceBalanceTimeData = leftStanceBalanceTimeStream.map(leftBalance => {

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

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const event_1 = require("../event");
 const data_speed_max_1 = require("../../data/data.speed-max");
 const activity_1 = require("../../activities/activity");
+const activity_parsing_options_1 = require("../../activities/activity-parsing-options");
 const data_heart_rate_1 = require("../../data/data.heart-rate");
 const data_altitude_1 = require("../../data/data.altitude");
 const data_distance_1 = require("../../data/data.distance");
@@ -20,6 +21,7 @@ const file_type_enum_1 = require("../adapters/file-type.enum");
 const importer_json_1 = require("../adapters/importers/json/importer.json");
 const data_pace_1 = require("../../data/data.pace");
 const data_speed_2 = require("../../data/data.speed");
+const data_swim_pace_1 = require("../../data/data.swim-pace");
 describe('Activity Utilities', () => {
     let event;
     beforeEach(() => {
@@ -238,7 +240,10 @@ describe('Activity Utilities', () => {
         });
         it('should exclude derived types when includeDerivedTypes is false', () => {
             const streams = [new stream_1.Stream(data_speed_1.DataSpeed.type, [10, 20])];
-            const result = activity_utilities_1.ActivityUtilities.createUnitStreamsFromStreams(streams, activity_types_1.ActivityTypes.Running, undefined, { includeDerivedTypes: false, includeUnitVariants: true });
+            const result = activity_utilities_1.ActivityUtilities.createUnitStreamsFromStreams(streams, activity_types_1.ActivityTypes.Running, undefined, {
+                includeDerivedTypes: false,
+                includeUnitVariants: true
+            });
             const paceStream = result.find(s => s.type === data_pace_1.DataPaceMinutesPerMile.type);
             const kmhStream = result.find(s => s.type === data_speed_2.DataSpeedKilometersPerHour.type);
             expect(paceStream).toBeUndefined();
@@ -247,7 +252,10 @@ describe('Activity Utilities', () => {
         it('should exclude unit variants when includeUnitVariants is false', () => {
             const streams = [new stream_1.Stream(data_speed_1.DataSpeed.type, [10, 20])];
             // We pass DataPace.type in unitStreamTypes so we can check if the derived base stream is present
-            const result = activity_utilities_1.ActivityUtilities.createUnitStreamsFromStreams(streams, activity_types_1.ActivityTypes.Running, [data_pace_1.DataPace.type], { includeDerivedTypes: true, includeUnitVariants: false });
+            const result = activity_utilities_1.ActivityUtilities.createUnitStreamsFromStreams(streams, activity_types_1.ActivityTypes.Running, [data_pace_1.DataPace.type], {
+                includeDerivedTypes: true,
+                includeUnitVariants: false
+            });
             const paceStream = result.find(s => s.type === data_pace_1.DataPace.type);
             const paceUnitStream = result.find(s => s.type === data_pace_1.DataPaceMinutesPerMile.type);
             expect(paceStream).toBeDefined(); // Derived type should be there
@@ -255,7 +263,10 @@ describe('Activity Utilities', () => {
         });
         it('should exclude both derived types and unit variants', () => {
             const streams = [new stream_1.Stream(data_speed_1.DataSpeed.type, [10, 20])];
-            const result = activity_utilities_1.ActivityUtilities.createUnitStreamsFromStreams(streams, activity_types_1.ActivityTypes.Running, [data_pace_1.DataPace.type], { includeDerivedTypes: false, includeUnitVariants: false });
+            const result = activity_utilities_1.ActivityUtilities.createUnitStreamsFromStreams(streams, activity_types_1.ActivityTypes.Running, [data_pace_1.DataPace.type], {
+                includeDerivedTypes: false,
+                includeUnitVariants: false
+            });
             const paceStream = result.find(s => s.type === data_pace_1.DataPace.type);
             const paceUnitStream = result.find(s => s.type === data_pace_1.DataPaceMinutesPerMile.type);
             expect(paceStream).toBeUndefined();
@@ -263,8 +274,8 @@ describe('Activity Utilities', () => {
         });
     });
     describe('generateMissingStreams', () => {
-        it('should generate unit streams by default (generateUnitStreams = true)', () => {
-            const activity = new activity_1.Activity(new Date(), new Date(), activity_types_1.ActivityTypes.Running, new creator_1.Creator('test'));
+        it('should generate unit streams when generateUnitStreams = true', () => {
+            const activity = new activity_1.Activity(new Date(), new Date(), activity_types_1.ActivityTypes.Running, new creator_1.Creator('test'), new activity_parsing_options_1.ActivityParsingOptions({ generateUnitStreams: true }));
             // Add a speed stream
             activity.addStream(new stream_1.Stream(data_speed_1.DataSpeed.type, [10, 20]));
             activity_utilities_1.ActivityUtilities.generateMissingStreams(activity);
@@ -278,7 +289,7 @@ describe('Activity Utilities', () => {
             activity.parseOptions = {
                 streams: { smooth: {}, fixAbnormal: {} },
                 maxActivityDurationDays: 14,
-                generateUnitStreams: false,
+                generateUnitStreams: false
             };
             // Add a speed stream
             activity.addStream(new stream_1.Stream(data_speed_1.DataSpeed.type, [10, 20]));
@@ -296,24 +307,69 @@ describe('Activity Utilities', () => {
             activity.parseOptions = {
                 streams: { smooth: {}, fixAbnormal: {} },
                 maxActivityDurationDays: 14,
-                generateUnitStreams: false, // DISABLE streams
+                generateUnitStreams: false // DISABLE streams
             };
             // Add a speed stream [10 m/s, 20 m/s]
             // Max speed = 20 m/s
             activity.addStream(new stream_1.Stream(data_speed_1.DataSpeed.type, [10, 20]));
             activity_utilities_1.ActivityUtilities.generateMissingStreamsAndStatsForActivity(activity);
-            // 1. Verify Streams are missing (as requested)
-            expect(activity.hasStreamData(data_speed_2.DataSpeedKilometersPerHour.type)).toBe(false);
-            // 1. Verify Streams are missing (as requested)
+            // 1. Verify Unit Streams are missing (as requested)
             expect(activity.hasStreamData(data_speed_2.DataSpeedKilometersPerHour.type)).toBe(false);
-            // 2. Verify Stats are PRESENT (Safety Check)
+            // 2. Verify Derived Base Streams are PRESENT (The fix)
+            expect(activity.hasStreamData(data_pace_1.DataPace.type)).toBe(true);
+            // 3. Verify Stats are PRESENT (Safety Check)
             // 20 m/s = 72 km/h
-            // We check for the stat by its string type if we can't import the constant easily, or iterate.
-            // Based on activity.utilities.ts it uses: DataSpeedMaxKilometersPerHour
             const allStats = Array.from(activity.getStats().values());
             const speedMaxKmh = allStats.find(s => s.getType() === data_speed_max_1.DataSpeedMaxKilometersPerHour.type);
             expect(speedMaxKmh).toBeDefined();
             expect(speedMaxKmh === null || speedMaxKmh === void 0 ? void 0 : speedMaxKmh.getValue()).toBe(72);
         });
+        it('should generate DataSwimPace when generateUnitStreams = false for swimming', () => {
+            const activity = new activity_1.Activity(new Date(), new Date(), activity_types_1.ActivityTypes.Swimming, new creator_1.Creator('test'));
+            activity.parseOptions = {
+                streams: { smooth: {}, fixAbnormal: {} },
+                maxActivityDurationDays: 14,
+                generateUnitStreams: false
+            };
+            activity.addStream(new stream_1.Stream(data_speed_1.DataSpeed.type, [1, 2])); // m/s
+            activity_utilities_1.ActivityUtilities.generateMissingStreamsAndStatsForActivity(activity);
+            // Verify Unit Streams missing
+            expect(activity.hasStreamData(data_speed_2.DataSpeedKilometersPerHour.type)).toBe(false);
+            // Verify Derived Base Stream (Swim Pace) IS present
+            expect(activity.hasStreamData(data_swim_pace_1.DataSwimPace.type)).toBe(true);
+        });
+        it('should generate DataDistanceMiles when generateUnitStreams = true', () => {
+            const activity = new activity_1.Activity(new Date(), new Date(), activity_types_1.ActivityTypes.Running, new creator_1.Creator('test'), new activity_parsing_options_1.ActivityParsingOptions({ generateUnitStreams: true }));
+            activity.addStream(new stream_1.Stream(data_distance_1.DataDistance.type, [1000, 2000]));
+            activity_utilities_1.ActivityUtilities.generateMissingStreamsAndStatsForActivity(activity);
+            // Should generate miles
+            expect(activity.hasStreamData(data_distance_1.DataDistanceMiles.type)).toBe(true);
+        });
+        it('should NOT generate DataDistanceMiles when generateUnitStreams = false', () => {
+            const activity = new activity_1.Activity(new Date(), new Date(), activity_types_1.ActivityTypes.Running, new creator_1.Creator('test'));
+            activity.parseOptions = {
+                streams: { smooth: {}, fixAbnormal: {} },
+                maxActivityDurationDays: 14,
+                generateUnitStreams: false
+            };
+            activity.addStream(new stream_1.Stream(data_distance_1.DataDistance.type, [1000, 2000]));
+            activity_utilities_1.ActivityUtilities.generateMissingStreamsAndStatsForActivity(activity);
+            // Should NOT generate miles
+            expect(activity.hasStreamData(data_distance_1.DataDistanceMiles.type)).toBe(false);
+            // But base Distance should still be there (it was added manually)
+            expect(activity.hasStreamData(data_distance_1.DataDistance.type)).toBe(true);
+        });
+        it('should generate unit streams for Mountain Biking using DataSpeed', () => {
+            const speedData = [10, 20, 30]; // m/s
+            const speedStream = new stream_1.Stream(data_speed_1.DataSpeed.type, speedData);
+            // Mountain Biking (defaults to Cycling group)
+            const unitStreams = activity_utilities_1.ActivityUtilities.createUnitStreamsFromStreams([speedStream], activity_types_1.ActivityTypes.MountainBiking, undefined, // Auto-detect all known unit types
+            { includeDerivedTypes: true, includeUnitVariants: true });
+            const kmhStream = unitStreams.find(s => s.type === 'Speed in kilometers per hour');
+            expect(kmhStream).toBeDefined();
+            if (kmhStream) {
+                expect(kmhStream.getData()[0]).toBeCloseTo(36, 1); // 10 m/s = 36 km/h
+            }
+        });
     });
 });

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

@@ -45,6 +45,7 @@ export class ActivityTypesHelper {
             case ActivityTypeGroups.TrailRunning:
                 return [DataPaceAvg.type, DataGradeAdjustedPaceAvg.type, DataSpeedAvg.type, DataGradeAdjustedSpeedAvg.type];
             case ActivityTypeGroups.WaterSports:
+            case ActivityTypeGroups.Swimming:
                 return [DataSpeedAvg.type, DataSwimPaceAvg.type];
             default:
                 return [DataSpeedAvg.type];
@@ -57,6 +58,7 @@ export class ActivityTypesHelper {
             case ActivityTypeGroups.TrailRunning:
                 return [DataPace.type, DataSpeed.type];
             case ActivityTypeGroups.WaterSports:
+            case ActivityTypeGroups.Swimming:
                 return [DataSpeed.type, DataSwimPace.type];
             default:
                 return [DataSpeed.type];

package/lib/esm/data/data-store.spec.js

@@ -68,7 +68,9 @@ describe('DataStore', () => {
                 temperatureUnits: [],
                 weightUnits: []
             };
-            const result = DynamicDataLoader.getUnitBasedDataTypesFromDataTypes([DataSpeed.type], settings, { includeDerivedTypes: false });
+            const result = DynamicDataLoader.getUnitBasedDataTypesFromDataTypes([DataSpeed.type], settings, {
+                includeDerivedTypes: false
+            });
             expect(result).toContain(DataSpeedKilometersPerHour.type);
             expect(result).not.toContain(DataPaceMinutesPerMile.type);
         });

package/lib/esm/events/adapters/importers/fit/importer.fit.js

@@ -621,10 +621,20 @@ export class EventImporterFIT {
         // Pause TIME on Object (activity, lap...)
         const pause = elapsedTime > movingTime && movingTime > 0 ? Math.round((elapsedTime - movingTime) * 100) / 100 : 0;
         stats.push(new DataPause(pause));
+        const getStatValue = (obj, keys) => {
+            for (const key of keys) {
+                if (isNumberOrString(obj[key])) {
+                    return obj[key];
+                }
+            }
+            return null;
+        };
+        const avgSpeed = getStatValue(object, ['enhanced_avg_speed', 'EnhancedAvgSpeed', 'avg_speed', 'AvgSpeed']);
+        const totalDistance = getStatValue(object, ['total_distance', 'TotalDistance']);
         // Assign is active lap status
-        stats.push(new DataActiveLap(!!(object.total_distance || object.avg_speed)));
-        if (isNumberOrString(object.total_distance)) {
-            stats.push(new DataDistance(object.total_distance));
+        stats.push(new DataActiveLap(!!(totalDistance || avgSpeed)));
+        if (totalDistance !== null) {
+            stats.push(new DataDistance(totalDistance));
         }
         else {
             stats.push(new DataDistance(0));
@@ -684,24 +694,16 @@ export class EventImporterFIT {
             stats.push(new DataPowerPedalSmoothnessRight(object.avg_right_pedal_smoothness));
         }
         // Speed
-        if (isNumberOrString(object.avg_speed)) {
-            stats.push(new DataSpeedAvg(object.avg_speed));
-        }
-        if (isNumberOrString(object.min_speed)) {
-            stats.push(new DataSpeedMin(object.min_speed));
-        }
-        if (isNumberOrString(object.max_speed)) {
-            stats.push(new DataSpeedMax(object.max_speed));
-        }
-        // Keep latest , enhanced @todo this can create a bug
-        if (isNumberOrString(object.enhanced_avg_speed)) {
-            stats.push(new DataSpeedAvg(object.enhanced_avg_speed));
+        if (avgSpeed !== null) {
+            stats.push(new DataSpeedAvg(avgSpeed));
         }
-        if (isNumberOrString(object.enhanced_min_speed)) {
-            stats.push(new DataSpeedMin(object.enhanced_min_speed));
+        const minSpeed = getStatValue(object, ['enhanced_min_speed', 'EnhancedMinSpeed', 'min_speed', 'MinSpeed']);
+        if (minSpeed !== null) {
+            stats.push(new DataSpeedMin(minSpeed));
         }
-        if (isNumberOrString(object.enhanced_max_speed)) {
-            stats.push(new DataSpeedMax(object.enhanced_max_speed));
+        const maxSpeed = getStatValue(object, ['enhanced_max_speed', 'EnhancedMaxSpeed', 'max_speed', 'MaxSpeed']);
+        if (maxSpeed !== null) {
+            stats.push(new DataSpeedMax(maxSpeed));
         }
         // Temperature
         if (isNumberOrString(object.avg_temperature)) {
@@ -714,12 +716,14 @@ export class EventImporterFIT {
             stats.push(new DataTemperatureMax(object.max_temperature));
         }
         // Ascent
-        if (isNumberOrString(object.total_ascent)) {
-            stats.push(new DataAscent(object.total_ascent));
+        const ascent = getStatValue(object, ['total_ascent', 'TotalAscent']);
+        if (ascent !== null) {
+            stats.push(new DataAscent(ascent));
         }
         // Descent
-        if (isNumberOrString(object.total_descent)) {
-            stats.push(new DataDescent(object.total_descent));
+        const descent = getStatValue(object, ['total_descent', 'TotalDescent']);
+        if (descent !== null) {
+            stats.push(new DataDescent(descent));
         }
         // Calories
         if (isNumberOrString(object.total_calories)) {

package/lib/esm/events/adapters/importers/fit/importer.fit.mapper.js

@@ -47,7 +47,7 @@ export const FITSampleMapper = [
     {
         dataType: DataDistance.type,
         getSampleValue: (sample) => {
-            return sample.distance;
+            return isNumber(sample.distance) ? sample.distance : sample.Distance;
         }
     },
     {
@@ -59,13 +59,19 @@ export const FITSampleMapper = [
     {
         dataType: DataAltitude.type,
         getSampleValue: (sample) => {
-            return isNumber(sample.enhanced_altitude)
-                ? Math.round(sample.enhanced_altitude * Math.pow(10, ALTITUDE_PRECISION_NUMBER_OF_DECIMAL_PLACES)) /
+            const altitude = isNumber(sample.enhanced_altitude)
+                ? sample.enhanced_altitude
+                : isNumber(sample.EnhancedAltitude)
+                    ? sample.EnhancedAltitude
+                    : isNumber(sample.altitude)
+                        ? sample.altitude
+                        : isNumber(sample.Altitude)
+                            ? sample.Altitude
+                            : null;
+            return isNumber(altitude)
+                ? Math.round(altitude * Math.pow(10, ALTITUDE_PRECISION_NUMBER_OF_DECIMAL_PLACES)) /
                     Math.pow(10, ALTITUDE_PRECISION_NUMBER_OF_DECIMAL_PLACES)
-                : isNumber(sample.altitude)
-                    ? Math.round(sample.altitude * Math.pow(10, ALTITUDE_PRECISION_NUMBER_OF_DECIMAL_PLACES)) /
-                        Math.pow(10, ALTITUDE_PRECISION_NUMBER_OF_DECIMAL_PLACES)
-                    : sample.altitude;
+                : altitude;
         }
     },
     {
@@ -102,12 +108,18 @@ export const FITSampleMapper = [
     {
         dataType: DataSpeed.type,
         getSampleValue: (sample) => {
-            if (Number.isFinite(sample.enhanced_speed)) {
+            if (isNumber(sample.enhanced_speed)) {
                 return sample.enhanced_speed;
             }
-            if (Number.isFinite(sample.speed)) {
+            if (isNumber(sample.EnhancedSpeed)) {
+                return sample.EnhancedSpeed;
+            }
+            if (isNumber(sample.speed)) {
                 return sample.speed;
             }
+            if (isNumber(sample.Speed)) {
+                return sample.Speed;
+            }
             return null;
         }
     },

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

@@ -288,9 +288,12 @@ export class ActivityUtilities {
     static generateMissingStreams(activity) {
         // Compute missing streams
         this.generateMissingStreamsForActivity(activity);
-        if (!activity.parseOptions || activity.parseOptions.generateUnitStreams) {
-            activity.addStreams(this.createUnitStreamsFromStreams(activity.getAllStreams(), activity.type));
-        }
+        // Always include derived base streams (like Pace), but conditionally include unit variants
+        const includeUnitVariants = !activity.parseOptions || activity.parseOptions.generateUnitStreams;
+        activity.addStreams(this.createUnitStreamsFromStreams(activity.getAllStreams(), activity.type, undefined, {
+            includeDerivedTypes: true,
+            includeUnitVariants
+        }));
     }
     static getSummaryStatsForActivities(activities) {
         const stats = [];
@@ -677,34 +680,37 @@ export class ActivityUtilities {
         includeUnitVariants: true
     }) {
         // @todo perhaps check input to be unitStreamTypesStrictly
-        const unitStreamTypesToCreate = unitStreamTypes || DynamicDataLoader.allUnitDerivedDataTypes;
+        const unitStreamTypesToCreate = unitStreamTypes || [
+            ...DynamicDataLoader.allUnitDerivedDataTypes,
+            ...DynamicDataLoader.speedDerivedDataTypes
+        ];
         let baseUnitStreams = [];
-        const speedStream = streams.find(stream => stream.type === DataSpeed.type);
-        if (speedStream) {
-            if (options.includeDerivedTypes) {
-                baseUnitStreams = baseUnitStreams.concat(this.createByActivityTypeSpeedBasedStreams(speedStream, activityType));
+        // Iterate over all possible base types that can have unit variants
+        // This allows us to dynamically include ALL base streams (like Distance, Power, etc.) that need unit conversion
+        Object.keys(DynamicDataLoader.dataTypeUnitGroups).forEach(baseDataType => {
+            const stream = streams.find(s => s.type === baseDataType);
+            if (!stream) {
+                return;
             }
-            else {
-                baseUnitStreams.push(speedStream);
+            // Special handling for derived types (Pace from Speed, etc.)
+            if (baseDataType === DataSpeed.type && options.includeDerivedTypes) {
+                baseUnitStreams = baseUnitStreams.concat(this.createByActivityTypeSpeedBasedStreams(stream, activityType));
+                return;
             }
-        }
-        const gradeAdjustedSpeedStream = streams.find(stream => stream.type === DataGradeAdjustedSpeed.type);
-        if (gradeAdjustedSpeedStream) {
-            if (options.includeDerivedTypes) {
-                baseUnitStreams = baseUnitStreams.concat(this.createByActivityTypeAltiDistanceSpeedBasedStreams(gradeAdjustedSpeedStream, activityType));
+            if (baseDataType === DataGradeAdjustedSpeed.type && options.includeDerivedTypes) {
+                baseUnitStreams = baseUnitStreams.concat(this.createByActivityTypeAltiDistanceSpeedBasedStreams(stream, activityType));
+                return;
             }
-            else {
-                baseUnitStreams.push(gradeAdjustedSpeedStream);
+            if (baseDataType === DataVerticalSpeed.type) {
+                // Vertical speed handling
+                if (ActivityTypesHelper.verticalSpeedDerivedDataTypesToUseForActivityType(activityType).length) {
+                    baseUnitStreams.push(stream);
+                }
+                return;
             }
-        }
-        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 ?
+            // For everything else (like Distance), just add the base stream so it can be used for unit generation
+            baseUnitStreams.push(stream);
+        });
         const startWith = baseUnitStreams.filter(baseUnitStream => unitStreamTypesToCreate.indexOf(baseUnitStream.type) !== -1 && streams.indexOf(baseUnitStream) === -1);
         if (options.includeUnitVariants === false) {
             return startWith;
@@ -864,7 +870,8 @@ export class ActivityUtilities {
             activity.addStream(leftPowerStream);
         }
         // If left stance time stream available, then add the right balance stream too
-        if (activity.hasStreamData(DataStanceTimeBalanceLeft.type) && !activity.hasStreamData(DataStanceTimeBalanceRight.type)) {
+        if (activity.hasStreamData(DataStanceTimeBalanceLeft.type) &&
+            !activity.hasStreamData(DataStanceTimeBalanceRight.type)) {
             const rightStanceBalanceTimeStream = activity.createStream(DataStanceTimeBalanceRight.type);
             const leftStanceBalanceTimeStream = activity.getStreamData(DataStanceTimeBalanceLeft.type);
             const rightStanceBalanceTimeData = leftStanceBalanceTimeStream.map(leftBalance => {

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

@@ -1,9 +1,10 @@
 import { Event } from '../event';
 import { DataSpeedMaxKilometersPerHour } from '../../data/data.speed-max';
 import { Activity } from '../../activities/activity';
+import { ActivityParsingOptions } from '../../activities/activity-parsing-options';
 import { DataHeartRate } from '../../data/data.heart-rate';
 import { DataAltitude } from '../../data/data.altitude';
-import { DataDistance } from '../../data/data.distance';
+import { DataDistance, DataDistanceMiles } from '../../data/data.distance';
 import { DataDuration } from '../../data/data.duration';
 import { Creator } from '../../creators/creator';
 import { ActivityTypes } from '../../activities/activity.types';
@@ -18,6 +19,7 @@ import { FileType } from '../adapters/file-type.enum';
 import { EventImporterJSON } from '../adapters/importers/json/importer.json';
 import { DataPace, DataPaceMinutesPerMile } from '../../data/data.pace';
 import { DataSpeedKilometersPerHour } from '../../data/data.speed';
+import { DataSwimPace } from '../../data/data.swim-pace';
 describe('Activity Utilities', () => {
     let event;
     beforeEach(() => {
@@ -236,7 +238,10 @@ describe('Activity Utilities', () => {
         });
         it('should exclude derived types when includeDerivedTypes is false', () => {
             const streams = [new Stream(DataSpeed.type, [10, 20])];
-            const result = ActivityUtilities.createUnitStreamsFromStreams(streams, ActivityTypes.Running, undefined, { includeDerivedTypes: false, includeUnitVariants: true });
+            const result = ActivityUtilities.createUnitStreamsFromStreams(streams, ActivityTypes.Running, undefined, {
+                includeDerivedTypes: false,
+                includeUnitVariants: true
+            });
             const paceStream = result.find(s => s.type === DataPaceMinutesPerMile.type);
             const kmhStream = result.find(s => s.type === DataSpeedKilometersPerHour.type);
             expect(paceStream).toBeUndefined();
@@ -245,7 +250,10 @@ describe('Activity Utilities', () => {
         it('should exclude unit variants when includeUnitVariants is false', () => {
             const streams = [new Stream(DataSpeed.type, [10, 20])];
             // We pass DataPace.type in unitStreamTypes so we can check if the derived base stream is present
-            const result = ActivityUtilities.createUnitStreamsFromStreams(streams, ActivityTypes.Running, [DataPace.type], { includeDerivedTypes: true, includeUnitVariants: false });
+            const result = ActivityUtilities.createUnitStreamsFromStreams(streams, ActivityTypes.Running, [DataPace.type], {
+                includeDerivedTypes: true,
+                includeUnitVariants: false
+            });
             const paceStream = result.find(s => s.type === DataPace.type);
             const paceUnitStream = result.find(s => s.type === DataPaceMinutesPerMile.type);
             expect(paceStream).toBeDefined(); // Derived type should be there
@@ -253,7 +261,10 @@ describe('Activity Utilities', () => {
         });
         it('should exclude both derived types and unit variants', () => {
             const streams = [new Stream(DataSpeed.type, [10, 20])];
-            const result = ActivityUtilities.createUnitStreamsFromStreams(streams, ActivityTypes.Running, [DataPace.type], { includeDerivedTypes: false, includeUnitVariants: false });
+            const result = ActivityUtilities.createUnitStreamsFromStreams(streams, ActivityTypes.Running, [DataPace.type], {
+                includeDerivedTypes: false,
+                includeUnitVariants: false
+            });
             const paceStream = result.find(s => s.type === DataPace.type);
             const paceUnitStream = result.find(s => s.type === DataPaceMinutesPerMile.type);
             expect(paceStream).toBeUndefined();
@@ -261,8 +272,8 @@ describe('Activity Utilities', () => {
         });
     });
     describe('generateMissingStreams', () => {
-        it('should generate unit streams by default (generateUnitStreams = true)', () => {
-            const activity = new Activity(new Date(), new Date(), ActivityTypes.Running, new Creator('test'));
+        it('should generate unit streams when generateUnitStreams = true', () => {
+            const activity = new Activity(new Date(), new Date(), ActivityTypes.Running, new Creator('test'), new ActivityParsingOptions({ generateUnitStreams: true }));
             // Add a speed stream
             activity.addStream(new Stream(DataSpeed.type, [10, 20]));
             ActivityUtilities.generateMissingStreams(activity);
@@ -276,7 +287,7 @@ describe('Activity Utilities', () => {
             activity.parseOptions = {
                 streams: { smooth: {}, fixAbnormal: {} },
                 maxActivityDurationDays: 14,
-                generateUnitStreams: false,
+                generateUnitStreams: false
             };
             // Add a speed stream
             activity.addStream(new Stream(DataSpeed.type, [10, 20]));
@@ -294,24 +305,69 @@ describe('Activity Utilities', () => {
             activity.parseOptions = {
                 streams: { smooth: {}, fixAbnormal: {} },
                 maxActivityDurationDays: 14,
-                generateUnitStreams: false, // DISABLE streams
+                generateUnitStreams: false // DISABLE streams
             };
             // Add a speed stream [10 m/s, 20 m/s]
             // Max speed = 20 m/s
             activity.addStream(new Stream(DataSpeed.type, [10, 20]));
             ActivityUtilities.generateMissingStreamsAndStatsForActivity(activity);
-            // 1. Verify Streams are missing (as requested)
-            expect(activity.hasStreamData(DataSpeedKilometersPerHour.type)).toBe(false);
-            // 1. Verify Streams are missing (as requested)
+            // 1. Verify Unit Streams are missing (as requested)
             expect(activity.hasStreamData(DataSpeedKilometersPerHour.type)).toBe(false);
-            // 2. Verify Stats are PRESENT (Safety Check)
+            // 2. Verify Derived Base Streams are PRESENT (The fix)
+            expect(activity.hasStreamData(DataPace.type)).toBe(true);
+            // 3. Verify Stats are PRESENT (Safety Check)
             // 20 m/s = 72 km/h
-            // We check for the stat by its string type if we can't import the constant easily, or iterate.
-            // Based on activity.utilities.ts it uses: DataSpeedMaxKilometersPerHour
             const allStats = Array.from(activity.getStats().values());
             const speedMaxKmh = allStats.find(s => s.getType() === DataSpeedMaxKilometersPerHour.type);
             expect(speedMaxKmh).toBeDefined();
             expect(speedMaxKmh === null || speedMaxKmh === void 0 ? void 0 : speedMaxKmh.getValue()).toBe(72);
         });
+        it('should generate DataSwimPace when generateUnitStreams = false for swimming', () => {
+            const activity = new Activity(new Date(), new Date(), ActivityTypes.Swimming, new Creator('test'));
+            activity.parseOptions = {
+                streams: { smooth: {}, fixAbnormal: {} },
+                maxActivityDurationDays: 14,
+                generateUnitStreams: false
+            };
+            activity.addStream(new Stream(DataSpeed.type, [1, 2])); // m/s
+            ActivityUtilities.generateMissingStreamsAndStatsForActivity(activity);
+            // Verify Unit Streams missing
+            expect(activity.hasStreamData(DataSpeedKilometersPerHour.type)).toBe(false);
+            // Verify Derived Base Stream (Swim Pace) IS present
+            expect(activity.hasStreamData(DataSwimPace.type)).toBe(true);
+        });
+        it('should generate DataDistanceMiles when generateUnitStreams = true', () => {
+            const activity = new Activity(new Date(), new Date(), ActivityTypes.Running, new Creator('test'), new ActivityParsingOptions({ generateUnitStreams: true }));
+            activity.addStream(new Stream(DataDistance.type, [1000, 2000]));
+            ActivityUtilities.generateMissingStreamsAndStatsForActivity(activity);
+            // Should generate miles
+            expect(activity.hasStreamData(DataDistanceMiles.type)).toBe(true);
+        });
+        it('should NOT generate DataDistanceMiles when generateUnitStreams = false', () => {
+            const activity = new Activity(new Date(), new Date(), ActivityTypes.Running, new Creator('test'));
+            activity.parseOptions = {
+                streams: { smooth: {}, fixAbnormal: {} },
+                maxActivityDurationDays: 14,
+                generateUnitStreams: false
+            };
+            activity.addStream(new Stream(DataDistance.type, [1000, 2000]));
+            ActivityUtilities.generateMissingStreamsAndStatsForActivity(activity);
+            // Should NOT generate miles
+            expect(activity.hasStreamData(DataDistanceMiles.type)).toBe(false);
+            // But base Distance should still be there (it was added manually)
+            expect(activity.hasStreamData(DataDistance.type)).toBe(true);
+        });
+        it('should generate unit streams for Mountain Biking using DataSpeed', () => {
+            const speedData = [10, 20, 30]; // m/s
+            const speedStream = new Stream(DataSpeed.type, speedData);
+            // Mountain Biking (defaults to Cycling group)
+            const unitStreams = ActivityUtilities.createUnitStreamsFromStreams([speedStream], ActivityTypes.MountainBiking, undefined, // Auto-detect all known unit types
+            { includeDerivedTypes: true, includeUnitVariants: true });
+            const kmhStream = unitStreams.find(s => s.type === 'Speed in kilometers per hour');
+            expect(kmhStream).toBeDefined();
+            if (kmhStream) {
+                expect(kmhStream.getData()[0]).toBeCloseTo(36, 1); // 10 m/s = 36 km/h
+            }
+        });
     });
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sports-alliance/sports-lib",
-  "version": "6.1.10",
+  "version": "6.1.12",
   "description": "A Library to for importing / exporting and processing GPX, TCX, FIT and JSON files from services such as Strava, Movescount, Garmin, Polar etc",
   "keywords": [
     "gpx",
@@ -55,7 +55,7 @@
   "dependencies": {
     "fast-xml-parser": "^5.3.3",
     "fit-file-parser": "^2.1.0",
-    "geolib": "^3.3.1",
+    "geolib": "^3.3.4",
     "gpx-builder": "^3.7.8",
     "kalmanjs": "^1.1.0",
     "lowpassf": "^0.5.0",