@sports-alliance/sports-lib 6.0.3 → 6.1.0

package/lib/cjs/streams/stream.spec.d.ts

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

package/lib/cjs/streams/stream.spec.js

@@ -0,0 +1,170 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const data_altitude_1 = require("../data/data.altitude");
+const stream_1 = require("./stream");
+const data_pace_1 = require("../data/data.pace");
+const data_swim_pace_1 = require("../data/data.swim-pace");
+const data_speed_1 = require("../data/data.speed");
+const data_gnss_distance_1 = require("../data/data.gnss-distance");
+const data_grade_adjusted_speed_1 = require("../data/data.grade-adjusted-speed");
+const data_time_1 = require("../data/data.time");
+const data_grade_adjusted_pace_1 = require("../data/data.grade-adjusted-pace");
+const data_vertical_speed_1 = require("../data/data.vertical-speed");
+describe('Stream', () => {
+    beforeEach(() => { });
+    it('should get data', () => {
+        const stream = new stream_1.Stream(data_altitude_1.DataAltitude.type, [200, null, 502, Infinity, -Infinity, NaN, 0]);
+        expect(stream.getData()).toEqual([200, null, 502, Infinity, -Infinity, NaN, 0]);
+        expect(stream.getData(true)).toEqual([200, 502, Infinity, -Infinity, 0]);
+        expect(stream.getData(false, true)).toEqual([200, null, 502, NaN, 0]);
+        expect(stream.getData(true, true)).toEqual([200, 502, 0]);
+    });
+    it('should if it can be exported', () => {
+        let stream;
+        // Pace not exportable
+        stream = new stream_1.Stream(data_pace_1.DataPace.type);
+        expect(stream.isExportable()).toBe(false);
+        stream = new stream_1.Stream(data_pace_1.DataPaceMinutesPerMile.type);
+        expect(stream.isExportable()).toBe(false);
+        // Swim pace not exportable
+        stream = new stream_1.Stream(data_swim_pace_1.DataSwimPace.type);
+        expect(stream.isExportable()).toBe(false);
+        stream = new stream_1.Stream(data_swim_pace_1.DataSwimPaceMinutesPer100Yard.type);
+        expect(stream.isExportable()).toBe(false);
+        // Speed exportable
+        stream = new stream_1.Stream(data_speed_1.DataSpeed.type);
+        expect(stream.isExportable()).toBe(true);
+        // Speed unit not
+        stream = new stream_1.Stream(data_speed_1.DataSpeedKilometersPerHour.type);
+        expect(stream.isExportable()).toBe(false);
+        // Black listed ones
+        stream = new stream_1.Stream(data_gnss_distance_1.DataGNSSDistance.type);
+        expect(stream.isExportable()).toBe(false);
+        stream = new stream_1.Stream(data_time_1.DataTime.type);
+        expect(stream.isExportable()).toBe(false);
+        // Grade one
+        stream = new stream_1.Stream(data_grade_adjusted_speed_1.DataGradeAdjustedSpeed.type);
+        expect(stream.isExportable()).toBe(true);
+        stream = new stream_1.Stream(data_grade_adjusted_speed_1.DataGradeAdjustedSpeedKilometersPerHour.type);
+        expect(stream.isExportable()).toBe(false);
+        // GAP should not be exportable
+        stream = new stream_1.Stream(data_grade_adjusted_pace_1.DataGradeAdjustedPace.type);
+        expect(stream.isExportable()).toBe(false);
+        stream = new stream_1.Stream(data_grade_adjusted_pace_1.DataGradeAdjustedPaceMinutesPerMile.type);
+        expect(stream.isExportable()).toBe(false);
+        // Verticalos
+        stream = new stream_1.Stream(data_vertical_speed_1.DataVerticalSpeed.type);
+        expect(stream.isExportable()).toBe(true);
+        stream = new stream_1.Stream(data_vertical_speed_1.DataVerticalSpeedFeetPerHour.type);
+        expect(stream.isExportable()).toBe(false);
+    });
+    it('should get stream data by time', () => {
+        const stream = new stream_1.Stream(data_altitude_1.DataAltitude.type, [200, null, 502, Infinity, -Infinity, NaN, 0]);
+        const date = new Date();
+        expect(stream.getStreamDataByTime(date)).toEqual([
+            {
+                time: date.getTime(),
+                value: 200
+            },
+            {
+                time: date.getTime() + 1000,
+                value: null
+            },
+            {
+                time: date.getTime() + 2000,
+                value: 502
+            },
+            {
+                time: date.getTime() + 3000,
+                value: Infinity
+            },
+            {
+                time: date.getTime() + 4000,
+                value: -Infinity
+            },
+            {
+                time: date.getTime() + 5000,
+                value: NaN
+            },
+            {
+                time: date.getTime() + 6000,
+                value: 0
+            }
+        ]);
+        expect(stream.getStreamDataByTime(date, true, true)).toEqual([
+            {
+                time: date.getTime(),
+                value: 200
+            },
+            {
+                time: date.getTime() + 2000,
+                value: 502
+            },
+            {
+                time: date.getTime() + 6000,
+                value: 0
+            }
+        ]);
+    });
+    it('should get stream data by duration', () => {
+        const stream = new stream_1.Stream(data_altitude_1.DataAltitude.type, [200, null, 502, Infinity, -Infinity, NaN, 0]);
+        expect(stream.getStreamDataByDuration(0)).toEqual([
+            {
+                time: 0,
+                value: 200
+            },
+            {
+                time: 1000,
+                value: null
+            },
+            {
+                time: 2000,
+                value: 502
+            },
+            {
+                time: 3000,
+                value: Infinity
+            },
+            {
+                time: 4000,
+                value: -Infinity
+            },
+            {
+                time: 5000,
+                value: NaN
+            },
+            {
+                time: 6000,
+                value: 0
+            }
+        ]);
+        expect(stream.getStreamDataByDuration(0, true, true)).toEqual([
+            {
+                time: 0,
+                value: 200
+            },
+            {
+                time: 2000,
+                value: 502
+            },
+            {
+                time: 6000,
+                value: 0
+            }
+        ]);
+        expect(stream.getStreamDataByDuration(33, true, true)).toEqual([
+            {
+                time: 33,
+                value: 200
+            },
+            {
+                time: 2033,
+                value: 502
+            },
+            {
+                time: 6033,
+                value: 0
+            }
+        ]);
+    });
+});

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

