@sports-alliance/sports-lib 7.0.13 → 7.1.1

package/lib/cjs/data/data.total-flow.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DataTotalFlow = void 0;
+const data_number_1 = require("./data.number");
+class DataTotalFlow extends data_number_1.DataNumber {
+}
+exports.DataTotalFlow = DataTotalFlow;
+DataTotalFlow.type = 'Total Flow';
+DataTotalFlow.unit = '';

package/lib/cjs/data/data.total-grit.d.ts

@@ -0,0 +1,5 @@
+import { DataNumber } from './data.number';
+export declare class DataTotalGrit extends DataNumber {
+    static type: string;
+    static unit: string;
+}

package/lib/cjs/data/data.total-grit.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DataTotalGrit = void 0;
+const data_number_1 = require("./data.number");
+class DataTotalGrit extends data_number_1.DataNumber {
+}
+exports.DataTotalGrit = DataTotalGrit;
+DataTotalGrit.type = 'Total Grit';
+DataTotalGrit.unit = '';

package/lib/cjs/data/data.training-load-peak.d.ts

@@ -0,0 +1,5 @@
+import { DataNumber } from './data.number';
+export declare class DataTrainingLoadPeak extends DataNumber {
+    static type: string;
+    static unit: string;
+}

package/lib/cjs/data/data.training-load-peak.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DataTrainingLoadPeak = void 0;
+const data_number_1 = require("./data.number");
+class DataTrainingLoadPeak extends data_number_1.DataNumber {
+}
+exports.DataTrainingLoadPeak = DataTrainingLoadPeak;
+DataTrainingLoadPeak.type = 'Training Load Peak';
+DataTrainingLoadPeak.unit = '';

package/lib/cjs/data/data.weight.d.ts

@@ -0,0 +1,6 @@
+import { DataNumber } from './data.number';
+export declare class DataWeight extends DataNumber {
+    static type: string;
+    static unit: string;
+    getDisplayValue(): string;
+}

package/lib/cjs/data/data.weight.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DataWeight = void 0;
+const data_number_1 = require("./data.number");
+class DataWeight extends data_number_1.DataNumber {
+    getDisplayValue() {
+        return this.getValue().toFixed(1);
+    }
+}
+exports.DataWeight = DataWeight;
+DataWeight.type = 'Weight';
+DataWeight.unit = 'kg';

package/lib/cjs/events/adapters/importers/fit/importer.fit.d.ts

@@ -1,5 +1,7 @@
 import { EventInterface } from '../../../event.interface';
 import { CreatorInterface } from '../../../../creators/creator.interface';
