@sports-alliance/sports-lib 7.1.2 → 7.2.2

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,116 @@ 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.store.ts
 var DataTotalTrainingEffectLegacy = class extends DataAerobicTrainingEffect {
   static {
@@ -4309,7 +4437,21 @@ var DataStore = {
   DataRightTorqueEffectiveness,
   DataTotalFlow,
   DataTotalGrit,
-  DataTrainingLoadPeak
+  DataTrainingLoadPeak,
+  DataGroundContactTime,
+  DataGroundContactTimeAvg,
+  DataGroundContactTimeMax,
+  DataGroundContactTimeMin,
+  DataGroundContactTimeBalance,
+  DataGroundContactTimeBalanceLeft,
+  DataGroundContactTimeBalanceRight,
+  DataVerticalOscillationAvg,
+  DataVerticalOscillationMax,
+  DataVerticalOscillationMin,
+  DataFitnessAge,
+  DataMaxHRSetting,
+  DataDepth,
+  DataDepthMax
 };
 var DynamicDataLoader = class _DynamicDataLoader {
   static {
@@ -4540,6 +4682,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 +6612,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 +9773,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) => {
@@ -10542,6 +10734,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)) {
@@ -11051,9 +11244,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 +11369,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 +11381,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 +11622,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 +11854,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.2",
   "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.4",
     "geolib": "^3.3.4",
     "gpx-builder": "^3.7.8",
     "kalmanjs": "^1.1.0",