@@ -0,0 +1,18 @@
+export declare class ActivityParsingOptions {
+    static readonly DEFAULT: ActivityParsingOptions;
+    /**
+     * Enable/Disable streams calculations
+     */
+    streams: {
+        smooth: {
+            altitudeSmooth?: boolean;
+            grade?: boolean;
+            gradeSmooth?: boolean;
+        };
+        fixAbnormal: {
+            speed?: boolean;
+        };
+    };
+    maxActivityDurationDays: number;
+    constructor(options: ActivityParsingOptions);
+}

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

@@ -0,0 +1,13 @@
+export class ActivityParsingOptions {
+    constructor(options) {
+        this.streams = options.streams;
+        this.maxActivityDurationDays = options.maxActivityDurationDays;
+    }
+}
+ActivityParsingOptions.DEFAULT = new ActivityParsingOptions({
+    streams: {
+        smooth: { altitudeSmooth: true, grade: true, gradeSmooth: true },
+        fixAbnormal: { speed: false }
+    },
+    maxActivityDurationDays: 14
+});

package/lib/esm/activities/activity.d.ts

@@ -0,0 +1,75 @@
+import { ActivityInterface } from './activity.interface';
+import { LapInterface } from '../laps/lap.interface';
+import { IntensityZonesInterface } from '../intensity-zones/intensity-zones.interface';
+import { Creator } from '../creators/creator';
+import { ActivityTypes } from './activity.types';
+import { DurationClassAbstract } from '../duration/duration.class.abstract';
+import { CreatorInterface } from '../creators/creator.interface';
+import { StreamDataItem, StreamInterface } from '../streams/stream.interface';
+import { ActivityJSONInterface } from './activity.json.interface';
+import { DataPositionInterface } from '../data/data.position.interface';
+import { DataEvent } from '../data/data.event';
+import { DataStartEvent } from '../data/data.start-event';
+import { DataStopEvent } from '../data/data.stop-event';
+import { DataRiderPositionChangeEvent } from '../data/data.rider-position-change-event';
+import { ActivityParsingOptions } from './activity-parsing-options';
+export declare class Activity extends DurationClassAbstract implements ActivityInterface {
+    private static readonly TRAINER_TYPES;
+    name: string;
+    type: ActivityTypes;
+    creator: CreatorInterface;
+    parseOptions: ActivityParsingOptions;
+    intensityZones: IntensityZonesInterface[];
+    private laps;
+    private streams;
+    private events;
+    constructor(startDate: Date, endDate: Date, type: ActivityTypes, creator: Creator, options?: ActivityParsingOptions, name?: string);
+    createStream(type: string): StreamInterface;
+    addDataToStream(type: string, date: Date, value: number): this;
+    addStream(stream: StreamInterface): this;
+    clearStreams(): this;
+    removeStream(streamType: string | StreamInterface): this;
+    replaceStreamData(streamType: string, data: (number | null)[]): this;
+    addStreams(streams: StreamInterface[]): this;
+    getAllStreams(): StreamInterface[];
+    getAllExportableStreams(): StreamInterface[];
+    hasStreamData(streamType: string | StreamInterface, startDate?: Date, endDate?: Date): boolean;
+    hasPositionData(startDate?: Date, endDate?: Date): boolean;
+    isTrainer(): boolean;
+    hasPowerMeter(): boolean;
+    getStream(streamType: string): StreamInterface;
+    getStreamData(streamType: string | StreamInterface, startDate?: Date, endDate?: Date): (number | null)[];
+    /**
+     * Gets the data array of an activity stream excluding the non numeric ones
+     * @todo include strings and all data abstract types
+     * @param streamType
+     * @param startDate
+     * @param endDate
+     */
+    getSquashedStreamData(streamType: string, startDate?: Date, endDate?: Date): number[];
+    getPositionData(startDate?: Date, endDate?: Date): (DataPositionInterface | null)[];
+    getSquashedPositionData(startDate?: Date, endDate?: Date): DataPositionInterface[];
+    getStreamDataTypesBasedOnDataType(streamTypeToBaseOn: string, streamTypes: string[]): {
+        [type: string]: number | null;
+    }[];
+    getStreamDataTypesBasedOnTime(streamTypes?: string[]): {
+        [type: number]: {
+            [type: string]: number | null;
+        };
+    };
+    getStreamDataByTime(streamType: string, filterNull?: boolean, filterInfinity?: boolean): StreamDataItem[];
+    getStreamDataByDuration(streamType: string, filterNull?: boolean, filterInfinity?: boolean): StreamDataItem[];
+    addLap(lap: LapInterface): this;
+    getLaps(activity?: ActivityInterface): LapInterface[];
+    hasLaps(): boolean;
+    getAllEvents(): DataEvent[];
+    getStartEvents(): DataStartEvent[];
+    getStopEvents(): DataStopEvent[];
+    getStopAllEvents(): DataStopEvent[];
+    getAllRiderPositionChangeEvents(): DataRiderPositionChangeEvent[];
+    addEvent(event: DataEvent): this;
+    setAllEvents(events: DataEvent[]): this;
+    generateTimeStream(streamTypes?: string[]): StreamInterface;
+    getDateIndex(date: Date): number;
+    toJSON(): ActivityJSONInterface;
+}

