@sports-alliance/sports-lib 6.0.4 → 6.1.1

package/lib/esm/events/utilities/grade-calculator/low-pass-filter.js

@@ -0,0 +1,86 @@
+export class LowPassFilter {
+    constructor(smoothing) {
+        this._smoothing = smoothing || 0.5; // must be smaller than 1
+        this._buffer = []; // FIFO queue
+        this._bufferMaxSize = 10;
+    }
+    static smooth(values, smoothing = 0.5) {
+        return new LowPassFilter(smoothing).smoothArray(values);
+    }
+    /**
+     * Init buffer with array of values
+     * @param {number[]} values
+     * @returns {number[]}
+     */
+    init(values) {
+        for (let i = 0; i < values.length; i++) {
+            this.__push(values[i]);
+        }
+        return this._buffer;
+    }
+    /**
+     * Add new value to buffer (FIFO queue)
+     * @param {number} value
+     * @returns {number}
+     * @private
+     */
+    __push(value) {
+        const removed = this._buffer.length === this._bufferMaxSize ? this._buffer.shift() : 0;
+        this._buffer.push(value);
+        return removed;
+    }
+    /**
+     * Smooth value from stream
+     * @param {number} nextValue
+     * @returns {number}
+     */
+    next(nextValue) {
+        // push new value to the end, and remove oldest one
+        const removed = this.__push(nextValue);
+        // smooth value using all values from buffer
+        const result = this._buffer.reduce((last, current) => {
+            return this._smoothing * current + (1 - this._smoothing) * last;
+        }, removed);
+        // replace smoothed value
+        this._buffer[this._buffer.length - 1] = result;
+        return result;
+    }
+    /**
+     * Smooth array of values
+     * @param {number[]} values
+     * @returns {number[]}
+     */
+    smoothArray(values) {
+        let value = values.filter(v => Number.isFinite(v))[0];
+        if (!value) {
+            return values;
+        }
+        for (let i = 1; i < values.length; i++) {
+            if (values[i] === null) {
+                continue;
+            }
+            const currentValue = values[i];
+            value += (currentValue - value) * this._smoothing;
+            values[i] = Math.round(value * 100) / 100;
+        }
+        return values;
+    }
+    get bufferMaxSize() {
+        return this._bufferMaxSize;
+    }
+    set bufferMaxSize(value) {
+        this._bufferMaxSize = value;
+    }
+    get buffer() {
+        return this._buffer;
+    }
+    set buffer(value) {
+        this._buffer = value;
+    }
+    get smoothing() {
+        return this._smoothing;
+    }
+    set smoothing(value) {
+        this._smoothing = value;
+    }
+}

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

@@ -0,0 +1,45 @@
+export declare function isNumberOrString(property: any): boolean;
+export declare function isNumber(property: any): boolean;
+/**
+ * Converts speed from m/s to pace as of seconds per km
+ * @param {number} number
+ * @return {number}
+ */
+export declare function convertSpeedToPace(number: number): number;
+/**
+ * Converts m/s to seconds per 100m
+ * @param number
+ */
+export declare function convertSpeedToSwimPace(number: number): number;
+export declare function convertSpeedToSpeedInKilometersPerHour(number: number): number;
+export declare function convertSpeedToSpeedInMilesPerHour(number: number): number;
+export declare function convertSpeedToSpeedInFeetPerSecond(number: number): number;
+export declare function convertSpeedToSpeedInMetersPerMinute(number: number): number;
+export declare function convertSpeedToSpeedInFeetPerMinute(number: number): number;
+export declare function convertSpeedToSpeedInFeetPerHour(number: number): number;
+export declare function convertSpeedToSpeedInMetersPerHour(number: number): number;
+export declare function convertSpeedToSpeedInKnots(number: number): number;
+export declare function convertPaceToPaceInMinutesPerMile(number: number): number;
+export declare function convertMetersToMiles(number: number): number;
+/**
+ * Converts m/s to seconds per 100m
+ * @param number
+ */
+export declare function convertSwimPaceToSwimPacePer100Yard(number: number): number;
+export declare function getSize(obj: any): number;
+export declare function getSizeFormated(obj: any): string;
+/**
+ * from https://stackoverflow.com/questions/48340403/fill-missing-numeric-values-in-an-array
+ * Very badly written
+ * @param array
+ */
+export declare function fillMissingValuesLinear(array: (number | null)[]): number[];
+export declare const mean: (array: number[]) => number;
+export declare const meanWindowSmoothing: (array: number[], windowSize?: number, roundDecimals?: number) => number[];
+/**
+ * Remove spikes into a vector (http://fourier.eng.hmc.edu/e161/lectures/smooth_sharpen/node2.html)
+ * @param array to be filtered
+ * @param window Window size (should be odd number)
+ */
+export declare const medianFilter: (array: number[], window?: number) => number[];
+export declare const standardDeviation: (stream: number[]) => number;

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

