@sports-alliance/sports-lib 6.0.3 → 6.1.0

package/lib/esm/data/data.speed-min.d.ts

@@ -0,0 +1,34 @@
+import { DataSpeed, DataSpeedFeetPerMinute, DataSpeedFeetPerSecond, DataSpeedKilometersPerHour, DataSpeedKnots, DataSpeedMetersPerMinute, DataSpeedMilesPerHour } from './data.speed';
+export declare class DataSpeedMin extends DataSpeed {
+    static type: string;
+}
+export declare class DataSpeedMinKilometersPerHour extends DataSpeedKilometersPerHour {
+    static type: string;
+    static displayType: string;
+    getDisplayType(): string;
+}
+export declare class DataSpeedMinMilesPerHour extends DataSpeedMilesPerHour {
+    static type: string;
+    static displayType: string;
+    getDisplayType(): string;
+}
+export declare class DataSpeedMinFeetPerSecond extends DataSpeedFeetPerSecond {
+    static type: string;
+    static displayType: string;
+    getDisplayType(): string;
+}
+export declare class DataSpeedMinMetersPerMinute extends DataSpeedMetersPerMinute {
+    static type: string;
+    static displayType: string;
+    getDisplayType(): string;
+}
+export declare class DataSpeedMinFeetPerMinute extends DataSpeedFeetPerMinute {
+    static type: string;
+    static displayType: string;
+    getDisplayType(): string;
+}
+export declare class DataSpeedMinKnots extends DataSpeedKnots {
+    static type: string;
+    static displayType: string;
+    getDisplayType(): string;
+}

package/lib/esm/data/data.speed-min.js

@@ -0,0 +1,46 @@
+import { DataSpeed, DataSpeedFeetPerMinute, DataSpeedFeetPerSecond, DataSpeedKilometersPerHour, DataSpeedKnots, DataSpeedMetersPerMinute, DataSpeedMilesPerHour } from './data.speed';
+export class DataSpeedMin extends DataSpeed {
+}
+DataSpeedMin.type = 'Minimum Speed';
+export class DataSpeedMinKilometersPerHour extends DataSpeedKilometersPerHour {
+    getDisplayType() {
+        return super.getDisplayType();
+    }
+}
+DataSpeedMinKilometersPerHour.type = 'Minimum speed in kilometers per hour';
+DataSpeedMinKilometersPerHour.displayType = DataSpeedMin.type;
+export class DataSpeedMinMilesPerHour extends DataSpeedMilesPerHour {
+    getDisplayType() {
+        return super.getDisplayType();
+    }
+}
+DataSpeedMinMilesPerHour.type = 'Minimum speed in miles per hour';
+DataSpeedMinMilesPerHour.displayType = DataSpeedMin.type;
+export class DataSpeedMinFeetPerSecond extends DataSpeedFeetPerSecond {
+    getDisplayType() {
+        return super.getDisplayType();
+    }
+}
+DataSpeedMinFeetPerSecond.type = 'Minimum speed in feet per second';
+DataSpeedMinFeetPerSecond.displayType = DataSpeedMin.type;
+export class DataSpeedMinMetersPerMinute extends DataSpeedMetersPerMinute {
+    getDisplayType() {
+        return super.getDisplayType();
+    }
+}
+DataSpeedMinMetersPerMinute.type = 'Minimum speed in meters per minute';
+DataSpeedMinMetersPerMinute.displayType = DataSpeedMin.type;
+export class DataSpeedMinFeetPerMinute extends DataSpeedFeetPerMinute {
+    getDisplayType() {
+        return super.getDisplayType();
+    }
+}
+DataSpeedMinFeetPerMinute.type = 'Minimum speed in feet per minute';
+DataSpeedMinFeetPerMinute.displayType = DataSpeedMin.type;
+export class DataSpeedMinKnots extends DataSpeedKnots {
+    getDisplayType() {
+        return super.getDisplayType();
+    }
+}
+DataSpeedMinKnots.type = 'Minimum speed in knot';
+DataSpeedMinKnots.displayType = DataSpeedMin.type;

package/lib/esm/data/data.speed-zone-five-duration.d.ts

@@ -0,0 +1,4 @@
+import { DataDuration } from './data.duration';
+export declare class DataSpeedZoneFiveDuration extends DataDuration {
+    static type: string;
+}

package/lib/esm/data/data.speed-zone-five-duration.js

@@ -0,0 +1,4 @@
+import { DataDuration } from './data.duration';
+export class DataSpeedZoneFiveDuration extends DataDuration {
+}
+DataSpeedZoneFiveDuration.type = 'Speed Zone Five Duration';

