@sports-alliance/sports-lib 7.2.2 → 7.2.4

package/.agent/README.md

@@ -0,0 +1,16 @@
+# Agent Configuration for sports-lib
+
+This directory contains configuration, skills, and workflows for AI agents working on the `sports-lib` project.
+
+## Structure
+
+- **skills/**: Contains specialized "skills" (instructions + scripts) for the agent.
+  - `debug-utils`: Instructions for using the project's ad-hoc FIT file debugging scripts.
+- **workflows/**: Contains step-by-step guides for common tasks.
+  - `add-new-data.md`: How to identify and add new data fields from FIT files.
+
+## Usage
+
+When asking an agent to help with debugging or adding data, you can refer them to these specific skills or workflows if they don't automatically pick them up.
+- "Use the debug-utils skill to inspect this file."
+- "Follow the add-new-data workflow."

package/inspect_jump_raw.js

@@ -0,0 +1,24 @@
+const fs = require('fs');
+const FitParser = require('fit-file-parser').default;
+
+const content = fs.readFileSync('./samples/fit/jumps-mtb.fit');
+const fitParser = new FitParser({ force: true, mode: 'both' });
+
+fitParser.parse(content, (error, data) => {
+    if (error) {
+        console.error(error);
+        return;
+    }
+    console.log('=== ROOT KEYS ===');
+    console.log(Object.keys(data).join('\n'));
+    
+    if (data.jumps) {
+        console.log('\n=== FIRST JUMP ===');
+        console.log(data.jumps[0]);
+    }
+
+    if (data.user_profiles) {
+        console.log('\n=== USER PROFILES ===');
+        console.log(data.user_profiles);
+    }
+});

package/lib/cjs/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/cjs/data/data.event.js

@@ -3,5 +3,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.DataEvent = void 0;
 const data_number_1 = require("./data.number");
 class DataEvent extends data_number_1.DataNumber {
+    get timestamp() {
+        return this.getValue();
+    }
 }
 exports.DataEvent = DataEvent;

package/lib/cjs/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/cjs/data/data.jump-event.js

@@ -1,15 +1,62 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DataJumpEvent = void 0;
+exports.DataJumpEvent = exports.DataRotations = exports.DataScore = void 0;
 const data_event_1 = require("./data.event");
+const data_distance_1 = require("./data.distance");
+const data_speed_1 = require("./data.speed");
+const data_duration_1 = require("./data.duration");
+const data_number_1 = require("./data.number");
+const data_latitude_degrees_1 = require("./data.latitude-degrees");
+const data_longitude_degrees_1 = require("./data.longitude-degrees");
+class DataScore extends data_number_1.DataNumber {
+}
+exports.DataScore = DataScore;
+DataScore.type = 'Score';
+class DataRotations extends data_number_1.DataNumber {
+}
+exports.DataRotations = DataRotations;
+DataRotations.type = 'Rotations';
 class DataJumpEvent extends data_event_1.DataEvent {
-    constructor(timestamp, jumpData) {
-        super(timestamp);
-        this.jumpData = jumpData;
+    constructor(timestampOrObj, jumpData) {
+        if (typeof timestampOrObj === 'object') {
+            super(timestampOrObj.timestamp);
+            this.jumpData = this.hydrate(timestampOrObj.jumpData);
+        }
+        else {
+            super(timestampOrObj);
+            this.jumpData = this.hydrate(jumpData);
+        }
+    }
+    hydrate(data) {
+        return {
+            distance: data.distance instanceof data_distance_1.DataDistance ? data.distance : new data_distance_1.DataDistance(data.distance),
+            height: data.height ? (data.height instanceof data_distance_1.DataDistance ? data.height : new data_distance_1.DataDistance(data.height)) : undefined,
+            score: data.score instanceof DataScore ? data.score : new DataScore(data.score),
+            hang_time: data.hang_time ? (data.hang_time instanceof data_duration_1.DataDuration ? data.hang_time : new data_duration_1.DataDuration(data.hang_time)) : undefined,
+            position_lat: data.position_lat ? (data.position_lat instanceof data_latitude_degrees_1.DataLatitudeDegrees ? data.position_lat : new data_latitude_degrees_1.DataLatitudeDegrees(data.position_lat)) : undefined,
+            position_long: data.position_long ? (data.position_long instanceof data_longitude_degrees_1.DataLongitudeDegrees ? data.position_long : new data_longitude_degrees_1.DataLongitudeDegrees(data.position_long)) : undefined,
+            speed: data.speed ? (data.speed instanceof data_speed_1.DataSpeed ? data.speed : new data_speed_1.DataSpeed(data.speed)) : undefined,
+            rotations: data.rotations ? (data.rotations instanceof DataRotations ? data.rotations : new DataRotations(data.rotations)) : undefined,
+        };
     }
     toJSON() {
+        var _a, _b, _c, _d, _e, _f;
         const json = super.toJSON();
-        return Object.assign(Object.assign({}, json), { jumpData: this.jumpData });
+        return {
+            [DataJumpEvent.type]: {
+                timestamp: this.getValue(),
+                jumpData: {
+                    distance: this.jumpData.distance.getValue(),
+                    height: (_a = this.jumpData.height) === null || _a === void 0 ? void 0 : _a.getValue(),
+                    score: this.jumpData.score.getValue(),
+                    hang_time: (_b = this.jumpData.hang_time) === null || _b === void 0 ? void 0 : _b.getValue(),
+                    position_lat: (_c = this.jumpData.position_lat) === null || _c === void 0 ? void 0 : _c.getValue(),
+                    position_long: (_d = this.jumpData.position_long) === null || _d === void 0 ? void 0 : _d.getValue(),
+                    speed: (_e = this.jumpData.speed) === null || _e === void 0 ? void 0 : _e.getValue(),
+                    rotations: (_f = this.jumpData.rotations) === null || _f === void 0 ? void 0 : _f.getValue(),
+                }
+            }
+        };
     }
 }
 exports.DataJumpEvent = DataJumpEvent;

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

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

package/lib/cjs/data/data.jump-event.spec.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const data_jump_event_1 = require("./data.jump-event");
+const data_distance_1 = require("./data.distance");
+const data_speed_1 = require("./data.speed");
+const data_duration_1 = require("./data.duration");
+const data_latitude_degrees_1 = require("./data.latitude-degrees");
+const data_longitude_degrees_1 = require("./data.longitude-degrees");
+describe('DataJumpEvent', () => {
+    const timestamp = 1234567890;
+    // Manual creation requires Data objects
+    const jumpData = {
+        distance: new data_distance_1.DataDistance(5.5),
+        height: new data_distance_1.DataDistance(1.2),
+        score: new data_jump_event_1.DataScore(85),
+        hang_time: new data_duration_1.DataDuration(0.8),
+        position_lat: new data_latitude_degrees_1.DataLatitudeDegrees(40.7128),
+        position_long: new data_longitude_degrees_1.DataLongitudeDegrees(-74.0060),
+        speed: new data_speed_1.DataSpeed(15.2),
+        rotations: new data_jump_event_1.DataRotations(0)
+    };
+    it('should be created using constructor with separate arguments (Manual)', () => {
+        const jumpEvent = new data_jump_event_1.DataJumpEvent(timestamp, jumpData);
+        expect(jumpEvent.getType()).toBe('Jump Event');
+        expect(jumpEvent.getValue()).toBe(timestamp);
+        // Expect exact object match
+        expect(jumpEvent.jumpData).toEqual(jumpData);
+    });
+    it('should be created using constructor with object argument (Manual Object)', () => {
+        const jumpEvent = new data_jump_event_1.DataJumpEvent({ timestamp, jumpData });
+        expect(jumpEvent.getType()).toBe('Jump Event');
+        expect(jumpEvent.getValue()).toBe(timestamp);
+        expect(jumpEvent.jumpData).toEqual(jumpData);
+    });
+    it('should serialize to JSON correctly', () => {
+        const jumpEvent = new data_jump_event_1.DataJumpEvent(timestamp, jumpData);
+        const json = jumpEvent.toJSON();
+        // toJSON output should be simple values
+        expect(json).toEqual({
+            'Jump Event': {
+                timestamp: timestamp,
+                jumpData: {
+                    distance: 5.5,
+                    height: 1.2,
+                    score: 85,
+                    hang_time: 0.8,
+                    position_lat: 40.7128,
+                    position_long: -74.0060,
+                    speed: 15.2,
+                    rotations: 0
+                }
+            }
+        });
+    });
+    it('should hydrate from JSON object correctly (simulating generic importer)', () => {
+        // Generic importer passes primitive values
+        const jsonValue = {
+            timestamp,
+            jumpData: {
+                distance: 5.5,
+                height: 1.2,
+                score: 85,
+                hang_time: 0.8,
+                position_lat: 40.7128,
+                position_long: -74.0060,
+                speed: 15.2,
+                rotations: 0
+            }
+        };
+        // Constructor should hydrate primitives into Data objects
+        const jumpEvent = new data_jump_event_1.DataJumpEvent(jsonValue);
+        expect(jumpEvent.getType()).toBe('Jump Event');
+        expect(jumpEvent.getValue()).toBe(timestamp);
+        // Assertions check if properties are converted to Data objects
+        expect(jumpEvent.jumpData.distance).toBeInstanceOf(data_distance_1.DataDistance);
+        expect(jumpEvent.jumpData.distance.getValue()).toBe(5.5);
+        expect(jumpEvent.jumpData.score).toBeInstanceOf(data_jump_event_1.DataScore);
+        expect(jumpEvent.jumpData.score.getValue()).toBe(85);
+        expect(jumpEvent.jumpData.speed).toBeInstanceOf(data_speed_1.DataSpeed);
+        expect(jumpEvent.jumpData.speed.getValue()).toBe(15.2);
+    });
+});

package/lib/cjs/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/cjs/data/data.jump-stats.js

@@ -0,0 +1,112 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DataJumpHeightAvg = exports.DataJumpHeightMax = exports.DataJumpHeightMin = exports.DataJumpScoreAvg = exports.DataJumpScoreMax = exports.DataJumpScoreMin = exports.DataJumpRotationsAvg = exports.DataJumpRotationsMax = exports.DataJumpRotationsMin = exports.DataJumpSpeedAvg = exports.DataJumpSpeedMax = exports.DataJumpSpeedMin = exports.DataJumpDistanceAvg = exports.DataJumpDistanceMax = exports.DataJumpDistanceMin = exports.DataJumpHangTimeAvg = exports.DataJumpHangTimeMax = exports.DataJumpHangTimeMin = void 0;
+const data_number_1 = require("./data.number");
+class DataJumpHangTimeMin extends data_number_1.DataNumber {
+    constructor(value) { super(value); }
+}
+exports.DataJumpHangTimeMin = DataJumpHangTimeMin;
+DataJumpHangTimeMin.type = 'Jump Hang Time Min';
+DataJumpHangTimeMin.unit = 's';
+class DataJumpHangTimeMax extends data_number_1.DataNumber {
+    constructor(value) { super(value); }
+}
+exports.DataJumpHangTimeMax = DataJumpHangTimeMax;
+DataJumpHangTimeMax.type = 'Jump Hang Time Max';
+DataJumpHangTimeMax.unit = 's';
+class DataJumpHangTimeAvg extends data_number_1.DataNumber {
+    constructor(value) { super(value); }
+}
+exports.DataJumpHangTimeAvg = DataJumpHangTimeAvg;
+DataJumpHangTimeAvg.type = 'Jump Hang Time Avg';
+DataJumpHangTimeAvg.unit = 's';
+class DataJumpDistanceMin extends data_number_1.DataNumber {
+    constructor(value) { super(value); }
+}
+exports.DataJumpDistanceMin = DataJumpDistanceMin;
+DataJumpDistanceMin.type = 'Jump Distance Min';
+DataJumpDistanceMin.unit = 'm';
+class DataJumpDistanceMax extends data_number_1.DataNumber {
+    constructor(value) { super(value); }
+}
+exports.DataJumpDistanceMax = DataJumpDistanceMax;
+DataJumpDistanceMax.type = 'Jump Distance Max';
+DataJumpDistanceMax.unit = 'm';
+class DataJumpDistanceAvg extends data_number_1.DataNumber {
+    constructor(value) { super(value); }
+}
+exports.DataJumpDistanceAvg = DataJumpDistanceAvg;
+DataJumpDistanceAvg.type = 'Jump Distance Avg';
+DataJumpDistanceAvg.unit = 'm';
+class DataJumpSpeedMin extends data_number_1.DataNumber {
+    constructor(value) { super(value); }
+}
+exports.DataJumpSpeedMin = DataJumpSpeedMin;
+DataJumpSpeedMin.type = 'Jump Speed Min';
+DataJumpSpeedMin.unit = 'm/s';
+class DataJumpSpeedMax extends data_number_1.DataNumber {
+    constructor(value) { super(value); }
+}
+exports.DataJumpSpeedMax = DataJumpSpeedMax;
+DataJumpSpeedMax.type = 'Jump Speed Max';
+DataJumpSpeedMax.unit = 'm/s';
+class DataJumpSpeedAvg extends data_number_1.DataNumber {
+    constructor(value) { super(value); }
+}
+exports.DataJumpSpeedAvg = DataJumpSpeedAvg;
+DataJumpSpeedAvg.type = 'Jump Speed Avg';
+DataJumpSpeedAvg.unit = 'm/s';
+class DataJumpRotationsMin extends data_number_1.DataNumber {
+    constructor(value) { super(value); }
+}
+exports.DataJumpRotationsMin = DataJumpRotationsMin;
+DataJumpRotationsMin.type = 'Jump Rotations Min';
+DataJumpRotationsMin.unit = '';
+class DataJumpRotationsMax extends data_number_1.DataNumber {
+    constructor(value) { super(value); }
+}
+exports.DataJumpRotationsMax = DataJumpRotationsMax;
+DataJumpRotationsMax.type = 'Jump Rotations Max';
+DataJumpRotationsMax.unit = '';
+class DataJumpRotationsAvg extends data_number_1.DataNumber {
+    constructor(value) { super(value); }
+}
+exports.DataJumpRotationsAvg = DataJumpRotationsAvg;
+DataJumpRotationsAvg.type = 'Jump Rotations Avg';
+DataJumpRotationsAvg.unit = '';
+class DataJumpScoreMin extends data_number_1.DataNumber {
+    constructor(value) { super(value); }
+}
+exports.DataJumpScoreMin = DataJumpScoreMin;
+DataJumpScoreMin.type = 'Jump Score Min';
+DataJumpScoreMin.unit = '';
+class DataJumpScoreMax extends data_number_1.DataNumber {
+    constructor(value) { super(value); }
+}
+exports.DataJumpScoreMax = DataJumpScoreMax;
+DataJumpScoreMax.type = 'Jump Score Max';
+DataJumpScoreMax.unit = '';
+class DataJumpScoreAvg extends data_number_1.DataNumber {
+    constructor(value) { super(value); }
+}
+exports.DataJumpScoreAvg = DataJumpScoreAvg;
+DataJumpScoreAvg.type = 'Jump Score Avg';
+DataJumpScoreAvg.unit = '';
+class DataJumpHeightMin extends data_number_1.DataNumber {
+    constructor(value) { super(value); }
+}
+exports.DataJumpHeightMin = DataJumpHeightMin;
+DataJumpHeightMin.type = 'Jump Height Min';
+DataJumpHeightMin.unit = 'm';
+class DataJumpHeightMax extends data_number_1.DataNumber {
+    constructor(value) { super(value); }
+}
+exports.DataJumpHeightMax = DataJumpHeightMax;
+DataJumpHeightMax.type = 'Jump Height Max';
+DataJumpHeightMax.unit = 'm';
+class DataJumpHeightAvg extends data_number_1.DataNumber {
+    constructor(value) { super(value); }
+}
+exports.DataJumpHeightAvg = DataJumpHeightAvg;
+DataJumpHeightAvg.type = 'Jump Height Avg';
+DataJumpHeightAvg.unit = 'm';

package/lib/cjs/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/cjs/data/data.rider-position-change-event.js

@@ -3,9 +3,15 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.DataRiderPositionChangeEvent = void 0;
 const data_event_1 = require("./data.event");
 class DataRiderPositionChangeEvent extends data_event_1.DataEvent {
-    constructor(index, positionChange) {
-        super(index);
-        this.positionChange = positionChange;
+    constructor(indexOrObj, positionChange) {
+        if (typeof indexOrObj === 'object') {
+            super(indexOrObj.index);
+            this.positionChange = indexOrObj.positionChange;
+        }
+        else {
+            super(indexOrObj);
+            this.positionChange = positionChange;
+        }
     }
 }
 exports.DataRiderPositionChangeEvent = DataRiderPositionChangeEvent;

package/lib/cjs/data/data.store.js

@@ -213,6 +213,7 @@ const data_fitness_age_1 = require("./data.fitness-age");
 const data_max_hr_setting_1 = require("./data.max-hr-setting");
 const data_depth_1 = require("./data.depth");
 const data_depth_max_1 = require("./data.depth-max");
+const data_jump_stats_1 = require("./data.jump-stats");
 // "Total Training effect" was renamed to "Aerobic Training Effect" in sports-lib 6.0
 class DataTotalTrainingEffectLegacy extends data_aerobic_training_effect_1.DataAerobicTrainingEffect {
 }
@@ -500,6 +501,8 @@ exports.DataStore = {
     DataGrit: data_grit_1.DataGrit,
     DataJumpCount: data_jump_count_1.DataJumpCount,
     DataJumpEvent: data_jump_event_1.DataJumpEvent,
+    DataScore: data_jump_event_1.DataScore,
+    DataRotations: data_jump_event_1.DataRotations,
     DataLeftPedalSmoothness: data_left_pedal_smoothness_1.DataLeftPedalSmoothness,
     DataLeftTorqueEffectiveness: data_left_torque_effectiveness_1.DataLeftTorqueEffectiveness,
     DataMaxRespirationRate: data_max_respiration_rate_1.DataMaxRespirationRate,
@@ -524,7 +527,25 @@ exports.DataStore = {
     DataFitnessAge: data_fitness_age_1.DataFitnessAge,
     DataMaxHRSetting: data_max_hr_setting_1.DataMaxHRSetting,
     DataDepth: data_depth_1.DataDepth,
-    DataDepthMax: data_depth_max_1.DataDepthMax
+    DataDepthMax: data_depth_max_1.DataDepthMax,
+    DataJumpHangTimeMin: data_jump_stats_1.DataJumpHangTimeMin,
+    DataJumpHangTimeMax: data_jump_stats_1.DataJumpHangTimeMax,
+    DataJumpHangTimeAvg: data_jump_stats_1.DataJumpHangTimeAvg,
+    DataJumpDistanceMin: data_jump_stats_1.DataJumpDistanceMin,
+    DataJumpDistanceMax: data_jump_stats_1.DataJumpDistanceMax,
+    DataJumpDistanceAvg: data_jump_stats_1.DataJumpDistanceAvg,
+    DataJumpSpeedMin: data_jump_stats_1.DataJumpSpeedMin,
+    DataJumpSpeedMax: data_jump_stats_1.DataJumpSpeedMax,
+    DataJumpSpeedAvg: data_jump_stats_1.DataJumpSpeedAvg,
+    DataJumpRotationsMin: data_jump_stats_1.DataJumpRotationsMin,
+    DataJumpRotationsMax: data_jump_stats_1.DataJumpRotationsMax,
+    DataJumpRotationsAvg: data_jump_stats_1.DataJumpRotationsAvg,
+    DataJumpScoreMin: data_jump_stats_1.DataJumpScoreMin,
+    DataJumpScoreMax: data_jump_stats_1.DataJumpScoreMax,
+    DataJumpScoreAvg: data_jump_stats_1.DataJumpScoreAvg,
+    DataJumpHeightMin: data_jump_stats_1.DataJumpHeightMin,
+    DataJumpHeightMax: data_jump_stats_1.DataJumpHeightMax,
+    DataJumpHeightAvg: data_jump_stats_1.DataJumpHeightAvg
 };
 class DynamicDataLoader {
     static getDataInstanceFromDataType(dataType, opts) {