@sports-alliance/sports-lib 7.2.2 → 7.2.4

package/lib/esm/index.js

@@ -3488,6 +3488,9 @@ var DataStepsOld = class extends DataNumber {
 
 // src/data/data.event.ts
 var DataEvent = class extends DataNumber {
+  get timestamp() {
+    return this.getValue();
+  }
 };
 
 // src/data/data.stop-event.ts
@@ -3692,9 +3695,14 @@ var DataRiderPositionChangeEvent = class extends DataEvent {
   static {
     this.type = "Rider Position Change Event";
   }
-  constructor(index, positionChange) {
-    super(index);
-    this.positionChange = positionChange;
+  constructor(indexOrObj, positionChange) {
+    if (typeof indexOrObj === "object") {
+      super(indexOrObj.index);
+      this.positionChange = indexOrObj.positionChange;
+    } else {
+      super(indexOrObj);
+      this.positionChange = positionChange;
+    }
   }
 };
 
@@ -3890,19 +3898,57 @@ var DataJumpCount = class extends DataNumber {
 };
 
 // src/data/data.jump-event.ts
-var DataJumpEvent = class extends DataEvent {
-  constructor(timestamp, jumpData) {
-    super(timestamp);
-    this.jumpData = jumpData;
+var DataScore = class extends DataNumber {
+  static {
+    this.type = "Score";
   }
+};
+var DataRotations = class extends DataNumber {
+  static {
+    this.type = "Rotations";
+  }
+};
+var DataJumpEvent = class _DataJumpEvent extends DataEvent {
   static {
     this.type = "Jump Event";
   }
+  constructor(timestampOrObj, jumpData) {
+    if (typeof timestampOrObj === "object") {
+      super(timestampOrObj.timestamp);
+      this.jumpData = this.hydrate(timestampOrObj.jumpData);
+    } else {
+      super(timestampOrObj);
+      this.jumpData = this.hydrate(jumpData);
+    }
+  }
+  hydrate(data) {
+    return {
+      distance: data.distance instanceof DataDistance ? data.distance : new DataDistance(data.distance),
+      height: data.height ? data.height instanceof DataDistance ? data.height : new DataDistance(data.height) : void 0,
+      score: data.score instanceof DataScore ? data.score : new DataScore(data.score),
+      hang_time: data.hang_time ? data.hang_time instanceof DataDuration ? data.hang_time : new DataDuration(data.hang_time) : void 0,
+      position_lat: data.position_lat ? data.position_lat instanceof DataLatitudeDegrees ? data.position_lat : new DataLatitudeDegrees(data.position_lat) : void 0,
+      position_long: data.position_long ? data.position_long instanceof DataLongitudeDegrees ? data.position_long : new DataLongitudeDegrees(data.position_long) : void 0,
+      speed: data.speed ? data.speed instanceof DataSpeed ? data.speed : new DataSpeed(data.speed) : void 0,
+      rotations: data.rotations ? data.rotations instanceof DataRotations ? data.rotations : new DataRotations(data.rotations) : void 0
+    };
+  }
   toJSON() {
     const json = super.toJSON();
     return {
-      ...json,
-      jumpData: this.jumpData
+      [_DataJumpEvent.type]: {
+        timestamp: this.getValue(),
+        jumpData: {
+          distance: this.jumpData.distance.getValue(),
+          height: this.jumpData.height?.getValue(),
+          score: this.jumpData.score.getValue(),
+          hang_time: this.jumpData.hang_time?.getValue(),
+          position_lat: this.jumpData.position_lat?.getValue(),
+          position_long: this.jumpData.position_long?.getValue(),
+          speed: this.jumpData.speed?.getValue(),
+          rotations: this.jumpData.rotations?.getValue()
+        }
+      }
     };
   }
 };
@@ -4142,6 +4188,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 {
@@ -4427,6 +4673,8 @@ var DataStore = {
   DataGrit,
   DataJumpCount,
   DataJumpEvent,
+  DataScore,
+  DataRotations,
   DataLeftPedalSmoothness,
   DataLeftTorqueEffectiveness,
   DataMaxRespirationRate,
@@ -4451,7 +4699,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 +10344,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 +10471,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 +10695,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 +11076,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) {
@@ -12620,6 +12958,7 @@ export {
   DataEPOC,
   DataEVPE,
   DataEnergy,
+  DataEvent,
   DataFeeling,
   DataGPSAltitude,
   DataGradeAdjustedPace,
@@ -12645,6 +12984,7 @@ export {
   DataHeartRateMax,
   DataHeartRateMin,
   DataIBI,
+  DataJumpEvent,
   DataLatitudeDegrees,
   DataLeftBalance,
   DataLeftPedalSmoothness,
@@ -12668,6 +13008,8 @@ export {
   DataRightBalance,
   DataRightPedalSmoothness,
   DataRightTorqueEffectiveness,
+  DataRotations,
+  DataScore,
   DataSeaLevelPressure,
   DataSpeed,
   DataSpeedAvg,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sports-alliance/sports-lib",
-  "version": "7.2.2",
+  "version": "7.2.4",
   "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",