@sports-alliance/sports-lib 6.1.6 → 6.1.8

package/lib/cjs/activities/activity-parsing-options.d.ts

@@ -14,5 +14,6 @@ export declare class ActivityParsingOptions {
         };
     };
     maxActivityDurationDays: number;
+    generateUnitStreams: boolean;
     constructor(options: ActivityParsingOptions);
 }

package/lib/cjs/activities/activity-parsing-options.js

@@ -3,8 +3,10 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ActivityParsingOptions = void 0;
 class ActivityParsingOptions {
     constructor(options) {
+        var _a;
         this.streams = options.streams;
         this.maxActivityDurationDays = options.maxActivityDurationDays;
+        this.generateUnitStreams = (_a = options.generateUnitStreams) !== null && _a !== void 0 ? _a : true;
     }
 }
 exports.ActivityParsingOptions = ActivityParsingOptions;
@@ -13,5 +15,6 @@ ActivityParsingOptions.DEFAULT = new ActivityParsingOptions({
         smooth: { altitudeSmooth: true, grade: true, gradeSmooth: true },
         fixAbnormal: { speed: false }
     },
-    maxActivityDurationDays: 14
+    maxActivityDurationDays: 14,
+    generateUnitStreams: true
 });

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

@@ -39,4 +39,40 @@ describe('DataStore', () => {
         // @todo here we should think
         expect(data_store_1.DynamicDataLoader.allUnitDerivedDataTypes.sort()).toEqual(unitDerivedDataTypes.sort());
     });
+    describe('getUnitBasedDataTypesFromDataTypes', () => {
+        it('should include derived types by default', () => {
+            const types = [data_speed_1.DataSpeedKilometersPerHour.type, data_pace_1.DataPace.type];
+            const settings = {
+                speedUnits: [data_speed_1.DataSpeedKilometersPerHour.type],
+                swimPaceUnits: [],
+                paceUnits: [data_pace_1.DataPaceMinutesPerMile.type],
+                gradeAdjustedSpeedUnits: [],
+                gradeAdjustedPaceUnits: [],
+                verticalSpeedUnits: [],
+                distanceUnits: [],
+                elevationUnits: [],
+                temperatureUnits: [],
+                weightUnits: []
+            };
+            const result = data_store_1.DynamicDataLoader.getUnitBasedDataTypesFromDataTypes([data_speed_1.DataSpeed.type], settings);
+            expect(result).toContain(data_pace_1.DataPaceMinutesPerMile.type);
+        });
+        it('should exclude derived types when includeDerivedTypes is false', () => {
+            const settings = {
+                speedUnits: [data_speed_1.DataSpeedKilometersPerHour.type],
+                swimPaceUnits: [],
+                paceUnits: [data_pace_1.DataPaceMinutesPerMile.type],
+                gradeAdjustedSpeedUnits: [],
+                gradeAdjustedPaceUnits: [],
+                verticalSpeedUnits: [],
+                distanceUnits: [],
+                elevationUnits: [],
+                temperatureUnits: [],
+                weightUnits: []
+            };
+            const result = data_store_1.DynamicDataLoader.getUnitBasedDataTypesFromDataTypes([data_speed_1.DataSpeed.type], settings, { includeDerivedTypes: false });
+            expect(result).toContain(data_speed_1.DataSpeedKilometersPerHour.type);
+            expect(result).not.toContain(data_pace_1.DataPaceMinutesPerMile.type);
+        });
+    });
 });

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