package/lib/esm/data/data.speed-zone-four-duration.d.ts

@@ -0,0 +1,4 @@
+import { DataDuration } from './data.duration';
+export declare class DataSpeedZoneFourDuration extends DataDuration {
+    static type: string;
+}

package/lib/esm/data/data.speed-zone-four-duration.js

@@ -0,0 +1,4 @@
+import { DataDuration } from './data.duration';
+export class DataSpeedZoneFourDuration extends DataDuration {
+}
+DataSpeedZoneFourDuration.type = 'Speed Zone Four Duration';

package/lib/esm/data/data.speed-zone-one-duration.d.ts

@@ -0,0 +1,4 @@
+import { DataDuration } from './data.duration';
+export declare class DataSpeedZoneOneDuration extends DataDuration {
+    static type: string;
+}

package/lib/esm/data/data.speed-zone-one-duration.js

@@ -0,0 +1,4 @@
+import { DataDuration } from './data.duration';
+export class DataSpeedZoneOneDuration extends DataDuration {
+}
+DataSpeedZoneOneDuration.type = 'Speed Zone One Duration';

package/lib/esm/data/data.speed-zone-three-duration.d.ts

@@ -0,0 +1,4 @@
+import { DataDuration } from './data.duration';
+export declare class DataSpeedZoneThreeDuration extends DataDuration {
+    static type: string;
+}

package/lib/esm/data/data.speed-zone-three-duration.js

@@ -0,0 +1,4 @@
+import { DataDuration } from './data.duration';
+export class DataSpeedZoneThreeDuration extends DataDuration {
+}
+DataSpeedZoneThreeDuration.type = 'Speed Zone Three Duration';

package/lib/esm/data/data.speed-zone-two-duration.d.ts

@@ -0,0 +1,4 @@
+import { DataDuration } from './data.duration';
+export declare class DataSpeedZoneTwoDuration extends DataDuration {
+    static type: string;
+}

package/lib/esm/data/data.speed-zone-two-duration.js

@@ -0,0 +1,4 @@
+import { DataDuration } from './data.duration';
+export class DataSpeedZoneTwoDuration extends DataDuration {
+}
+DataSpeedZoneTwoDuration.type = 'Speed Zone Two Duration';

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

@@ -0,0 +1,43 @@
+import { DataNumber } from './data.number';
+export declare class DataSpeed extends DataNumber {
+    static type: string;
+    static unit: string;
+    getDisplayValue(): string;
+    getValue(formatForDataType?: string): number;
+}
+export declare class DataSpeedKilometersPerHour extends DataSpeed {
+    static type: string;
+    static displayType: string;
+    static unit: string;
+    getDisplayType(): string;
+}
+export declare class DataSpeedMilesPerHour extends DataSpeed {
+    static type: string;
+    static displayType: string;
+    static unit: string;
+    getDisplayType(): string;
+}
+export declare class DataSpeedFeetPerSecond extends DataSpeed {
+    static type: string;
+    static displayType: string;
+    static unit: string;
+    getDisplayType(): string;
+}
+export declare class DataSpeedMetersPerMinute extends DataSpeed {
+    static type: string;
+    static displayType: string;
+    static unit: string;
+    getDisplayType(): string;
+}
+export declare class DataSpeedFeetPerMinute extends DataSpeed {
+    static type: string;
+    static displayType: string;
+    static unit: string;
+    getDisplayType(): string;
+}
+export declare class DataSpeedKnots extends DataSpeed {
+    static type: string;
+    static displayType: string;
+    static unit: string;
+    getDisplayType(): string;
+}

package/lib/esm/data/data.speed.js