package/lib/esm/activities/activity.interface.d.ts

@@ -0,0 +1,206 @@
+import { CreatorInterface } from '../creators/creator.interface';
+import { SerializableClassInterface } from '../serializable/serializable.class.interface';
+import { LapInterface } from '../laps/lap.interface';
+import { IntensityZonesInterface } from '../intensity-zones/intensity-zones.interface';
+import { StatsClassInterface } from '../stats/stats.class.interface';
+import { DurationClassInterface } from '../duration/duration.class.interface';
+import { ActivityTypes } from './activity.types';
+import { StreamDataItem, StreamInterface } from '../streams/stream.interface';
+import { ActivityJSONInterface } from './activity.json.interface';
+import { IDClassInterface } from '../id/id.class.interface';
+import { DataPositionInterface } from '../data/data.position.interface';
+import { DataEvent } from '../data/data.event';
+import { DataStartEvent } from '../data/data.start-event';
+import { DataStopEvent } from '../data/data.stop-event';
+import { DataStopAllEvent } from '../data/data.stop-all-event';
+import { DataRiderPositionChangeEvent } from '../data/data.rider-position-change-event';
+import { ActivityParsingOptions } from './activity-parsing-options';
+export interface ActivityInterface extends StatsClassInterface, DurationClassInterface, SerializableClassInterface, IDClassInterface {
+    name: string;
+    type: ActivityTypes;
+    creator: CreatorInterface;
+    parseOptions: ActivityParsingOptions;
+    intensityZones: IntensityZonesInterface[];
+    /**
+     * Checks if there are data for that stream type
+     * @param streamType
+     * @param startDate
+     * @param endDate
+     */
+    hasStreamData(streamType: string | StreamInterface, startDate?: Date, endDate?: Date): boolean;
+    /**
+     * Checks if there are lat,long data pairs
+     * @param startDate
+     * @param endDate
+     */
+    hasPositionData(startDate?: Date, endDate?: Date): boolean;
+    /**
+     * Checks if the equipment is a trainer
+     */
+    isTrainer(): boolean;
+    /**
+     * Checks if the activity has a power meter
+     */
+    hasPowerMeter(): boolean;
+    /**
+     * Gets the data of a stream with optional params of start and end
+     * @param streamType
+     * @param startDate
+     * @param endDate
+     */
+    getStreamData(streamType: string | StreamInterface, startDate?: Date, endDate?: Date): (number | null)[];
+    /**
+     * Gets the data of a stream with optional params of start and end but removes nulls
+     * @param streamType
+     * @param startDate
+     * @param endDate
+     */
+    getSquashedStreamData(streamType: string, startDate?: Date, endDate?: Date): number[];
+    /**
+     * Gets the data of the stream based on timestamps
+     * @param streamType
+     * @param filterNull
+     */
+    getStreamDataByTime(streamType: string, filterNull?: boolean): StreamDataItem[];
+    /**
+     * Gets the data of the stream based on duration
+     * @param streamType
+     * @param filterNull
+     * @param filterInfinity
+     */
+    getStreamDataByDuration(streamType: string, filterNull?: boolean, filterInfinity?: boolean): StreamDataItem[];
+    /**
+     * Gets more than one stream data based on time
+     * @param streamTypes
+     */
+    getStreamDataTypesBasedOnTime(streamTypes?: string[]): {
+        [type: number]: {
+            [type: string]: number | null;
+        };
+    };
+    /**
+     * Gets more than one stream type based on another stream type
+     * @param streamTypeToBaseOn
+     * @param streamTypes
+     */
+    getStreamDataTypesBasedOnDataType(streamTypeToBaseOn: string, streamTypes: string[]): {
+        [type: string]: number | null;
+    }[];
+    /**
+     * Creates a stream with null filled data values
+     * @param type
+     */
+    createStream(type: string): StreamInterface;
+    /**
+     * Gets a stream
+     * @param type
+     */
+    getStream(type: string): StreamInterface;
+    /**
+     * Adds a stream
+     * @param stream
+     */
+    addStream(stream: StreamInterface): this;
+    /**
+     * Adds multiple streams
+     * @param streams
+     */
+    addStreams(streams: StreamInterface[]): this;
+    /**
+     * Removes a stream
+     * @param streamType
+     */
+    removeStream(streamType: string | StreamInterface): this;
+    /**
+     * Replace stream data by another
+     * @param streamType
+     * @param data
+     */
+    replaceStreamData(streamType: string, data: (number | null)[]): this;
+    /**
+     * Gets all available streams
+     */
+    getAllStreams(): StreamInterface[];
+    /**
+     * Gets all non-unitbased streams (essential streams)
+     */
+    getAllExportableStreams(): StreamInterface[];
+    /**
+     * Removes all streams
+     */
+    clearStreams(): this;
+    /**
+     * Adds a value to the streams data
+     * Floor is used so a date with > end date does not create and extra slug in the array
+     * @param type
+     * @param date
+     * @param value
+     */
+    addDataToStream(type: string, date: Date, value: number): this;
+    /**
+     * Gets the data of 2 streams (lat,long) formated as positional data
+     * @param startDate
+     * @param endDate
+     */
+    getPositionData(startDate?: Date, endDate?: Date): (DataPositionInterface | null)[];
+    /**
+     * Gets the data of 2 streams (lat,long) formated as positional data but ommits nulls
+     * @param startDate
+     * @param endDate
+     */
+    getSquashedPositionData(startDate?: Date, endDate?: Date): (DataPositionInterface | null)[];
+    /**
+     * Gets the laps of the activity
+     */
+    getLaps(): LapInterface[];
+    /**
+     * Adds a lap to the activity
+     * @param lap
+     */
+    addLap(lap: LapInterface): this;
+    /**
+     * Gets the laps of the activity
+     */
+    hasLaps(): boolean;
+    /**
+     * Gets all the timebased events of the activity
+     */
+    getAllEvents(): DataEvent[];
+    /**
+     * Adds an event to the activity
+     * @param event
+     */
+    addEvent(event: DataEvent): this;
+    /**
+     * Sets all the events to the activity
+     * @param events
+     */
+    setAllEvents(events: DataEvent[]): this;
+    /**
+     * Gets only the start type of events
+     */
+    getStartEvents(): DataStartEvent[];
+    /**
+     * Gets only the stop type of events
+     */
+    getStopEvents(): DataStopEvent[];
+    /**
+     * Gets the stop all type of events
+     */
+    getStopAllEvents(): DataStopAllEvent[];
+    /**
+     * Gets all rider position change events
+     */
+    getAllRiderPositionChangeEvents(): DataRiderPositionChangeEvent[];
+    /**
+     * Generates a time stream based on the type of streams requested
+     * @param streamTypes
+     */
+    generateTimeStream(streamTypes?: string[]): StreamInterface;
+    /**
+     * Gets the date index/duration from a date relative to the activity
+     * @param date
+     */
+    getDateIndex(date: Date): number;
+    toJSON(): ActivityJSONInterface;
+}

package/lib/esm/activities/activity.interface.js

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