@sports-alliance/sports-lib 6.1.11 → 6.1.12

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/events/utilities/activity.utilities.js

@@ -688,32 +688,33 @@ class ActivityUtilities {
             ...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;
-        }
-        const startWith = baseUnitStreams.filter((baseUnitStream) => unitStreamTypesToCreate.indexOf(baseUnitStream.type) !== -1 && streams.indexOf(baseUnitStream) === -1);
+            // 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;
         }

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(() => {
@@ -272,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);
@@ -322,5 +324,52 @@ describe('Activity Utilities', () => {
             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/events/utilities/activity.utilities.js

@@ -685,32 +685,33 @@ export class ActivityUtilities {
             ...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;
-        }
-        const startWith = baseUnitStreams.filter((baseUnitStream) => unitStreamTypesToCreate.indexOf(baseUnitStream.type) !== -1 && streams.indexOf(baseUnitStream) === -1);
+            // 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;
         }

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(() => {
@@ -270,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);
@@ -320,5 +322,52 @@ describe('Activity Utilities', () => {
             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.11",
+  "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",