@sports-alliance/sports-lib 6.0.4 → 6.1.0

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

@@ -0,0 +1,55 @@
+import { DataNumber } from './data.number';
+export declare class DataVerticalSpeed extends DataNumber {
+    static type: string;
+    static unit: string;
+    getValue(formatForDataType?: string): number;
+    getDisplayValue(): string;
+}
+export declare class DataVerticalSpeedFeetPerSecond extends DataVerticalSpeed {
+    static type: string;
+    static displayType: string;
+    static unit: string;
+    getDisplayType(): string;
+}
+export declare class DataVerticalSpeedMetersPerMinute extends DataVerticalSpeed {
+    static type: string;
+    static displayType: string;
+    static unit: string;
+    getDisplayType(): string;
+    getDisplayValue(): string;
+}
+export declare class DataVerticalSpeedFeetPerMinute extends DataVerticalSpeed {
+    static type: string;
+    static displayType: string;
+    static unit: string;
+    getDisplayType(): string;
+    getDisplayValue(): string;
+}
+export declare class DataVerticalSpeedMetersPerHour extends DataVerticalSpeed {
+    static type: string;
+    static displayType: string;
+    static unit: string;
+    getDisplayType(): string;
+    getDisplayValue(): string;
+}
+export declare class DataVerticalSpeedFeetPerHour extends DataVerticalSpeed {
+    static type: string;
+    static displayType: string;
+    static unit: string;
+    getDisplayType(): string;
+    getDisplayValue(): string;
+}
+export declare class DataVerticalSpeedKilometerPerHour extends DataVerticalSpeed {
+    static type: string;
+    static displayType: string;
+    static unit: string;
+    getDisplayType(): string;
+    getDisplayValue(): string;
+}
+export declare class DataVerticalSpeedMilesPerHour extends DataVerticalSpeed {
+    static type: string;
+    static displayType: string;
+    static unit: string;
+    getDisplayType(): string;
+    getDisplayValue(): string;
+}

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

