@sports-alliance/sports-lib 7.0.0 → 7.0.2

package/lib/esm/events/adapters/importers/fit/importer.fit.garmin.profile.mapper.spec.d.ts

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

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

@@ -0,0 +1,32 @@
+import { GarminProfileMapper } from './importer.fit.garmin.profile.mapper';
+describe('GarminProfileMapper', () => {
+    describe('getSportName', () => {
+        it('should translate sport ID', () => {
+            // Assuming ID 1 is Running
+            expect(GarminProfileMapper.getSportName(1)).toBe('running');
+        });
+        it('should return null for unknown sport', () => {
+            expect(GarminProfileMapper.getSportName(99999)).toBeNull();
+        });
+        it('should return names in snake_case (regression check for extraction logic)', () => {
+            // Checking ID 4 which is 'fitness_equipment' (was 'fitnessEquipment' in raw SDK)
+            expect(GarminProfileMapper.getSportName(4)).toBe('fitness_equipment');
+        });
+    });
+    describe('getSubSportName', () => {
+        it('should translate sub sport ID', () => {
+            // Assuming ID 1 is Treadmill
+            expect(GarminProfileMapper.getSubSportName(1)).toBe('treadmill');
+        });
+        it('should return names in snake_case (regression check for extraction logic)', () => {
+            // Checking ID 6 which is 'indoor_cycling' (was 'indoorCycling' in raw SDK)
+            expect(GarminProfileMapper.getSubSportName(6)).toBe('indoor_cycling');
+        });
+        it('should correctly map Enduro and Downhill MTB (IDs 153/154)', () => {
+            // ID 153 = mountain_enduro
+            expect(GarminProfileMapper.getSubSportName(153)).toBe('mountain_enduro');
+            // ID 154 = mountain_downhill
+            expect(GarminProfileMapper.getSubSportName(154)).toBe('mountain_downhill');
+        });
+    });
+});

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

