@sports-alliance/sports-lib 7.1.2 → 7.2.3

package/lib/esm/index.js

@@ -3046,6 +3046,17 @@ var DataStanceTimeBalanceLeft = class extends DataStanceTimeBalance {
   }
 };
 
+// src/data/data-ground-contact-time-balance.ts
+var DataGroundContactTimeBalance = class extends DataPercent {
+};
+
+// src/data/data-ground-contact-time-balance-left.ts
+var DataGroundContactTimeBalanceLeft = class extends DataGroundContactTimeBalance {
+  static {
+    this.type = "Ground Contact Time Balance Left";
+  }
+};
+
 // src/data/data.step-length.ts
 var DataStepLength = class extends DataDistance {
   static {
@@ -3669,6 +3680,13 @@ var DataStanceTimeBalanceRight = class extends DataStanceTimeBalance {
   }
 };
 
+// src/data/data-ground-contact-time-balance-right.ts
+var DataGroundContactTimeBalanceRight = class extends DataGroundContactTimeBalance {
+  static {
+    this.type = "Ground Contact Time Balance Right";
+  }
+};
+
 // src/data/data.rider-position-change-event.ts
 var DataRiderPositionChangeEvent = class extends DataEvent {
   static {
@@ -4014,6 +4032,316 @@ var DataTrainingLoadPeak = class extends DataNumber {
   }
 };
 
+// src/data/data.ground-contact-time.ts
+var DataGroundContactTime = class extends DataNumber {
+  static {
+    this.type = "Ground Contact Time";
+  }
+  static {
+    this.unit = "ms";
+  }
+};
+
+// src/data/data.ground-contact-time-avg.ts
+var DataGroundContactTimeAvg = class extends DataNumber {
+  static {
+    this.type = "Ground Contact Time Avg";
+  }
+  static {
+    this.unit = "ms";
+  }
+};
+
+// src/data/data.ground-contact-time-max.ts
+var DataGroundContactTimeMax = class extends DataNumber {
+  static {
+    this.type = "Ground Contact Time Max";
+  }
+  static {
+    this.unit = "ms";
+  }
+};
+
+// src/data/data.ground-contact-time-min.ts
+var DataGroundContactTimeMin = class extends DataNumber {
+  static {
+    this.type = "Ground Contact Time Min";
+  }
+  static {
+    this.unit = "ms";
+  }
+};
+
+// src/data/data.vertical-oscillation-avg.ts
+var DataVerticalOscillationAvg = class extends DataNumber {
+  static {
+    this.type = "Average Vertical Oscillation";
+  }
+  static {
+    this.unit = "mm";
+  }
+};
+
+// src/data/data.vertical-oscillation-max.ts
+var DataVerticalOscillationMax = class extends DataNumber {
+  static {
+    this.type = "Maximum Vertical Oscillation";
+  }
+  static {
+    this.unit = "mm";
+  }
+};
+
+// src/data/data.vertical-oscillation-min.ts
+var DataVerticalOscillationMin = class extends DataNumber {
+  static {
+    this.type = "Minimum Vertical Oscillation";
+  }
+  static {
+    this.unit = "mm";
+  }
+};
+
+// src/data/data.fitness-age.ts
+var DataFitnessAge = class extends DataNumber {
+  static {
+    this.type = "Fitness Age";
+  }
+  static {
+    this.unit = "years";
+  }
+};
+
+// src/data/data.max-hr-setting.ts
+var DataMaxHRSetting = class extends DataNumber {
+  static {
+    this.type = "Max HR Setting";
+  }
+  static {
+    this.unit = "bpm";
+  }
+};
+
+// src/data/data.depth.ts
+var DataDepth = class extends DataNumber {
+  static {
+    this.type = "Depth";
+  }
+  static {
+    this.unit = "m";
+  }
+};
+
+// src/data/data.depth-max.ts
+var DataDepthMax = class extends DataNumber {
+  static {
+    this.type = "Maximum Depth";
+  }
+  static {
+    this.unit = "m";
+  }
+};
+
+// 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 {
@@ -4309,7 +4637,39 @@ var DataStore = {
   DataRightTorqueEffectiveness,
   DataTotalFlow,
   DataTotalGrit,
-  DataTrainingLoadPeak
+  DataTrainingLoadPeak,
+  DataGroundContactTime,
+  DataGroundContactTimeAvg,
+  DataGroundContactTimeMax,
+  DataGroundContactTimeMin,
+  DataGroundContactTimeBalance,
+  DataGroundContactTimeBalanceLeft,
+  DataGroundContactTimeBalanceRight,
+  DataVerticalOscillationAvg,
+  DataVerticalOscillationMax,
+  DataVerticalOscillationMin,
+  DataFitnessAge,
+  DataMaxHRSetting,
+  DataDepth,
+  DataDepthMax,
+  DataJumpHangTimeMin,
+  DataJumpHangTimeMax,
+  DataJumpHangTimeAvg,
+  DataJumpDistanceMin,
+  DataJumpDistanceMax,
+  DataJumpDistanceAvg,
+  DataJumpSpeedMin,
+  DataJumpSpeedMax,
+  DataJumpSpeedAvg,
+  DataJumpRotationsMin,
+  DataJumpRotationsMax,
+  DataJumpRotationsAvg,
+  DataJumpScoreMin,
+  DataJumpScoreMax,
+  DataJumpScoreAvg,
+  DataJumpHeightMin,
+  DataJumpHeightMax,
+  DataJumpHeightAvg
 };
 var DynamicDataLoader = class _DynamicDataLoader {
   static {
@@ -4540,6 +4900,13 @@ var DynamicDataLoader = class _DynamicDataLoader {
     ];
   }
   static getDataInstanceFromDataType(dataType, opts) {
+    if (dataType === DataStanceTime.type) {
+      dataType = DataGroundContactTime.type;
+    } else if (dataType === DataStanceTimeBalanceLeft.type) {
+      dataType = DataGroundContactTimeBalanceLeft.type;
+    } else if (dataType === DataStanceTimeBalanceRight.type) {
+      dataType = DataGroundContactTimeBalanceRight.type;
+    }
     const className = Object.keys(DataStore).find((dataClass) => {
       return DataStore[dataClass] && DataStore[dataClass].type && DataStore[dataClass].type === dataType;
     });
@@ -6463,11 +6830,34 @@ var ActivityUtilities = class _ActivityUtilities {
       activity.addStat(new DataRightBalance(avgRightBalance));
       activity.addStat(new DataLeftBalance(100 - avgRightBalance));
     }
+    if (!activity.getStat(DataGroundContactTimeBalanceLeft.type) && activity.hasStreamData(DataGroundContactTimeBalanceLeft.type)) {
+      const avgStanceTimeLeftBalance = this.round(this.getDataTypeAvg(activity, DataGroundContactTimeBalanceLeft.type), 2);
+      activity.addStat(new DataGroundContactTimeBalanceLeft(avgStanceTimeLeftBalance));
+      activity.addStat(new DataGroundContactTimeBalanceRight(100 - avgStanceTimeLeftBalance));
+    }
     if (!activity.getStat(DataStanceTimeBalanceLeft.type) && activity.hasStreamData(DataStanceTimeBalanceLeft.type)) {
       const avgStanceTimeLeftBalance = this.round(this.getDataTypeAvg(activity, DataStanceTimeBalanceLeft.type), 2);
       activity.addStat(new DataStanceTimeBalanceLeft(avgStanceTimeLeftBalance));
       activity.addStat(new DataStanceTimeBalanceRight(100 - avgStanceTimeLeftBalance));
     }
+    if (!activity.getStat(DataGroundContactTimeMax.type) && activity.hasStreamData(DataGroundContactTime.type)) {
+      activity.addStat(new DataGroundContactTimeMax(this.getDataTypeMax(activity, DataGroundContactTime.type)));
+    }
+    if (!activity.getStat(DataGroundContactTimeMin.type) && activity.hasStreamData(DataGroundContactTime.type)) {
+      activity.addStat(new DataGroundContactTimeMin(this.getDataTypeMin(activity, DataGroundContactTime.type)));
+    }
+    if (!activity.getStat(DataGroundContactTimeAvg.type) && activity.hasStreamData(DataGroundContactTime.type)) {
+      activity.addStat(new DataGroundContactTimeAvg(this.getDataTypeAvg(activity, DataGroundContactTime.type)));
+    }
+    if (!activity.getStat(DataVerticalOscillationMax.type) && activity.hasStreamData(DataVerticalOscillation.type)) {
+      activity.addStat(new DataVerticalOscillationMax(this.getDataTypeMax(activity, DataVerticalOscillation.type)));
+    }
+    if (!activity.getStat(DataVerticalOscillationMin.type) && activity.hasStreamData(DataVerticalOscillation.type)) {
+      activity.addStat(new DataVerticalOscillationMin(this.getDataTypeMin(activity, DataVerticalOscillation.type)));
+    }
+    if (!activity.getStat(DataVerticalOscillationAvg.type) && activity.hasStreamData(DataVerticalOscillation.type)) {
+      activity.addStat(new DataVerticalOscillationAvg(this.getDataTypeAvg(activity, DataVerticalOscillation.type)));
+    }
   }
   static generateMissingSpeedDerivedStatsForActivity(activity) {
     const speedMax = activity.getStat(DataSpeedMax.type);
@@ -9601,12 +9991,32 @@ var FITSampleMapper = [
       return sample.left_right_balance.right === false ? sample.left_right_balance.value : 100 - sample.left_right_balance.value;
     }
   },
+  {
+    dataType: DataGroundContactTime.type,
+    getSampleValue: (sample) => {
+      return sample.stance_time;
+    }
+  },
+  // Keep DataStanceTime for backward compatibility
   {
     dataType: DataStanceTime.type,
     getSampleValue: (sample) => {
       return sample.stance_time;
     }
   },
+  {
+    dataType: DataGroundContactTimeBalanceLeft.type,
+    getSampleValue: (sample) => {
+      return sample.stance_time_balance;
+    }
+  },
+  {
+    dataType: DataGroundContactTimeBalanceRight.type,
+    getSampleValue: (sample) => {
+      return isNumber(sample.stance_time_balance) ? 100 - sample.stance_time_balance : null;
+    }
+  },
+  // Keep DataStanceTimeBalanceLeft for backward compatibility
   {
     dataType: DataStanceTimeBalanceLeft.type,
     getSampleValue: (sample) => {
@@ -9886,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) => {
@@ -10003,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
                 })
               );
             });