@@ -0,0 +1,88 @@
+import { DataNumber } from './data.number';
+import { convertPaceToPaceInMinutesPerMile, convertSpeedToPace, convertSpeedToSpeedInFeetPerMinute, convertSpeedToSpeedInFeetPerSecond, convertSpeedToSpeedInKilometersPerHour, convertSpeedToSpeedInKnots, convertSpeedToSpeedInMetersPerMinute, convertSpeedToSpeedInMilesPerHour, convertSpeedToSwimPace, convertSwimPaceToSwimPacePer100Yard } from '../events/utilities/helpers';
+import { DataPace, DataPaceMinutesPerMile } from './data.pace';
+import { DataSwimPace, DataSwimPaceMinutesPer100Yard } from './data.swim-pace';
+export class DataSpeed extends DataNumber {
+    getDisplayValue() {
+        return this.getValue().toFixed(2);
+    }
+    getValue(formatForDataType) {
+        switch (formatForDataType) {
+            // Speed cases conversions
+            case DataSpeedKilometersPerHour.type:
+                return convertSpeedToSpeedInKilometersPerHour(this.value);
+            case DataSpeedMilesPerHour.type:
+                return convertSpeedToSpeedInMilesPerHour(this.value);
+            case DataSpeedFeetPerSecond.type:
+                return convertSpeedToSpeedInFeetPerSecond(this.value);
+            case DataSpeedMetersPerMinute.type:
+                return convertSpeedToSpeedInMetersPerMinute(this.value);
+            case DataSpeedFeetPerMinute.type:
+                return convertSpeedToSpeedInFeetPerMinute(this.value);
+            case DataSpeedKnots.type:
+                return convertSpeedToSpeedInKnots(this.value);
+            // Pace
+            case DataPace.type:
+                return convertSpeedToPace(this.value);
+            case DataPaceMinutesPerMile.type:
+                return convertPaceToPaceInMinutesPerMile(convertSpeedToPace(this.value));
+            // Swim pace
+            case DataSwimPace.type:
+                return convertSpeedToSwimPace(this.value);
+            case DataSwimPaceMinutesPer100Yard.type:
+                return convertSwimPaceToSwimPacePer100Yard(convertSpeedToSwimPace(this.value));
+            default:
+                return super.getValue(formatForDataType);
+        }
+    }
+}
+DataSpeed.type = 'Speed';
+DataSpeed.unit = 'm/s';
+export class DataSpeedKilometersPerHour extends DataSpeed {
+    getDisplayType() {
+        return super.getDisplayType();
+    }
+}
+DataSpeedKilometersPerHour.type = 'Speed in kilometers per hour';
+DataSpeedKilometersPerHour.displayType = DataSpeed.type;
+DataSpeedKilometersPerHour.unit = 'km/h';
+export class DataSpeedMilesPerHour extends DataSpeed {
+    getDisplayType() {
+        return super.getDisplayType();
+    }
+}
+DataSpeedMilesPerHour.type = 'Speed in miles per hour';
+DataSpeedMilesPerHour.displayType = DataSpeed.type;
+DataSpeedMilesPerHour.unit = 'mph';
+export class DataSpeedFeetPerSecond extends DataSpeed {
+    getDisplayType() {
+        return super.getDisplayType();
+    }
+}
+DataSpeedFeetPerSecond.type = 'Speed in feet per second';
+DataSpeedFeetPerSecond.displayType = DataSpeed.type;
+DataSpeedFeetPerSecond.unit = 'ft/s';
+export class DataSpeedMetersPerMinute extends DataSpeed {
+    getDisplayType() {
+        return super.getDisplayType();
+    }
+}
+DataSpeedMetersPerMinute.type = 'Speed in meters per minute';
+DataSpeedMetersPerMinute.displayType = DataSpeed.type;
+DataSpeedMetersPerMinute.unit = 'm/min';
+export class DataSpeedFeetPerMinute extends DataSpeed {
+    getDisplayType() {
+        return super.getDisplayType();
+    }
+}
+DataSpeedFeetPerMinute.type = 'Speed in feet per minute';
+DataSpeedFeetPerMinute.displayType = DataSpeed.type;
+DataSpeedFeetPerMinute.unit = 'ft/min';
+export class DataSpeedKnots extends DataSpeed {
+    getDisplayType() {
+        return super.getDisplayType();
+    }
+}
+DataSpeedKnots.type = 'Speed in knots';
+DataSpeedKnots.displayType = DataSpeed.type;
+DataSpeedKnots.unit = 'kn';

package/lib/esm/data/data.sport-profile-name.d.ts

@@ -0,0 +1,4 @@
+import { DataString } from './data.string';
+export declare class DataSportProfileName extends DataString {
+    static type: string;
+}

package/lib/esm/data/data.sport-profile-name.js

@@ -0,0 +1,4 @@
+import { DataString } from './data.string';
+export class DataSportProfileName extends DataString {
+}
+DataSportProfileName.type = 'Sport Profile Name';

package/lib/esm/data/data.stance-time.d.ts

@@ -0,0 +1,5 @@
+import { DataNumber } from './data.number';
+export declare class DataStanceTime extends DataNumber {
+    static type: string;
+    static unit: string;
+}

package/lib/esm/data/data.stance-time.js

@@ -0,0 +1,5 @@
+import { DataNumber } from './data.number';
+export class DataStanceTime extends DataNumber {
+}
+DataStanceTime.type = 'Stance Time';
+DataStanceTime.unit = 'ms';