@@ -0,0 +1,162 @@
+export function isNumberOrString(property) {
+    return typeof property === 'number' || typeof property === 'string';
+}
+export function isNumber(property) {
+    return typeof property === 'number' && !isNaN(property);
+}
+/**
+ * Converts speed from m/s to pace as of seconds per km
+ * @param {number} number
+ * @return {number}
+ */
+export function convertSpeedToPace(number) {
+    return number === 0 ? Infinity : 1000 / number;
+}
+/**
+ * Converts m/s to seconds per 100m
+ * @param number
+ */
+export function convertSpeedToSwimPace(number) {
+    return number === 0 ? Infinity : 100 / number;
+}
+export function convertSpeedToSpeedInKilometersPerHour(number) {
+    return number * 3.6;
+}
+export function convertSpeedToSpeedInMilesPerHour(number) {
+    return number * 2.237;
+}
+export function convertSpeedToSpeedInFeetPerSecond(number) {
+    return number * 3.28084;
+}
+export function convertSpeedToSpeedInMetersPerMinute(number) {
+    return number * 60;
+}
+export function convertSpeedToSpeedInFeetPerMinute(number) {
+    return number * 196.85;
+}
+export function convertSpeedToSpeedInFeetPerHour(number) {
+    return number * 11811.024;
+}
+export function convertSpeedToSpeedInMetersPerHour(number) {
+    return number * 3600;
+}
+export function convertSpeedToSpeedInKnots(number) {
+    return number * 1.943844;
+}
+export function convertPaceToPaceInMinutesPerMile(number) {
+    return number * 1.60934;
+}
+export function convertMetersToMiles(number) {
+    return number === 0 ? 0 : number / 1609;
+}
+/**
+ * Converts m/s to seconds per 100m
+ * @param number
+ */
+export function convertSwimPaceToSwimPacePer100Yard(number) {
+    return number * 1.93613298;
+}
+export function getSize(obj) {
+    return getSizeWithOptionalFormat(obj, false);
+}
+export function getSizeFormated(obj) {
+    return getSizeWithOptionalFormat(obj, true);
+}
+function getSizeWithOptionalFormat(obj, format = true) {
+    let size;
+    try {
+        size = new Blob([obj]).size;
+    }
+    catch (e) {
+        size = Buffer.from(obj).length;
+    }
+    function formatByteSize(bytes) {
+        if (bytes < 1024) {
+            return bytes + ' bytes';
+        }
+        else if (bytes < 1048576) {
+            return (bytes / 1024).toFixed(4) + ' KiB';
+        }
+        else if (bytes < 1073741824) {
+            return (bytes / 1048576).toFixed(4) + ' MiB';
+        }
+        else {
+            return (bytes / 1073741824).toFixed(4) + ' GiB';
+        }
+    }
+    return format ? formatByteSize(size) : size;
+}
+/**
+ * from https://stackoverflow.com/questions/48340403/fill-missing-numeric-values-in-an-array
+ * Very badly written
+ * @param array
+ */
+export function fillMissingValuesLinear(array) {
+    let i = 0, j, delta;
+    while (i < array.length) {
+        if (array[i] !== null) {
+            i++;
+            continue;
+        }
+        j = i;
+        // eslint-disable-next-line no-empty
+        while (array[++j] === null) { }
+        // @ts-ignore
+        delta = (array[j] - array[i - 1]) / (j - i + 1);
+        do {
+            // @ts-ignore
+            array[i] = delta + array[i - 1];
+            i++;
+        } while (i < j);
+    }
+    return array;
+}
+export const mean = (array) => {
+    return array.reduce((a, b) => a + b, 0) / array.length;
+};
+export const meanWindowSmoothing = (array, windowSize = 7, roundDecimals = 3) => {
+    const roundDecimalsFactor = Math.pow(10, roundDecimals);
+    return array.map((value, index) => {
+        const window = array.slice(index, index + windowSize); // Get window
+        return Math.round(mean(window) * roundDecimalsFactor) / roundDecimalsFactor; // Round and return
+    });
+};
+const median = (inputArray) => {
+    const s = inputArray.slice().sort((a, b) => {
+        return a - b;
+    });
+    return s[Math.floor((s.length - 1) / 2)];
+};
+/**
+ * Remove spikes into a vector (http://fourier.eng.hmc.edu/e161/lectures/smooth_sharpen/node2.html)
+ * @param array to be filtered
+ * @param window Window size (should be odd number)
+ */
+export const medianFilter = (array, window = 11) => {
+    if (window % 2 === 0) {
+        throw new Error('Window size should be an odd number');
+    }
+    if (array.length < window) {
+        return array;
+    }
+    const f = [];
+    const w = [];
+    let i;
+    w.push(array[0]);
+    for (i = 0; i < array.length; i++) {
+        const midWindowIndex = Math.floor(window / 2);
+        if (array.length - 1 >= i + midWindowIndex) {
+            w.push(array[i + midWindowIndex]);
+        }
+        f.push(median(w));
+        if (i >= midWindowIndex) {
+            w.shift();
+        }
+    }
+    return f;
+};
+export const standardDeviation = (stream) => {
+    const avg = mean(stream);
+    const variance = mean(stream.map(value => Math.pow(value, 2))) - Math.pow(avg, 2);
+    return variance > 0 ? Math.sqrt(variance) : 0;
+};