@@ -0,0 +1,103 @@
+import { DataNumber } from './data.number';
+import { convertSpeedToSpeedInFeetPerHour, convertSpeedToSpeedInFeetPerMinute, convertSpeedToSpeedInFeetPerSecond, convertSpeedToSpeedInKilometersPerHour, convertSpeedToSpeedInMetersPerHour, convertSpeedToSpeedInMetersPerMinute, convertSpeedToSpeedInMilesPerHour } from '../events/utilities/helpers';
+export class DataVerticalSpeed extends DataNumber {
+    getValue(formatForDataType) {
+        switch (formatForDataType) {
+            case DataVerticalSpeedKilometerPerHour.type:
+                return convertSpeedToSpeedInKilometersPerHour(this.value);
+            case DataVerticalSpeedMilesPerHour.type:
+                return convertSpeedToSpeedInMilesPerHour(this.value);
+            case DataVerticalSpeedFeetPerSecond.type:
+                return convertSpeedToSpeedInFeetPerSecond(this.value);
+            case DataVerticalSpeedMetersPerMinute.type:
+                return convertSpeedToSpeedInMetersPerMinute(this.value);
+            case DataVerticalSpeedFeetPerMinute.type:
+                return convertSpeedToSpeedInFeetPerMinute(this.value);
+            case DataVerticalSpeedFeetPerHour.type:
+                return convertSpeedToSpeedInFeetPerHour(this.value);
+            case DataVerticalSpeedMetersPerHour.type:
+                return convertSpeedToSpeedInMetersPerHour(this.value);
+            default:
+                return super.getValue(formatForDataType);
+        }
+    }
+    getDisplayValue() {
+        return this.getValue().toFixed(2);
+    }
+}
+DataVerticalSpeed.type = 'Vertical Speed';
+DataVerticalSpeed.unit = 'm/s';
+export class DataVerticalSpeedFeetPerSecond extends DataVerticalSpeed {
+    getDisplayType() {
+        return super.getDisplayType();
+    }
+}
+DataVerticalSpeedFeetPerSecond.type = 'Vertical speed in feet per second';
+DataVerticalSpeedFeetPerSecond.displayType = DataVerticalSpeed.type;
+DataVerticalSpeedFeetPerSecond.unit = 'ft/s';
+export class DataVerticalSpeedMetersPerMinute extends DataVerticalSpeed {
+    getDisplayType() {
+        return super.getDisplayType();
+    }
+    getDisplayValue() {
+        return this.getValue().toFixed(1);
+    }
+}
+DataVerticalSpeedMetersPerMinute.type = 'Vertical speed in meters per minute';
+DataVerticalSpeedMetersPerMinute.displayType = DataVerticalSpeed.type;
+DataVerticalSpeedMetersPerMinute.unit = 'm/min';
+export class DataVerticalSpeedFeetPerMinute extends DataVerticalSpeed {
+    getDisplayType() {
+        return super.getDisplayType();
+    }
+    getDisplayValue() {
+        return this.getValue().toFixed(1);
+    }
+}
+DataVerticalSpeedFeetPerMinute.type = 'Vertical speed in feet per minute';
+DataVerticalSpeedFeetPerMinute.displayType = DataVerticalSpeed.type;
+DataVerticalSpeedFeetPerMinute.unit = 'ft/min';
+export class DataVerticalSpeedMetersPerHour extends DataVerticalSpeed {
+    getDisplayType() {
+        return super.getDisplayType();
+    }
+    getDisplayValue() {
+        return this.getValue().toFixed(0);
+    }
+}
+DataVerticalSpeedMetersPerHour.type = 'Vertical speed in meters per hour';
+DataVerticalSpeedMetersPerHour.displayType = DataVerticalSpeed.type;
+DataVerticalSpeedMetersPerHour.unit = 'm/h';
+export class DataVerticalSpeedFeetPerHour extends DataVerticalSpeed {
+    getDisplayType() {
+        return super.getDisplayType();
+    }
+    getDisplayValue() {
+        return this.getValue().toFixed(0);
+    }
+}
+DataVerticalSpeedFeetPerHour.type = 'Vertical speed in feet per hour';
+DataVerticalSpeedFeetPerHour.displayType = DataVerticalSpeed.type;
+DataVerticalSpeedFeetPerHour.unit = 'ft/h';
+export class DataVerticalSpeedKilometerPerHour extends DataVerticalSpeed {
+    getDisplayType() {
+        return super.getDisplayType();
+    }
+    getDisplayValue() {
+        return this.getValue().toFixed(2);
+    }
+}
+DataVerticalSpeedKilometerPerHour.type = 'Vertical speed in kilometers per hour';
+DataVerticalSpeedKilometerPerHour.displayType = DataVerticalSpeed.type;
+DataVerticalSpeedKilometerPerHour.unit = 'km/h';
+export class DataVerticalSpeedMilesPerHour extends DataVerticalSpeed {
+    getDisplayType() {
+        return super.getDisplayType();
+    }
+    getDisplayValue() {
+        return this.getValue().toFixed(2);
+    }
+}
+DataVerticalSpeedMilesPerHour.type = 'Vertical speed in miles per hour';
+DataVerticalSpeedMilesPerHour.displayType = DataVerticalSpeed.type;
+DataVerticalSpeedMilesPerHour.unit = 'mph';

package/lib/esm/data/data.vo2-max.d.ts

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

package/lib/esm/data/data.vo2-max.js

@@ -0,0 +1,7 @@
+import { DataNumber } from './data.number';
+export class DataVO2Max extends DataNumber {
+    getDisplayValue() {
+        return this.getValue().toFixed(2);
+    }
+}
+DataVO2Max.type = 'VO2 Max';

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

@@ -0,0 +1,56 @@
+import { SerializableClassInterface } from '../../serializable/serializable.class.interface';
+export declare class IBIData implements SerializableClassInterface {
+    static type: string;
+    /**
+     * Key is time time since start of the array
+     * value is the ibi
+     * @type {Map<number, number>}
+     */
+    private ibiDataMap;
+    constructor(ibiDataArray?: Array<number>);
+    /**
+     * Parses an IBI data array
+     * eg: [600, 600, 100] becomes a map of {600:600, 1200: 600, 1300:100}
+     * @param {Array<number>} ibiArray
+     */
+    parseIBIArray(ibiArray: Array<number>): void;
+    /**
+     * Sets the ibi for the specific time
+     * @param time
+     * @param ibi
+     */
+    setIBI(time: number, ibi: number): void;
+    /**
+     * Gets the IBI data map
+     * @return {Map<number, number>}
+     */
+    getIBIDataMap(): Map<number, number>;
+    /**
+     * Gets the IBI data map but uses BPM units instead of IBI
+     * @return {Map<number, number>}
+     */
+    getAsBPM(): Map<number, number>;
+    getAsArray(): number[];
+    /**
+     * Low Limit filter. Removes all hr values above limit
+     * @param {number} bpmLowLimit in BPM
+     */
+    lowLimitBPMFilter(bpmLowLimit?: number): IBIData;
+    /**
+     * High limit filter. Removes all hr values above limit
+     * @param bpmHighLimit
+     */
+    highLimitBPMFilter(bpmHighLimit?: number): IBIData;
+    /**
+     *  Low pass filter
+     * @param windowSize
+     */
+    lowPassFilter(windowSize?: number): IBIData;
+    /**
+     * Moving median filter
+     * @param {number} windowSize
+     * @return {this}
+     */
+    movingMedianFilter(windowSize?: number): this;
+    toJSON(): any;
+}