@@ -10222,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)) {
@@ -10542,6 +10961,7 @@ var EventImporterFIT = class {
       stats.push(new DataCyclingSeatedTime(seatedTime));
     }
     if (Number.isFinite(object.avg_stance_time)) {
+      stats.push(new DataGroundContactTimeAvg(object.avg_stance_time));
       stats.push(new DataStanceTime(object.avg_stance_time));
     }
     if (Number.isFinite(object.avg_vertical_oscillation)) {
@@ -10608,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) {
@@ -11051,9 +11534,11 @@ var EventImporterSuuntoJSON = class {
       }).map((lapWindow) => lapWindow.Window) : [];
       const activities = activityStartEventSamples.map(
         (activityStartEventSample, index) => {
+          const lastSampleTime = eventJSONObject.DeviceLog.Samples[eventJSONObject.DeviceLog.Samples.length - 1].TimeISO8601;
+          const fallbackEndTime = stopEventSample ? stopEventSample.TimeISO8601 : lastSampleTime;
           const activity = new Activity(
             new Date(activityStartEventSample.TimeISO8601),
-            activityStartEventSamples.length - 1 === index ? new Date(stopEventSample ? stopEventSample.TimeISO8601 : eventJSONObject.DeviceLog.Header.TimeISO8601 || eventJSONObject.DeviceLog.Header.DateTime) : new Date(activityStartEventSamples[index + 1].TimeISO8601),
+            activityStartEventSamples.length - 1 === index ? new Date(fallbackEndTime) : new Date(activityStartEventSamples[index + 1].TimeISO8601),
             ActivityTypes[ImporterSuuntoActivityIds[activityStartEventSample.Events[0].Activity.ActivityType]],
             creator,
             options
@@ -11174,9 +11659,6 @@ var EventImporterSuuntoJSON = class {
       }
       const event = new Event("", activities[0].startDate, activities[activities.length - 1].endDate, "suunto" /* SUUNTO */);
       activities.forEach((activity) => event.addActivity(activity));
-      this.getStats(eventJSONObject.DeviceLog.Header).forEach((stat) => {
-        event.addStat(stat);
-      });
       if (eventJSONObject.DeviceLog.Header.Settings) {
         this.getSettings(eventJSONObject.DeviceLog.Header.Settings).forEach((stat) => {
           event.getActivities().forEach((activity) => activity.addStat(stat));
@@ -11189,6 +11671,9 @@ var EventImporterSuuntoJSON = class {
         stats.forEach((stat) => activities[0].addStat(stat));
       }
       EventUtilities.generateStatsForAll(event);
+      this.getStats(eventJSONObject.DeviceLog.Header).forEach((stat) => {
+        event.addStat(stat);
+      });
       resolve(event);
     });
   }
@@ -11427,6 +11912,47 @@ var EventImporterSuuntoJSON = class {
         }
       }
     }
+    if (object.hasOwnProperty("GroundContactTime")) {
+      if (Array.isArray(object.GroundContactTime)) {
+        if (isNumber(object.GroundContactTime[0].Avg)) {
+          stats.push(new DataGroundContactTimeAvg(object.GroundContactTime[0].Avg * 1e3));
+        }
+        if (isNumber(object.GroundContactTime[0].Max)) {
+          stats.push(new DataGroundContactTimeMax(object.GroundContactTime[0].Max * 1e3));
+        }
+        if (isNumber(object.GroundContactTime[0].Min)) {
+          stats.push(new DataGroundContactTimeMin(object.GroundContactTime[0].Min * 1e3));
+        }
+      }
+    }
+    if (object.hasOwnProperty("VerticalOscillation")) {
+      if (Array.isArray(object.VerticalOscillation)) {
+        if (isNumber(object.VerticalOscillation[0].Avg)) {
+          stats.push(new DataVerticalOscillationAvg(object.VerticalOscillation[0].Avg * 1e3));
+        }
+        if (isNumber(object.VerticalOscillation[0].Max)) {
+          stats.push(new DataVerticalOscillationMax(object.VerticalOscillation[0].Max * 1e3));
+        }
+        if (isNumber(object.VerticalOscillation[0].Min)) {
+          stats.push(new DataVerticalOscillationMin(object.VerticalOscillation[0].Min * 1e3));
+        }
+      }
+    }
+    if (isNumber(object.FitnessAge)) {
+      stats.push(new DataFitnessAge(object.FitnessAge));
+    }
+    if (object.Personal && isNumber(object.Personal.MaxHR)) {
+      stats.push(new DataMaxHRSetting(object.Personal.MaxHR * 60));
+    }
+    if (object.hasOwnProperty("Depth")) {
+      if (Array.isArray(object.Depth)) {
+        if (isNumber(object.Depth[0].Max) && object.Depth[0].Max > 0) {
+          stats.push(new DataDepthMax(object.Depth[0].Max));
+        }
+      } else if (isNumber(object.Depth.Max) && object.Depth.Max > 0) {
+        stats.push(new DataDepthMax(object.Depth.Max));
+      }
+    }
     return stats;
   }
 };
@@ -11618,6 +12144,23 @@ var SuuntoSampleMapper = [
     dataType: DataBatteryVoltage.type,
     sampleField: "BatteryVoltage",
     convertSampleValue: (value) => Number(value)
+  },
+  {
+    dataType: DataVerticalOscillation.type,
+    sampleField: "VerticalOscillation",
+    convertSampleValue: (value) => Number(value * 1e3)
+    // Convert m to mm
+  },
+  {
+    dataType: DataGroundContactTime.type,
+    sampleField: "GroundContactTime",
+    convertSampleValue: (value) => Number(value * 1e3)
+    // Convert s to ms
+  },
+  {
+    dataType: DataDepth.type,
+    sampleField: "Depth",
+    convertSampleValue: (value) => Number(value)
   }
 ];
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sports-alliance/sports-lib",
-  "version": "7.1.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.2",
+    "fit-file-parser": "2.2.5",
     "geolib": "^3.3.4",
     "gpx-builder": "^3.7.8",
     "kalmanjs": "^1.1.0",