@sports-alliance/sports-lib 7.1.2 → 7.2.3

package/lib/cjs/data/data.vertical-oscillation-min.js

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

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

@@ -129,6 +129,7 @@ const data_cycling_standing_time_1 = require("../../../../data/data.cycling-stan
 const data_cycling_seated_time_1 = require("../../../../data/data.cycling-seated-time");
 const data_cycling_position_1 = require("../../../../data/data.cycling-position");
 const data_rider_position_change_event_1 = require("../../../../data/data.rider-position-change-event");
+const data_ground_contact_time_avg_1 = require("../../../../data/data.ground-contact-time-avg");
 const data_stance_time_1 = require("../../../../data/data.stance-time");
 const data_vertical_oscillation_1 = require("../../../../data/data.vertical-oscillation");
 const data_vertical_ratio_1 = require("../../../../data/data.vertical-ratio");
@@ -166,6 +167,7 @@ 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");
+const data_jump_stats_1 = require("../../../../data/data.jump-stats");
 // 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 {
@@ -183,7 +185,7 @@ class EventImporterFIT {
                     mode: 'both'
                 });
                 fitFileParser.parse(arrayBuffer, (error, fitDataObject) => {
-                    var _a;
+                    var _a, _b;
                     if (error) {
                         // For now, assume any error from parser on this file means it's broken/empty in a way we treat as EmptyEventLibError
                         // to satisfy existing tests. Or ideally we wrap in a generic EventLibError.
@@ -216,6 +218,17 @@ class EventImporterFIT {
                             });
                         });
                     }
+                    // Check for jumps data at the top level
+                    if (fitDataObject.jumps && fitDataObject.jumps.length > 0) {
+                        (_b = fitDataObject.sessions) === null || _b === void 0 ? void 0 : _b.forEach((session) => {
+                            const sessionStartTime = new Date(session.start_time).getTime();
+                            const sessionEndTime = sessionStartTime + (session.total_elapsed_time || 0) * 1000;
+                            session.jumps = fitDataObject.jumps.filter((jump) => {
+                                const jumpTime = new Date(jump.timestamp).getTime();
+                                return jumpTime >= sessionStartTime && jumpTime < sessionEndTime;
+                            });
+                        });
+                    }
                     // Iterate over the sessions and create their activities
                     const activities = fitDataObject.sessions.map((sessionObject) => {
                         // Get the activity from the sessionObject
@@ -350,7 +363,12 @@ class EventImporterFIT {
                                 activity.addEvent(new data_jump_event_1.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
                                 }));
                             });
                         }
@@ -625,13 +643,6 @@ 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;
@@ -1008,7 +1019,11 @@ class EventImporterFIT {
             stats.push(new data_cycling_seated_time_1.DataCyclingSeatedTime(seatedTime));
         }
         // Running dynamics