@@ -45,7 +45,9 @@ export declare class DynamicDataLoader {
      * @param dataTypes
      * @param userUnitSettings
      */
-    static getUnitBasedDataTypesFromDataTypes(dataTypes: string[], userUnitSettings?: UserUnitSettingsInterface): string[];
+    static getUnitBasedDataTypesFromDataTypes(dataTypes: string[], userUnitSettings?: UserUnitSettingsInterface, options?: {
+        includeDerivedTypes?: boolean;
+    }): string[];
     /**
      * Gets the unitbased types
      * @param dataType

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

@@ -498,19 +498,23 @@ class DynamicDataLoader {
      * @param dataTypes
      * @param userUnitSettings
      */
-    static getUnitBasedDataTypesFromDataTypes(dataTypes, userUnitSettings) {
+    static getUnitBasedDataTypesFromDataTypes(dataTypes, userUnitSettings, options = { includeDerivedTypes: true }) {
         let unitBasedDataTypes = [];
         if (!userUnitSettings) {
             return unitBasedDataTypes;
         }
         if (dataTypes.indexOf(data_speed_1.DataSpeed.type) !== -1) {
             unitBasedDataTypes = unitBasedDataTypes.concat(userUnitSettings.speedUnits);
-            unitBasedDataTypes = unitBasedDataTypes.concat(userUnitSettings.swimPaceUnits);
-            unitBasedDataTypes = unitBasedDataTypes.concat(userUnitSettings.paceUnits);
+            if (options.includeDerivedTypes) {
+                unitBasedDataTypes = unitBasedDataTypes.concat(userUnitSettings.swimPaceUnits);
+                unitBasedDataTypes = unitBasedDataTypes.concat(userUnitSettings.paceUnits);
+            }
         }
         if (dataTypes.indexOf(data_grade_adjusted_speed_1.DataGradeAdjustedSpeed.type) !== -1) {
             unitBasedDataTypes = unitBasedDataTypes.concat(userUnitSettings.gradeAdjustedSpeedUnits);
-            unitBasedDataTypes = unitBasedDataTypes.concat(userUnitSettings.gradeAdjustedPaceUnits);
+            if (options.includeDerivedTypes) {
+                unitBasedDataTypes = unitBasedDataTypes.concat(userUnitSettings.gradeAdjustedPaceUnits);
+            }
         }
         if (dataTypes.indexOf(data_vertical_speed_1.DataVerticalSpeed.type) !== -1) {
             unitBasedDataTypes = unitBasedDataTypes.concat(userUnitSettings.verticalSpeedUnits);

package/lib/cjs/events/utilities/activity.utilities.d.ts

@@ -63,14 +63,19 @@ export declare class ActivityUtilities {
      */
     private static createByActivityTypeAltiDistanceSpeedBasedStreams;
     /**
+  
      * @todo unit test (get the pun?)
      * This creates streams that are deriving as unit based streams
      * For example it will create pace from speed, swim pace from speed but also speed in km/h as a unitstream
      * @param streams
      * @param activityType
      * @param unitStreamTypes DynamicDataLoader.allUnitDerivedDataTypes this acts like a whitelist for the unit derived units ONLY!
+     * @param options
      */
-    static createUnitStreamsFromStreams(streams: StreamInterface[], activityType: ActivityTypes, unitStreamTypes?: string[]): StreamInterface[];
+    static createUnitStreamsFromStreams(streams: StreamInterface[], activityType: ActivityTypes, unitStreamTypes?: string[], options?: {
+        includeDerivedTypes?: boolean;
+        includeUnitVariants?: boolean;
+    }): StreamInterface[];
     /**
      * Generates missing streams for an activity such as distance etc if they are missing
      * This will always create a steam even if the distance is 0

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

@@ -291,7 +291,9 @@ class ActivityUtilities {
     static generateMissingStreams(activity) {
         // Compute missing streams
         this.generateMissingStreamsForActivity(activity);
-        activity.addStreams(this.createUnitStreamsFromStreams(activity.getAllStreams(), activity.type));
+        if (!activity.parseOptions || activity.parseOptions.generateUnitStreams) {
+            activity.addStreams(this.createUnitStreamsFromStreams(activity.getAllStreams(), activity.type));
+        }
     }
     static getSummaryStatsForActivities(activities) {
         const stats = [];
@@ -664,24 +666,39 @@ class ActivityUtilities {
         }, []);
     }
     /**
+  
      * @todo unit test (get the pun?)
      * This creates streams that are deriving as unit based streams
      * For example it will create pace from speed, swim pace from speed but also speed in km/h as a unitstream
      * @param streams
      * @param activityType
      * @param unitStreamTypes DynamicDataLoader.allUnitDerivedDataTypes this acts like a whitelist for the unit derived units ONLY!
+     * @param options
      */
-    static createUnitStreamsFromStreams(streams, activityType, unitStreamTypes) {
+    static createUnitStreamsFromStreams(streams, activityType, unitStreamTypes, options = {
+        includeDerivedTypes: true,
+        includeUnitVariants: true
+    }) {
         // @todo perhaps check input to be unitStreamTypesStrictly
         const unitStreamTypesToCreate = unitStreamTypes || data_store_1.DynamicDataLoader.allUnitDerivedDataTypes;
         let baseUnitStreams = [];
         const speedStream = streams.find(stream => stream.type === data_speed_1.DataSpeed.type);
         if (speedStream) {
-            baseUnitStreams = baseUnitStreams.concat(this.createByActivityTypeSpeedBasedStreams(speedStream, activityType));
+            if (options.includeDerivedTypes) {
+                baseUnitStreams = baseUnitStreams.concat(this.createByActivityTypeSpeedBasedStreams(speedStream, activityType));
+            }
+            else {
+                baseUnitStreams.push(speedStream);
+            }
         }
         const gradeAdjustedSpeedStream = streams.find(stream => stream.type === data_grade_adjusted_speed_1.DataGradeAdjustedSpeed.type);
         if (gradeAdjustedSpeedStream) {
-            baseUnitStreams = baseUnitStreams.concat(this.createByActivityTypeAltiDistanceSpeedBasedStreams(gradeAdjustedSpeedStream, activityType));
+            if (options.includeDerivedTypes) {
+                baseUnitStreams = baseUnitStreams.concat(this.createByActivityTypeAltiDistanceSpeedBasedStreams(gradeAdjustedSpeedStream, activityType));
+            }
+            else {
+                baseUnitStreams.push(gradeAdjustedSpeedStream);
+            }
         }
         const verticalSpeedStream = streams.find(stream => stream.type === data_vertical_speed_1.DataVerticalSpeed.type);
         if (verticalSpeedStream) {
@@ -692,6 +709,9 @@ class ActivityUtilities {
         }
         // @todo add distance ?
         const startWith = baseUnitStreams.filter(baseUnitStream => unitStreamTypesToCreate.indexOf(baseUnitStream.type) !== -1 && streams.indexOf(baseUnitStream) === -1);
+        if (options.includeUnitVariants === false) {
+            return startWith;
+        }
         return Object.keys(data_store_1.DynamicDataLoader.dataTypeUnitGroups).reduce((array, baseDataType) => {
             const baseStream = baseUnitStreams.find(stream => stream.type === baseDataType);
             if (!baseStream) {

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

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const event_1 = require("../event");
+const data_speed_max_1 = require("../../data/data.speed-max");
 const activity_1 = require("../../activities/activity");
 const data_heart_rate_1 = require("../../data/data.heart-rate");
 const data_altitude_1 = require("../../data/data.altitude");
@@ -17,6 +18,8 @@ const lap_types_1 = require("../../laps/lap.types");
 const data_time_1 = require("../../data/data.time");
 const file_type_enum_1 = require("../adapters/file-type.enum");
 const importer_json_1 = require("../adapters/importers/json/importer.json");
+const data_pace_1 = require("../../data/data.pace");
+const data_speed_2 = require("../../data/data.speed");
 describe('Activity Utilities', () => {
     let event;
     beforeEach(() => {
@@ -224,4 +227,93 @@ describe('Activity Utilities', () => {
             done();
         });
     });
+    describe('createUnitStreamsFromStreams', () => {
+        it('should include derived types and unit variants by default', () => {
+            const streams = [new stream_1.Stream(data_speed_1.DataSpeed.type, [10, 20])];
+            const result = activity_utilities_1.ActivityUtilities.createUnitStreamsFromStreams(streams, activity_types_1.ActivityTypes.Running);
+            const paceStream = result.find(s => s.type === data_pace_1.DataPaceMinutesPerMile.type);
+            const kmhStream = result.find(s => s.type === data_speed_2.DataSpeedKilometersPerHour.type);
+            expect(paceStream).toBeDefined();
+            expect(kmhStream).toBeDefined();
+        });
+        it('should exclude derived types when includeDerivedTypes is false', () => {
+            const streams = [new stream_1.Stream(data_speed_1.DataSpeed.type, [10, 20])];
+            const result = activity_utilities_1.ActivityUtilities.createUnitStreamsFromStreams(streams, activity_types_1.ActivityTypes.Running, undefined, { includeDerivedTypes: false, includeUnitVariants: true });
+            const paceStream = result.find(s => s.type === data_pace_1.DataPaceMinutesPerMile.type);
+            const kmhStream = result.find(s => s.type === data_speed_2.DataSpeedKilometersPerHour.type);
+            expect(paceStream).toBeUndefined();
+            expect(kmhStream).toBeDefined();
+        });
+        it('should exclude unit variants when includeUnitVariants is false', () => {
+            const streams = [new stream_1.Stream(data_speed_1.DataSpeed.type, [10, 20])];
+            // We pass DataPace.type in unitStreamTypes so we can check if the derived base stream is present
+            const result = activity_utilities_1.ActivityUtilities.createUnitStreamsFromStreams(streams, activity_types_1.ActivityTypes.Running, [data_pace_1.DataPace.type], { includeDerivedTypes: true, includeUnitVariants: false });
+            const paceStream = result.find(s => s.type === data_pace_1.DataPace.type);
+            const paceUnitStream = result.find(s => s.type === data_pace_1.DataPaceMinutesPerMile.type);
+            expect(paceStream).toBeDefined(); // Derived type should be there
+            expect(paceUnitStream).toBeUndefined(); // Unit variant should be gone
+        });
+        it('should exclude both derived types and unit variants', () => {
+            const streams = [new stream_1.Stream(data_speed_1.DataSpeed.type, [10, 20])];
+            const result = activity_utilities_1.ActivityUtilities.createUnitStreamsFromStreams(streams, activity_types_1.ActivityTypes.Running, [data_pace_1.DataPace.type], { includeDerivedTypes: false, includeUnitVariants: false });
+            const paceStream = result.find(s => s.type === data_pace_1.DataPace.type);
+            const paceUnitStream = result.find(s => s.type === data_pace_1.DataPaceMinutesPerMile.type);
+            expect(paceStream).toBeUndefined();
+            expect(paceUnitStream).toBeUndefined();
+        });
+    });
+    describe('generateMissingStreams', () => {
+        it('should generate unit streams by default (generateUnitStreams = true)', () => {
+            const activity = new activity_1.Activity(new Date(), new Date(), activity_types_1.ActivityTypes.Running, new creator_1.Creator('test'));
+            // Add a speed stream
+            activity.addStream(new stream_1.Stream(data_speed_1.DataSpeed.type, [10, 20]));
+            activity_utilities_1.ActivityUtilities.generateMissingStreams(activity);
+            // Should have generated "sister" types (e.g. Pace) and unit variants (e.g. Speed km/h)
+            expect(activity.hasStreamData(data_speed_2.DataSpeedKilometersPerHour.type)).toBe(true);
+            expect(activity.hasStreamData(data_pace_1.DataPaceMinutesPerMile.type)).toBe(true);
+        });
+        it('should NOT generate unit streams when generateUnitStreams = false', () => {
+            const activity = new activity_1.Activity(new Date(), new Date(), activity_types_1.ActivityTypes.Running, new creator_1.Creator('test'));
+            // Mock parsing options
+            activity.parseOptions = {
+                streams: { smooth: {}, fixAbnormal: {} },
+                maxActivityDurationDays: 14,
+                generateUnitStreams: false,
+            };
+            // Add a speed stream
+            activity.addStream(new stream_1.Stream(data_speed_1.DataSpeed.type, [10, 20]));
+            activity_utilities_1.ActivityUtilities.generateMissingStreams(activity);
+            // Should NOT have generated unit variants
+            expect(activity.hasStreamData(data_speed_2.DataSpeedKilometersPerHour.type)).toBe(false);
+            // It might still generate some "derived" streams depending on other flags, but our specific unit loop should be skipped
+            // The Pace stream comes from createUnitStreamsFromStreams too, so it should also be missing
+            expect(activity.hasStreamData(data_pace_1.DataPaceMinutesPerMile.type)).toBe(false);
+        });
+    });
+    describe('generateMissingStreamsAndStatsForActivity', () => {
+        it('should generate unit STATS even if unit STREAMS are disabled', () => {
+            const activity = new activity_1.Activity(new Date(), new Date(), activity_types_1.ActivityTypes.Running, new creator_1.Creator('test'));
+            activity.parseOptions = {
+                streams: { smooth: {}, fixAbnormal: {} },
+                maxActivityDurationDays: 14,
+                generateUnitStreams: false, // DISABLE streams
+            };
+            // Add a speed stream [10 m/s, 20 m/s]
+            // Max speed = 20 m/s
+            activity.addStream(new stream_1.Stream(data_speed_1.DataSpeed.type, [10, 20]));
+            activity_utilities_1.ActivityUtilities.generateMissingStreamsAndStatsForActivity(activity);
+            // 1. Verify Streams are missing (as requested)
+            expect(activity.hasStreamData(data_speed_2.DataSpeedKilometersPerHour.type)).toBe(false);
+            // 1. Verify Streams are missing (as requested)
+            expect(activity.hasStreamData(data_speed_2.DataSpeedKilometersPerHour.type)).toBe(false);
+            // 2. Verify Stats are PRESENT (Safety Check)
+            // 20 m/s = 72 km/h
+            // We check for the stat by its string type if we can't import the constant easily, or iterate.
+            // Based on activity.utilities.ts it uses: DataSpeedMaxKilometersPerHour
+            const allStats = Array.from(activity.getStats().values());
+            const speedMaxKmh = allStats.find(s => s.getType() === data_speed_max_1.DataSpeedMaxKilometersPerHour.type);
+            expect(speedMaxKmh).toBeDefined();
+            expect(speedMaxKmh === null || speedMaxKmh === void 0 ? void 0 : speedMaxKmh.getValue()).toBe(72);
+        });
+    });
 });

package/lib/esm/activities/activity-parsing-options.d.ts

@@ -14,5 +14,6 @@ export declare class ActivityParsingOptions {
         };
     };
     maxActivityDurationDays: number;
+    generateUnitStreams: boolean;
     constructor(options: ActivityParsingOptions);
 }

package/lib/esm/activities/activity-parsing-options.js

@@ -1,7 +1,9 @@
 export class ActivityParsingOptions {
     constructor(options) {
+        var _a;
         this.streams = options.streams;
         this.maxActivityDurationDays = options.maxActivityDurationDays;
+        this.generateUnitStreams = (_a = options.generateUnitStreams) !== null && _a !== void 0 ? _a : true;
     }
 }
 ActivityParsingOptions.DEFAULT = new ActivityParsingOptions({
@@ -9,5 +11,6 @@ ActivityParsingOptions.DEFAULT = new ActivityParsingOptions({
         smooth: { altitudeSmooth: true, grade: true, gradeSmooth: true },
         fixAbnormal: { speed: false }
     },
-    maxActivityDurationDays: 14
+    maxActivityDurationDays: 14,
+    generateUnitStreams: true
 });

package/lib/esm/data/data-store.spec.js

@@ -1,4 +1,4 @@
-import { DataSpeedFeetPerMinute, DataSpeedFeetPerSecond, DataSpeedKilometersPerHour, DataSpeedKnots, DataSpeedMetersPerMinute, DataSpeedMilesPerHour } from './data.speed';
+import { DataSpeedFeetPerMinute, DataSpeedFeetPerSecond, DataSpeedKilometersPerHour, DataSpeedKnots, DataSpeedMetersPerMinute, DataSpeedMilesPerHour, DataSpeed } from './data.speed';
 import { DataPace, DataPaceMinutesPerMile } from './data.pace';
 import { DataSwimPace, DataSwimPaceMinutesPer100Yard } from './data.swim-pace';
 import { DataGradeAdjustedSpeedFeetPerMinute, DataGradeAdjustedSpeedFeetPerSecond, DataGradeAdjustedSpeedKilometersPerHour, DataGradeAdjustedSpeedKnots, DataGradeAdjustedSpeedMetersPerMinute, DataGradeAdjustedSpeedMilesPerHour } from './data.grade-adjusted-speed';
@@ -37,4 +37,40 @@ describe('DataStore', () => {
         // @todo here we should think
         expect(DynamicDataLoader.allUnitDerivedDataTypes.sort()).toEqual(unitDerivedDataTypes.sort());
     });
+    describe('getUnitBasedDataTypesFromDataTypes', () => {
+        it('should include derived types by default', () => {
+            const types = [DataSpeedKilometersPerHour.type, DataPace.type];
+            const settings = {
+                speedUnits: [DataSpeedKilometersPerHour.type],
+                swimPaceUnits: [],
+                paceUnits: [DataPaceMinutesPerMile.type],
+                gradeAdjustedSpeedUnits: [],
+                gradeAdjustedPaceUnits: [],
+                verticalSpeedUnits: [],
+                distanceUnits: [],
+                elevationUnits: [],
+                temperatureUnits: [],
+                weightUnits: []
+            };
+            const result = DynamicDataLoader.getUnitBasedDataTypesFromDataTypes([DataSpeed.type], settings);
+            expect(result).toContain(DataPaceMinutesPerMile.type);
+        });
+        it('should exclude derived types when includeDerivedTypes is false', () => {
+            const settings = {
+                speedUnits: [DataSpeedKilometersPerHour.type],
+                swimPaceUnits: [],
+                paceUnits: [DataPaceMinutesPerMile.type],
+                gradeAdjustedSpeedUnits: [],
+                gradeAdjustedPaceUnits: [],
+                verticalSpeedUnits: [],
+                distanceUnits: [],
+                elevationUnits: [],
+                temperatureUnits: [],
+                weightUnits: []
+            };
+            const result = DynamicDataLoader.getUnitBasedDataTypesFromDataTypes([DataSpeed.type], settings, { includeDerivedTypes: false });
+            expect(result).toContain(DataSpeedKilometersPerHour.type);
+            expect(result).not.toContain(DataPaceMinutesPerMile.type);
+        });
+    });
 });

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

@@ -45,7 +45,9 @@ export declare class DynamicDataLoader {
      * @param dataTypes
      * @param userUnitSettings
      */
-    static getUnitBasedDataTypesFromDataTypes(dataTypes: string[], userUnitSettings?: UserUnitSettingsInterface): string[];
+    static getUnitBasedDataTypesFromDataTypes(dataTypes: string[], userUnitSettings?: UserUnitSettingsInterface, options?: {
+        includeDerivedTypes?: boolean;
+    }): string[];
     /**
      * Gets the unitbased types
      * @param dataType

package/lib/esm/data/data.store.js

@@ -493,19 +493,23 @@ export class DynamicDataLoader {
      * @param dataTypes
      * @param userUnitSettings
      */
-    static getUnitBasedDataTypesFromDataTypes(dataTypes, userUnitSettings) {
+    static getUnitBasedDataTypesFromDataTypes(dataTypes, userUnitSettings, options = { includeDerivedTypes: true }) {
         let unitBasedDataTypes = [];
         if (!userUnitSettings) {
             return unitBasedDataTypes;
         }
         if (dataTypes.indexOf(DataSpeed.type) !== -1) {
             unitBasedDataTypes = unitBasedDataTypes.concat(userUnitSettings.speedUnits);
-            unitBasedDataTypes = unitBasedDataTypes.concat(userUnitSettings.swimPaceUnits);
-            unitBasedDataTypes = unitBasedDataTypes.concat(userUnitSettings.paceUnits);
+            if (options.includeDerivedTypes) {
+                unitBasedDataTypes = unitBasedDataTypes.concat(userUnitSettings.swimPaceUnits);
+                unitBasedDataTypes = unitBasedDataTypes.concat(userUnitSettings.paceUnits);
+            }
         }
         if (dataTypes.indexOf(DataGradeAdjustedSpeed.type) !== -1) {
             unitBasedDataTypes = unitBasedDataTypes.concat(userUnitSettings.gradeAdjustedSpeedUnits);
-            unitBasedDataTypes = unitBasedDataTypes.concat(userUnitSettings.gradeAdjustedPaceUnits);
+            if (options.includeDerivedTypes) {
+                unitBasedDataTypes = unitBasedDataTypes.concat(userUnitSettings.gradeAdjustedPaceUnits);
+            }
         }
         if (dataTypes.indexOf(DataVerticalSpeed.type) !== -1) {
             unitBasedDataTypes = unitBasedDataTypes.concat(userUnitSettings.verticalSpeedUnits);

package/lib/esm/events/utilities/activity.utilities.d.ts

@@ -63,14 +63,19 @@ export declare class ActivityUtilities {
      */
     private static createByActivityTypeAltiDistanceSpeedBasedStreams;
     /**
+  
      * @todo unit test (get the pun?)
      * This creates streams that are deriving as unit based streams
      * For example it will create pace from speed, swim pace from speed but also speed in km/h as a unitstream
      * @param streams
      * @param activityType
      * @param unitStreamTypes DynamicDataLoader.allUnitDerivedDataTypes this acts like a whitelist for the unit derived units ONLY!
+     * @param options
      */
-    static createUnitStreamsFromStreams(streams: StreamInterface[], activityType: ActivityTypes, unitStreamTypes?: string[]): StreamInterface[];
+    static createUnitStreamsFromStreams(streams: StreamInterface[], activityType: ActivityTypes, unitStreamTypes?: string[], options?: {
+        includeDerivedTypes?: boolean;
+        includeUnitVariants?: boolean;
+    }): StreamInterface[];
     /**
      * Generates missing streams for an activity such as distance etc if they are missing
      * This will always create a steam even if the distance is 0

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

@@ -288,7 +288,9 @@ export class ActivityUtilities {
     static generateMissingStreams(activity) {
         // Compute missing streams
         this.generateMissingStreamsForActivity(activity);
-        activity.addStreams(this.createUnitStreamsFromStreams(activity.getAllStreams(), activity.type));
+        if (!activity.parseOptions || activity.parseOptions.generateUnitStreams) {
+            activity.addStreams(this.createUnitStreamsFromStreams(activity.getAllStreams(), activity.type));
+        }
     }
     static getSummaryStatsForActivities(activities) {
         const stats = [];
@@ -661,24 +663,39 @@ export class ActivityUtilities {
         }, []);
     }
     /**
+  
      * @todo unit test (get the pun?)
      * This creates streams that are deriving as unit based streams
      * For example it will create pace from speed, swim pace from speed but also speed in km/h as a unitstream
      * @param streams
      * @param activityType
      * @param unitStreamTypes DynamicDataLoader.allUnitDerivedDataTypes this acts like a whitelist for the unit derived units ONLY!
+     * @param options
      */
-    static createUnitStreamsFromStreams(streams, activityType, unitStreamTypes) {
+    static createUnitStreamsFromStreams(streams, activityType, unitStreamTypes, options = {
+        includeDerivedTypes: true,
+        includeUnitVariants: true
+    }) {
         // @todo perhaps check input to be unitStreamTypesStrictly
         const unitStreamTypesToCreate = unitStreamTypes || DynamicDataLoader.allUnitDerivedDataTypes;
         let baseUnitStreams = [];
         const speedStream = streams.find(stream => stream.type === DataSpeed.type);
         if (speedStream) {
-            baseUnitStreams = baseUnitStreams.concat(this.createByActivityTypeSpeedBasedStreams(speedStream, activityType));
+            if (options.includeDerivedTypes) {
+                baseUnitStreams = baseUnitStreams.concat(this.createByActivityTypeSpeedBasedStreams(speedStream, activityType));
+            }
+            else {
+                baseUnitStreams.push(speedStream);
+            }
         }
         const gradeAdjustedSpeedStream = streams.find(stream => stream.type === DataGradeAdjustedSpeed.type);
         if (gradeAdjustedSpeedStream) {
-            baseUnitStreams = baseUnitStreams.concat(this.createByActivityTypeAltiDistanceSpeedBasedStreams(gradeAdjustedSpeedStream, activityType));
+            if (options.includeDerivedTypes) {
+                baseUnitStreams = baseUnitStreams.concat(this.createByActivityTypeAltiDistanceSpeedBasedStreams(gradeAdjustedSpeedStream, activityType));
+            }
+            else {
+                baseUnitStreams.push(gradeAdjustedSpeedStream);
+            }
         }
         const verticalSpeedStream = streams.find(stream => stream.type === DataVerticalSpeed.type);
         if (verticalSpeedStream) {
@@ -689,6 +706,9 @@ export class ActivityUtilities {
         }
         // @todo add distance ?
         const startWith = baseUnitStreams.filter(baseUnitStream => unitStreamTypesToCreate.indexOf(baseUnitStream.type) !== -1 && streams.indexOf(baseUnitStream) === -1);
+        if (options.includeUnitVariants === false) {
+            return startWith;
+        }
         return Object.keys(DynamicDataLoader.dataTypeUnitGroups).reduce((array, baseDataType) => {
             const baseStream = baseUnitStreams.find(stream => stream.type === baseDataType);
             if (!baseStream) {

package/lib/esm/events/utilities/activity.utilities.spec.js

@@ -1,4 +1,5 @@
 import { Event } from '../event';
+import { DataSpeedMaxKilometersPerHour } from '../../data/data.speed-max';
 import { Activity } from '../../activities/activity';
 import { DataHeartRate } from '../../data/data.heart-rate';
 import { DataAltitude } from '../../data/data.altitude';
@@ -15,6 +16,8 @@ import { LapTypes } from '../../laps/lap.types';
 import { DataTime } from '../../data/data.time';
 import { FileType } from '../adapters/file-type.enum';
 import { EventImporterJSON } from '../adapters/importers/json/importer.json';
+import { DataPace, DataPaceMinutesPerMile } from '../../data/data.pace';
+import { DataSpeedKilometersPerHour } from '../../data/data.speed';
 describe('Activity Utilities', () => {
     let event;
     beforeEach(() => {
@@ -222,4 +225,93 @@ describe('Activity Utilities', () => {
             done();
         });
     });
+    describe('createUnitStreamsFromStreams', () => {
+        it('should include derived types and unit variants by default', () => {
+            const streams = [new Stream(DataSpeed.type, [10, 20])];
+            const result = ActivityUtilities.createUnitStreamsFromStreams(streams, ActivityTypes.Running);
+            const paceStream = result.find(s => s.type === DataPaceMinutesPerMile.type);
+            const kmhStream = result.find(s => s.type === DataSpeedKilometersPerHour.type);
+            expect(paceStream).toBeDefined();
+            expect(kmhStream).toBeDefined();
+        });
+        it('should exclude derived types when includeDerivedTypes is false', () => {
+            const streams = [new Stream(DataSpeed.type, [10, 20])];
+            const result = ActivityUtilities.createUnitStreamsFromStreams(streams, ActivityTypes.Running, undefined, { includeDerivedTypes: false, includeUnitVariants: true });
+            const paceStream = result.find(s => s.type === DataPaceMinutesPerMile.type);
+            const kmhStream = result.find(s => s.type === DataSpeedKilometersPerHour.type);
+            expect(paceStream).toBeUndefined();
+            expect(kmhStream).toBeDefined();
+        });
+        it('should exclude unit variants when includeUnitVariants is false', () => {
+            const streams = [new Stream(DataSpeed.type, [10, 20])];
+            // We pass DataPace.type in unitStreamTypes so we can check if the derived base stream is present
+            const result = ActivityUtilities.createUnitStreamsFromStreams(streams, ActivityTypes.Running, [DataPace.type], { includeDerivedTypes: true, includeUnitVariants: false });
+            const paceStream = result.find(s => s.type === DataPace.type);
+            const paceUnitStream = result.find(s => s.type === DataPaceMinutesPerMile.type);
+            expect(paceStream).toBeDefined(); // Derived type should be there
+            expect(paceUnitStream).toBeUndefined(); // Unit variant should be gone
+        });
+        it('should exclude both derived types and unit variants', () => {
+            const streams = [new Stream(DataSpeed.type, [10, 20])];
+            const result = ActivityUtilities.createUnitStreamsFromStreams(streams, ActivityTypes.Running, [DataPace.type], { includeDerivedTypes: false, includeUnitVariants: false });
+            const paceStream = result.find(s => s.type === DataPace.type);
+            const paceUnitStream = result.find(s => s.type === DataPaceMinutesPerMile.type);
+            expect(paceStream).toBeUndefined();
+            expect(paceUnitStream).toBeUndefined();
+        });
+    });
+    describe('generateMissingStreams', () => {
+        it('should generate unit streams by default (generateUnitStreams = true)', () => {
+            const activity = new Activity(new Date(), new Date(), ActivityTypes.Running, new Creator('test'));
+            // Add a speed stream
+            activity.addStream(new Stream(DataSpeed.type, [10, 20]));
+            ActivityUtilities.generateMissingStreams(activity);
+            // Should have generated "sister" types (e.g. Pace) and unit variants (e.g. Speed km/h)
+            expect(activity.hasStreamData(DataSpeedKilometersPerHour.type)).toBe(true);
+            expect(activity.hasStreamData(DataPaceMinutesPerMile.type)).toBe(true);
+        });
+        it('should NOT generate unit streams when generateUnitStreams = false', () => {
+            const activity = new Activity(new Date(), new Date(), ActivityTypes.Running, new Creator('test'));
+            // Mock parsing options
+            activity.parseOptions = {
+                streams: { smooth: {}, fixAbnormal: {} },
+                maxActivityDurationDays: 14,
+                generateUnitStreams: false,
+            };
+            // Add a speed stream
+            activity.addStream(new Stream(DataSpeed.type, [10, 20]));
+            ActivityUtilities.generateMissingStreams(activity);
+            // Should NOT have generated unit variants
+            expect(activity.hasStreamData(DataSpeedKilometersPerHour.type)).toBe(false);
+            // It might still generate some "derived" streams depending on other flags, but our specific unit loop should be skipped
+            // The Pace stream comes from createUnitStreamsFromStreams too, so it should also be missing
+            expect(activity.hasStreamData(DataPaceMinutesPerMile.type)).toBe(false);
+        });
+    });
+    describe('generateMissingStreamsAndStatsForActivity', () => {
+        it('should generate unit STATS even if unit STREAMS are disabled', () => {
+            const activity = new Activity(new Date(), new Date(), ActivityTypes.Running, new Creator('test'));
+            activity.parseOptions = {
+                streams: { smooth: {}, fixAbnormal: {} },
+                maxActivityDurationDays: 14,
+                generateUnitStreams: false, // DISABLE streams
+            };
+            // Add a speed stream [10 m/s, 20 m/s]
+            // Max speed = 20 m/s
+            activity.addStream(new Stream(DataSpeed.type, [10, 20]));
+            ActivityUtilities.generateMissingStreamsAndStatsForActivity(activity);
+            // 1. Verify Streams are missing (as requested)
+            expect(activity.hasStreamData(DataSpeedKilometersPerHour.type)).toBe(false);
+            // 1. Verify Streams are missing (as requested)
+            expect(activity.hasStreamData(DataSpeedKilometersPerHour.type)).toBe(false);
+            // 2. Verify Stats are PRESENT (Safety Check)
+            // 20 m/s = 72 km/h
+            // We check for the stat by its string type if we can't import the constant easily, or iterate.
+            // Based on activity.utilities.ts it uses: DataSpeedMaxKilometersPerHour
+            const allStats = Array.from(activity.getStats().values());
+            const speedMaxKmh = allStats.find(s => s.getType() === DataSpeedMaxKilometersPerHour.type);
+            expect(speedMaxKmh).toBeDefined();
+            expect(speedMaxKmh === null || speedMaxKmh === void 0 ? void 0 : speedMaxKmh.getValue()).toBe(72);
+        });
+    });
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sports-alliance/sports-lib",
-  "version": "6.1.6",
+  "version": "6.1.8",
   "description": "A Library to for importing / exporting and processing GPX, TCX, FIT and JSON files from services such as Strava, Movescount, Garmin, Polar etc",
   "keywords": [
     "gpx",