@sports-alliance/sports-lib 7.0.12 → 7.1.0

package/lib/esm/index.js

@@ -3739,6 +3739,281 @@ var DataGradeSmooth = class extends DataPercent {
   }
 };
 
+// src/data/data.weight.ts
+var DataWeight = class extends DataNumber {
+  static {
+    this.type = "Weight";
+  }
+  static {
+    this.unit = "kg";
+  }
+  getDisplayValue() {
+    return this.getValue().toFixed(1);
+  }
+};
+
+// src/data/data.height.ts
+var DataHeight = class extends DataNumber {
+  static {
+    this.type = "Height";
+  }
+  static {
+    this.unit = "m";
+  }
+  getDisplayValue() {
+    return this.getValue().toFixed(2);
+  }
+};
+
+// src/data/data.age.ts
+var DataAge = class extends DataNumber {
+  static {
+    this.type = "Age";
+  }
+  static {
+    this.unit = "years";
+  }
+  getDisplayValue() {
+    return this.getValue().toString();
+  }
+};
+
+// src/data/data.gender.ts
+var DataGender = class extends DataString {
+  static {
+    this.type = "Gender";
+  }
+};
+
+// src/data/data.avg-flow.ts
+var DataAvgFlow = class extends DataNumber {
+  static {
+    this.type = "Avg Flow";
+  }
+  static {
+    this.unit = "";
+  }
+};
+
+// src/data/data.avg-grit.ts
+var DataAvgGrit = class extends DataNumber {
+  static {
+    this.type = "Avg Grit";
+  }
+  static {
+    this.unit = "";
+  }
+};
+
+// src/data/data.avg-respiration-rate.ts
+var DataAvgRespirationRate = class extends DataNumber {
+  static {
+    this.type = "Avg Respiration Rate";
+  }
+  static {
+    this.unit = "br/min";
+  }
+};
+
+// src/data/data.avg-vam.ts
+var DataAvgVAM = class extends DataNumber {
+  static {
+    this.type = "Avg VAM";
+  }
+  static {
+    this.unit = "m/h";
+  }
+};
+
+// src/data/data.est-sweat-loss.ts
+var DataEstSweatLoss = class extends DataNumber {
+  static {
+    this.type = "Est Sweat Loss";
+  }
+  static {
+    this.unit = "ml";
+  }
+  constructor(value) {
+    super(value);
+  }
+};
+
+// src/data/data.flow.ts
+var DataFlow = class extends DataNumber {
+  static {
+    this.type = "Flow";
+  }
+  static {
+    this.unit = "";
+  }
+};
+
+// src/data/data.grit.ts
+var DataGrit = class extends DataNumber {
+  static {
+    this.type = "Grit";
+  }
+  static {
+    this.unit = "";
+  }
+};
+
+// src/data/data.jump-count.ts
+var DataJumpCount = class extends DataNumber {
+  static {
+    this.type = "Jump Count";
+  }
+  static {
+    this.unit = "";
+  }
+  constructor(jumpCount) {
+    super(jumpCount);
+  }
+};
+
+// src/data/data.jump-event.ts
+var DataJumpEvent = class extends DataEvent {
+  constructor(timestamp, jumpData) {
+    super(timestamp);
+    this.jumpData = jumpData;
+  }
+  static {
+    this.type = "Jump Event";
+  }
+  toJSON() {
+    const json = super.toJSON();
+    return {
+      ...json,
+      jumpData: this.jumpData
+    };
+  }
+};
+
+// src/data/data.left-pedal-smoothness.ts
+var DataLeftPedalSmoothness = class extends DataNumber {
+  static {
+    this.type = "Left Pedal Smoothness";
+  }
+  static {
+    this.unit = "%";
+  }
+  getDisplayValue() {
+    return Math.round(this.getValue());
+  }
+};
+
+// src/data/data.left-torque-effectiveness.ts
+var DataLeftTorqueEffectiveness = class extends DataNumber {
+  static {
+    this.type = "Left Torque Effectiveness";
+  }
+  static {
+    this.unit = "%";
+  }
+  getDisplayValue() {
+    return Math.round(this.getValue());
+  }
+};
+
+// src/data/data.max-respiration-rate.ts
+var DataMaxRespirationRate = class extends DataNumber {
+  static {
+    this.type = "Max Respiration Rate";
+  }
+  static {
+    this.unit = "br/min";
+  }
+};
+
+// src/data/data.min-respiration-rate.ts
+var DataMinRespirationRate = class extends DataNumber {
+  static {
+    this.type = "Min Respiration Rate";
+  }
+  static {
+    this.unit = "br/min";
+  }
+};
+
+// src/data/data.primary-benefit.ts
+var DataPrimaryBenefit = class extends DataNumber {
+  static {
+    this.type = "Primary Benefit";
+  }
+  static {
+    this.unit = "";
+  }
+  constructor(value) {
+    super(value);
+  }
+};
+
+// src/data/data.resting-calories.ts
+var DataRestingCalories = class extends DataNumber {
+  static {
+    this.type = "Resting Calories";
+  }
+  static {
+    this.unit = "kcal";
+  }
+};
+
+// src/data/data.right-pedal-smoothness.ts
+var DataRightPedalSmoothness = class extends DataNumber {
+  static {
+    this.type = "Right Pedal Smoothness";
+  }
+  static {
+    this.unit = "%";
+  }
+  getDisplayValue() {
+    return Math.round(this.getValue());
+  }
+};
+
+// src/data/data.right-torque-effectiveness.ts
+var DataRightTorqueEffectiveness = class extends DataNumber {
+  static {
+    this.type = "Right Torque Effectiveness";
+  }
+  static {
+    this.unit = "%";
+  }
+  getDisplayValue() {
+    return Math.round(this.getValue());
+  }
+};
+
+// src/data/data.total-flow.ts
+var DataTotalFlow = class extends DataNumber {
+  static {
+    this.type = "Total Flow";
+  }
+  static {
+    this.unit = "";
+  }
+};
+
+// src/data/data.total-grit.ts
+var DataTotalGrit = class extends DataNumber {
+  static {
+    this.type = "Total Grit";
+  }
+  static {
+    this.unit = "";
+  }
+};
+
+// src/data/data.training-load-peak.ts
+var DataTrainingLoadPeak = class extends DataNumber {
+  static {
+    this.type = "Training Load Peak";
+  }
+  static {
+    this.unit = "";
+  }
+};
+
 // src/data/data.store.ts
 var DataTotalTrainingEffectLegacy = class extends DataAerobicTrainingEffect {
   static {
@@ -4010,7 +4285,31 @@ var DataStore = {
   DataTargetSpeedZone,
   DataTargetDistance,
   DataTargetTime,
-  DataTotalTrainingEffectLegacy
+  DataTotalTrainingEffectLegacy,
+  DataWeight,
+  DataHeight,
+  DataAge,
+  DataGender,
+  DataAvgFlow,
+  DataAvgGrit,
+  DataAvgRespirationRate,
+  DataAvgVAM,
+  DataEstSweatLoss,
+  DataFlow,
+  DataGrit,
+  DataJumpCount,
+  DataJumpEvent,
+  DataLeftPedalSmoothness,
+  DataLeftTorqueEffectiveness,
+  DataMaxRespirationRate,
+  DataMinRespirationRate,
+  DataPrimaryBenefit,
+  DataRestingCalories,
+  DataRightPedalSmoothness,
+  DataRightTorqueEffectiveness,
+  DataTotalFlow,
+  DataTotalGrit,
+  DataTrainingLoadPeak
 };
 var DynamicDataLoader = class _DynamicDataLoader {
   static {
@@ -4029,7 +4328,11 @@ var DynamicDataLoader = class _DynamicDataLoader {
       DataPace.type,
       DataGradeAdjustedSpeed.type,
       DataGradeAdjustedPace.type,
-      DataSpeed.type
+      DataSpeed.type,
+      DataWeight.type,
+      DataHeight.type,
+      DataAge.type,
+      DataGender.type
     ];
   }
   static {
@@ -4874,9 +5177,7 @@ var Stream = class {
 };
 
 // src/geodesy/adapters/geolib.adapter.ts
-import getPreciseDistance from "geolib/es/getPreciseDistance";
-import getDistance from "geolib/es/getDistance";
-import findNearest from "geolib/es/findNearest";
+import { getPreciseDistance, getDistance, findNearest } from "geolib";
 var GeoLibAdapter = class {
   constructor() {
     this.findNearest = findNearest;
@@ -9323,6 +9624,42 @@ var FITSampleMapper = [
     getSampleValue: (sample) => {
       return sample.vertical_ratio;
     }
+  },
+  {
+    dataType: DataGrit.type,
+    getSampleValue: (sample) => {
+      return sample.grit;
+    }
+  },
+  {
+    dataType: DataFlow.type,
+    getSampleValue: (sample) => {
+      return sample.flow;
+    }
+  },
+  {
+    dataType: DataLeftTorqueEffectiveness.type,
+    getSampleValue: (sample) => {
+      return sample.left_torque_effectiveness;
+    }
+  },
+  {
+    dataType: DataRightTorqueEffectiveness.type,
+    getSampleValue: (sample) => {
+      return sample.right_torque_effectiveness;
+    }
+  },
+  {
+    dataType: DataLeftPedalSmoothness.type,
+    getSampleValue: (sample) => {
+      return sample.left_pedal_smoothness;
+    }
+  },
+  {
+    dataType: DataRightPedalSmoothness.type,
+    getSampleValue: (sample) => {
+      return sample.right_pedal_smoothness;
+    }
   }
 ];
 
@@ -9388,6 +9725,7 @@ var Device = class {
       antTransmissionType: this.antTransmissionType || null,
       antNetwork: this.antNetwork || null,
       sourceType: this.sourceType || null,
+      antId: this.antId || null,
       cumOperatingTime: this.cumOperatingTime || null
     };
   }
@@ -9655,6 +9993,21 @@ var EventImporterFIT = class {
               }
             }
           });
+          if (fitDataObject.jumps && fitDataObject.jumps.length) {
+            fitDataObject.jumps.filter((jump) => {
+              const timestamp = new Date(jump.timestamp);
+              const margin = 24 * 60 * 60 * 1e3;
+              return timestamp.getTime() >= activity.startDate.getTime() - margin && timestamp.getTime() <= activity.endDate.getTime() + margin;
+            }).forEach((jump) => {
+              activity.addEvent(
+                new DataJumpEvent(activity.getDateIndex(jump.timestamp), {
+                  distance: jump.distance,
+                  height: jump.height,
+                  score: jump.score
+                })
+              );
+            });
+          }
           const isLengthsBased = this.isLengthsBased(sessionObject);
           const samples = isLengthsBased ? this.generateSamplesFromLengths(sessionObject, options) : fitDataObject.records.filter((record) => {
             return record.timestamp >= activity.startDate && record.timestamp <= activity.endDate;
@@ -9780,6 +10133,9 @@ var EventImporterFIT = class {
       device.antTransmissionType = deviceInfo.ant_transmission_type;
       device.antNetwork = deviceInfo.ant_network;
       device.sourceType = deviceInfo.source_type;
+      if (deviceInfo.ant_id) {
+        device.antId = deviceInfo.ant_id;
+      }
       device.cumOperatingTime = deviceInfo.cum_operating_time;
       return device;
     });
@@ -9866,6 +10222,88 @@ 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)) {
+          activity.addStat(new DataWeight(userProfile.weight));
+        }
+        if (isNumberOrString(userProfile.height)) {
+          activity.addStat(new DataHeight(userProfile.height));
+        }
+        if (isNumberOrString(userProfile.age)) {
+          activity.addStat(new DataAge(userProfile.age));
+        }
+        if (userProfile.gender) {
+          activity.addStat(new DataGender(userProfile.gender));
+        }
+      }
+      if (fitDataObject.time_in_zone && fitDataObject.time_in_zone.length) {
+        const sessionTimeInZone = fitDataObject.time_in_zone.find(
+          (z) => z.reference_mesg === 18 && (z.reference_index === 0 || z.reference_index === void 0)
+        );
+        if (sessionTimeInZone && sessionTimeInZone.time_in_hr_zone && Array.isArray(sessionTimeInZone.time_in_hr_zone)) {
+          const hrZones = sessionTimeInZone.time_in_hr_zone;
+          const hrZoneBoundaries = sessionTimeInZone.hr_zone_high_boundary;
+          if (!activity.getStat(DataHeartRateZoneOneDuration.type)) {
+            if (hrZones[0] !== void 0 && hrZones[0] !== null) {
+              activity.addStat(new DataHeartRateZoneOneDuration(hrZones[0]));
+            }
+            if (hrZones[1] !== void 0 && hrZones[1] !== null) {
+              activity.addStat(new DataHeartRateZoneTwoDuration(hrZones[1]));
+            }
+            if (hrZones[2] !== void 0 && hrZones[2] !== null) {
+              activity.addStat(new DataHeartRateZoneThreeDuration(hrZones[2]));
+            }
+            if (hrZones[3] !== void 0 && hrZones[3] !== null) {
+              activity.addStat(new DataHeartRateZoneFourDuration(hrZones[3]));
+            }
+            if (hrZones[4] !== void 0 && hrZones[4] !== null) {
+              activity.addStat(new DataHeartRateZoneFiveDuration(hrZones[4]));
+            }
+          }
+          const existingHrZones = activity.intensityZones.find((iz) => iz.type === DataHeartRate.type);
+          if (!existingHrZones && Array.isArray(hrZoneBoundaries) && hrZoneBoundaries.length > 0) {
+            const hrIntensityZones = new IntensityZones(DataHeartRate.type);
+            hrIntensityZones.zone1Duration = hrZones[0] || 0;
+            hrIntensityZones.zone2Duration = hrZones[1] || 0;
+            hrIntensityZones.zone3Duration = hrZones[2] || 0;
+            hrIntensityZones.zone4Duration = hrZones[3] || 0;
+            hrIntensityZones.zone5Duration = hrZones[4] || 0;
+            if (isNumber(hrZoneBoundaries[0]) && hrZoneBoundaries[0] !== 255) {
+              hrIntensityZones.zone2LowerLimit = hrZoneBoundaries[0];
+            }
+            if (isNumber(hrZoneBoundaries[1]) && hrZoneBoundaries[1] !== 255) {
+              hrIntensityZones.zone3LowerLimit = hrZoneBoundaries[1];
+            }
+            if (isNumber(hrZoneBoundaries[2]) && hrZoneBoundaries[2] !== 255) {
+              hrIntensityZones.zone4LowerLimit = hrZoneBoundaries[2];
+            }
+            if (isNumber(hrZoneBoundaries[3]) && hrZoneBoundaries[3] !== 255) {
+              hrIntensityZones.zone5LowerLimit = hrZoneBoundaries[3];
+            }
+            activity.intensityZones.push(hrIntensityZones);
+          } else if (existingHrZones && Array.isArray(hrZoneBoundaries) && hrZoneBoundaries.length > 0) {
+            if (!existingHrZones.zone2LowerLimit && isNumber(hrZoneBoundaries[0]) && hrZoneBoundaries[0] !== 255) {
+              existingHrZones.zone2LowerLimit = hrZoneBoundaries[0];
+            }
+            if (!existingHrZones.zone3LowerLimit && isNumber(hrZoneBoundaries[1]) && hrZoneBoundaries[1] !== 255) {
+              existingHrZones.zone3LowerLimit = hrZoneBoundaries[1];
+            }
+            if (!existingHrZones.zone4LowerLimit && isNumber(hrZoneBoundaries[2]) && hrZoneBoundaries[2] !== 255) {
+              existingHrZones.zone4LowerLimit = hrZoneBoundaries[2];
+            }
+            if (!existingHrZones.zone5LowerLimit && isNumber(hrZoneBoundaries[3]) && hrZoneBoundaries[3] !== 255) {
+              existingHrZones.zone5LowerLimit = hrZoneBoundaries[3];
+            }
+          }
+        }
+      }
       return activity;
     }
   }