package/lib/esm/geodesy/adapters/adapter.interface.d.ts

@@ -0,0 +1,4 @@
+import { DataPositionInterface } from '../../data/data.position.interface';
+export interface GeoLibAdapterInterface {
+    getDistance(positionArray: DataPositionInterface[], precise?: boolean, accuracy?: number): number;
+}

package/lib/esm/geodesy/adapters/adapter.interface.js

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

package/lib/esm/geodesy/adapters/geolib.adapter.d.ts

@@ -0,0 +1,7 @@
+import { GeoLibAdapterInterface } from './adapter.interface';
+import { DataPositionInterface } from '../../data/data.position.interface';
+export declare class GeoLibAdapter implements GeoLibAdapterInterface {
+    findNearest: (point: import("geolib/es/types").GeolibInputCoordinates, coords: import("geolib/es/types").GeolibInputCoordinates[]) => import("geolib/es/types").GeolibInputCoordinates;
+    constructor();
+    getDistance(positionArray: DataPositionInterface[], precise?: boolean, accuracy?: number): number;
+}

package/lib/esm/geodesy/adapters/geolib.adapter.js

@@ -0,0 +1,28 @@
+import getPreciseDistance from 'geolib/es/getPreciseDistance';
+import getDistance from 'geolib/es/getDistance';
+import findNearest from 'geolib/es/findNearest';
+export class GeoLibAdapter {
+    constructor() {
+        this.findNearest = findNearest;
+    }
+    getDistance(positionArray, precise = false, accuracy = 0.1) {
+        let distance = 0;
+        const excludeFirstPointsArray = positionArray.slice(1);
+        let firstPosition = positionArray[0];
+        for (const nextPosition of excludeFirstPointsArray) {
+            const firstPositionAsDecimal = {
+                longitude: firstPosition.longitudeDegrees,
+                latitude: firstPosition.latitudeDegrees
+            };
+            const nextPositionAsDecimal = {
+                longitude: nextPosition.longitudeDegrees,
+                latitude: nextPosition.latitudeDegrees
+            };
+            distance += precise
+                ? getPreciseDistance(firstPositionAsDecimal, nextPositionAsDecimal, accuracy)
+                : getDistance(firstPositionAsDecimal, nextPositionAsDecimal, accuracy);
+            firstPosition = nextPosition;
+        }
+        return distance;
+    }
+}