@@ -116,8 +116,8 @@ import FitFileParser from 'fit-file-parser';
 // Threshold to detect that session.timestamp are not trustable (when exceeding 15% of session.total_elapsed_time)
 const INVALID_DATES_ELAPSED_TIME_RATIO_THRESHOLD = 1.15;
 export class EventImporterFIT {
-    static getFromArrayBuffer(arrayBuffer, options = ActivityParsingOptions.DEFAULT, name = 'New Event') {
-        return __awaiter(this, void 0, void 0, function* () {
+    static getFromArrayBuffer(arrayBuffer_1) {
+        return __awaiter(this, arguments, void 0, function* (arrayBuffer, options = ActivityParsingOptions.DEFAULT, name = 'New Event') {
             return new Promise((resolve, reject) => {
                 const fitFileParser = new FitFileParser({
                     force: true,
@@ -128,6 +128,7 @@ export class EventImporterFIT {
                     mode: 'both'
                 });
                 fitFileParser.parse(arrayBuffer, (error, fitDataObject) => {
+                    var _a;
                     if (error) {
                         // For now, assume any error from parser on this file means it's broken/empty in a way we treat as EmptyEventLibError
                         // to satisfy existing tests. Or ideally we wrap in a generic EventLibError.
@@ -139,6 +140,27 @@ export class EventImporterFIT {
                         reject(new EmptyEventLibError());
                         return;
                     }
+                    // Check if we have length data at the top level (new parser behavior or missing mapping)
+                    if (fitDataObject.lengths && fitDataObject.lengths.length > 0) {
+                        (_a = fitDataObject.sessions) === null || _a === void 0 ? void 0 : _a.forEach((session) => {
+                            var _a;
+                            const sessionStartTime = new Date(session.start_time).getTime();
+                            const sessionEndTime = sessionStartTime + (session.total_elapsed_time || 0) * 1000;
+                            session.lengths = fitDataObject.lengths.filter((length) => {
+                                const lengthTime = new Date(length.timestamp || length.start_time).getTime();
+                                return lengthTime >= sessionStartTime && lengthTime < sessionEndTime;
+                            });
+                            // Also distribute to laps
+                            (_a = session.laps) === null || _a === void 0 ? void 0 : _a.forEach((lap) => {
+                                const lapStartTime = new Date(lap.start_time).getTime();
+                                const lapEndTime = lapStartTime + (lap.total_elapsed_time || 0) * 1000;
+                                lap.lengths = fitDataObject.lengths.filter((length) => {
+                                    const lengthTime = new Date(length.timestamp || length.start_time).getTime();
+                                    return lengthTime >= lapStartTime && lengthTime < lapEndTime;
+                                });
+                            });
+                        });
+                    }
                     // Iterate over the sessions and create their activities
                     const activities = fitDataObject.sessions.map((sessionObject) => {
                         // Get the activity from the sessionObject

package/lib/esm/events/adapters/importers/fit/importer.fit.suunto.device.names.js

@@ -1,5 +1,6 @@
 import { ImporterSuuntoDeviceNames } from '../suunto/importer.suunto.device.names';
 export const ImporterFitSuuntoDeviceNames = {
+    19: ImporterSuuntoDeviceNames.Ambit2,
     28: ImporterSuuntoDeviceNames.Brighton,
     29: ImporterSuuntoDeviceNames.Amsterdam,
     34: ImporterSuuntoDeviceNames.Ibiza,

package/lib/esm/events/adapters/importers/fit/importer.fit.wahoo.device.names.js

@@ -1,6 +1,10 @@
 export const ImporterFitWahooDeviceNames = {
     28: 'ELEMNT',
+    30: 'ELEMNT MINI',
     31: 'ELEMNT BOLT',
+    33: 'ELEMNT RIVAL',
     37: 'ELEMNT ROAM',
-    43: 'ELEMNT BOLT'
+    38: 'ELEMNT MINI',
+    43: 'ELEMNT BOLT',
+    47: 'ELEMNT ROAM'
 };

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

@@ -54,7 +54,7 @@ export class EventImporterGPX {
                 // @todo for routes add a separate parser
                 const endDate = isActivity
                     ? new Date(samples[samples.length - 1].time[0])
-                    : new Date(startDate.getTime() + samples.length * 1000);
+                    : new Date(startDate.getTime() + (samples.length > 0 ? samples.length - 1 : 0) * 1000);
                 let activityType = isActivity ? ActivityTypes.unknown : ActivityTypes.route;
                 if (trackOrRoute.type && ActivityTypes[trackOrRoute.type]) {
                     activityType = ActivityTypes[trackOrRoute.type];

package/lib/esm/events/adapters/importers/gpx/importer.gpx.spec.js

@@ -51,4 +51,21 @@ describe('importer.gpx', () => {
         const result = yield EventImporterGPX.getFromString(gpxString, xmldom.DOMParser);
         expect(result.getFirstActivity().name).toEqual('Meylan Road Cycling');
     }));
+    it('parses route.gpx from samples', () => __awaiter(void 0, void 0, void 0, function* () {
+        const fs = yield import('fs');
+        const path = yield import('path');
+        const samplesDir = path.resolve(__dirname, '../../../../../samples/gpx');
+        const filePath = path.join(samplesDir, 'route.gpx');
+        const fileString = fs.readFileSync(filePath, 'utf-8');
+        const result = yield EventImporterGPX.getFromString(fileString, xmldom.DOMParser);
+        expect(result.getActivities().length).toBeGreaterThan(0);
+        const activity = result.getFirstActivity();
+        expect(activity.type).toEqual('Route');
+        const distance = activity.getStat('Distance');
+        expect(distance).toBeDefined();
+        expect(distance.getValue()).toBeGreaterThan(0);
+        // Check if the number of samples matches the number of points in the GPX
+        const latStream = activity.getStream('Latitude');
+        expect(latStream.getData().length).toBe(2987); // I counted 2987 rtept earlier
+    }));
 });

package/lib/esm/events/adapters/importers/suunto/importer.suunto.device.names.js

@@ -18,6 +18,7 @@ export const ImporterSuuntoDeviceNames = {
     Gdansk: 'Spartan WHR Baro',
     'Spartan Sport Wrist HR Baro': 'Spartan WHR Baro',
     Helsinki: '3 Fitness',
+    Ambit2: 'Ambit2',
     'Ambit3 Sport': 'Ambit3 Sport',
     'Ambit3 Peak': 'Ambit3 Peak',
     'Ambit3 Run': 'Ambit3 Run',

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

@@ -108,8 +108,8 @@ const ALTITUDE_SPIKES_FILTER_WIN = 3;
 // Fix abnormal streams
 const SPEED_STREAM_STD_DEV_THRESHOLD_DEFAULT = 25 / 3.6; // Kph to mps
 const SPEED_STREAM_STD_DEV_THRESHOLD_MAP = new Map([
-    [ActivityTypeGroups.Running, 15 / 3.6],
-    [ActivityTypeGroups.Cycling, 27 / 3.6],
+    [ActivityTypeGroups.Running, 15 / 3.6], // kph to m/s
+    [ActivityTypeGroups.Cycling, 27 / 3.6], // kph to m/s
     [ActivityTypeGroups.Swimming, 5 / 3.6] // kph to m/s
 ]);
 export class ActivityUtilities {
@@ -275,7 +275,7 @@ export class ActivityUtilities {
                 this.shapeStream(DataSpeed.type, activity, squashedSpeedData => {
                     // Grade stream
                     const SPEED_KALMAN_SMOOTHING = {
-                        R: 0.01,
+                        R: 0.01, // Speed model calculation is something stable
                         Q: speedStdDev * 2 // We intend to get a measurement error which can be under and over std dev (explaining the double factor)
                     };
                     // Apply kalman filter
@@ -291,7 +291,7 @@ export class ActivityUtilities {
         // 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,
+            includeDerivedTypes: true, // Always include derived base types (Pace etc)
             includeUnitVariants
         }));
     }
@@ -757,9 +757,9 @@ export class ActivityUtilities {
                     return prevPosition;
                 }
                 if (prevPosition && position) {
-                    distance += this.round(this.geoLibAdapter.getDistance([prevPosition, position]), 2);
+                    distance += this.geoLibAdapter.getDistance([prevPosition, position]);
                 }
-                streamData[index] = distance;
+                streamData[index] = this.round(distance, 2);
                 return position;
             });
             if (!activity.hasStreamData(DataDistance.type)) {
@@ -812,7 +812,7 @@ export class ActivityUtilities {
                 this.shapeStream(DataGradeSmooth.type, activity, squashedGradeData => {
                     // Grade stream
                     const GRADE_KALMAN_SMOOTHING = {
-                        R: 0.01,
+                        R: 0.01, // Grade model is stable
                         Q: 0.5 // Grade measurement error which can be expected
                     };
                     // Predict proper grade values

package/lib/esm/events/utilities/grade-calculator/low-pass-filter.js

@@ -1,12 +1,12 @@
 export class LowPassFilter {
+    static smooth(values, smoothing = 0.5) {
+        return new LowPassFilter(smoothing).smoothArray(values);
+    }
     constructor(smoothing) {
         this._smoothing = smoothing || 0.5; // must be smaller than 1
         this._buffer = []; // FIFO queue
         this._bufferMaxSize = 10;
     }
-    static smooth(values, smoothing = 0.5) {
-        return new LowPassFilter(smoothing).smoothArray(values);
-    }
     /**
      * Init buffer with array of values
      * @param {number[]} values

package/lib/esm/events/utilities/helpers.d.ts

@@ -1,4 +1,4 @@
-export declare function isNumberOrString(property: any): boolean;
+export declare function isNumberOrString(property: any): property is string | number;
 export declare function isNumber(property: any): boolean;
 /**
  * Converts speed from m/s to pace as of seconds per km

package/lib/esm/index.d.ts

@@ -20,7 +20,7 @@ export declare class SportsLib {
      * @param arrayBuffer
      * @param options
      */
-    static importFromFit(arrayBuffer: ArrayBuffer, options?: ActivityParsingOptions): Promise<EventInterface>;
+    static importFromFit(arrayBuffer: ArrayBuffer | Buffer<ArrayBuffer>, options?: ActivityParsingOptions): Promise<EventInterface>;
     /**
      * Parses and returns an event using Suunto format
      * @param jsonString