@sports-alliance/sports-lib 6.1.11 → 6.1.13

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.js

@@ -41,7 +41,8 @@ class Activity extends duration_class_abstract_1.DurationClassAbstract {
         this.name = name;
     }
     createStream(type) {
-        return new stream_1.Stream(type, Array(activity_utilities_1.ActivityUtilities.getDataLength(this.startDate, this.endDate)).fill(null));
+        const stream = new stream_1.Stream(type, Array(activity_utilities_1.ActivityUtilities.getDataLength(this.startDate, this.endDate)).fill(null));
+        return stream;
     }
     addDataToStream(type, date, value) {
         this.getStreamData(type)[this.getDateIndex(date)] = value;
@@ -49,7 +50,7 @@ class Activity extends duration_class_abstract_1.DurationClassAbstract {
     }
     addStream(stream) {
         if (this.streams.find(activityStream => activityStream.type === stream.type)) {
-            throw new Error(`Duplicate type of stream when adding ${stream.type} to activity ${this.getID()}`);
+            throw new Error(`Duplicate type of stream when adding ${stream.type} to activity ${this.getID()} `);
         }
         this.streams.push(stream);
         return this;
@@ -101,7 +102,7 @@ class Activity extends duration_class_abstract_1.DurationClassAbstract {
     getStream(streamType) {
         const find = this.streams.find(stream => stream.type === streamType);
         if (!find) {
-            throw Error(`No stream found with type ${streamType}`);
+            throw Error(`No stream found with type ${streamType} `);
         }
         return find;
     }

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/adapters/importers/fit/importer.fit.d.ts

@@ -13,6 +13,7 @@ export declare class EventImporterFIT {
      * Generate streams samples based on lengths on an activity
      * When based on lengths, an activity do not provides sample under records object
      * @param sessionObject
+     * @param options
      * @private
      */
     private static generateSamplesFromLengths;

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

@@ -272,7 +272,7 @@ class EventImporterFIT {
                         // Note: this is how Strava generate streams for this kind of activities
                         const isLengthsBased = this.isLengthsBased(sessionObject);
                         const samples = isLengthsBased
-                            ? this.generateSamplesFromLengths(sessionObject)
+                            ? this.generateSamplesFromLengths(sessionObject, options)
                             : fitDataObject.records.filter((record) => {
                                 return record.timestamp >= activity.startDate && record.timestamp <= activity.endDate;
                             });
@@ -351,9 +351,10 @@ class EventImporterFIT {
      * Generate streams samples based on lengths on an activity
      * When based on lengths, an activity do not provides sample under records object
      * @param sessionObject
+     * @param options
      * @private
      */
-    static generateSamplesFromLengths(sessionObject) {
+    static generateSamplesFromLengths(sessionObject, options) {
         if (!this.isLengthsBased(sessionObject)) {
             throw new parsing_event_lib_error_1.ParsingEventLibError('Trying to get samples from activities lengths, but no lengths is available');
         }
@@ -370,12 +371,18 @@ class EventImporterFIT {
                 lap.lengths.forEach((length) => {
                     // Resolve start/end date of current length
                     const lengthStartDate = length.start_time;
-                    const lengthEndDate = new Date(lengthStartDate.getTime() + (length.total_timer_time || length.total_elapsed_time || 0) * 1000);
+                    const lengthDuration = (length.total_timer_time || length.total_elapsed_time || 0);
+                    const lengthEndDate = new Date(lengthStartDate.getTime() + lengthDuration * 1000);
+                    // We check if length is valid comparing to max activity duration
+                    if (lengthDuration > options.maxActivityDurationDays * 24 * 60 * 60) {
+                        return;
+                    }
                     if (lengthEndDate.getTime() <= lengthStartDate.getTime()) {
                         return;
                     }
                     // Generate a stream from length start date to end date filled by null values
-                    let lengthStream = Array(activity_utilities_1.ActivityUtilities.getDataLength(lengthStartDate, lengthEndDate)).fill(null);
+                    const streamLength = activity_utilities_1.ActivityUtilities.getDataLength(lengthStartDate, lengthEndDate);
+                    let lengthStream = Array(streamLength).fill(null);
                     // Define distance step to be used for distance stream
                     const lengthStepSize = lengthMeters / (lengthStream.length - 1);
                     // Generate the length stream based on data we have on current length

package/lib/cjs/events/adapters/importers/fit/importer.fit.oom.spec.d.ts

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

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

@@ -0,0 +1,60 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const importer_fit_1 = require("./importer.fit");
+describe('EventImporterFIT OOM Reproduction', () => {
+    const oomSamplesDir = path.resolve(__dirname, '../../../../../samples/fit/oom');
+    it('should parse OOM sample fit files', () => __awaiter(void 0, void 0, void 0, function* () {
+        if (!fs.existsSync(oomSamplesDir)) {
+            console.warn(`OOM Samples directory not found at ${oomSamplesDir}. Skipping reproduction.`);
+            return;
+        }
+        const files = fs.readdirSync(oomSamplesDir).filter(f => f.endsWith('.fit'));
+        for (const file of files) {
+            console.log(`>>> START Processing ${file}`);
+            const filePath = path.join(oomSamplesDir, file);
+            const fileBuffer = fs.readFileSync(filePath);
+            const arrayBuffer = fileBuffer.buffer.slice(fileBuffer.byteOffset, fileBuffer.byteOffset + fileBuffer.byteLength);
+            console.log(`Testing file: ${file} (${fileBuffer.length} bytes)`);
+            try {
+                const event = yield importer_fit_1.EventImporterFIT.getFromArrayBuffer(arrayBuffer, undefined, file);
+                expect(event).toBeDefined();
+                console.log(`✅ Successfully parsed ${file}`);
+            }
+            catch (error) {
+                console.error(`❌ Failed to parse ${file}:`, error);
+                // We don't necessarily want to throw here if we want to test all files
+            }
+            console.log(`<<< END Processing ${file}`);
+        }
+    }), 100000); // 100s timeout as these might take time if they are huge
+});

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.js

@@ -38,7 +38,8 @@ export class Activity extends DurationClassAbstract {
         this.name = name;
     }
     createStream(type) {
-        return new Stream(type, Array(ActivityUtilities.getDataLength(this.startDate, this.endDate)).fill(null));
+        const stream = new Stream(type, Array(ActivityUtilities.getDataLength(this.startDate, this.endDate)).fill(null));
+        return stream;
     }
     addDataToStream(type, date, value) {
         this.getStreamData(type)[this.getDateIndex(date)] = value;
@@ -46,7 +47,7 @@ export class Activity extends DurationClassAbstract {
     }
     addStream(stream) {
         if (this.streams.find(activityStream => activityStream.type === stream.type)) {
-            throw new Error(`Duplicate type of stream when adding ${stream.type} to activity ${this.getID()}`);
+            throw new Error(`Duplicate type of stream when adding ${stream.type} to activity ${this.getID()} `);
         }
         this.streams.push(stream);
         return this;
@@ -98,7 +99,7 @@ export class Activity extends DurationClassAbstract {
     getStream(streamType) {
         const find = this.streams.find(stream => stream.type === streamType);
         if (!find) {
-            throw Error(`No stream found with type ${streamType}`);
+            throw Error(`No stream found with type ${streamType} `);
         }
         return find;
     }

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/adapters/importers/fit/importer.fit.d.ts

@@ -13,6 +13,7 @@ export declare class EventImporterFIT {
      * Generate streams samples based on lengths on an activity
      * When based on lengths, an activity do not provides sample under records object
      * @param sessionObject
+     * @param options
      * @private
      */
     private static generateSamplesFromLengths;

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

@@ -266,7 +266,7 @@ export class EventImporterFIT {
                         // Note: this is how Strava generate streams for this kind of activities
                         const isLengthsBased = this.isLengthsBased(sessionObject);
                         const samples = isLengthsBased
-                            ? this.generateSamplesFromLengths(sessionObject)
+                            ? this.generateSamplesFromLengths(sessionObject, options)
                             : fitDataObject.records.filter((record) => {
                                 return record.timestamp >= activity.startDate && record.timestamp <= activity.endDate;
                             });
@@ -345,9 +345,10 @@ export class EventImporterFIT {
      * Generate streams samples based on lengths on an activity
      * When based on lengths, an activity do not provides sample under records object
      * @param sessionObject
+     * @param options
      * @private
      */
-    static generateSamplesFromLengths(sessionObject) {
+    static generateSamplesFromLengths(sessionObject, options) {
         if (!this.isLengthsBased(sessionObject)) {
             throw new ParsingEventLibError('Trying to get samples from activities lengths, but no lengths is available');
         }
@@ -364,12 +365,18 @@ export class EventImporterFIT {
                 lap.lengths.forEach((length) => {
                     // Resolve start/end date of current length
                     const lengthStartDate = length.start_time;
-                    const lengthEndDate = new Date(lengthStartDate.getTime() + (length.total_timer_time || length.total_elapsed_time || 0) * 1000);
+                    const lengthDuration = (length.total_timer_time || length.total_elapsed_time || 0);
+                    const lengthEndDate = new Date(lengthStartDate.getTime() + lengthDuration * 1000);
+                    // We check if length is valid comparing to max activity duration
+                    if (lengthDuration > options.maxActivityDurationDays * 24 * 60 * 60) {
+                        return;
+                    }
                     if (lengthEndDate.getTime() <= lengthStartDate.getTime()) {
                         return;
                     }
                     // Generate a stream from length start date to end date filled by null values
-                    let lengthStream = Array(ActivityUtilities.getDataLength(lengthStartDate, lengthEndDate)).fill(null);
+                    const streamLength = ActivityUtilities.getDataLength(lengthStartDate, lengthEndDate);
+                    let lengthStream = Array(streamLength).fill(null);
                     // Define distance step to be used for distance stream
                     const lengthStepSize = lengthMeters / (lengthStream.length - 1);
                     // Generate the length stream based on data we have on current length

package/lib/esm/events/adapters/importers/fit/importer.fit.oom.spec.d.ts

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

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

@@ -0,0 +1,39 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import * as fs from 'fs';
+import * as path from 'path';
+import { EventImporterFIT } from './importer.fit';
+describe('EventImporterFIT OOM Reproduction', () => {
+    const oomSamplesDir = path.resolve(__dirname, '../../../../../samples/fit/oom');
+    it('should parse OOM sample fit files', () => __awaiter(void 0, void 0, void 0, function* () {
+        if (!fs.existsSync(oomSamplesDir)) {
+            console.warn(`OOM Samples directory not found at ${oomSamplesDir}. Skipping reproduction.`);
+            return;
+        }
+        const files = fs.readdirSync(oomSamplesDir).filter(f => f.endsWith('.fit'));
+        for (const file of files) {
+            console.log(`>>> START Processing ${file}`);
+            const filePath = path.join(oomSamplesDir, file);
+            const fileBuffer = fs.readFileSync(filePath);
+            const arrayBuffer = fileBuffer.buffer.slice(fileBuffer.byteOffset, fileBuffer.byteOffset + fileBuffer.byteLength);
+            console.log(`Testing file: ${file} (${fileBuffer.length} bytes)`);
+            try {
+                const event = yield EventImporterFIT.getFromArrayBuffer(arrayBuffer, undefined, file);
+                expect(event).toBeDefined();
+                console.log(`✅ Successfully parsed ${file}`);
+            }
+            catch (error) {
+                console.error(`❌ Failed to parse ${file}:`, error);
+                // We don't necessarily want to throw here if we want to test all files
+            }
+            console.log(`<<< END Processing ${file}`);
+        }
+    }), 100000); // 100s timeout as these might take time if they are huge
+});

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.13",
   "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",

package/reproduce_oom.ts

@@ -0,0 +1,35 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { EventImporterFIT } from './src/events/adapters/importers/fit/importer.fit';
+
+async function reproduce() {
+    const oomSamplesDir = path.resolve(__dirname, 'samples/fit/oom');
+
+    if (!fs.existsSync(oomSamplesDir)) {
+        console.warn(`OOM Samples directory not found at ${oomSamplesDir}.`);
+        return;
+    }
+
+    const files = fs.readdirSync(oomSamplesDir).filter(f => f.endsWith('.fit'));
+
+    for (const file of files) {
+        process.stdout.write(`>>> START Processing ${file}\n`);
+        const filePath = path.join(oomSamplesDir, file);
+        const fileBuffer = fs.readFileSync(filePath);
+        const arrayBuffer = fileBuffer.buffer.slice(fileBuffer.byteOffset, fileBuffer.byteOffset + fileBuffer.byteLength);
+
+        console.log(`Testing file: ${file} (${fileBuffer.length} bytes)`);
+        try {
+            const event = await EventImporterFIT.getFromArrayBuffer(arrayBuffer, undefined, file);
+            console.log(`✅ Successfully parsed ${file}`);
+        } catch (error) {
+            console.error(`❌ Failed to parse ${file}:`, error);
+        }
+        process.stdout.write(`<<< END Processing ${file}\n`);
+    }
+}
+
+reproduce().catch(err => {
+    console.error('FATAL ERROR:', err);
+    process.exit(1);
+});