package/lib/esm/id/id.abstract.class.d.ts

@@ -0,0 +1,6 @@
+import { IDClassInterface } from './id.class.interface';
+export declare abstract class IDClass implements IDClassInterface {
+    private id?;
+    getID(): string | null;
+    setID(id: string): this;
+}

package/lib/esm/id/id.abstract.class.js

@@ -0,0 +1,9 @@
+export class IDClass {
+    getID() {
+        return this.id || null;
+    }
+    setID(id) {
+        this.id = id;
+        return this;
+    }
+}

package/lib/esm/id/id.class.interface.d.ts

@@ -0,0 +1,4 @@
+export interface IDClassInterface {
+    setID(id: string | null): this;
+    getID(): string | null;
+}

package/lib/esm/id/id.class.interface.js

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

package/lib/esm/id/id.class.spec.d.ts

@@ -0,0 +1,3 @@
+import { IDClass } from './id.abstract.class';
+export declare class IdClass extends IDClass {
+}

package/lib/esm/id/id.class.spec.js

@@ -0,0 +1,13 @@
+import { IDClass } from './id.abstract.class';
+describe('IDClass', () => {
+    let idClass;
+    beforeEach(() => {
+        idClass = new IdClass();
+    });
+    it('should correctly set an ID', () => {
+        idClass.setID('123');
+        expect(idClass.getID()).toBe('123');
+    });
+});
+export class IdClass extends IDClass {
+}

package/lib/esm/index.d.ts

