@sports-alliance/sports-lib 6.1.6 → 6.1.7

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

@@ -664,24 +664,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 +707,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

@@ -17,6 +17,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 +226,39 @@ 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();
+        });
+    });
 });

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

@@ -661,24 +661,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 +704,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

@@ -15,6 +15,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 +224,39 @@ 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();
+        });
+    });
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sports-alliance/sports-lib",
-  "version": "6.1.6",
+  "version": "6.1.7",
   "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",