package/lib/esm/data/ibi/data.ibi.filters.d.ts

@@ -0,0 +1,26 @@
+import { IBIData } from './data.ibi';
+/**
+ * Collection of filters parsers and converters for IBI (R-R) data
+ */
+export declare class IBIFilters {
+    /**
+     * A limit filter. It removes all values outside the limit
+     * @param {IBIData} ibiData
+     * @param {number} limit
+     * @param {boolean} lowLimit
+     */
+    static limitFilter(ibiData: IBIData, limit: number, lowLimit: boolean): void;
+    /**
+     * Running median filter
+     * @param {IBIData} ibiData
+     * @param {number} windowSize
+     */
+    static movingMedianFilter(ibiData: IBIData, windowSize?: number): void;
+    /**
+     * Low pass filter
+     * @param {IBIData} ibiData
+     * @param {number} windowSize
+     * @param linearWeight
+     */
+    static lowPassFilter(ibiData: IBIData, windowSize?: number, linearWeight?: boolean): void;
+}

package/lib/esm/data/ibi/data.ibi.filters.js

@@ -0,0 +1,52 @@
+const CreateMedianFilter = require('moving-median');
+const LowPassFilter = require('lowpassf');
+/**
+ * Collection of filters parsers and converters for IBI (R-R) data
+ */
+export class IBIFilters {
+    /**
+     * A limit filter. It removes all values outside the limit
+     * @param {IBIData} ibiData
+     * @param {number} limit
+     * @param {boolean} lowLimit
+     */
+    static limitFilter(ibiData, limit, lowLimit) {
+        ibiData.getIBIDataMap().forEach((value, key, map) => {
+            if (value < limit && lowLimit) {
+                map.delete(key);
+            }
+            else if (value > limit && !lowLimit) {
+                map.delete(key);
+            }
+        });
+    }
+    /**
+     * Running median filter
+     * @param {IBIData} ibiData
+     * @param {number} windowSize
+     */
+    static movingMedianFilter(ibiData, windowSize) {
+        windowSize = windowSize || 5;
+        const medianFilter = CreateMedianFilter(windowSize);
+        ibiData.getIBIDataMap().forEach((ibi, elapsedTime) => {
+            ibiData.setIBI(elapsedTime, Math.round(medianFilter(ibi)));
+        });
+    }
+    /**
+     * Low pass filter
+     * @param {IBIData} ibiData
+     * @param {number} windowSize
+     * @param linearWeight
+     */
+    static lowPassFilter(ibiData, windowSize, linearWeight) {
+        const lowPassFilter = new LowPassFilter();
+        windowSize = windowSize || 5;
+        linearWeight = linearWeight ? lowPassFilter.LinearWeightAverage : lowPassFilter.SimpleAverage;
+        lowPassFilter.setLogic(linearWeight);
+        lowPassFilter.setSamplingRange(windowSize);
+        ibiData.getIBIDataMap().forEach((ibi, elapsedTime) => {
+            lowPassFilter.putValue(ibi);
+            ibiData.setIBI(elapsedTime, Math.round(lowPassFilter.getFilteredValue()));
+        });
+    }
+}

package/lib/esm/data/ibi/data.ibi.js

