@sports-alliance/sports-lib 7.2.2 → 7.2.3

package/.agent/README.md

@@ -0,0 +1,16 @@
+# Agent Configuration for sports-lib
+
+This directory contains configuration, skills, and workflows for AI agents working on the `sports-lib` project.
+
+## Structure
+
+- **skills/**: Contains specialized "skills" (instructions + scripts) for the agent.
+  - `debug-utils`: Instructions for using the project's ad-hoc FIT file debugging scripts.
+- **workflows/**: Contains step-by-step guides for common tasks.
+  - `add-new-data.md`: How to identify and add new data fields from FIT files.
+
+## Usage
+
+When asking an agent to help with debugging or adding data, you can refer them to these specific skills or workflows if they don't automatically pick them up.
+- "Use the debug-utils skill to inspect this file."
+- "Follow the add-new-data workflow."

package/inspect_jump_raw.js

@@ -0,0 +1,24 @@
+const fs = require('fs');
+const FitParser = require('fit-file-parser').default;
+
+const content = fs.readFileSync('./samples/fit/jumps-mtb.fit');
+const fitParser = new FitParser({ force: true, mode: 'both' });
+
+fitParser.parse(content, (error, data) => {
+    if (error) {
+        console.error(error);
+        return;
+    }
+    console.log('=== ROOT KEYS ===');
+    console.log(Object.keys(data).join('\n'));
+    
+    if (data.jumps) {
+        console.log('\n=== FIRST JUMP ===');
+        console.log(data.jumps[0]);
+    }
+
+    if (data.user_profiles) {
+        console.log('\n=== USER PROFILES ===');
+        console.log(data.user_profiles);
+    }
+});

package/lib/cjs/data/data.jump-event.d.ts

@@ -1,8 +1,13 @@
 import { DataEvent } from './data.event';
 export interface JumpEventInterface {
     distance: number;
-    height: number;
+    height?: number;
     score: number;
+    hang_time?: number;
+    position_lat?: number;
+    position_long?: number;
+    speed?: number;
+    rotations?: number;
 }
 export declare class DataJumpEvent extends DataEvent {
     jumpData: JumpEventInterface;

package/lib/cjs/data/data.jump-stats.d.ts

@@ -0,0 +1,91 @@
+import { DataNumber } from './data.number';
+export declare class DataJumpHangTimeMin extends DataNumber {
+    static type: string;
+    static unit: string;
+    constructor(value: number);
+}
+export declare class DataJumpHangTimeMax extends DataNumber {
+    static type: string;
+    static unit: string;
+    constructor(value: number);
+}
+export declare class DataJumpHangTimeAvg extends DataNumber {
+    static type: string;
+    static unit: string;
+    constructor(value: number);
+}
+export declare class DataJumpDistanceMin extends DataNumber {
+    static type: string;
+    static unit: string;
+    constructor(value: number);
+}
+export declare class DataJumpDistanceMax extends DataNumber {
+    static type: string;
+    static unit: string;
+    constructor(value: number);
+}
+export declare class DataJumpDistanceAvg extends DataNumber {
+    static type: string;
+    static unit: string;
+    constructor(value: number);
+}
+export declare class DataJumpSpeedMin extends DataNumber {
+    static type: string;
+    static unit: string;
+    constructor(value: number);
+}
+export declare class DataJumpSpeedMax extends DataNumber {
+    static type: string;
+    static unit: string;
+    constructor(value: number);
+}
+export declare class DataJumpSpeedAvg extends DataNumber {
+    static type: string;
+    static unit: string;
+    constructor(value: number);
+}
+export declare class DataJumpRotationsMin extends DataNumber {
+    static type: string;
+    static unit: string;
+    constructor(value: number);
+}
+export declare class DataJumpRotationsMax extends DataNumber {
+    static type: string;
+    static unit: string;
+    constructor(value: number);
+}
+export declare class DataJumpRotationsAvg extends DataNumber {
+    static type: string;
+    static unit: string;
+    constructor(value: number);
+}
+export declare class DataJumpScoreMin extends DataNumber {
+    static type: string;
+    static unit: string;
+    constructor(value: number);
+}
+export declare class DataJumpScoreMax extends DataNumber {
+    static type: string;
+    static unit: string;
+    constructor(value: number);
+}
+export declare class DataJumpScoreAvg extends DataNumber {
+    static type: string;
+    static unit: string;
+    constructor(value: number);
+}
+export declare class DataJumpHeightMin extends DataNumber {
+    static type: string;
+    static unit: string;
+    constructor(value: number);
+}
+export declare class DataJumpHeightMax extends DataNumber {
+    static type: string;
+    static unit: string;
+    constructor(value: number);
+}
+export declare class DataJumpHeightAvg extends DataNumber {
+    static type: string;
+    static unit: string;
+    constructor(value: number);
+}

package/lib/cjs/data/data.jump-stats.js

@@ -0,0 +1,112 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DataJumpHeightAvg = exports.DataJumpHeightMax = exports.DataJumpHeightMin = exports.DataJumpScoreAvg = exports.DataJumpScoreMax = exports.DataJumpScoreMin = exports.DataJumpRotationsAvg = exports.DataJumpRotationsMax = exports.DataJumpRotationsMin = exports.DataJumpSpeedAvg = exports.DataJumpSpeedMax = exports.DataJumpSpeedMin = exports.DataJumpDistanceAvg = exports.DataJumpDistanceMax = exports.DataJumpDistanceMin = exports.DataJumpHangTimeAvg = exports.DataJumpHangTimeMax = exports.DataJumpHangTimeMin = void 0;
+const data_number_1 = require("./data.number");
+class DataJumpHangTimeMin extends data_number_1.DataNumber {
+    constructor(value) { super(value); }
+}
+exports.DataJumpHangTimeMin = DataJumpHangTimeMin;
+DataJumpHangTimeMin.type = 'Jump Hang Time Min';
+DataJumpHangTimeMin.unit = 's';
+class DataJumpHangTimeMax extends data_number_1.DataNumber {
+    constructor(value) { super(value); }
+}
+exports.DataJumpHangTimeMax = DataJumpHangTimeMax;
+DataJumpHangTimeMax.type = 'Jump Hang Time Max';
+DataJumpHangTimeMax.unit = 's';
+class DataJumpHangTimeAvg extends data_number_1.DataNumber {
+    constructor(value) { super(value); }
+}
+exports.DataJumpHangTimeAvg = DataJumpHangTimeAvg;
+DataJumpHangTimeAvg.type = 'Jump Hang Time Avg';
+DataJumpHangTimeAvg.unit = 's';
+class DataJumpDistanceMin extends data_number_1.DataNumber {
+    constructor(value) { super(value); }
+}
+exports.DataJumpDistanceMin = DataJumpDistanceMin;
+DataJumpDistanceMin.type = 'Jump Distance Min';
+DataJumpDistanceMin.unit = 'm';
+class DataJumpDistanceMax extends data_number_1.DataNumber {
+    constructor(value) { super(value); }
+}
+exports.DataJumpDistanceMax = DataJumpDistanceMax;
+DataJumpDistanceMax.type = 'Jump Distance Max';
+DataJumpDistanceMax.unit = 'm';
+class DataJumpDistanceAvg extends data_number_1.DataNumber {
+    constructor(value) { super(value); }
+}
+exports.DataJumpDistanceAvg = DataJumpDistanceAvg;
+DataJumpDistanceAvg.type = 'Jump Distance Avg';
+DataJumpDistanceAvg.unit = 'm';
+class DataJumpSpeedMin extends data_number_1.DataNumber {
+    constructor(value) { super(value); }
+}
+exports.DataJumpSpeedMin = DataJumpSpeedMin;
+DataJumpSpeedMin.type = 'Jump Speed Min';
+DataJumpSpeedMin.unit = 'm/s';
+class DataJumpSpeedMax extends data_number_1.DataNumber {
+    constructor(value) { super(value); }
+}
+exports.DataJumpSpeedMax = DataJumpSpeedMax;
+DataJumpSpeedMax.type = 'Jump Speed Max';
+DataJumpSpeedMax.unit = 'm/s';
+class DataJumpSpeedAvg extends data_number_1.DataNumber {
+    constructor(value) { super(value); }
+}
+exports.DataJumpSpeedAvg = DataJumpSpeedAvg;
+DataJumpSpeedAvg.type = 'Jump Speed Avg';
+DataJumpSpeedAvg.unit = 'm/s';
+class DataJumpRotationsMin extends data_number_1.DataNumber {
+    constructor(value) { super(value); }
+}
+exports.DataJumpRotationsMin = DataJumpRotationsMin;
+DataJumpRotationsMin.type = 'Jump Rotations Min';
+DataJumpRotationsMin.unit = '';
+class DataJumpRotationsMax extends data_number_1.DataNumber {
+    constructor(value) { super(value); }
+}
+exports.DataJumpRotationsMax = DataJumpRotationsMax;
+DataJumpRotationsMax.type = 'Jump Rotations Max';
+DataJumpRotationsMax.unit = '';
+class DataJumpRotationsAvg extends data_number_1.DataNumber {
+    constructor(value) { super(value); }
+}
+exports.DataJumpRotationsAvg = DataJumpRotationsAvg;
+DataJumpRotationsAvg.type = 'Jump Rotations Avg';
+DataJumpRotationsAvg.unit = '';
+class DataJumpScoreMin extends data_number_1.DataNumber {
+    constructor(value) { super(value); }
+}
+exports.DataJumpScoreMin = DataJumpScoreMin;
+DataJumpScoreMin.type = 'Jump Score Min';
+DataJumpScoreMin.unit = '';
+class DataJumpScoreMax extends data_number_1.DataNumber {
+    constructor(value) { super(value); }
+}
+exports.DataJumpScoreMax = DataJumpScoreMax;
+DataJumpScoreMax.type = 'Jump Score Max';
+DataJumpScoreMax.unit = '';
+class DataJumpScoreAvg extends data_number_1.DataNumber {
+    constructor(value) { super(value); }
+}
+exports.DataJumpScoreAvg = DataJumpScoreAvg;
+DataJumpScoreAvg.type = 'Jump Score Avg';
+DataJumpScoreAvg.unit = '';
+class DataJumpHeightMin extends data_number_1.DataNumber {
+    constructor(value) { super(value); }
+}
+exports.DataJumpHeightMin = DataJumpHeightMin;
+DataJumpHeightMin.type = 'Jump Height Min';
+DataJumpHeightMin.unit = 'm';
+class DataJumpHeightMax extends data_number_1.DataNumber {
+    constructor(value) { super(value); }
+}
+exports.DataJumpHeightMax = DataJumpHeightMax;
+DataJumpHeightMax.type = 'Jump Height Max';
+DataJumpHeightMax.unit = 'm';
+class DataJumpHeightAvg extends data_number_1.DataNumber {
+    constructor(value) { super(value); }
+}
+exports.DataJumpHeightAvg = DataJumpHeightAvg;
+DataJumpHeightAvg.type = 'Jump Height Avg';
+DataJumpHeightAvg.unit = 'm';

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

@@ -213,6 +213,7 @@ const data_fitness_age_1 = require("./data.fitness-age");
 const data_max_hr_setting_1 = require("./data.max-hr-setting");
 const data_depth_1 = require("./data.depth");
 const data_depth_max_1 = require("./data.depth-max");
+const data_jump_stats_1 = require("./data.jump-stats");
 // "Total Training effect" was renamed to "Aerobic Training Effect" in sports-lib 6.0
 class DataTotalTrainingEffectLegacy extends data_aerobic_training_effect_1.DataAerobicTrainingEffect {
 }
@@ -524,7 +525,25 @@ exports.DataStore = {
     DataFitnessAge: data_fitness_age_1.DataFitnessAge,
     DataMaxHRSetting: data_max_hr_setting_1.DataMaxHRSetting,
     DataDepth: data_depth_1.DataDepth,
-    DataDepthMax: data_depth_max_1.DataDepthMax
+    DataDepthMax: data_depth_max_1.DataDepthMax,
+    DataJumpHangTimeMin: data_jump_stats_1.DataJumpHangTimeMin,
+    DataJumpHangTimeMax: data_jump_stats_1.DataJumpHangTimeMax,
+    DataJumpHangTimeAvg: data_jump_stats_1.DataJumpHangTimeAvg,
+    DataJumpDistanceMin: data_jump_stats_1.DataJumpDistanceMin,
+    DataJumpDistanceMax: data_jump_stats_1.DataJumpDistanceMax,
+    DataJumpDistanceAvg: data_jump_stats_1.DataJumpDistanceAvg,
+    DataJumpSpeedMin: data_jump_stats_1.DataJumpSpeedMin,
+    DataJumpSpeedMax: data_jump_stats_1.DataJumpSpeedMax,
+    DataJumpSpeedAvg: data_jump_stats_1.DataJumpSpeedAvg,
+    DataJumpRotationsMin: data_jump_stats_1.DataJumpRotationsMin,
+    DataJumpRotationsMax: data_jump_stats_1.DataJumpRotationsMax,
+    DataJumpRotationsAvg: data_jump_stats_1.DataJumpRotationsAvg,
+    DataJumpScoreMin: data_jump_stats_1.DataJumpScoreMin,
+    DataJumpScoreMax: data_jump_stats_1.DataJumpScoreMax,
+    DataJumpScoreAvg: data_jump_stats_1.DataJumpScoreAvg,
+    DataJumpHeightMin: data_jump_stats_1.DataJumpHeightMin,
+    DataJumpHeightMax: data_jump_stats_1.DataJumpHeightMax,
+    DataJumpHeightAvg: data_jump_stats_1.DataJumpHeightAvg
 };
 class DynamicDataLoader {
     static getDataInstanceFromDataType(dataType, opts) {

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

@@ -167,6 +167,7 @@ const data_age_1 = require("../../../../data/data.age");
 const data_gender_1 = require("../../../../data/data.gender");
 const data_avg_grit_1 = require("../../../../data/data.avg-grit");
 const data_jump_event_1 = require("../../../../data/data.jump-event");
+const data_jump_stats_1 = require("../../../../data/data.jump-stats");
 // 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;
 class EventImporterFIT {
@@ -184,7 +185,7 @@ class EventImporterFIT {
                     mode: 'both'
                 });
                 fitFileParser.parse(arrayBuffer, (error, fitDataObject) => {
-                    var _a;
+                    var _a, _b;
                     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.
@@ -217,6 +218,17 @@ class EventImporterFIT {
                             });
                         });
                     }
+                    // Check for jumps data at the top level
+                    if (fitDataObject.jumps && fitDataObject.jumps.length > 0) {
+                        (_b = fitDataObject.sessions) === null || _b === void 0 ? void 0 : _b.forEach((session) => {
+                            const sessionStartTime = new Date(session.start_time).getTime();
+                            const sessionEndTime = sessionStartTime + (session.total_elapsed_time || 0) * 1000;
+                            session.jumps = fitDataObject.jumps.filter((jump) => {
+                                const jumpTime = new Date(jump.timestamp).getTime();
+                                return jumpTime >= sessionStartTime && jumpTime < sessionEndTime;
+                            });
+                        });
+                    }
                     // Iterate over the sessions and create their activities
                     const activities = fitDataObject.sessions.map((sessionObject) => {
                         // Get the activity from the sessionObject
@@ -351,7 +363,12 @@ class EventImporterFIT {
                                 activity.addEvent(new data_jump_event_1.DataJumpEvent(activity.getDateIndex(jump.timestamp), {
                                     distance: jump.distance,
                                     height: jump.height,
-                                    score: jump.score
+                                    score: jump.score,
+                                    hang_time: jump.hang_time,
+                                    position_lat: jump.position_lat,
+                                    position_long: jump.position_long,
+                                    speed: jump.speed,
+                                    rotations: jump.rotations
                                 }));
                             });
                         }
@@ -626,13 +643,6 @@ class EventImporterFIT {
             const activity = new activity_1.Activity(startDate, endDate, this.getActivityTypeFromSessionObject(sessionObject), this.getCreatorFromFitDataObject(fitDataObject), options);
             // Set the activity stats
             this.getStatsFromObject(sessionObject, activity, false).forEach(stat => activity.addStat(stat));
-            // Check for VO2 Max in jumps
-            if (fitDataObject.jumps && fitDataObject.jumps.length) {
-                const jumpWithMets = fitDataObject.jumps.find((j) => j.enhanced_mets);
-                if (jumpWithMets) {
-                    activity.addStat(new data_vo2_max_1.DataVO2Max(jumpWithMets.enhanced_mets * 3.5));
-                }
-            }
             // Check for User Profile
             if (fitDataObject.user_profile) {
                 const userProfile = fitDataObject.user_profile;
@@ -1085,6 +1095,94 @@ class EventImporterFIT {
         if ((0, helpers_1.isNumberOrString)(object.avg_vam)) {
             stats.push(new data_avg_vam_1.DataAvgVAM(object.avg_vam));
         }
+        // Jump Statistics
+        if (object.jumps && object.jumps.length > 0) {
+            const jumps = object.jumps;
+            let count = 0;
+            let hangTimeSum = 0, hangTimeMin = Number.MAX_VALUE, hangTimeMax = -Number.MAX_VALUE;
+            let distanceSum = 0, distanceMin = Number.MAX_VALUE, distanceMax = -Number.MAX_VALUE;
+            let speedSum = 0, speedMin = Number.MAX_VALUE, speedMax = -Number.MAX_VALUE;
+            let rotationsSum = 0, rotationsMin = Number.MAX_VALUE, rotationsMax = -Number.MAX_VALUE;
+            let scoreSum = 0, scoreMin = Number.MAX_VALUE, scoreMax = -Number.MAX_VALUE;
+            let heightSum = 0, heightMin = Number.MAX_VALUE, heightMax = -Number.MAX_VALUE;
+            jumps.forEach((j) => {
+                count++;
+                // Hangtime
+                if (Number.isFinite(j.hang_time)) {
+                    hangTimeSum += j.hang_time;
+                    hangTimeMin = Math.min(hangTimeMin, j.hang_time);
+                    hangTimeMax = Math.max(hangTimeMax, j.hang_time);
+                }
+                // Distance
+                if (Number.isFinite(j.distance)) {
+                    distanceSum += j.distance;
+                    distanceMin = Math.min(distanceMin, j.distance);
+                    distanceMax = Math.max(distanceMax, j.distance);
+                }
+                // Speed
+                if (Number.isFinite(j.speed)) {
+                    speedSum += j.speed;
+                    speedMin = Math.min(speedMin, j.speed);
+                    speedMax = Math.max(speedMax, j.speed);
+                }
+                // Rotations
+                if (Number.isFinite(j.rotations)) {
+                    rotationsSum += j.rotations;
+                    rotationsMin = Math.min(rotationsMin, j.rotations);
+                    rotationsMax = Math.max(rotationsMax, j.rotations);
+                }
+                // Score
+                if (Number.isFinite(j.score)) {
+                    scoreSum += j.score;
+                    scoreMin = Math.min(scoreMin, j.score);
+                    scoreMax = Math.max(scoreMax, j.score);
+                }
+                // Height
+                if (Number.isFinite(j.height)) {
+                    heightSum += j.height;
+                    heightMin = Math.min(heightMin, j.height);
+                    heightMax = Math.max(heightMax, j.height);
+                }
+            });
+            if (count > 0) {
+                if (hangTimeMin !== Number.MAX_VALUE)
+                    stats.push(new data_jump_stats_1.DataJumpHangTimeMin(hangTimeMin));
+                if (hangTimeMax !== -Number.MAX_VALUE)
+                    stats.push(new data_jump_stats_1.DataJumpHangTimeMax(hangTimeMax));
+                if (hangTimeSum > 0)
+                    stats.push(new data_jump_stats_1.DataJumpHangTimeAvg(hangTimeSum / count)); // Assuming count is correct divisor for existing values
+                if (distanceMin !== Number.MAX_VALUE)
+                    stats.push(new data_jump_stats_1.DataJumpDistanceMin(distanceMin));
+                if (distanceMax !== -Number.MAX_VALUE)
+                    stats.push(new data_jump_stats_1.DataJumpDistanceMax(distanceMax));
+                if (distanceSum > 0)
+                    stats.push(new data_jump_stats_1.DataJumpDistanceAvg(distanceSum / count));
+                if (speedMin !== Number.MAX_VALUE)
+                    stats.push(new data_jump_stats_1.DataJumpSpeedMin(speedMin));
+                if (speedMax !== -Number.MAX_VALUE)
+                    stats.push(new data_jump_stats_1.DataJumpSpeedMax(speedMax));
+                if (speedSum > 0)
+                    stats.push(new data_jump_stats_1.DataJumpSpeedAvg(speedSum / count));
+                if (rotationsMin !== Number.MAX_VALUE)
+                    stats.push(new data_jump_stats_1.DataJumpRotationsMin(rotationsMin));
+                if (rotationsMax !== -Number.MAX_VALUE)
+                    stats.push(new data_jump_stats_1.DataJumpRotationsMax(rotationsMax));
+                if (rotationsSum > 0)
+                    stats.push(new data_jump_stats_1.DataJumpRotationsAvg(rotationsSum / count));
+                if (scoreMin !== Number.MAX_VALUE)
+                    stats.push(new data_jump_stats_1.DataJumpScoreMin(scoreMin));
+                if (scoreMax !== -Number.MAX_VALUE)
+                    stats.push(new data_jump_stats_1.DataJumpScoreMax(scoreMax));
+                if (scoreSum > 0)
+                    stats.push(new data_jump_stats_1.DataJumpScoreAvg(scoreSum / count));
+                if (heightMin !== Number.MAX_VALUE)
+                    stats.push(new data_jump_stats_1.DataJumpHeightMin(heightMin));
+                if (heightMax !== -Number.MAX_VALUE)
+                    stats.push(new data_jump_stats_1.DataJumpHeightMax(heightMax));
+                if (heightSum > 0)
+                    stats.push(new data_jump_stats_1.DataJumpHeightAvg(heightSum / count));
+            }
+        }
         return stats;
     }
     static getCreatorFromFitDataObject(fitDataObject) {

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

@@ -47,7 +47,6 @@ const path = __importStar(require("path"));
 const importer_fit_1 = require("./importer.fit");
 const data_aerobic_training_effect_1 = require("../../../../data/data-aerobic-training-effect");
 const data_anaerobic_training_effect_1 = require("../../../../data/data-anaerobic-training-effect");
-const data_vo2_max_1 = require("../../../../data/data.vo2-max");
 const data_recovery_time_1 = require("../../../../data/data.recovery-time");
 const data_avg_respiration_rate_1 = require("../../../../data/data.avg-respiration-rate");
 const data_heart_rate_zone_five_duration_1 = require("../../../../data/data.heart-rate-zone-five-duration");
@@ -146,10 +145,6 @@ describe('EventImporterFIT MTB Jumps', () => {
         const anaerobic = activity.getStat(data_anaerobic_training_effect_1.DataAnaerobicTrainingEffect.type);
         expect(anaerobic).toBeDefined();
         expect(anaerobic.getValue()).toBe(2);
-        // VO2 Max
-        const vo2Max = activity.getStat(data_vo2_max_1.DataVO2Max.type);
-        expect(vo2Max).toBeDefined();
-        expect(vo2Max.getValue()).toBeCloseTo(57.0633, 4);
         expect(activity.getStat(data_temperature_max_1.DataTemperatureMax.type).getValue()).toBe(19);
         expect(activity.getStat(data_temperature_min_1.DataTemperatureMin.type).getValue()).toBe(7);
         // Positions
@@ -200,13 +195,46 @@ describe('EventImporterFIT MTB Jumps', () => {
         // Check Jumps
         const jumpEvents = activity.getAllEvents().filter((e) => e.getType() === data_jump_event_1.DataJumpEvent.type);
         expect(jumpEvents.length).toBeGreaterThan(0);
+        expect(jumpEvents.length).toBe(11);
         const jump = jumpEvents[0];
         expect(jump.jumpData).toBeDefined();
         expect((0, helpers_1.isNumber)(jump.jumpData.distance)).toBeTruthy();
-        expect((0, helpers_1.isNumber)(jump.jumpData.height)).toBeTruthy();
         expect((0, helpers_1.isNumber)(jump.jumpData.score)).toBeTruthy();
+        // Verify new jump fields with expected values
+        expect(jump.jumpData.distance).toBeCloseTo(2.069, 2);
+        expect(jump.jumpData.hang_time).toBeCloseTo(0.36, 2);
+        expect(jump.jumpData.score).toBeCloseTo(62.44, 1);
+        expect(jump.jumpData.position_lat).toBeCloseTo(39.6679, 3);
+        expect(jump.jumpData.position_long).toBeCloseTo(20.8382, 3);
+        expect(jump.jumpData.speed).toBeCloseTo(5.748, 2);
         console.log(`Found ${jumpEvents.length} jumps.`);
         console.log('First jump:', jump.jumpData);
+        // Verify Jump Statistics (Min, Max, Avg)
+        const { DataJumpDistanceAvg, DataJumpDistanceMax, DataJumpDistanceMin, DataJumpHangTimeAvg, DataJumpHangTimeMax, DataJumpHangTimeMin, DataJumpHeightAvg, DataJumpHeightMax, DataJumpHeightMin, DataJumpRotationsAvg, DataJumpRotationsMax, DataJumpRotationsMin, DataJumpScoreAvg, DataJumpScoreMax, DataJumpScoreMin, DataJumpSpeedAvg, DataJumpSpeedMax, DataJumpSpeedMin } = yield Promise.resolve().then(() => __importStar(require('../../../../data/data.jump-stats')));
+        // Hangtime
+        expect(activity.getStat(DataJumpHangTimeMin.type).getValue()).toBeCloseTo(0.36, 2);
+        expect(activity.getStat(DataJumpHangTimeMax.type).getValue()).toBeCloseTo(0.696, 3);
+        expect(activity.getStat(DataJumpHangTimeAvg.type).getValue()).toBeCloseTo(0.45, 2);
+        // Distance
+        expect(activity.getStat(DataJumpDistanceMin.type).getValue()).toBeCloseTo(1.40, 2);
+        expect(activity.getStat(DataJumpDistanceMax.type).getValue()).toBeCloseTo(4.68, 2);
+        expect(activity.getStat(DataJumpDistanceAvg.type).getValue()).toBeCloseTo(3.02, 2);
+        // Speed
+        expect(activity.getStat(DataJumpSpeedMin.type).getValue()).toBeCloseTo(3.88, 2);
+        expect(activity.getStat(DataJumpSpeedMax.type).getValue()).toBeCloseTo(8.995, 3);
+        expect(activity.getStat(DataJumpSpeedAvg.type).getValue()).toBeCloseTo(6.55, 2);
+        // Score
+        expect(activity.getStat(DataJumpScoreMin.type).getValue()).toBeCloseTo(53.9, 1);
+        expect(activity.getStat(DataJumpScoreMax.type).getValue()).toBeCloseTo(122.6, 1);
+        expect(activity.getStat(DataJumpScoreAvg.type).getValue()).toBeCloseTo(81.8, 1);
+        // Rotations (Should be undefined for this file)
+        expect(activity.getStat(DataJumpRotationsMin.type)).toBeUndefined();
+        expect(activity.getStat(DataJumpRotationsMax.type)).toBeUndefined();
+        expect(activity.getStat(DataJumpRotationsAvg.type)).toBeUndefined();
+        // Height (Should be undefined for this file)
+        expect(activity.getStat(DataJumpHeightMin.type)).toBeUndefined();
+        expect(activity.getStat(DataJumpHeightMax.type)).toBeUndefined();
+        expect(activity.getStat(DataJumpHeightAvg.type)).toBeUndefined();
         // We can check if we can find a sample with Grit.
         // In sports-lib, samples are often accessed via activity.getStream(type) or similar, BUT
         // importer creates `DataPoint`s? Or `DataSample`s?

package/lib/esm/data/data.jump-event.d.ts

@@ -1,8 +1,13 @@
 import { DataEvent } from './data.event';
 export interface JumpEventInterface {
     distance: number;
-    height: number;
+    height?: number;
     score: number;
+    hang_time?: number;
+    position_lat?: number;
+    position_long?: number;
+    speed?: number;
+    rotations?: number;
 }
 export declare class DataJumpEvent extends DataEvent {
     jumpData: JumpEventInterface;

package/lib/esm/data/data.jump-stats.d.ts

@@ -0,0 +1,91 @@
+import { DataNumber } from './data.number';
+export declare class DataJumpHangTimeMin extends DataNumber {
+    static type: string;
+    static unit: string;
+    constructor(value: number);
+}
+export declare class DataJumpHangTimeMax extends DataNumber {
+    static type: string;
+    static unit: string;
+    constructor(value: number);
+}
+export declare class DataJumpHangTimeAvg extends DataNumber {
+    static type: string;
+    static unit: string;
+    constructor(value: number);
+}
+export declare class DataJumpDistanceMin extends DataNumber {
+    static type: string;
+    static unit: string;
+    constructor(value: number);
+}
+export declare class DataJumpDistanceMax extends DataNumber {
+    static type: string;
+    static unit: string;
+    constructor(value: number);
+}
+export declare class DataJumpDistanceAvg extends DataNumber {
+    static type: string;
+    static unit: string;
+    constructor(value: number);
+}
+export declare class DataJumpSpeedMin extends DataNumber {
+    static type: string;
+    static unit: string;
+    constructor(value: number);
+}
+export declare class DataJumpSpeedMax extends DataNumber {
+    static type: string;
+    static unit: string;
+    constructor(value: number);
+}
+export declare class DataJumpSpeedAvg extends DataNumber {
+    static type: string;
+    static unit: string;
+    constructor(value: number);
+}
+export declare class DataJumpRotationsMin extends DataNumber {
+    static type: string;
+    static unit: string;
+    constructor(value: number);
+}
+export declare class DataJumpRotationsMax extends DataNumber {
+    static type: string;
+    static unit: string;
+    constructor(value: number);
+}
+export declare class DataJumpRotationsAvg extends DataNumber {
+    static type: string;
+    static unit: string;
+    constructor(value: number);
+}
+export declare class DataJumpScoreMin extends DataNumber {
+    static type: string;
+    static unit: string;
+    constructor(value: number);
+}
+export declare class DataJumpScoreMax extends DataNumber {
+    static type: string;
+    static unit: string;
+    constructor(value: number);
+}
+export declare class DataJumpScoreAvg extends DataNumber {
+    static type: string;
+    static unit: string;
+    constructor(value: number);
+}
+export declare class DataJumpHeightMin extends DataNumber {
+    static type: string;
+    static unit: string;
+    constructor(value: number);
+}
+export declare class DataJumpHeightMax extends DataNumber {
+    static type: string;
+    static unit: string;
+    constructor(value: number);
+}
+export declare class DataJumpHeightAvg extends DataNumber {
+    static type: string;
+    static unit: string;
+    constructor(value: number);
+}

package/lib/esm/index.js

@@ -4142,6 +4142,206 @@ var DataDepthMax = class extends DataNumber {
   }
 };
 
+// src/data/data.jump-stats.ts
+var DataJumpHangTimeMin = class extends DataNumber {
+  static {
+    this.type = "Jump Hang Time Min";
+  }
+  static {
+    this.unit = "s";
+  }
+  constructor(value) {
+    super(value);
+  }
+};
+var DataJumpHangTimeMax = class extends DataNumber {
+  static {
+    this.type = "Jump Hang Time Max";
+  }
+  static {
+    this.unit = "s";
+  }
+  constructor(value) {
+    super(value);
+  }
+};
+var DataJumpHangTimeAvg = class extends DataNumber {
+  static {
+    this.type = "Jump Hang Time Avg";
+  }
+  static {
+    this.unit = "s";
+  }
+  constructor(value) {
+    super(value);
+  }
+};
+var DataJumpDistanceMin = class extends DataNumber {
+  static {
+    this.type = "Jump Distance Min";
+  }
+  static {
+    this.unit = "m";
+  }
+  constructor(value) {
+    super(value);
+  }
+};
+var DataJumpDistanceMax = class extends DataNumber {
+  static {
+    this.type = "Jump Distance Max";
+  }
+  static {
+    this.unit = "m";
+  }
+  constructor(value) {
+    super(value);
+  }
+};
+var DataJumpDistanceAvg = class extends DataNumber {
+  static {
+    this.type = "Jump Distance Avg";
+  }
+  static {
+    this.unit = "m";
+  }
+  constructor(value) {
+    super(value);
+  }
+};
+var DataJumpSpeedMin = class extends DataNumber {
+  static {
+    this.type = "Jump Speed Min";
+  }
+  static {
+    this.unit = "m/s";
+  }
+  constructor(value) {
+    super(value);
+  }
+};
+var DataJumpSpeedMax = class extends DataNumber {
+  static {
+    this.type = "Jump Speed Max";
+  }
+  static {
+    this.unit = "m/s";
+  }
+  constructor(value) {
+    super(value);
+  }
+};
+var DataJumpSpeedAvg = class extends DataNumber {
+  static {
+    this.type = "Jump Speed Avg";
+  }
+  static {
+    this.unit = "m/s";
+  }
+  constructor(value) {
+    super(value);
+  }
+};
+var DataJumpRotationsMin = class extends DataNumber {
+  static {
+    this.type = "Jump Rotations Min";
+  }
+  static {
+    this.unit = "";
+  }
+  constructor(value) {
+    super(value);
+  }
+};
+var DataJumpRotationsMax = class extends DataNumber {
+  static {
+    this.type = "Jump Rotations Max";
+  }
+  static {
+    this.unit = "";
+  }
+  constructor(value) {
+    super(value);
+  }
+};
+var DataJumpRotationsAvg = class extends DataNumber {
+  static {
+    this.type = "Jump Rotations Avg";
+  }
+  static {
+    this.unit = "";
+  }
+  constructor(value) {
+    super(value);
+  }
+};
+var DataJumpScoreMin = class extends DataNumber {
+  static {
+    this.type = "Jump Score Min";
+  }
+  static {
+    this.unit = "";
+  }
+  constructor(value) {
+    super(value);
+  }
+};
+var DataJumpScoreMax = class extends DataNumber {
+  static {
+    this.type = "Jump Score Max";
+  }
+  static {
+    this.unit = "";
+  }
+  constructor(value) {
+    super(value);
+  }
+};
+var DataJumpScoreAvg = class extends DataNumber {
+  static {
+    this.type = "Jump Score Avg";
+  }
+  static {
+    this.unit = "";
+  }
+  constructor(value) {
+    super(value);
+  }
+};
+var DataJumpHeightMin = class extends DataNumber {
+  static {
+    this.type = "Jump Height Min";
+  }
+  static {
+    this.unit = "m";
+  }
+  constructor(value) {
+    super(value);
+  }
+};
+var DataJumpHeightMax = class extends DataNumber {
+  static {
+    this.type = "Jump Height Max";
+  }
+  static {
+    this.unit = "m";
+  }
+  constructor(value) {
+    super(value);
+  }
+};
+var DataJumpHeightAvg = class extends DataNumber {
+  static {
+    this.type = "Jump Height Avg";
+  }
+  static {
+    this.unit = "m";
+  }
+  constructor(value) {
+    super(value);
+  }
+};
+
 // src/data/data.store.ts
 var DataTotalTrainingEffectLegacy = class extends DataAerobicTrainingEffect {
   static {
@@ -4451,7 +4651,25 @@ var DataStore = {
   DataFitnessAge,
   DataMaxHRSetting,
   DataDepth,
-  DataDepthMax
+  DataDepthMax,
+  DataJumpHangTimeMin,
+  DataJumpHangTimeMax,
+  DataJumpHangTimeAvg,
+  DataJumpDistanceMin,
+  DataJumpDistanceMax,
+  DataJumpDistanceAvg,
+  DataJumpSpeedMin,
+  DataJumpSpeedMax,
+  DataJumpSpeedAvg,
+  DataJumpRotationsMin,
+  DataJumpRotationsMax,
+  DataJumpRotationsAvg,
+  DataJumpScoreMin,
+  DataJumpScoreMax,
+  DataJumpScoreAvg,
+  DataJumpHeightMin,
+  DataJumpHeightMax,
+  DataJumpHeightAvg
 };
 var DynamicDataLoader = class _DynamicDataLoader {
   static {
@@ -10078,6 +10296,16 @@ var EventImporterFIT = class {
             });
           });
         }
+        if (fitDataObject.jumps && fitDataObject.jumps.length > 0) {
+          fitDataObject.sessions?.forEach((session) => {
+            const sessionStartTime = new Date(session.start_time).getTime();
+            const sessionEndTime = sessionStartTime + (session.total_elapsed_time || 0) * 1e3;
+            session.jumps = fitDataObject.jumps.filter((jump) => {
+              const jumpTime = new Date(jump.timestamp).getTime();
+              return jumpTime >= sessionStartTime && jumpTime < sessionEndTime;
+            });
+          });
+        }
         const activities = fitDataObject.sessions.map((sessionObject) => {
           const activity = this.getActivityFromSessionObject(sessionObject, fitDataObject, options);
           sessionObject.laps.forEach((sessionLapObject, index) => {
@@ -10195,7 +10423,12 @@ var EventImporterFIT = class {
                 new DataJumpEvent(activity.getDateIndex(jump.timestamp), {
                   distance: jump.distance,
                   height: jump.height,
-                  score: jump.score
+                  score: jump.score,
+                  hang_time: jump.hang_time,
+                  position_lat: jump.position_lat,
+                  position_long: jump.position_long,
+                  speed: jump.speed,
+                  rotations: jump.rotations
                 })
               );
             });
@@ -10414,12 +10647,6 @@ var EventImporterFIT = class {
         options
       );
       this.getStatsFromObject(sessionObject, activity, false).forEach((stat) => activity.addStat(stat));
-      if (fitDataObject.jumps && fitDataObject.jumps.length) {
-        const jumpWithMets = fitDataObject.jumps.find((j) => j.enhanced_mets);
-        if (jumpWithMets) {
-          activity.addStat(new DataVO2Max(jumpWithMets.enhanced_mets * 3.5));
-        }
-      }
       if (fitDataObject.user_profile) {
         const userProfile = fitDataObject.user_profile;
         if (isNumberOrString(userProfile.weight)) {
@@ -10801,6 +11028,69 @@ var EventImporterFIT = class {
     if (isNumberOrString(object.avg_vam)) {
       stats.push(new DataAvgVAM(object.avg_vam));
     }
+    if (object.jumps && object.jumps.length > 0) {
+      const jumps = object.jumps;
+      let count = 0;
+      let hangTimeSum = 0, hangTimeMin = Number.MAX_VALUE, hangTimeMax = -Number.MAX_VALUE;
+      let distanceSum = 0, distanceMin = Number.MAX_VALUE, distanceMax = -Number.MAX_VALUE;
+      let speedSum = 0, speedMin = Number.MAX_VALUE, speedMax = -Number.MAX_VALUE;
+      let rotationsSum = 0, rotationsMin = Number.MAX_VALUE, rotationsMax = -Number.MAX_VALUE;
+      let scoreSum = 0, scoreMin = Number.MAX_VALUE, scoreMax = -Number.MAX_VALUE;
+      let heightSum = 0, heightMin = Number.MAX_VALUE, heightMax = -Number.MAX_VALUE;
+      jumps.forEach((j) => {
+        count++;
+        if (Number.isFinite(j.hang_time)) {
+          hangTimeSum += j.hang_time;
+          hangTimeMin = Math.min(hangTimeMin, j.hang_time);
+          hangTimeMax = Math.max(hangTimeMax, j.hang_time);
+        }
+        if (Number.isFinite(j.distance)) {
+          distanceSum += j.distance;
+          distanceMin = Math.min(distanceMin, j.distance);
+          distanceMax = Math.max(distanceMax, j.distance);
+        }
+        if (Number.isFinite(j.speed)) {
+          speedSum += j.speed;
+          speedMin = Math.min(speedMin, j.speed);
+          speedMax = Math.max(speedMax, j.speed);
+        }
+        if (Number.isFinite(j.rotations)) {
+          rotationsSum += j.rotations;
+          rotationsMin = Math.min(rotationsMin, j.rotations);
+          rotationsMax = Math.max(rotationsMax, j.rotations);
+        }
+        if (Number.isFinite(j.score)) {
+          scoreSum += j.score;
+          scoreMin = Math.min(scoreMin, j.score);
+          scoreMax = Math.max(scoreMax, j.score);
+        }
+        if (Number.isFinite(j.height)) {
+          heightSum += j.height;
+          heightMin = Math.min(heightMin, j.height);
+          heightMax = Math.max(heightMax, j.height);
+        }
+      });
+      if (count > 0) {
+        if (hangTimeMin !== Number.MAX_VALUE) stats.push(new DataJumpHangTimeMin(hangTimeMin));
+        if (hangTimeMax !== -Number.MAX_VALUE) stats.push(new DataJumpHangTimeMax(hangTimeMax));
+        if (hangTimeSum > 0) stats.push(new DataJumpHangTimeAvg(hangTimeSum / count));
+        if (distanceMin !== Number.MAX_VALUE) stats.push(new DataJumpDistanceMin(distanceMin));
+        if (distanceMax !== -Number.MAX_VALUE) stats.push(new DataJumpDistanceMax(distanceMax));
+        if (distanceSum > 0) stats.push(new DataJumpDistanceAvg(distanceSum / count));
+        if (speedMin !== Number.MAX_VALUE) stats.push(new DataJumpSpeedMin(speedMin));
+        if (speedMax !== -Number.MAX_VALUE) stats.push(new DataJumpSpeedMax(speedMax));
+        if (speedSum > 0) stats.push(new DataJumpSpeedAvg(speedSum / count));
+        if (rotationsMin !== Number.MAX_VALUE) stats.push(new DataJumpRotationsMin(rotationsMin));
+        if (rotationsMax !== -Number.MAX_VALUE) stats.push(new DataJumpRotationsMax(rotationsMax));
+        if (rotationsSum > 0) stats.push(new DataJumpRotationsAvg(rotationsSum / count));
+        if (scoreMin !== Number.MAX_VALUE) stats.push(new DataJumpScoreMin(scoreMin));
+        if (scoreMax !== -Number.MAX_VALUE) stats.push(new DataJumpScoreMax(scoreMax));
+        if (scoreSum > 0) stats.push(new DataJumpScoreAvg(scoreSum / count));
+        if (heightMin !== Number.MAX_VALUE) stats.push(new DataJumpHeightMin(heightMin));
+        if (heightMax !== -Number.MAX_VALUE) stats.push(new DataJumpHeightMax(heightMax));
+        if (heightSum > 0) stats.push(new DataJumpHeightAvg(heightSum / count));
+      }
+    }
     return stats;
   }
   static getCreatorFromFitDataObject(fitDataObject) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sports-alliance/sports-lib",
-  "version": "7.2.2",
+  "version": "7.2.3",
   "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",
@@ -54,7 +54,7 @@
   "license": "SEE LICENSE IN LICENSE.md",
   "dependencies": {
     "fast-xml-parser": "^5.3.3",
-    "fit-file-parser": "2.2.4",
+    "fit-file-parser": "2.2.5",
     "geolib": "^3.3.4",
     "gpx-builder": "^3.7.8",
     "kalmanjs": "^1.1.0",