@sports-alliance/sports-lib 7.2.2 → 7.2.4

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

@@ -167,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 {
@@ -184,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.
@@ -217,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
@@ -351,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
                                 }));
                             });
                         }
@@ -626,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;
@@ -1085,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.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();
+        expect((0, helpers_1.isNumber)(jump.jumpData.distance.getValue())).toBeTruthy();
+        expect((0, helpers_1.isNumber)(jump.jumpData.score.getValue())).toBeTruthy();
+        // Verify new jump fields with expected values
+        expect(jump.jumpData.distance.getValue()).toBeCloseTo(2.069, 2);
+        expect(jump.jumpData.hang_time.getValue()).toBeCloseTo(0.36, 2);
+        expect(jump.jumpData.score.getValue()).toBeCloseTo(62.44, 1);
+        expect(jump.jumpData.position_lat.getValue()).toBeCloseTo(39.6679, 3);
+        expect(jump.jumpData.position_long.getValue()).toBeCloseTo(20.8382, 3);
+        expect(jump.jumpData.speed.getValue()).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/index.d.ts

@@ -71,6 +71,8 @@ export * from './data/data.heart-rate-avg';
 export * from './data/data.heart-rate-max';
 export * from './data/data.heart-rate-min';
 export * from './data/data.ibi';
+export * from './data/data.event';
+export * from './data/data.jump-event';
 export * from './data/data.interface';
 export * from './data/data.latitude-degrees';
 export * from './data/data.left-balance';

package/lib/cjs/index.js

@@ -101,6 +101,8 @@ __exportStar(require("./data/data.heart-rate-avg"), exports);
 __exportStar(require("./data/data.heart-rate-max"), exports);
 __exportStar(require("./data/data.heart-rate-min"), exports);
 __exportStar(require("./data/data.ibi"), exports);
+__exportStar(require("./data/data.event"), exports);
+__exportStar(require("./data/data.jump-event"), exports);
 __exportStar(require("./data/data.interface"), exports);
 __exportStar(require("./data/data.latitude-degrees"), exports);
 __exportStar(require("./data/data.left-balance"), exports);

package/lib/esm/data/data.event.d.ts

@@ -1,3 +1,4 @@
 import { DataNumber } from './data.number';
 export declare abstract class DataEvent extends DataNumber {
+    get timestamp(): number;
 }

package/lib/esm/data/data.jump-event.d.ts

@@ -1,12 +1,33 @@
 import { DataEvent } from './data.event';
+import { DataDistance } from './data.distance';
+import { DataSpeed } from './data.speed';
+import { DataDuration } from './data.duration';
+import { DataNumber } from './data.number';
+import { DataLatitudeDegrees } from './data.latitude-degrees';
+import { DataLongitudeDegrees } from './data.longitude-degrees';
+export declare class DataScore extends DataNumber {
+    static type: string;
+}
+export declare class DataRotations extends DataNumber {
+    static type: string;
+}
 export interface JumpEventInterface {
-    distance: number;
-    height: number;
-    score: number;
+    distance: DataDistance;
+    height?: DataDistance;
+    score: DataScore;
+    hang_time?: DataDuration;
+    position_lat?: DataLatitudeDegrees;
+    position_long?: DataLongitudeDegrees;
+    speed?: DataSpeed;
+    rotations?: DataRotations;
 }
 export declare class DataJumpEvent extends DataEvent {
-    jumpData: JumpEventInterface;
     static type: string;
-    constructor(timestamp: number, jumpData: JumpEventInterface);
+    jumpData: JumpEventInterface;
+    constructor(timestampOrObj: number | {
+        timestamp: number;
+        jumpData: any;
+    }, jumpData?: any);
+    private hydrate;
     toJSON(): any;
 }

package/lib/esm/data/data.jump-event.spec.d.ts

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

package/lib/esm/data/data.jump-stats.d.ts

@@ -0,0 +1,91 @@
+import { DataNumber } from './data.number';
+export declare class DataJumpHangTimeMin extends DataNumber {
+    static type: string;
+    static unit: string;
+    constructor(value: number);
+}
+export declare class DataJumpHangTimeMax extends DataNumber {
+    static type: string;
+    static unit: string;
+    constructor(value: number);
+}
+export declare class DataJumpHangTimeAvg extends DataNumber {
+    static type: string;
+    static unit: string;
+    constructor(value: number);
+}
+export declare class DataJumpDistanceMin extends DataNumber {
+    static type: string;
+    static unit: string;
+    constructor(value: number);
+}
+export declare class DataJumpDistanceMax extends DataNumber {
+    static type: string;
+    static unit: string;
+    constructor(value: number);
+}
+export declare class DataJumpDistanceAvg extends DataNumber {
+    static type: string;
+    static unit: string;
+    constructor(value: number);
+}
+export declare class DataJumpSpeedMin extends DataNumber {
+    static type: string;
+    static unit: string;
+    constructor(value: number);
+}
+export declare class DataJumpSpeedMax extends DataNumber {
+    static type: string;
+    static unit: string;
+    constructor(value: number);
+}
+export declare class DataJumpSpeedAvg extends DataNumber {
+    static type: string;
+    static unit: string;
+    constructor(value: number);
+}
+export declare class DataJumpRotationsMin extends DataNumber {
+    static type: string;
+    static unit: string;
+    constructor(value: number);
+}
+export declare class DataJumpRotationsMax extends DataNumber {
+    static type: string;
+    static unit: string;
+    constructor(value: number);
+}
+export declare class DataJumpRotationsAvg extends DataNumber {
+    static type: string;
+    static unit: string;
+    constructor(value: number);
+}
+export declare class DataJumpScoreMin extends DataNumber {
+    static type: string;
+    static unit: string;
+    constructor(value: number);
+}
+export declare class DataJumpScoreMax extends DataNumber {
+    static type: string;
+    static unit: string;
+    constructor(value: number);
+}
+export declare class DataJumpScoreAvg extends DataNumber {
+    static type: string;
+    static unit: string;
+    constructor(value: number);
+}
+export declare class DataJumpHeightMin extends DataNumber {
+    static type: string;
+    static unit: string;
+    constructor(value: number);
+}
+export declare class DataJumpHeightMax extends DataNumber {
+    static type: string;
+    static unit: string;
+    constructor(value: number);
+}
+export declare class DataJumpHeightAvg extends DataNumber {
+    static type: string;
+    static unit: string;
+    constructor(value: number);
+}

package/lib/esm/data/data.rider-position-change-event.d.ts

@@ -3,5 +3,8 @@ import { RiderPosition } from './data.cycling-position';
 export declare class DataRiderPositionChangeEvent extends DataEvent {
     static type: string;
     positionChange: RiderPosition;
-    constructor(index: number, positionChange: RiderPosition);
+    constructor(indexOrObj: number | {
+        index: number;
+        positionChange: RiderPosition;
+    }, positionChange?: RiderPosition);
 }

package/lib/esm/index.d.ts

@@ -71,6 +71,8 @@ export * from './data/data.heart-rate-avg';
 export * from './data/data.heart-rate-max';
 export * from './data/data.heart-rate-min';
 export * from './data/data.ibi';
+export * from './data/data.event';
+export * from './data/data.jump-event';
 export * from './data/data.interface';
 export * from './data/data.latitude-degrees';
 export * from './data/data.left-balance';