@@ -0,0 +1,98 @@
+import { IBIFilters } from './data.ibi.filters';
+export class IBIData {
+    constructor(ibiDataArray) {
+        /**
+         * Key is time time since start of the array
+         * value is the ibi
+         * @type {Map<number, number>}
+         */
+        this.ibiDataMap = new Map();
+        if (ibiDataArray) {
+            this.parseIBIArray(ibiDataArray);
+        }
+    }
+    /**
+     * Parses an IBI data array
+     * eg: [600, 600, 100] becomes a map of {600:600, 1200: 600, 1300:100}
+     * @param {Array<number>} ibiArray
+     */
+    parseIBIArray(ibiArray) {
+        ibiArray.reduce((totalTime, ibiData) => {
+            if (ibiData > 0) {
+                totalTime += ibiData;
+                this.ibiDataMap.set(totalTime, ibiData);
+            }
+            return totalTime;
+        }, 0);
+    }
+    /**
+     * Sets the ibi for the specific time
+     * @param time
+     * @param ibi
+     */
+    setIBI(time, ibi) {
+        this.ibiDataMap.set(time, ibi);
+    }
+    /**
+     * Gets the IBI data map
+     * @return {Map<number, number>}
+     */
+    getIBIDataMap() {
+        return this.ibiDataMap;
+    }
+    /**
+     * Gets the IBI data map but uses BPM units instead of IBI
+     * @return {Map<number, number>}
+     */
+    getAsBPM() {
+        const hrDataMap = new Map();
+        this.ibiDataMap.forEach((value, key, map) => {
+            hrDataMap.set(key, Math.round(60000 / value));
+        });
+        return hrDataMap;
+    }
+    getAsArray() {
+        const ibi = [];
+        this.ibiDataMap.forEach((value, key, map) => {
+            ibi.push(value);
+        });
+        return ibi;
+    }
+    /**
+     * Low Limit filter. Removes all hr values above limit
+     * @param {number} bpmLowLimit in BPM
+     */
+    lowLimitBPMFilter(bpmLowLimit) {
+        IBIFilters.limitFilter(this, 60000 / (bpmLowLimit || 40), false); // Lower bpm higher IBI limit!
+        return this;
+    }
+    /**
+     * High limit filter. Removes all hr values above limit
+     * @param bpmHighLimit
+     */
+    highLimitBPMFilter(bpmHighLimit) {
+        IBIFilters.limitFilter(this, 60000 / (bpmHighLimit || 220), true); // Higher bpm lower IBI limit!
+        return this;
+    }
+    /**
+     *  Low pass filter
+     * @param windowSize
+     */
+    lowPassFilter(windowSize) {
+        IBIFilters.lowPassFilter(this, windowSize);
+        return this;
+    }
+    /**
+     * Moving median filter
+     * @param {number} windowSize
+     * @return {this}
+     */
+    movingMedianFilter(windowSize) {
+        IBIFilters.movingMedianFilter(this, windowSize);
+        return this;
+    }
+    toJSON() {
+        return Array.from(this.ibiDataMap.values());
+    }
+}
+IBIData.type = 'IBI'; // @todo hcakc fix

package/lib/esm/data/ibi/data.ibi.spec.d.ts

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

package/lib/esm/data/ibi/data.ibi.spec.js

@@ -0,0 +1,66 @@
+import { IBIData } from './data.ibi';
+describe('Data IBI', function () {
+    let ibiData;
+    beforeEach(() => {
+        ibiData = new IBIData([600, 700, 800, 900]);
+    });
+    it('should get the correct data map', function () {
+        const expectedResult = new Map();
+        expectedResult.set(600, 600);
+        expectedResult.set(1300, 700);
+        expectedResult.set(2100, 800);
+        expectedResult.set(3000, 900);
+        expect(ibiData.getIBIDataMap()).toEqual(expectedResult);
+    });
+    it('should convert correctly to heart rate by Math.Round', function () {
+        const expectedResult = new Map();
+        expectedResult.set(600, Math.round(60000 / 600));
+        expectedResult.set(1300, Math.round(60000 / 700));
+        expectedResult.set(2100, Math.round(60000 / 800));
+        expectedResult.set(3000, Math.round(60000 / 900));
+        expect(ibiData.getAsBPM()).toEqual(expectedResult);
+    });
+    it('should filter all bpm above 80', function () {
+        const expectedResult = new Map();
+        expectedResult.set(600, Math.round(60000 / 600));
+        expectedResult.set(1300, Math.round(60000 / 700));
+        expectedResult.set(2100, Math.round(60000 / 800));
+        expectedResult.set(3000, Math.round(60000 / 900));
+        expect(ibiData.getAsBPM()).toEqual(expectedResult);
+    });
+    it('should remove all bpm above 80', function () {
+        const expectedResult = new Map();
+        expectedResult.set(2100, Math.round(60000 / 800)); // 75
+        expectedResult.set(3000, Math.round(60000 / 900)); // 66
+        ibiData.highLimitBPMFilter(80);
+        expect(ibiData.getAsBPM()).toEqual(expectedResult);
+    });
+    it('should remove all bpm below 80', function () {
+        const expectedResult = new Map();
+        ibiData.lowLimitBPMFilter(80);
+        expectedResult.set(600, Math.round(60000 / 600)); // 100
+        expectedResult.set(1300, Math.round(60000 / 700)); // 85
+        expect(ibiData.getAsBPM()).toEqual(expectedResult);
+    });
+    it('should apply a low pass filter', function () {
+        const expectedResult = new Map();
+        expectedResult.set(600, 100);
+        expectedResult.set(1300, 92);
+        expectedResult.set(2100, 86);
+        expectedResult.set(3000, 80);
+        ibiData.lowPassFilter();
+        expect(ibiData.getAsBPM()).toEqual(expectedResult);
+    });
+    it('should apply a moving median filter', function () {
+        const expectedResult = new Map();
+        expectedResult.set(600, 100);
+        expectedResult.set(1300, 92);
+        expectedResult.set(2100, 86);
+        expectedResult.set(3000, 80);
+        ibiData.movingMedianFilter();
+        expect(ibiData.getAsBPM()).toEqual(expectedResult);
+    });
+    it('should export correctly to JSON', function () {
+        expect(ibiData.toJSON()).toEqual([600, 700, 800, 900]);
+    });
+});

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