+        // Stance Time
         if (Number.isFinite(object.avg_stance_time)) {
+            stats.push(new data_ground_contact_time_avg_1.DataGroundContactTimeAvg(object.avg_stance_time));
+            // Keep DataStanceTime for backward compatibility (if needed, though logically it's an Avg)
+            // The original code mapped avg_stance_time to DataStanceTime, which was arguably incorrect naming or type usage
             stats.push(new data_stance_time_1.DataStanceTime(object.avg_stance_time));
         }
         if (Number.isFinite(object.avg_vertical_oscillation)) {
@@ -1080,6 +1095,94 @@ class EventImporterFIT {
         if ((0, helpers_1.isNumberOrString)(object.avg_vam)) {
             stats.push(new data_avg_vam_1.DataAvgVAM(object.avg_vam));
         }
+        // Jump Statistics
+        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++;
+                // Hangtime
+                if (Number.isFinite(j.hang_time)) {
+                    hangTimeSum += j.hang_time;
+                    hangTimeMin = Math.min(hangTimeMin, j.hang_time);
+                    hangTimeMax = Math.max(hangTimeMax, j.hang_time);
+                }
+                // Distance
+                if (Number.isFinite(j.distance)) {
+                    distanceSum += j.distance;
+                    distanceMin = Math.min(distanceMin, j.distance);
+                    distanceMax = Math.max(distanceMax, j.distance);
+                }
+                // Speed
+                if (Number.isFinite(j.speed)) {
+                    speedSum += j.speed;
+                    speedMin = Math.min(speedMin, j.speed);
+                    speedMax = Math.max(speedMax, j.speed);
+                }
+                // Rotations
+                if (Number.isFinite(j.rotations)) {
+                    rotationsSum += j.rotations;
+                    rotationsMin = Math.min(rotationsMin, j.rotations);
+                    rotationsMax = Math.max(rotationsMax, j.rotations);
+                }
+                // Score
+                if (Number.isFinite(j.score)) {
+                    scoreSum += j.score;
+                    scoreMin = Math.min(scoreMin, j.score);
+                    scoreMax = Math.max(scoreMax, j.score);
+                }
+                // Height
+                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 data_jump_stats_1.DataJumpHangTimeMin(hangTimeMin));
+                if (hangTimeMax !== -Number.MAX_VALUE)
+                    stats.push(new data_jump_stats_1.DataJumpHangTimeMax(hangTimeMax));
+                if (hangTimeSum > 0)
+                    stats.push(new data_jump_stats_1.DataJumpHangTimeAvg(hangTimeSum / count)); // Assuming count is correct divisor for existing values
+                if (distanceMin !== Number.MAX_VALUE)
+                    stats.push(new data_jump_stats_1.DataJumpDistanceMin(distanceMin));
+                if (distanceMax !== -Number.MAX_VALUE)
+                    stats.push(new data_jump_stats_1.DataJumpDistanceMax(distanceMax));
+                if (distanceSum > 0)
+                    stats.push(new data_jump_stats_1.DataJumpDistanceAvg(distanceSum / count));
+                if (speedMin !== Number.MAX_VALUE)
+                    stats.push(new data_jump_stats_1.DataJumpSpeedMin(speedMin));
+                if (speedMax !== -Number.MAX_VALUE)
+                    stats.push(new data_jump_stats_1.DataJumpSpeedMax(speedMax));
+                if (speedSum > 0)
+                    stats.push(new data_jump_stats_1.DataJumpSpeedAvg(speedSum / count));
+                if (rotationsMin !== Number.MAX_VALUE)
+                    stats.push(new data_jump_stats_1.DataJumpRotationsMin(rotationsMin));
+                if (rotationsMax !== -Number.MAX_VALUE)
+                    stats.push(new data_jump_stats_1.DataJumpRotationsMax(rotationsMax));
+                if (rotationsSum > 0)
+                    stats.push(new data_jump_stats_1.DataJumpRotationsAvg(rotationsSum / count));
+                if (scoreMin !== Number.MAX_VALUE)
+                    stats.push(new data_jump_stats_1.DataJumpScoreMin(scoreMin));
+                if (scoreMax !== -Number.MAX_VALUE)
+                    stats.push(new data_jump_stats_1.DataJumpScoreMax(scoreMax));
+                if (scoreSum > 0)
+                    stats.push(new data_jump_stats_1.DataJumpScoreAvg(scoreSum / count));
+                if (heightMin !== Number.MAX_VALUE)
+                    stats.push(new data_jump_stats_1.DataJumpHeightMin(heightMin));
+                if (heightMax !== -Number.MAX_VALUE)
+                    stats.push(new data_jump_stats_1.DataJumpHeightMax(heightMax));
+                if (heightSum > 0)
+                    stats.push(new data_jump_stats_1.DataJumpHeightAvg(heightSum / count));
+            }
+        }
         return stats;
     }
     static getCreatorFromFitDataObject(fitDataObject) {

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

@@ -21,6 +21,9 @@ const data_stryd_distance_1 = require("../../../../data/data.stryd-distance");
 const data_stryd_speed_1 = require("../../../../data/data.stryd-speed");
 const data_right_balance_1 = require("../../../../data/data.right-balance");
 const data_left_balance_1 = require("../../../../data/data.left-balance");
+const data_ground_contact_time_1 = require("../../../../data/data.ground-contact-time");
+const data_ground_contact_time_balance_left_1 = require("../../../../data/data-ground-contact-time-balance-left");
+const data_ground_contact_time_balance_right_1 = require("../../../../data/data-ground-contact-time-balance-right");
 const data_stance_time_1 = require("../../../../data/data.stance-time");
 const data_stance_time_balance_left_1 = require("../../../../data/data-stance-time-balance-left");
 const data_step_length_1 = require("../../../../data/data.step-length");
@@ -213,12 +216,32 @@ exports.FITSampleMapper = [
                 : 100 - sample.left_right_balance.value;
         }
     },
+    {
+        dataType: data_ground_contact_time_1.DataGroundContactTime.type,
+        getSampleValue: (sample) => {
+            return sample.stance_time;
+        }
+    },
+    // Keep DataStanceTime for backward compatibility
     {
         dataType: data_stance_time_1.DataStanceTime.type,
         getSampleValue: (sample) => {
             return sample.stance_time;
         }
     },