package/lib/esm/data/data.start-altitude.d.ts

@@ -0,0 +1,4 @@
+import { DataAltitude } from './data.altitude';
+export declare class DataStartAltitude extends DataAltitude {
+    static type: string;
+}

package/lib/esm/data/data.start-altitude.js

@@ -0,0 +1,4 @@
+import { DataAltitude } from './data.altitude';
+export class DataStartAltitude extends DataAltitude {
+}
+DataStartAltitude.type = 'Starting Altitude';

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

@@ -0,0 +1,4 @@
+import { DataEvent } from './data.event';
+export declare class DataStartEvent extends DataEvent {
+    static type: string;
+}

package/lib/esm/data/data.start-event.js

@@ -0,0 +1,4 @@
+import { DataEvent } from './data.event';
+export class DataStartEvent extends DataEvent {
+}
+DataStartEvent.type = 'Start Event';

package/lib/esm/data/data.start-position.d.ts

@@ -0,0 +1,4 @@
+import { DataPosition } from './data.position';
+export declare class DataStartPosition extends DataPosition {
+    static type: string;
+}

package/lib/esm/data/data.start-position.js

@@ -0,0 +1,4 @@
+import { DataPosition } from './data.position';
+export class DataStartPosition extends DataPosition {
+}
+DataStartPosition.type = 'Start Position';

package/lib/esm/data/data.step-length.d.ts

@@ -0,0 +1,4 @@
+import { DataDistance } from './data.distance';
+export declare class DataStepLength extends DataDistance {
+    static type: string;
+}

package/lib/esm/data/data.step-length.js

@@ -0,0 +1,4 @@
+import { DataDistance } from './data.distance';
+export class DataStepLength extends DataDistance {
+}
+DataStepLength.type = 'Step Length';

package/lib/esm/data/data.steps-old.d.ts

@@ -0,0 +1,4 @@
+import { DataNumber } from './data.number';
+export declare class DataStepsOld extends DataNumber {
+    static type: string;
+}

package/lib/esm/data/data.steps-old.js

@@ -0,0 +1,4 @@
+import { DataNumber } from './data.number';
+export class DataStepsOld extends DataNumber {
+}
+DataStepsOld.type = ' Steps';

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

@@ -0,0 +1,4 @@
+import { DataNumber } from './data.number';
+export declare class DataSteps extends DataNumber {
+    static type: string;
+}

package/lib/esm/data/data.steps.js

@@ -0,0 +1,4 @@
+import { DataNumber } from './data.number';
+export class DataSteps extends DataNumber {
+}
+DataSteps.type = 'Steps';

package/lib/esm/data/data.stop-all-event.d.ts

@@ -0,0 +1,4 @@
+import { DataEvent } from './data.event';
+export declare class DataStopAllEvent extends DataEvent {
+    static type: string;
+}

package/lib/esm/data/data.stop-all-event.js

@@ -0,0 +1,4 @@
+import { DataEvent } from './data.event';
+export class DataStopAllEvent extends DataEvent {
+}
+DataStopAllEvent.type = 'Stop ALL Event';

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

@@ -0,0 +1,4 @@
+import { DataEvent } from './data.event';
+export declare class DataStopEvent extends DataEvent {
+    static type: string;
+}

package/lib/esm/data/data.stop-event.js

@@ -0,0 +1,4 @@
+import { DataEvent } from './data.event';
+export class DataStopEvent extends DataEvent {
+}
+DataStopEvent.type = 'Stop Event';

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