@@ -0,0 +1,19 @@
+import { DurationClassInterface } from './duration.class.interface';
+import { StatsClassAbstract } from '../stats/stats.class.abstract';
+import { DataPause } from '../data/data.pause';
+import { DataDuration } from '../data/data.duration';
+import { DataTimerTime } from '../data/data.timer-time';
+import { DataMovingTime } from '../data/data.moving-time';
+export declare abstract class DurationClassAbstract extends StatsClassAbstract implements DurationClassInterface {
+    startDate: Date;
+    endDate: Date;
+    protected constructor(startDate: Date, endDate: Date);
+    getDuration(): DataDuration;
+    getTimer(): DataTimerTime;
+    getMovingTime(): DataMovingTime;
+    getPause(): DataPause;
+    setDuration(duration: DataDuration): void;
+    setTimer(duration: DataTimerTime): void;
+    setMovingTime(duration: DataMovingTime): void;
+    setPause(pause: DataPause): void;
+}

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

@@ -0,0 +1,36 @@
+import { StatsClassAbstract } from '../stats/stats.class.abstract';
+import { DataPause } from '../data/data.pause';
+import { DataDuration } from '../data/data.duration';
+import { DataTimerTime } from '../data/data.timer-time';
+import { DataMovingTime } from '../data/data.moving-time';
+export class DurationClassAbstract extends StatsClassAbstract {
+    constructor(startDate, endDate) {
+        super();
+        this.startDate = startDate;
+        this.endDate = endDate;
+    }
+    getDuration() {
+        return this.stats.get(DataDuration.type);
+    }
+    getTimer() {
+        return this.stats.get(DataTimerTime.type);
+    }
+    getMovingTime() {
+        return this.stats.get(DataMovingTime.type);
+    }
+    getPause() {
+        return this.stats.get(DataPause.type);
+    }
+    setDuration(duration) {
+        this.stats.set(DataDuration.type, duration);
+    }
+    setTimer(duration) {
+        this.stats.set(DataTimerTime.type, duration);
+    }
+    setMovingTime(duration) {
+        this.stats.set(DataMovingTime.type, duration);
+    }
+    setPause(pause) {
+        this.stats.set(DataPause.type, pause);
+    }
+}

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

@@ -0,0 +1,31 @@
+import { DataPause } from '../data/data.pause';
+import { DataDuration } from '../data/data.duration';
+import { DataTimerTime } from '../data/data.timer-time';
+import { DataMovingTime } from '../data/data.moving-time';
+export interface DurationClassInterface {
+    startDate: Date;
+    endDate: Date;
+    /**
+     * Returns the duration in seconds
+     * (This excludes pauses)
+     */
+    getDuration(): DataDuration;
+    /**
+     * Returns the timer in seconds
+     * (This excludes pauses)
+     */
+    getTimer(): DataTimerTime;
+    /**
+     * Returns the moving time in seconds
+     * (This excludes pauses)
+     */
+    getMovingTime(): DataMovingTime;
+    /**
+     * Returns the paused time
+     */
+    getPause(): DataPause;
+    setDuration(duration: DataDuration): void;
+    setTimer(duration: DataTimerTime): void;
+    setMovingTime(duration: DataMovingTime): void;
+    setPause(pause: DataPause): void;
+}

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

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