+    {
+        dataType: data_ground_contact_time_balance_left_1.DataGroundContactTimeBalanceLeft.type,
+        getSampleValue: (sample) => {
+            return sample.stance_time_balance; // The field sample refers to the balance on left leg
+        }
+    },
+    {
+        dataType: data_ground_contact_time_balance_right_1.DataGroundContactTimeBalanceRight.type,
+        getSampleValue: (sample) => {
+            return (0, helpers_1.isNumber)(sample.stance_time_balance) ? 100 - sample.stance_time_balance : null;
+        }
+    },
+    // Keep DataStanceTimeBalanceLeft for backward compatibility
     {
         dataType: data_stance_time_balance_left_1.DataStanceTimeBalanceLeft.type,
         getSampleValue: (sample) => {

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

@@ -47,7 +47,6 @@ const path = __importStar(require("path"));
 const importer_fit_1 = require("./importer.fit");
 const data_aerobic_training_effect_1 = require("../../../../data/data-aerobic-training-effect");
 const data_anaerobic_training_effect_1 = require("../../../../data/data-anaerobic-training-effect");
-const data_vo2_max_1 = require("../../../../data/data.vo2-max");
 const data_recovery_time_1 = require("../../../../data/data.recovery-time");
 const data_avg_respiration_rate_1 = require("../../../../data/data.avg-respiration-rate");
 const data_heart_rate_zone_five_duration_1 = require("../../../../data/data.heart-rate-zone-five-duration");
@@ -146,10 +145,6 @@ describe('EventImporterFIT MTB Jumps', () => {
         const anaerobic = activity.getStat(data_anaerobic_training_effect_1.DataAnaerobicTrainingEffect.type);
         expect(anaerobic).toBeDefined();
         expect(anaerobic.getValue()).toBe(2);
-        // VO2 Max
-        const vo2Max = activity.getStat(data_vo2_max_1.DataVO2Max.type);
-        expect(vo2Max).toBeDefined();
-        expect(vo2Max.getValue()).toBeCloseTo(57.0633, 4);
         expect(activity.getStat(data_temperature_max_1.DataTemperatureMax.type).getValue()).toBe(19);
         expect(activity.getStat(data_temperature_min_1.DataTemperatureMin.type).getValue()).toBe(7);
         // Positions
@@ -200,13 +195,46 @@ describe('EventImporterFIT MTB Jumps', () => {
         // Check Jumps
         const jumpEvents = activity.getAllEvents().filter((e) => e.getType() === data_jump_event_1.DataJumpEvent.type);
         expect(jumpEvents.length).toBeGreaterThan(0);
+        expect(jumpEvents.length).toBe(11);
         const jump = jumpEvents[0];
         expect(jump.jumpData).toBeDefined();
         expect((0, helpers_1.isNumber)(jump.jumpData.distance)).toBeTruthy();
-        expect((0, helpers_1.isNumber)(jump.jumpData.height)).toBeTruthy();
         expect((0, helpers_1.isNumber)(jump.jumpData.score)).toBeTruthy();
+        // Verify new jump fields with expected values
+        expect(jump.jumpData.distance).toBeCloseTo(2.069, 2);
+        expect(jump.jumpData.hang_time).toBeCloseTo(0.36, 2);
+        expect(jump.jumpData.score).toBeCloseTo(62.44, 1);
+        expect(jump.jumpData.position_lat).toBeCloseTo(39.6679, 3);
+        expect(jump.jumpData.position_long).toBeCloseTo(20.8382, 3);
+        expect(jump.jumpData.speed).toBeCloseTo(5.748, 2);
         console.log(`Found ${jumpEvents.length} jumps.`);
         console.log('First jump:', jump.jumpData);
+        // Verify Jump Statistics (Min, Max, Avg)
+        const { DataJumpDistanceAvg, DataJumpDistanceMax, DataJumpDistanceMin, DataJumpHangTimeAvg, DataJumpHangTimeMax, DataJumpHangTimeMin, DataJumpHeightAvg, DataJumpHeightMax, DataJumpHeightMin, DataJumpRotationsAvg, DataJumpRotationsMax, DataJumpRotationsMin, DataJumpScoreAvg, DataJumpScoreMax, DataJumpScoreMin, DataJumpSpeedAvg, DataJumpSpeedMax, DataJumpSpeedMin } = yield Promise.resolve().then(() => __importStar(require('../../../../data/data.jump-stats')));
+        // Hangtime
+        expect(activity.getStat(DataJumpHangTimeMin.type).getValue()).toBeCloseTo(0.36, 2);
+        expect(activity.getStat(DataJumpHangTimeMax.type).getValue()).toBeCloseTo(0.696, 3);
+        expect(activity.getStat(DataJumpHangTimeAvg.type).getValue()).toBeCloseTo(0.45, 2);
+        // Distance
+        expect(activity.getStat(DataJumpDistanceMin.type).getValue()).toBeCloseTo(1.40, 2);
+        expect(activity.getStat(DataJumpDistanceMax.type).getValue()).toBeCloseTo(4.68, 2);
+        expect(activity.getStat(DataJumpDistanceAvg.type).getValue()).toBeCloseTo(3.02, 2);
+        // Speed
+        expect(activity.getStat(DataJumpSpeedMin.type).getValue()).toBeCloseTo(3.88, 2);
+        expect(activity.getStat(DataJumpSpeedMax.type).getValue()).toBeCloseTo(8.995, 3);
+        expect(activity.getStat(DataJumpSpeedAvg.type).getValue()).toBeCloseTo(6.55, 2);
+        // Score
+        expect(activity.getStat(DataJumpScoreMin.type).getValue()).toBeCloseTo(53.9, 1);
+        expect(activity.getStat(DataJumpScoreMax.type).getValue()).toBeCloseTo(122.6, 1);
+        expect(activity.getStat(DataJumpScoreAvg.type).getValue()).toBeCloseTo(81.8, 1);
+        // Rotations (Should be undefined for this file)
+        expect(activity.getStat(DataJumpRotationsMin.type)).toBeUndefined();
+        expect(activity.getStat(DataJumpRotationsMax.type)).toBeUndefined();
+        expect(activity.getStat(DataJumpRotationsAvg.type)).toBeUndefined();
+        // Height (Should be undefined for this file)
+        expect(activity.getStat(DataJumpHeightMin.type)).toBeUndefined();
+        expect(activity.getStat(DataJumpHeightMax.type)).toBeUndefined();
+        expect(activity.getStat(DataJumpHeightAvg.type)).toBeUndefined();
         // We can check if we can find a sample with Grit.
         // In sports-lib, samples are often accessed via activity.getStream(type) or similar, BUT
         // importer creates `DataPoint`s? Or `DataSample`s?

package/lib/cjs/events/adapters/importers/suunto/importer.suunto.integration.spec.js

@@ -45,6 +45,16 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const importer_suunto_json_1 = require("./importer.suunto.json");
+const data_ground_contact_time_1 = require("../../../../data/data.ground-contact-time");
+const data_ground_contact_time_avg_1 = require("../../../../data/data.ground-contact-time-avg");
+const data_ground_contact_time_max_1 = require("../../../../data/data.ground-contact-time-max");
+const data_ground_contact_time_min_1 = require("../../../../data/data.ground-contact-time-min");
+const data_vertical_oscillation_1 = require("../../../../data/data.vertical-oscillation");
+const data_vertical_oscillation_avg_1 = require("../../../../data/data.vertical-oscillation-avg");
+const data_vertical_oscillation_max_1 = require("../../../../data/data.vertical-oscillation-max");
+const data_vertical_oscillation_min_1 = require("../../../../data/data.vertical-oscillation-min");
+const data_fitness_age_1 = require("../../../../data/data.fitness-age");
+const data_max_hr_setting_1 = require("../../../../data/data.max-hr-setting");
 describe('EventImporterSuuntoJSON Integration', () => {
     // Go up 5 levels from src/events/adapters/importers/suunto -> sports-lib root
     const samplesDir = path.resolve(__dirname, '../../../../../samples/suunto');
@@ -58,7 +68,6 @@ describe('EventImporterSuuntoJSON Integration', () => {
             console.warn('No .json files found in samples directory.');
             return;
         }
-        console.log(`Found ${files.length} .json files to test:`, files);
         for (const file of files) {
             const filePath = path.join(samplesDir, file);
             const fileString = fs.readFileSync(filePath, 'utf-8');
@@ -67,7 +76,6 @@ describe('EventImporterSuuntoJSON Integration', () => {
                 const event = yield importer_suunto_json_1.EventImporterSuuntoJSON.getFromJSONString(fileString);
                 expect(event).toBeDefined();
                 expect(event.getActivities().length).toBeGreaterThan(0);
-                console.log(`✅ Successfully parsed ${file}`);
             }
             catch (error) {
                 console.error(`❌ Failed to parse ${file}:`, error);
@@ -75,5 +83,81 @@ describe('EventImporterSuuntoJSON Integration', () => {
             }
         }
     }));
-    // Note: If SML/XML files existed, we would test EventImporterSuuntoSML here too.
+    describe('running-with-extra-data.json', () => {
+        let event;
+        let activity;
+        beforeAll(() => __awaiter(void 0, void 0, void 0, function* () {
+            const filePath = path.join(samplesDir, 'running-with-extra-data.json');
+            if (!fs.existsSync(filePath)) {
+                console.warn('running-with-extra-data.json not found. Skipping detailed tests.');
+                return;
+            }
+            const fileString = fs.readFileSync(filePath, 'utf-8');
+            event = yield importer_suunto_json_1.EventImporterSuuntoJSON.getFromJSONString(fileString);
+            // DEBUG: print one sample's date from the source file just blindly 
+            // (we can't easily access json here again without parsing, but we can infer from activity)
+            // Find the main running activity (longest duration)
+            activity = event.getActivities().reduce((prev, current) => (prev.getDuration().getValue() > current.getDuration().getValue()) ? prev : current);
+        }));
+        it('should parse Ground Contact Time stream', () => {
+            if (!activity)
+                return;
+            // Depending on the file structure, GCT might be in the first or second activity. 
+            // We selected the longest one.
+            const hasStream = activity.hasStreamData(data_ground_contact_time_1.DataGroundContactTime.type);
+            expect(hasStream).toBe(true);
+            if (hasStream) {
+                const stream = activity.getStreamData(data_ground_contact_time_1.DataGroundContactTime.type);
+                expect(stream.length).toBeGreaterThan(0);
+            }
+        });
+        it('should parse Ground Contact Time stats (avg, max, min)', () => {
+            if (!activity)
+                return;
+            const avgStat = activity.getStat(data_ground_contact_time_avg_1.DataGroundContactTimeAvg.type);
+            const maxStat = activity.getStat(data_ground_contact_time_max_1.DataGroundContactTimeMax.type);
+            const minStat = activity.getStat(data_ground_contact_time_min_1.DataGroundContactTimeMin.type);
+            expect(avgStat).toBeDefined();
+            expect(avgStat === null || avgStat === void 0 ? void 0 : avgStat.getValue()).toBeCloseTo(255.969, 3);
+            expect(maxStat).toBeDefined();
+            expect(maxStat === null || maxStat === void 0 ? void 0 : maxStat.getValue()).toBe(339);
+            expect(minStat).toBeDefined();
+            expect(minStat === null || minStat === void 0 ? void 0 : minStat.getValue()).toBe(219);
+        });
+        it('should parse Vertical Oscillation stream', () => {
+            if (!activity)
+                return;
+            const hasStream = activity.hasStreamData(data_vertical_oscillation_1.DataVerticalOscillation.type);
+            expect(hasStream).toBe(true);
+        });
+        it('should parse Vertical Oscillation stats (avg, max, min)', () => {
+            if (!activity)
+                return;
+            const avgStat = activity.getStat(data_vertical_oscillation_avg_1.DataVerticalOscillationAvg.type);
+            const maxStat = activity.getStat(data_vertical_oscillation_max_1.DataVerticalOscillationMax.type);
+            const minStat = activity.getStat(data_vertical_oscillation_min_1.DataVerticalOscillationMin.type);
+            expect(avgStat).toBeDefined();
+            expect(avgStat === null || avgStat === void 0 ? void 0 : avgStat.getValue()).toBeCloseTo(74.359, 3);
+            expect(maxStat).toBeDefined();
+            expect(maxStat === null || maxStat === void 0 ? void 0 : maxStat.getValue()).toBe(87);
+            expect(minStat).toBeDefined();
+            expect(minStat === null || minStat === void 0 ? void 0 : minStat.getValue()).toBe(42);
+        });
+        it('should parse Fitness Age from header (Event or Activity)', () => {
+            let stat = event.getStat(data_fitness_age_1.DataFitnessAge.type);
+            if (!stat && activity) {
+                stat = activity.getStat(data_fitness_age_1.DataFitnessAge.type);
+            }
+            expect(stat).toBeDefined();
+            expect(stat === null || stat === void 0 ? void 0 : stat.getValue()).toBe(25);
+        });
+        it('should parse Personal MaxHR from header (Event or Activity)', () => {
+            let stat = event.getStat(data_max_hr_setting_1.DataMaxHRSetting.type);
+            if (!stat && activity) {
+                stat = activity.getStat(data_max_hr_setting_1.DataMaxHRSetting.type);
+            }
+            expect(stat).toBeDefined();
+            expect(stat === null || stat === void 0 ? void 0 : stat.getValue()).toBe(171);
+        });
+    });
 });

package/lib/cjs/events/adapters/importers/suunto/importer.suunto.json.js

@@ -100,6 +100,18 @@ const data_speed_zone_two_duration_1 = require("../../../../data/data.speed-zone
 const data_speed_zone_three_duration_1 = require("../../../../data/data.speed-zone-three-duration");
 const data_speed_zone_four_duration_1 = require("../../../../data/data.speed-zone-four-duration");
 const data_speed_zone_five_duration_1 = require("../../../../data/data.speed-zone-five-duration");
+const data_ground_contact_time_1 = require("../../../../data/data.ground-contact-time");
+const data_ground_contact_time_avg_1 = require("../../../../data/data.ground-contact-time-avg");
+const data_ground_contact_time_max_1 = require("../../../../data/data.ground-contact-time-max");
+const data_ground_contact_time_min_1 = require("../../../../data/data.ground-contact-time-min");
+const data_vertical_oscillation_1 = require("../../../../data/data.vertical-oscillation");
+const data_vertical_oscillation_avg_1 = require("../../../../data/data.vertical-oscillation-avg");
+const data_vertical_oscillation_max_1 = require("../../../../data/data.vertical-oscillation-max");
+const data_vertical_oscillation_min_1 = require("../../../../data/data.vertical-oscillation-min");
+const data_fitness_age_1 = require("../../../../data/data.fitness-age");
+const data_max_hr_setting_1 = require("../../../../data/data.max-hr-setting");
+const data_depth_1 = require("../../../../data/data.depth");
+const data_depth_max_1 = require("../../../../data/data.depth-max");
 const file_type_enum_1 = require("../../file-type.enum");
 const activity_parsing_options_1 = require("../../../../activities/activity-parsing-options");
 class EventImporterSuuntoJSON {
@@ -152,8 +164,11 @@ class EventImporterSuuntoJSON {
                 : [];
             // Create the activities
             const activities = activityStartEventSamples.map((activityStartEventSample, index) => {
+                // If no stop event, use the last sample time as end date
+                const lastSampleTime = eventJSONObject.DeviceLog.Samples[eventJSONObject.DeviceLog.Samples.length - 1].TimeISO8601;
+                const fallbackEndTime = stopEventSample ? stopEventSample.TimeISO8601 : lastSampleTime;
                 const activity = new activity_1.Activity(new Date(activityStartEventSample.TimeISO8601), activityStartEventSamples.length - 1 === index
-                    ? new Date(stopEventSample ? stopEventSample.TimeISO8601 : (eventJSONObject.DeviceLog.Header.TimeISO8601 || eventJSONObject.DeviceLog.Header.DateTime))
+                    ? new Date(fallbackEndTime)
                     : new Date(activityStartEventSamples[index + 1].TimeISO8601), activity_types_1.ActivityTypes[(importer_suunto_activity_ids_1.ImporterSuuntoActivityIds[activityStartEventSample.Events[0].Activity.ActivityType])], creator, options);
                 // Set the end date to the stop event time if the activity is the last or the only one else set it on the next itery time
                 // Create the stats these are a 1:1 ref arrays
@@ -268,10 +283,6 @@ class EventImporterSuuntoJSON {
             // @todo check if start and end date can derive from the json
             const event = new event_1.Event('', activities[0].startDate, activities[activities.length - 1].endDate, file_type_enum_1.FileType.SUUNTO);
             activities.forEach(activity => event.addActivity(activity));
-            // Populate the event stats from the Header Object // @todo maybe remove
-            this.getStats(eventJSONObject.DeviceLog.Header).forEach(stat => {
-                event.addStat(stat);
-            });
             // Get the settings and add it to all activities as it's logical
             if (eventJSONObject.DeviceLog.Header.Settings) {
                 this.getSettings(eventJSONObject.DeviceLog.Header.Settings).forEach(stat => {
@@ -285,9 +296,12 @@ class EventImporterSuuntoJSON {
                     stat instanceof data_pool_length_1.DataPoolLength);
                 stats.forEach(stat => activities[0].addStat(stat));
             }
-            // @todo see how we can have those event stats persisted as the below generation wipes those off.
             // Generate stats
             event_utilities_1.EventUtilities.generateStatsForAll(event);
+            // Populate the event stats from the Header Object
+            this.getStats(eventJSONObject.DeviceLog.Header).forEach(stat => {
+                event.addStat(stat);
+            });
             resolve(event);
         });
     }
@@ -355,8 +369,12 @@ class EventImporterSuuntoJSON {
         return samples;
     }
     static setStreamsForActivity(activity, samples) {
+        // console.log(`Setting streams for activity with ${samples.length} samples`);
         exports.SuuntoSampleMapper.forEach(sampleMapping => {
             const subjectSamples = samples.filter(sample => (0, helpers_1.isNumberOrString)(sample[sampleMapping.sampleField]));
+            // if (sampleMapping.sampleField === 'GroundContactTime') {
+            //    console.log(`GCT Samples found: ${subjectSamples.length}`);
+            // }
             if (subjectSamples.length) {
                 activity.addStream(activity.createStream(sampleMapping.dataType));
                 subjectSamples.forEach(subjectSample => {
@@ -525,6 +543,53 @@ class EventImporterSuuntoJSON {
                 }
             }
         }
+        // Ground Contact Time (Running Dynamics)
+        if (object.hasOwnProperty('GroundContactTime')) {
+            if (Array.isArray(object.GroundContactTime)) {
+                if ((0, helpers_1.isNumber)(object.GroundContactTime[0].Avg)) {
+                    stats.push(new data_ground_contact_time_avg_1.DataGroundContactTimeAvg(object.GroundContactTime[0].Avg * 1000)); // Convert s to ms
+                }
+                if ((0, helpers_1.isNumber)(object.GroundContactTime[0].Max)) {
+                    stats.push(new data_ground_contact_time_max_1.DataGroundContactTimeMax(object.GroundContactTime[0].Max * 1000));
+                }
+                if ((0, helpers_1.isNumber)(object.GroundContactTime[0].Min)) {
+                    stats.push(new data_ground_contact_time_min_1.DataGroundContactTimeMin(object.GroundContactTime[0].Min * 1000));
+                }
+            }
+        }
+        // Vertical Oscillation (Running Dynamics)
+        if (object.hasOwnProperty('VerticalOscillation')) {
+            if (Array.isArray(object.VerticalOscillation)) {
+                if ((0, helpers_1.isNumber)(object.VerticalOscillation[0].Avg)) {
+                    stats.push(new data_vertical_oscillation_avg_1.DataVerticalOscillationAvg(object.VerticalOscillation[0].Avg * 1000)); // Convert m to mm
+                }
+                if ((0, helpers_1.isNumber)(object.VerticalOscillation[0].Max)) {
+                    stats.push(new data_vertical_oscillation_max_1.DataVerticalOscillationMax(object.VerticalOscillation[0].Max * 1000));
+                }
+                if ((0, helpers_1.isNumber)(object.VerticalOscillation[0].Min)) {
+                    stats.push(new data_vertical_oscillation_min_1.DataVerticalOscillationMin(object.VerticalOscillation[0].Min * 1000));
+                }
+            }
+        }
+        // Fitness Age
+        if ((0, helpers_1.isNumber)(object.FitnessAge)) {
+            stats.push(new data_fitness_age_1.DataFitnessAge(object.FitnessAge));
+        }
+        // Personal MaxHR
+        if (object.Personal && (0, helpers_1.isNumber)(object.Personal.MaxHR)) {
+            stats.push(new data_max_hr_setting_1.DataMaxHRSetting(object.Personal.MaxHR * 60)); // Convert from Hz to bpm
+        }
+        // Depth (Diving)
+        if (object.hasOwnProperty('Depth')) {
+            if (Array.isArray(object.Depth)) {
+                if ((0, helpers_1.isNumber)(object.Depth[0].Max) && object.Depth[0].Max > 0) {
+                    stats.push(new data_depth_max_1.DataDepthMax(object.Depth[0].Max));
+                }
+            }
+            else if ((0, helpers_1.isNumber)(object.Depth.Max) && object.Depth.Max > 0) {
+                stats.push(new data_depth_max_1.DataDepthMax(object.Depth.Max));
+            }
+        }
         return stats;
     }
 }
@@ -717,5 +782,20 @@ exports.SuuntoSampleMapper = [
         dataType: data_battery_voltage_1.DataBatteryVoltage.type,
         sampleField: 'BatteryVoltage',
         convertSampleValue: (value) => Number(value)
+    },
+    {
+        dataType: data_vertical_oscillation_1.DataVerticalOscillation.type,
+        sampleField: 'VerticalOscillation',
+        convertSampleValue: (value) => Number(value * 1000) // Convert m to mm
+    },
+    {
+        dataType: data_ground_contact_time_1.DataGroundContactTime.type,
+        sampleField: 'GroundContactTime',
+        convertSampleValue: (value) => Number(value * 1000) // Convert s to ms
+    },
+    {
+        dataType: data_depth_1.DataDepth.type,
+        sampleField: 'Depth',
+        convertSampleValue: (value) => Number(value)
     }
 ];

package/lib/cjs/events/utilities/activity.utilities.js

@@ -82,6 +82,18 @@ const data_speed_zone_two_duration_1 = require("../../data/data.speed-zone-two-d
 const data_speed_zone_three_duration_1 = require("../../data/data.speed-zone-three-duration");
 const data_speed_zone_four_duration_1 = require("../../data/data.speed-zone-four-duration");
 const data_speed_zone_five_duration_1 = require("../../data/data.speed-zone-five-duration");
+const data_ground_contact_time_1 = require("../../data/data.ground-contact-time");
+const data_ground_contact_time_avg_1 = require("../../data/data.ground-contact-time-avg");
+const data_ground_contact_time_max_1 = require("../../data/data.ground-contact-time-max");
+const data_ground_contact_time_min_1 = require("../../data/data.ground-contact-time-min");
+const data_ground_contact_time_balance_left_1 = require("../../data/data-ground-contact-time-balance-left");
+const data_ground_contact_time_balance_right_1 = require("../../data/data-ground-contact-time-balance-right");
+const data_vertical_oscillation_1 = require("../../data/data.vertical-oscillation");
+const data_vertical_oscillation_avg_1 = require("../../data/data.vertical-oscillation-avg");
+const data_vertical_oscillation_max_1 = require("../../data/data.vertical-oscillation-max");
+const data_vertical_oscillation_min_1 = require("../../data/data.vertical-oscillation-min");
+const data_stance_time_balance_left_1 = require("../../data/data-stance-time-balance-left");
+const data_stance_time_balance_right_1 = require("../../data/data-stance-time-balance-right");
 const data_store_1 = require("../../data/data.store");
 const data_start_position_1 = require("../../data/data.start-position");
 const data_end_position_1 = require("../../data/data.end-position");
@@ -101,8 +113,6 @@ const data_altitude_smooth_1 = require("../../data/data.altitude-smooth");
 const data_grade_smooth_1 = require("../../data/data.grade-smooth");
 const data_swolf_25m_1 = require("../../data/data.swolf-25m");
 const data_swolf_50m_1 = require("../../data/data.swolf-50m");
-const data_stance_time_balance_left_1 = require("../../data/data-stance-time-balance-left");
-const data_stance_time_balance_right_1 = require("../../data/data-stance-time-balance-right");
 const low_pass_filter_1 = require("./grade-calculator/low-pass-filter");
 const data_power_normalized_1 = require("../../data/data.power-normalized");
 const data_power_work_1 = require("../../data/data.power-work");
@@ -1310,11 +1320,37 @@ class ActivityUtilities {
             activity.addStat(new data_left_balance_1.DataLeftBalance(100 - avgRightBalance));
         }
         // Assign L/R balance stance time from streams if exists
+        if (!activity.getStat(data_ground_contact_time_balance_left_1.DataGroundContactTimeBalanceLeft.type) && activity.hasStreamData(data_ground_contact_time_balance_left_1.DataGroundContactTimeBalanceLeft.type)) {
+            const avgStanceTimeLeftBalance = this.round(this.getDataTypeAvg(activity, data_ground_contact_time_balance_left_1.DataGroundContactTimeBalanceLeft.type), 2);
+            activity.addStat(new data_ground_contact_time_balance_left_1.DataGroundContactTimeBalanceLeft(avgStanceTimeLeftBalance));
+            activity.addStat(new data_ground_contact_time_balance_right_1.DataGroundContactTimeBalanceRight(100 - avgStanceTimeLeftBalance));
+        }
+        // Backward compatibility for Stance Time Balance
         if (!activity.getStat(data_stance_time_balance_left_1.DataStanceTimeBalanceLeft.type) && activity.hasStreamData(data_stance_time_balance_left_1.DataStanceTimeBalanceLeft.type)) {
             const avgStanceTimeLeftBalance = this.round(this.getDataTypeAvg(activity, data_stance_time_balance_left_1.DataStanceTimeBalanceLeft.type), 2);
             activity.addStat(new data_stance_time_balance_left_1.DataStanceTimeBalanceLeft(avgStanceTimeLeftBalance));
             activity.addStat(new data_stance_time_balance_right_1.DataStanceTimeBalanceRight(100 - avgStanceTimeLeftBalance));
         }
+        // Ground Contact Time
+        if (!activity.getStat(data_ground_contact_time_max_1.DataGroundContactTimeMax.type) && activity.hasStreamData(data_ground_contact_time_1.DataGroundContactTime.type)) {
+            activity.addStat(new data_ground_contact_time_max_1.DataGroundContactTimeMax(this.getDataTypeMax(activity, data_ground_contact_time_1.DataGroundContactTime.type)));
+        }
+        if (!activity.getStat(data_ground_contact_time_min_1.DataGroundContactTimeMin.type) && activity.hasStreamData(data_ground_contact_time_1.DataGroundContactTime.type)) {
+            activity.addStat(new data_ground_contact_time_min_1.DataGroundContactTimeMin(this.getDataTypeMin(activity, data_ground_contact_time_1.DataGroundContactTime.type)));
+        }
+        if (!activity.getStat(data_ground_contact_time_avg_1.DataGroundContactTimeAvg.type) && activity.hasStreamData(data_ground_contact_time_1.DataGroundContactTime.type)) {
+            activity.addStat(new data_ground_contact_time_avg_1.DataGroundContactTimeAvg(this.getDataTypeAvg(activity, data_ground_contact_time_1.DataGroundContactTime.type)));
+        }
+        // Vertical Oscillation
+        if (!activity.getStat(data_vertical_oscillation_max_1.DataVerticalOscillationMax.type) && activity.hasStreamData(data_vertical_oscillation_1.DataVerticalOscillation.type)) {
+            activity.addStat(new data_vertical_oscillation_max_1.DataVerticalOscillationMax(this.getDataTypeMax(activity, data_vertical_oscillation_1.DataVerticalOscillation.type)));
+        }
+        if (!activity.getStat(data_vertical_oscillation_min_1.DataVerticalOscillationMin.type) && activity.hasStreamData(data_vertical_oscillation_1.DataVerticalOscillation.type)) {
+            activity.addStat(new data_vertical_oscillation_min_1.DataVerticalOscillationMin(this.getDataTypeMin(activity, data_vertical_oscillation_1.DataVerticalOscillation.type)));
+        }
+        if (!activity.getStat(data_vertical_oscillation_avg_1.DataVerticalOscillationAvg.type) && activity.hasStreamData(data_vertical_oscillation_1.DataVerticalOscillation.type)) {
+            activity.addStat(new data_vertical_oscillation_avg_1.DataVerticalOscillationAvg(this.getDataTypeAvg(activity, data_vertical_oscillation_1.DataVerticalOscillation.type)));
+        }
     }
     static generateMissingSpeedDerivedStatsForActivity(activity) {
         // Pace

package/lib/esm/data/data-ground-contact-time-balance-left.d.ts

@@ -0,0 +1,4 @@
+import { DataGroundContactTimeBalance } from './data-ground-contact-time-balance';
+export declare class DataGroundContactTimeBalanceLeft extends DataGroundContactTimeBalance {
+    static type: string;
+}

package/lib/esm/data/data-ground-contact-time-balance-right.d.ts

@@ -0,0 +1,4 @@
+import { DataGroundContactTimeBalance } from './data-ground-contact-time-balance';
+export declare class DataGroundContactTimeBalanceRight extends DataGroundContactTimeBalance {
+    static type: string;
+}

package/lib/esm/data/data-ground-contact-time-balance.d.ts

@@ -0,0 +1,3 @@
+import { DataPercent } from './data.percent';
+export declare abstract class DataGroundContactTimeBalance extends DataPercent {
+}