@@ -0,0 +1,69 @@
+import { DataInterface } from './data.interface';
+import { DataAerobicTrainingEffect } from './data-aerobic-training-effect';
+import { UserUnitSettingsInterface } from '../users/settings/user.unit.settings.interface';
+import { Data } from './data';
+export declare class DataTotalTrainingEffectLegacy extends DataAerobicTrainingEffect {
+    static type: string;
+}
+/**
+ * Only concrete classes no abstracts
+ */
+export declare const DataStore: any;
+export declare class DynamicDataLoader {
+    static positionalDataTypes: string[];
+    static baseDataTypes: string[];
+    static basicDataTypes: string[];
+    static advancedDataTypes: string[];
+    static dataTypeUnitGroups: DataTypeUnitGroups;
+    static speedDerivedDataTypes: string[];
+    static dataTypeMinDataType: {
+        [type: string]: string;
+    };
+    static dataTypeMaxDataType: {
+        [type: string]: string;
+    };
+    static dataTypeAvgDataType: {
+        [type: string]: string;
+    };
+    static allUnitDerivedDataTypes: string[];
+    static zoneStatsTypeMap: {
+        type: string;
+        stats: string[];
+    }[];
+    static getDataInstanceFromDataType(dataType: string, opts: any): DataInterface;
+    static getDataClassFromDataType(dataType: string): typeof Data;
+    static isUnitDerivedDataType(dataType: string): boolean;
+    static isSpeedDerivedDataType(dataType: string): boolean;
+    static isBlackListedStream(dataType: string): boolean;
+    /**
+     * This get's the basic data types for the charts depending or not on the user datatype settings
+     * There are no unit specific datatypes here so if the user has selected pace it implies metric
+     */
+    static getNonUnitBasedDataTypes(showAllData: boolean, dataTypesToUse: string[]): string[];
+    /**
+     * This gets the base and extended unit datatypes from a datatype array depending on the user settings
+     * @param dataTypes
+     * @param userUnitSettings
+     */
+    static getUnitBasedDataTypesFromDataTypes(dataTypes: string[], userUnitSettings?: UserUnitSettingsInterface): string[];
+    /**
+     * Gets the unitbased types
+     * @param dataType
+     * @param userUnitSettings
+     */
+    static getUnitBasedDataTypesFromDataType(dataType: string, userUnitSettings?: UserUnitSettingsInterface): string[];
+    /**
+     * Gets back an array of the unit based data for the data that was asked
+     * For example if the user has for speed selected m/s+km/h doing:
+     * getUnitBasedDataFromData(speedData) will return an array of [DataSpeed, DataSpeedInKilometersPerHour] instances
+     * @param data
+     * @param userUnitSettings
+     * @todo move to solo unit settings eg speed settings
+     */
+    static getUnitBasedDataFromDataInstance(data: DataInterface, userUnitSettings?: UserUnitSettingsInterface): DataInterface[];
+}
+export interface DataTypeUnitGroups {
+    [type: string]: {
+        [type: string]: (value: number) => number;
+    };
+}

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

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

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

@@ -0,0 +1,66 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { DataStore } from './data.store';
+describe('DataStore Export Verification', () => {
+    const dataDir = __dirname;
+    const files = fs.readdirSync(dataDir);
+    // Files that are not data classes or should be ignored
+    const ignoredFiles = [
+        'data.store.ts',
+        'data.store.spec.ts',
+        'data.store.export.spec.ts',
+        'data.interface.ts',
+        'data.json.interface.ts',
+        'data.position.interface.ts',
+        'data.spec.ts',
+        'data.ts',
+        'data.string.ts',
+        'data.number.ts',
+        'data.boolean.ts',
+        'data.percent.ts',
+        'data.array.ts',
+        'data.balance.ts', // interface/base
+    ];
+    files.forEach(file => {
+        // Only verify regular TS files related to data
+        if (!file.endsWith('.ts') || file.endsWith('.d.ts') || file.endsWith('.spec.ts')) {
+            return;
+        }
+        // Check if file starts with data
+        if (!file.startsWith('data')) {
+            return;
+        }
+        if (ignoredFiles.includes(file)) {
+            return;
+        }
+        it(`should export data classes from ${file} in DataStore`, () => {
+            const modulePath = path.join(dataDir, file);
+            // Verify file exists before requiring to avoid weird errors
+            if (fs.existsSync(modulePath)) {
+                const moduleExport = require(modulePath);
+                Object.keys(moduleExport).forEach(key => {
+                    const ExportedItem = moduleExport[key];
+                    // Check if it looks like a Data class
+                    // 1. It's a function (class constructor)
+                    // 2. Name starts with Data
+                    // 3. It is not an abstract class (we use a simple heuristic or explicit ignore list if needed)
+                    // Simple heuristic: if it has a static 'type' property, it probably should be in DataStore.
+                    if (typeof ExportedItem === 'function' && key.startsWith('Data')) {
+                        // Check for static 'type' property which usually indicates a concrete data class
+                        if (ExportedItem.type) {
+                            expect(DataStore[key]).toBeDefined();
+                            // verify it points to the same class
+                            expect(DataStore[key]).toBe(ExportedItem);
+                        }
+                        else {
+                            // If it doesn't have a 'type', it acts like a base class (e.g. DataQuantity)
+                            // We can log it or ignore it.
+                            // For now, let's assume if it's named Data*, it might be relevant, 
+                            // but strictly enforcing presence in DataStore usually requires the 'type' to be useful for the loader.
+                        }
+                    }
+                });
+            }
+        });
+    });
+});