@@ -0,0 +1,149 @@
+import { EventInterface } from './events/event.interface';
+import { EventJSONInterface } from './events/event.json.interface';
+import { ActivityParsingOptions } from './activities/activity-parsing-options';
+export declare class SportsLib {
+    /**
+     * Parses and returns an event using GPX format
+     * @param gpxString
+     * @param options
+     * @param domParser custom DOMParser (case of NodeJs usage)
+     */
+    static importFromGPX(gpxString: string, domParser?: any, options?: ActivityParsingOptions): Promise<EventInterface>;
+    /**
+     * Parses and returns an event using TCX format
+     * @param xmlDocument
+     * @param options
+     */
+    static importFromTCX(xmlDocument: XMLDocument, options?: ActivityParsingOptions): Promise<EventInterface>;
+    /**
+     * Parses and returns an event using FIT format
+     * @param arrayBuffer
+     * @param options
+     */
+    static importFromFit(arrayBuffer: ArrayBuffer, options?: ActivityParsingOptions): Promise<EventInterface>;
+    /**
+     * Parses and returns an event using Suunto format
+     * @param jsonString
+     * @param options
+     */
+    static importFromSuunto(jsonString: string, options?: ActivityParsingOptions): Promise<EventInterface>;
+    /**
+     * Parses and returns an event using native format (SportsLib exported format)
+     * @param json EventJSONInterface
+     */
+    static importFromJSON(json: EventJSONInterface): EventInterface;
+}
+export * from './activities/activity.interface';
+export * from './activities/activity.json.interface';
+export * from './activities/activity.types';
+export * from './constants/constants';
+export * from './data/data-aerobic-training-effect';
+export * from './data/data.absolute-pressure';
+export * from './data/data.accumulated-power';
+export * from './data/data.activity-types';
+export * from './data/data.air-power';
+export * from './data/data.altitude';
+export * from './data/data.altitude-avg';
+export * from './data/data.altitude-gps';
+export * from './data/data.altitude-max';
+export * from './data/data.altitude-min';
+export * from './data/data.ascent';
+export * from './data/data.cadence-avg';
+export * from './data/data.cadence-max';
+export * from './data/data.cadence-min';
+export * from './data/data.descent';
+export * from './data/data.description';
+export * from './data/data.device-names';
+export * from './data/data.distance';
+export * from './data/data.duration';
+export * from './data/data.ehpe';
+export * from './data/data.energy';
+export * from './data/data.epoc';
+export * from './data/data.evpe';
+export * from './data/data.feeling';
+export * from './data/data.grade-adjusted-pace';
+export * from './data/data.grade-adjusted-pace-avg';
+export * from './data/data.grade-adjusted-speed';
+export * from './data/data.grade-adjusted-speed-avg';
+export * from './data/data.heart-rate';
+export * from './data/data.heart-rate-avg';
+export * from './data/data.heart-rate-max';
+export * from './data/data.heart-rate-min';
+export * from './data/data.ibi';
+export * from './data/data.interface';
+export * from './data/data.latitude-degrees';
+export * from './data/data.left-balance';
+export * from './data/data.longitude-degrees';
+export * from './data/data.moving-time';
+export * from './data/data.pace';
+export * from './data/data.pace-avg';
+export * from './data/data.peak-epoc';
+export * from './data/data.peak-training-effect';
+export * from './data/data.position.interface';
+export * from './data/data.power';
+export * from './data/data.power-avg';
+export * from './data/data.power-left';
+export * from './data/data.power-max';
+export * from './data/data.power-min';
+export * from './data/data.power-right';
+export * from './data/data.recovery-time';
+export * from './data/data.right-balance';
+export * from './data/data.rpe';
+export * from './data/data.sea-level-pressure';
+export * from './data/data.speed';
+export * from './data/data.speed-avg';
+export * from './data/data.speed-max';
+export * from './data/data.speed-min';
+export * from './data/data.start-position';
+export * from './data/data.store';
+export * from './data/data.stryd-altitude';
+export * from './data/data.stryd-distance';
+export * from './data/data.stryd-speed';
+export * from './data/data.swim-pace';
+export * from './data/data.swim-pace-avg';
+export * from './data/data.swim-pace-max';
+export * from './data/data.temperature';
+export * from './data/data.temperature-avg';
+export * from './data/data.temperature-max';
+export * from './data/data.temperature-min';
+export * from './data/data.vertical-speed';
+export * from './data/data.vertical-speed-avg';
+export * from './data/data.vo2-max';
+export * from './data/ibi/data.ibi';
+export * from './events/adapters/exporters/exporter.gpx';
+export * from './events/adapters/exporters/exporter.json';
+export * from './events/adapters/importers/fit/importer.fit';
+export * from './events/adapters/importers/gpx/importer.gpx';
+export * from './events/adapters/importers/json/importer.json';
+export * from './events/adapters/importers/suunto/importer.suunto.json';
+export * from './events/adapters/importers/suunto/importer.suunto.sml';
+export * from './events/adapters/importers/tcx/importer.tcx';
+export * from './events/event.interface';
+export * from './events/event.json.interface';
+export * from './events/utilities/activity.utilities';
+export * from './events/utilities/event.utilities';
+export * from './events/utilities/helpers';
+export * from './geodesy/adapters/geolib.adapter';
+export * from './laps/lap.interface';
+export * from './laps/lap.types';
+export * from './meta-data/event-meta-data.interface';
+export * from './meta-data/meta-data';
+export * from './privacy/privacy.class.interface';
+export * from './service-tokens/oauth1-service-token.interface';
+export * from './service-tokens/oauth2-service-token.interface';
+export * from './stats/stats.class.interface';
+export * from './streams/compressed.stream.interface';
+export * from './streams/stream';
+export * from './streams/stream.interface';
+export * from './tiles/tile.settings.interface';
+export * from './users/settings/dashboard/user.dashboard.settings.interface';
+export * from './users/settings/user.app.settings.interface';
+export * from './users/settings/user.chart.settings.interface';
+export * from './users/settings/user.map.settings.interface';
+export * from './users/settings/user.my-tracks.settings.interface';
+export * from './users/settings/user.settings.interface';
+export * from './users/settings/user.summaries.settings.interface';
+export * from './users/settings/user.unit.settings.interface';
+export * from './users/user';
+export * from './users/user.export-to-csv.settings.interface';
+export * from './users/user.service.meta.interface';