package/lib/esm/errors/duration-exceeded-event-lib.error.d.ts

@@ -0,0 +1,6 @@
+import { EventLibError } from './event-lib.error';
+export declare class DurationExceededEventLibError extends EventLibError {
+    static readonly CODE: string;
+    readonly code: string;
+    constructor(message: string);
+}

package/lib/esm/errors/duration-exceeded-event-lib.error.js

@@ -0,0 +1,9 @@
+import { EventLibError } from './event-lib.error';
+export class DurationExceededEventLibError extends EventLibError {
+    constructor(message) {
+        super(message, null);
+        this.code = DurationExceededEventLibError.CODE;
+        Object.setPrototypeOf(this, DurationExceededEventLibError.prototype); // Set the prototype explicitly.
+    }
+}
+DurationExceededEventLibError.CODE = 'DURATION_EXCEEDED_EVENT_ERROR';

package/lib/esm/errors/empty-event-sports-libs.error.d.ts

@@ -0,0 +1,6 @@
+import { EventLibError } from './event-lib.error';
+export declare class EmptyEventLibError extends EventLibError {
+    static readonly CODE: string;
+    readonly code: string;
+    constructor(message?: string);
+}

package/lib/esm/errors/empty-event-sports-libs.error.js

@@ -0,0 +1,9 @@
+import { EventLibError } from './event-lib.error';
+export class EmptyEventLibError extends EventLibError {
+    constructor(message = 'No activities found') {
+        super(message, null);
+        this.code = EmptyEventLibError.CODE;
+        Object.setPrototypeOf(this, EmptyEventLibError.prototype); // Set the prototype explicitly.
+    }
+}
+EmptyEventLibError.CODE = 'EVENT_EMPTY_ERROR';

package/lib/esm/errors/event-lib.error.d.ts

@@ -0,0 +1,6 @@
+import { LibError } from './lib.error';
+import { EventInterface } from '../events/event.interface';
+export declare abstract class EventLibError extends LibError {
+    event: EventInterface | null;
+    protected constructor(message: string, event: EventInterface | null);
+}

package/lib/esm/errors/event-lib.error.js

@@ -0,0 +1,8 @@
+import { LibError } from './lib.error';
+export class EventLibError extends LibError {
+    constructor(message, event) {
+        super(message);
+        Object.setPrototypeOf(this, EventLibError.prototype); // Set the prototype explicitly.
+        this.event = event;
+    }
+}

package/lib/esm/errors/lib.error.d.ts

@@ -0,0 +1,4 @@
+export declare abstract class LibError extends Error {
+    abstract readonly code: string;
+    protected constructor(message: string);
+}

package/lib/esm/errors/lib.error.js

@@ -0,0 +1,6 @@
+export class LibError extends Error {
+    constructor(message) {
+        super(message);
+        Object.setPrototypeOf(this, LibError.prototype); // Set the prototype explicitly.
+    }
+}

package/lib/esm/errors/parsing-event-lib.error.d.ts

@@ -0,0 +1,6 @@
+import { EventLibError } from './event-lib.error';
+export declare class ParsingEventLibError extends EventLibError {
+    static readonly CODE: string;
+    readonly code: string;
+    constructor(message: string);
+}

package/lib/esm/errors/parsing-event-lib.error.js

@@ -0,0 +1,9 @@
+import { EventLibError } from './event-lib.error';
+export class ParsingEventLibError extends EventLibError {
+    constructor(message) {
+        super(message, null);
+        this.code = ParsingEventLibError.CODE;
+        Object.setPrototypeOf(this, ParsingEventLibError.prototype); // Set the prototype explicitly.
+    }
+}
+ParsingEventLibError.CODE = 'PARSING_LIB_ERROR';

package/lib/esm/events/adapters/exporters/exporter.gpx.d.ts

@@ -0,0 +1,7 @@
+import { EventInterface } from '../../event.interface';
+import { EventExporter } from './exporter.interface';
+export declare class EventExporterGPX implements EventExporter {
+    fileType: string;
+    fileExtension: string;
+    getAsString(event: EventInterface): Promise<string>;
+}