@@ -9967,6 +10405,9 @@ var EventImporterFIT = class {
     if (isNumberOrString(object.max_heart_rate)) {
       stats.push(new DataHeartRateMax(object.max_heart_rate));
     }
+    if (object.vo2_max_cycling && object.vo2_max_cycling > 10) {
+      stats.push(new DataVO2Max(object.vo2_max_cycling));
+    }
     if (isNumberOrString(object.avg_cadence)) {
       stats.push(new DataCadenceAvg(object.avg_cadence));
     }
@@ -9979,6 +10420,14 @@ var EventImporterFIT = class {
     if (isNumberOrString(object.avg_power)) {
       stats.push(new DataPowerAvg(object.avg_power));
     }
+    if (isNumberOrString(object.total_flow)) {
+    }
+    if (isNumberOrString(object.avg_grit)) {
+      stats.push(new DataAvgGrit(object.avg_grit));
+    }
+    if (isNumberOrString(object.avg_flow)) {
+      stats.push(new DataAvgFlow(object.avg_flow));
+    }
     if (isNumberOrString(object.min_power)) {
       stats.push(new DataPowerMin(object.min_power));
     }
@@ -10043,7 +10492,9 @@ var EventImporterFIT = class {
     if (isNumberOrString(object.total_training_effect)) {
       stats.push(new DataAerobicTrainingEffect(object.total_training_effect));
     }
-    if (isNumberOrString(object.total_anaerobic_effect)) {
+    if (isNumberOrString(object.total_anaerobic_training_effect)) {
+      stats.push(new DataAnaerobicTrainingEffect(object.total_anaerobic_training_effect));
+    } else if (isNumberOrString(object.total_anaerobic_effect)) {
       stats.push(new DataAnaerobicTrainingEffect(object.total_anaerobic_effect));
     }
     if (isNumberOrString(object.estimated_vo2_max)) {
@@ -10103,6 +10554,60 @@ var EventImporterFIT = class {
       const avgStrideLengthMeters = object.avg_step_length / 1e3;
       stats.push(new DataAvgStrideLength(Math.round(avgStrideLengthMeters * 100) / 100));
     }
+    if (isNumberOrString(object.avg_respiration_rate) || isNumberOrString(object.enhanced_avg_respiration_rate)) {
+      stats.push(
+        new DataAvgRespirationRate(object.enhanced_avg_respiration_rate || object.avg_respiration_rate)
+      );
+    }
+    if (isNumberOrString(object.max_respiration_rate) || isNumberOrString(object.enhanced_max_respiration_rate)) {
+      stats.push(
+        new DataMaxRespirationRate(object.enhanced_max_respiration_rate || object.max_respiration_rate)
+      );
+    }
+    if (isNumberOrString(object.min_respiration_rate) || isNumberOrString(object.enhanced_min_respiration_rate)) {
+      stats.push(
+        new DataMinRespirationRate(object.enhanced_min_respiration_rate || object.min_respiration_rate)
+      );
+    }
+    if (isNumberOrString(object.total_grit)) {
+      stats.push(new DataTotalGrit(object.total_grit));
+    }
+    if (isNumberOrString(object.avg_flow)) {
+      stats.push(new DataAvgFlow(object.avg_flow));
+    }
+    if (isNumberOrString(object.est_sweat_loss)) {
+      stats.push(new DataEstSweatLoss(object.est_sweat_loss));
+    }
+    if (isNumberOrString(object.primary_benefit)) {
+      stats.push(new DataPrimaryBenefit(object.primary_benefit));
+    }
+    if (object.sport_profile_name) {
+      stats.push(new DataSportProfileName(object.sport_profile_name));
+    }
+    if (isNumberOrString(object.jump_count)) {
+      stats.push(new DataJumpCount(object.jump_count));
+    }
+    if (isNumberOrString(object.training_load_peak)) {
+      stats.push(new DataTrainingLoadPeak(object.training_load_peak));
+    }
+    if (isNumber(object.start_position_lat) && isNumber(object.start_position_long)) {
+      stats.push(new DataStartPosition({
+        latitudeDegrees: object.start_position_lat,
+        longitudeDegrees: object.start_position_long
+      }));
+    }
+    if (isNumber(object.end_position_lat) && isNumber(object.end_position_long)) {
+      stats.push(new DataEndPosition({
+        latitudeDegrees: object.end_position_lat,
+        longitudeDegrees: object.end_position_long
+      }));
+    }
+    if (isNumberOrString(object.resting_calories)) {
+      stats.push(new DataRestingCalories(object.resting_calories));
+    }
+    if (isNumberOrString(object.avg_vam)) {
+      stats.push(new DataAvgVAM(object.avg_vam));
+    }
     return stats;
   }
   static getCreatorFromFitDataObject(fitDataObject) {
@@ -11889,6 +12394,8 @@ export {
   DataIBI,
   DataLatitudeDegrees,
   DataLeftBalance,
+  DataLeftPedalSmoothness,
+  DataLeftTorqueEffectiveness,
   DataLongitudeDegrees,
   DataMovingTime,
   DataPace,
@@ -11906,6 +12413,8 @@ export {
   DataRPE,
   DataRecoveryTime,
   DataRightBalance,
+  DataRightPedalSmoothness,
+  DataRightTorqueEffectiveness,
   DataSeaLevelPressure,
   DataSpeed,
   DataSpeedAvg,

package/package.json

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