+import { ActivityInterface } from '../../../../activities/activity.interface';
+import { DataInterface } from '../../../../data/data.interface';
 import { ActivityParsingOptions } from '../../../../activities/activity-parsing-options';
 import { Buffer } from 'buffer';
 export declare class EventImporterFIT {
@@ -27,7 +29,7 @@ export declare class EventImporterFIT {
      */
     private static swapTimesIfRequired;
     private static getActivityTypeFromSessionObject;
-    private static getStatsFromObject;
+    static getStatsFromObject(object: any, activity: ActivityInterface, isLap: boolean): DataInterface[];
     static getCreatorFromFitDataObject(fitDataObject: any): CreatorInterface;
 }
 export interface FITFileActivityEvent {

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

@@ -8,9 +8,6 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.EventImporterFIT = void 0;
 const event_1 = require("../../../event");
@@ -107,6 +104,20 @@ const data_anaerobic_training_effect_1 = require("../../../../data/data-anaerobi
 const importer_fit_wahoo_device_names_1 = require("./importer.fit.wahoo.device.names");
 const importer_fit_coros_device_names_1 = require("./importer.fit.coros.device.names");
 const importer_fit_srm_device_names_1 = require("./importer.fit.srm.device.names");
+const data_avg_respiration_rate_1 = require("../../../../data/data.avg-respiration-rate");
+const data_max_respiration_rate_1 = require("../../../../data/data.max-respiration-rate");
+const data_min_respiration_rate_1 = require("../../../../data/data.min-respiration-rate");
+const data_jump_count_1 = require("../../../../data/data.jump-count");
+const data_total_grit_1 = require("../../../../data/data.total-grit");
+const data_avg_flow_1 = require("../../../../data/data.avg-flow");
+const data_est_sweat_loss_1 = require("../../../../data/data.est-sweat-loss");
+const data_primary_benefit_1 = require("../../../../data/data.primary-benefit");
+const data_sport_profile_name_1 = require("../../../../data/data.sport-profile-name");
+const data_resting_calories_1 = require("../../../../data/data.resting-calories");
+const data_training_load_peak_1 = require("../../../../data/data.training-load-peak");
+const data_avg_vam_1 = require("../../../../data/data.avg-vam");
+const data_end_position_1 = require("../../../../data/data.end-position");
+const data_start_position_1 = require("../../../../data/data.start-position");
 const activity_parsing_options_1 = require("../../../../activities/activity-parsing-options");
 const importer_fit_hammerhead_device_names_1 = require("./importer.fit.hammerhead.device.names");
 const importer_fit_lezyne_device_names_1 = require("./importer.fit.lezyne.device.names");
@@ -116,16 +127,22 @@ const parsing_event_lib_error_1 = require("../../../../errors/parsing-event-lib.
 const data_power_down_1 = require("../../../../data/data.power-down");
 const data_power_up_1 = require("../../../../data/data.power-up");
 const importer_fit_development_device_names_1 = require("./importer.fit.development.device.names");
+const data_weight_1 = require("../../../../data/data.weight");
+const data_height_1 = require("../../../../data/data.height");
+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");
 // eslint-disable-next-line @typescript-eslint/no-var-requires
 // @ts-ignore
-const fit_file_parser_1 = __importDefault(require("fit-file-parser"));
+const FitFileParser = require('fit-file-parser').default;
 // 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 {
     static getFromArrayBuffer(arrayBuffer_1) {
         return __awaiter(this, arguments, void 0, function* (arrayBuffer, options = activity_parsing_options_1.ActivityParsingOptions.DEFAULT, name = 'New Event') {
             return new Promise((resolve, reject) => {
-                const fitFileParser = new fit_file_parser_1.default({
+                const fitFileParser = new FitFileParser({
                     force: true,
                     speedUnit: 'm/s',
                     lengthUnit: 'm',
@@ -288,6 +305,23 @@ class EventImporterFIT {
                                 }
                             }
                         });
+                        // Add jumps
+                        if (fitDataObject.jumps && fitDataObject.jumps.length) {
+                            fitDataObject.jumps
+                                .filter((jump) => {
+                                const timestamp = new Date(jump.timestamp);
+                                // Relaxed check for jumps as they might be recorded slightly outside session stats or have timezone offsets
+                                const margin = 24 * 60 * 60 * 1000; // 24 hours
+                                return timestamp.getTime() >= activity.startDate.getTime() - margin && timestamp.getTime() <= activity.endDate.getTime() + margin;
+                            })
+                                .forEach((jump) => {
+                                activity.addEvent(new data_jump_event_1.DataJumpEvent(activity.getDateIndex(jump.timestamp), {
+                                    distance: jump.distance,
+                                    height: jump.height,
+                                    score: jump.score
+                                }));
+                            });
+                        }
                         // Get the samples..
                         // Test if activity is lengths based
                         // Indeed when based on lengths, an activity do not provides samples under records object (e.g. Pool swimming activities)
@@ -442,6 +476,9 @@ class EventImporterFIT {
             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;
         });
@@ -556,6 +593,100 @@ 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;
+                if ((0, helpers_1.isNumberOrString)(userProfile.weight)) {
+                    activity.addStat(new data_weight_1.DataWeight(userProfile.weight));
+                }
+                if ((0, helpers_1.isNumberOrString)(userProfile.height)) {
+                    activity.addStat(new data_height_1.DataHeight(userProfile.height));
+                }
+                if ((0, helpers_1.isNumberOrString)(userProfile.age)) {
+                    activity.addStat(new data_age_1.DataAge(userProfile.age));
+                }
+                if (userProfile.gender) {
+                    activity.addStat(new data_gender_1.DataGender(userProfile.gender));
+                }
+            }
+            // Check for HR zone durations from time_in_zone messages
+            // This is an alternative source when sessionObject.time_in_hr_zone is not available
+            if (fitDataObject.time_in_zone && fitDataObject.time_in_zone.length) {
+                // Find session-level time_in_zone message (reference_mesg = 18 for session, reference_index = 0 for first session)
+                const sessionTimeInZone = fitDataObject.time_in_zone.find((z) => z.reference_mesg === 18 && (z.reference_index === 0 || z.reference_index === undefined));
+                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;
+                    // Only add zone duration stats if not already set from sessionObject.time_in_hr_zone
+                    if (!activity.getStat(data_heart_rate_zone_one_duration_1.DataHeartRateZoneOneDuration.type)) {
+                        if (hrZones[0] !== undefined && hrZones[0] !== null) {
+                            activity.addStat(new data_heart_rate_zone_one_duration_1.DataHeartRateZoneOneDuration(hrZones[0]));
+                        }
+                        if (hrZones[1] !== undefined && hrZones[1] !== null) {
+                            activity.addStat(new data_heart_rate_zone_two_duration_1.DataHeartRateZoneTwoDuration(hrZones[1]));
+                        }
+                        if (hrZones[2] !== undefined && hrZones[2] !== null) {
+                            activity.addStat(new data_heart_rate_zone_three_duration_1.DataHeartRateZoneThreeDuration(hrZones[2]));
+                        }
+                        if (hrZones[3] !== undefined && hrZones[3] !== null) {
+                            activity.addStat(new data_heart_rate_zone_four_duration_1.DataHeartRateZoneFourDuration(hrZones[3]));
+                        }
+                        if (hrZones[4] !== undefined && hrZones[4] !== null) {
+                            activity.addStat(new data_heart_rate_zone_five_duration_1.DataHeartRateZoneFiveDuration(hrZones[4]));
+                        }
+                    }
+                    // Check if IntensityZones for HR is already set, if not create one with boundaries
+                    const existingHrZones = activity.intensityZones.find(iz => iz.type === data_heart_rate_1.DataHeartRate.type);
+                    if (!existingHrZones && Array.isArray(hrZoneBoundaries) && hrZoneBoundaries.length > 0) {
+                        // Create IntensityZones with boundaries
+                        const hrIntensityZones = new intensity_zones_1.IntensityZones(data_heart_rate_1.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;
+                        // hr_zone_high_boundary[n] is the upper limit of zone n+1
+                        // Zone 2 lower limit = Zone 1 high boundary = hrZoneBoundaries[0]
+                        // Zone 3 lower limit = Zone 2 high boundary = hrZoneBoundaries[1]
+                        // etc.
+                        if ((0, helpers_1.isNumber)(hrZoneBoundaries[0]) && hrZoneBoundaries[0] !== 255) {
+                            hrIntensityZones.zone2LowerLimit = hrZoneBoundaries[0];
+                        }
+                        if ((0, helpers_1.isNumber)(hrZoneBoundaries[1]) && hrZoneBoundaries[1] !== 255) {
+                            hrIntensityZones.zone3LowerLimit = hrZoneBoundaries[1];
+                        }
+                        if ((0, helpers_1.isNumber)(hrZoneBoundaries[2]) && hrZoneBoundaries[2] !== 255) {
+                            hrIntensityZones.zone4LowerLimit = hrZoneBoundaries[2];
+                        }
+                        if ((0, helpers_1.isNumber)(hrZoneBoundaries[3]) && hrZoneBoundaries[3] !== 255) {
+                            hrIntensityZones.zone5LowerLimit = hrZoneBoundaries[3];
+                        }
+                        activity.intensityZones.push(hrIntensityZones);
+                    }
+                    else if (existingHrZones && Array.isArray(hrZoneBoundaries) && hrZoneBoundaries.length > 0) {
+                        // Update existing IntensityZones with boundary data if not set
+                        if (!existingHrZones.zone2LowerLimit && (0, helpers_1.isNumber)(hrZoneBoundaries[0]) && hrZoneBoundaries[0] !== 255) {
+                            existingHrZones.zone2LowerLimit = hrZoneBoundaries[0];
+                        }
+                        if (!existingHrZones.zone3LowerLimit && (0, helpers_1.isNumber)(hrZoneBoundaries[1]) && hrZoneBoundaries[1] !== 255) {
+                            existingHrZones.zone3LowerLimit = hrZoneBoundaries[1];
+                        }
+                        if (!existingHrZones.zone4LowerLimit && (0, helpers_1.isNumber)(hrZoneBoundaries[2]) && hrZoneBoundaries[2] !== 255) {
+                            existingHrZones.zone4LowerLimit = hrZoneBoundaries[2];
+                        }
+                        if (!existingHrZones.zone5LowerLimit && (0, helpers_1.isNumber)(hrZoneBoundaries[3]) && hrZoneBoundaries[3] !== 255) {
+                            existingHrZones.zone5LowerLimit = hrZoneBoundaries[3];
+                        }
+                    }
+                }
+            }
             return activity;
         }
     }
@@ -686,6 +817,9 @@ class EventImporterFIT {
             stats.push(new data_heart_rate_max_1.DataHeartRateMax(object.max_heart_rate));
         }
         // Cadence
+        if (object.vo2_max_cycling && object.vo2_max_cycling > 10) {
+            stats.push(new data_vo2_max_1.DataVO2Max(object.vo2_max_cycling));
+        }
         if ((0, helpers_1.isNumberOrString)(object.avg_cadence)) {
             stats.push(new data_cadence_avg_1.DataCadenceAvg(object.avg_cadence));
         }
@@ -699,6 +833,15 @@ class EventImporterFIT {
         if ((0, helpers_1.isNumberOrString)(object.avg_power)) {
             stats.push(new data_power_avg_1.DataPowerAvg(object.avg_power));
         }
+        // Grit & Flow
+        if ((0, helpers_1.isNumberOrString)(object.total_flow)) {
+        }
+        if ((0, helpers_1.isNumberOrString)(object.avg_grit)) {
+            stats.push(new data_avg_grit_1.DataAvgGrit(object.avg_grit));
+        }
+        if ((0, helpers_1.isNumberOrString)(object.avg_flow)) {
+            stats.push(new data_avg_flow_1.DataAvgFlow(object.avg_flow));
+        }
         if ((0, helpers_1.isNumberOrString)(object.min_power)) {
             stats.push(new data_power_min_1.DataPowerMin(object.min_power));
         }
@@ -770,7 +913,10 @@ class EventImporterFIT {
             stats.push(new data_aerobic_training_effect_1.DataAerobicTrainingEffect(object.total_training_effect));
         }
         // Total training anaerobic effect
-        if ((0, helpers_1.isNumberOrString)(object.total_anaerobic_effect)) {
+        if ((0, helpers_1.isNumberOrString)(object.total_anaerobic_training_effect)) {
+            stats.push(new data_anaerobic_training_effect_1.DataAnaerobicTrainingEffect(object.total_anaerobic_training_effect));
+        }
+        else if ((0, helpers_1.isNumberOrString)(object.total_anaerobic_effect)) {
             stats.push(new data_anaerobic_training_effect_1.DataAnaerobicTrainingEffect(object.total_anaerobic_effect));
         }
         // Vo2Max
@@ -843,6 +989,65 @@ class EventImporterFIT {
             const avgStrideLengthMeters = object.avg_step_length / 1000;
             stats.push(new data_avg_stride_length_1.DataAvgStrideLength(Math.round(avgStrideLengthMeters * 100) / 100));
         }
+        // Respiration Rate
+        if ((0, helpers_1.isNumberOrString)(object.avg_respiration_rate) || (0, helpers_1.isNumberOrString)(object.enhanced_avg_respiration_rate)) {
+            stats.push(new data_avg_respiration_rate_1.DataAvgRespirationRate(object.enhanced_avg_respiration_rate || object.avg_respiration_rate));
+        }
+        if ((0, helpers_1.isNumberOrString)(object.max_respiration_rate) || (0, helpers_1.isNumberOrString)(object.enhanced_max_respiration_rate)) {
+            stats.push(new data_max_respiration_rate_1.DataMaxRespirationRate(object.enhanced_max_respiration_rate || object.max_respiration_rate));
+        }
+        if ((0, helpers_1.isNumberOrString)(object.min_respiration_rate) || (0, helpers_1.isNumberOrString)(object.enhanced_min_respiration_rate)) {
+            stats.push(new data_min_respiration_rate_1.DataMinRespirationRate(object.enhanced_min_respiration_rate || object.min_respiration_rate));
+        }
+        // Total Grit
+        if ((0, helpers_1.isNumberOrString)(object.total_grit)) {
+            stats.push(new data_total_grit_1.DataTotalGrit(object.total_grit));
+        }
+        // Avg Flow
+        if ((0, helpers_1.isNumberOrString)(object.avg_flow)) {
+            stats.push(new data_avg_flow_1.DataAvgFlow(object.avg_flow));
+        }
+        // Est Sweat Loss
+        if ((0, helpers_1.isNumberOrString)(object.est_sweat_loss)) {
+            stats.push(new data_est_sweat_loss_1.DataEstSweatLoss(object.est_sweat_loss));
+        }
+        // Primary Benefit
+        if ((0, helpers_1.isNumberOrString)(object.primary_benefit)) {
+            stats.push(new data_primary_benefit_1.DataPrimaryBenefit(object.primary_benefit));
+        }
+        // Sport Profile Name
+        if (object.sport_profile_name) {
+            stats.push(new data_sport_profile_name_1.DataSportProfileName(object.sport_profile_name));
+        }
+        // Jump Count
+        if ((0, helpers_1.isNumberOrString)(object.jump_count)) {
+            stats.push(new data_jump_count_1.DataJumpCount(object.jump_count));
+        }
+        // Training Load Peak
+        if ((0, helpers_1.isNumberOrString)(object.training_load_peak)) {
+            stats.push(new data_training_load_peak_1.DataTrainingLoadPeak(object.training_load_peak));
+        }
+        // Positions
+        if ((0, helpers_1.isNumber)(object.start_position_lat) && (0, helpers_1.isNumber)(object.start_position_long)) {
+            stats.push(new data_start_position_1.DataStartPosition({
+                latitudeDegrees: object.start_position_lat,
+                longitudeDegrees: object.start_position_long,
+            }));
+        }
+        if ((0, helpers_1.isNumber)(object.end_position_lat) && (0, helpers_1.isNumber)(object.end_position_long)) {
+            stats.push(new data_end_position_1.DataEndPosition({
+                latitudeDegrees: object.end_position_lat,
+                longitudeDegrees: object.end_position_long,
+            }));
+        }
+        // Resting Calories
+        if ((0, helpers_1.isNumberOrString)(object.resting_calories)) {
+            stats.push(new data_resting_calories_1.DataRestingCalories(object.resting_calories));
+        }
+        // Avg VAM
+        if ((0, helpers_1.isNumberOrString)(object.avg_vam)) {
+            stats.push(new data_avg_vam_1.DataAvgVAM(object.avg_vam));
+        }
         return stats;
     }
     static getCreatorFromFitDataObject(fitDataObject) {

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

@@ -27,6 +27,12 @@ const data_step_length_1 = require("../../../../data/data.step-length");
 const data_vertical_ratio_1 = require("../../../../data/data.vertical-ratio");
 const data_ground_time_1 = require("../../../../data/data.ground-time");
 const data_air_power_1 = require("../../../../data/data.air-power");
+const data_grit_1 = require("../../../../data/data.grit");
+const data_flow_1 = require("../../../../data/data.flow");
+const data_left_torque_effectiveness_1 = require("../../../../data/data.left-torque-effectiveness");
+const data_right_torque_effectiveness_1 = require("../../../../data/data.right-torque-effectiveness");
+const data_left_pedal_smoothness_1 = require("../../../../data/data.left-pedal-smoothness");
+const data_right_pedal_smoothness_1 = require("../../../../data/data.right-pedal-smoothness");
 const constants_1 = require("../../../../constants/constants");
 exports.FITSampleMapper = [
     {
@@ -230,5 +236,41 @@ exports.FITSampleMapper = [
         getSampleValue: (sample) => {
             return sample.vertical_ratio;
         }
+    },
+    {
+        dataType: data_grit_1.DataGrit.type,
+        getSampleValue: (sample) => {
+            return sample.grit;
+        }
+    },
+    {
+        dataType: data_flow_1.DataFlow.type,
+        getSampleValue: (sample) => {
+            return sample.flow;
+        }
+    },
+    {
+        dataType: data_left_torque_effectiveness_1.DataLeftTorqueEffectiveness.type,
+        getSampleValue: (sample) => {
+            return sample.left_torque_effectiveness;
+        }
+    },
+    {
+        dataType: data_right_torque_effectiveness_1.DataRightTorqueEffectiveness.type,
+        getSampleValue: (sample) => {
+            return sample.right_torque_effectiveness;
+        }
+    },
+    {
+        dataType: data_left_pedal_smoothness_1.DataLeftPedalSmoothness.type,
+        getSampleValue: (sample) => {
+            return sample.left_pedal_smoothness;
+        }
+    },
+    {
+        dataType: data_right_pedal_smoothness_1.DataRightPedalSmoothness.type,
+        getSampleValue: (sample) => {
+            return sample.right_pedal_smoothness;
+        }
     }
 ];

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

@@ -0,0 +1 @@
+export {};