@sports-alliance/sports-lib 6.0.4 → 6.1.0

package/lib/esm/events/adapters/importers/fit/importer.fit.lezyne.device.names.d.ts

@@ -0,0 +1,3 @@
+export declare const ImporterFitLezyneDeviceNames: {
+    [index: number]: string;
+};

package/lib/esm/events/adapters/importers/fit/importer.fit.lezyne.device.names.js

@@ -0,0 +1,3 @@
+export const ImporterFitLezyneDeviceNames = {
+    4: 'Enhanced Super GPS'
+};

package/lib/esm/events/adapters/importers/fit/importer.fit.magellan.device.names.d.ts

@@ -0,0 +1,3 @@
+export declare const ImporterFitMagellanDeviceNames: {
+    [index: number]: string;
+};

package/lib/esm/events/adapters/importers/fit/importer.fit.magellan.device.names.js

@@ -0,0 +1,5 @@
+export const ImporterFitMagellanDeviceNames = {
+    105: 'Cyclo 105',
+    315: 'Cyclo 315',
+    505: 'Cyclo 505'
+};

package/lib/esm/events/adapters/importers/fit/importer.fit.mapper.d.ts

@@ -0,0 +1,5 @@
+import { SampleInfo } from '../sample-info.interface';
+export declare const FITSampleMapper: {
+    dataType: string;
+    getSampleValue(sample: any, sampleInfo?: SampleInfo): number | null;
+}[];

package/lib/esm/events/adapters/importers/fit/importer.fit.mapper.js

@@ -0,0 +1,219 @@
+import { DataLatitudeDegrees } from '../../../../data/data.latitude-degrees';
+import { DataAltitude } from '../../../../data/data.altitude';
+import { DataHeartRate } from '../../../../data/data.heart-rate';
+import { DataCadence } from '../../../../data/data.cadence';
+import { DataTemperature } from '../../../../data/data.temperature';
+import { DataDistance } from '../../../../data/data.distance';
+import { DataSpeed } from '../../../../data/data.speed';
+import { DataVerticalSpeed } from '../../../../data/data.vertical-speed';
+import { DataPower } from '../../../../data/data.power';
+import { DataLongitudeDegrees } from '../../../../data/data.longitude-degrees';
+import { DataFormPower } from '../../../../data/data.form-power';
+import { DataLegStiffness } from '../../../../data/data.leg-stiffness';
+import { DataVerticalOscillation } from '../../../../data/data.vertical-oscillation';
+import { isNumber } from '../../../utilities/helpers';
+import { DataAccumulatedPower } from '../../../../data/data.accumulated-power';
+import { DataStrydAltitude } from '../../../../data/data.stryd-altitude';
+import { DataStrydDistance } from '../../../../data/data.stryd-distance';
+import { DataStrydSpeed } from '../../../../data/data.stryd-speed';
+import { DataRightBalance } from '../../../../data/data.right-balance';
+import { DataLeftBalance } from '../../../../data/data.left-balance';
+import { DataStanceTime } from '../../../../data/data.stance-time';
+import { DataStanceTimeBalanceLeft } from '../../../../data/data-stance-time-balance-left';
+import { DataStepLength } from '../../../../data/data.step-length';
+import { DataVerticalRatio } from '../../../../data/data.vertical-ratio';
+import { DataGroundTime } from '../../../../data/data.ground-time';
+import { DataAirPower } from '../../../../data/data.air-power';
+import { ALTITUDE_PRECISION_NUMBER_OF_DECIMAL_PLACES, GNSS_DEGREES_PRECISION_NUMBER_OF_DECIMAL_PLACES } from '../../../../constants/constants';
+export const FITSampleMapper = [
+    {
+        dataType: DataLatitudeDegrees.type,
+        getSampleValue: (sample) => {
+            return isNumber(sample.position_lat)
+                ? Math.round(sample.position_lat * Math.pow(10, GNSS_DEGREES_PRECISION_NUMBER_OF_DECIMAL_PLACES)) /
+                    Math.pow(10, GNSS_DEGREES_PRECISION_NUMBER_OF_DECIMAL_PLACES)
+                : sample.position_lat;
+        }
+    },
+    {
+        dataType: DataLongitudeDegrees.type,
+        getSampleValue: (sample) => {
+            return isNumber(sample.position_long)
+                ? Math.round(sample.position_long * Math.pow(10, GNSS_DEGREES_PRECISION_NUMBER_OF_DECIMAL_PLACES)) /
+                    Math.pow(10, GNSS_DEGREES_PRECISION_NUMBER_OF_DECIMAL_PLACES)
+                : sample.position_long;
+        }
+    },
+    {
+        dataType: DataDistance.type,
+        getSampleValue: (sample) => {
+            return sample.distance;
+        }
+    },
+    {
+        dataType: DataHeartRate.type,
+        getSampleValue: (sample) => {
+            return sample.heart_rate;
+        }
+    },
+    {
+        dataType: DataAltitude.type,
+        getSampleValue: (sample) => {
+            return isNumber(sample.enhanced_altitude)
+                ? Math.round(sample.enhanced_altitude * Math.pow(10, ALTITUDE_PRECISION_NUMBER_OF_DECIMAL_PLACES)) /
+                    Math.pow(10, ALTITUDE_PRECISION_NUMBER_OF_DECIMAL_PLACES)
+                : isNumber(sample.altitude)
+                    ? Math.round(sample.altitude * Math.pow(10, ALTITUDE_PRECISION_NUMBER_OF_DECIMAL_PLACES)) /
+                        Math.pow(10, ALTITUDE_PRECISION_NUMBER_OF_DECIMAL_PLACES)
+                    : sample.altitude;
+        }
+    },
+    {
+        dataType: DataStrydAltitude.type,
+        getSampleValue: (sample) => {
+            return isNumber(sample.Elevation)
+                ? Math.round(sample.Elevation * Math.pow(10, ALTITUDE_PRECISION_NUMBER_OF_DECIMAL_PLACES)) /
+                    Math.pow(10, ALTITUDE_PRECISION_NUMBER_OF_DECIMAL_PLACES)
+                : sample.Elevation;
+        }
+    },
+    {
+        dataType: DataStrydDistance.type,
+        getSampleValue: (sample) => {
+            return sample.Distance;
+        }
+    },
+    {
+        dataType: DataStrydSpeed.type,
+        getSampleValue: (sample) => {
+            return sample.Speed;
+        }
+    },
+    {
+        dataType: DataCadence.type,
+        getSampleValue: (sample) => {
+            let cadenceValue = sample.cadence;
+            if (isNumber(sample.fractional_cadence)) {
+                cadenceValue += sample.fractional_cadence;
+            }
+            return cadenceValue;
+        }
+    },
+    {
+        dataType: DataSpeed.type,
+        getSampleValue: (sample) => {
+            if (Number.isFinite(sample.enhanced_speed)) {
+                return sample.enhanced_speed;
+            }
+            if (Number.isFinite(sample.speed)) {
+                return sample.speed;
+            }
+            return null;
+        }
+    },
+    {
+        dataType: DataVerticalSpeed.type,
+        getSampleValue: (sample) => {
+            return sample.vertical_speed;
+        }
+    },
+    {
+        dataType: DataPower.type,
+        getSampleValue: (sample, sampleInfo) => {
+            // Ensure power stream compliance when in some cases power sample field could be missing even if others samples have it
+            // Just set watts to 0 when this happen
+            // Case example: ride file "7432332116.fit"  from integration tests
+            const watts = isNumber(sample.power) ? sample.power : isNumber(sample.Power) ? sample.Power : sample.RP_Power;
+            return (sampleInfo === null || sampleInfo === void 0 ? void 0 : sampleInfo.hasPowerMeter) ? watts || 0 : null;
+        }
+    },
+    {
+        dataType: DataAccumulatedPower.type,
+        getSampleValue: (sample) => {
+            return sample.accumulated_power;
+        }
+    },
+    {
+        dataType: DataTemperature.type,
+        getSampleValue: (sample) => {
+            return sample.temperature;
+        }
+    },
+    {
+        dataType: DataFormPower.type,
+        getSampleValue: (sample) => {
+            return sample['Form Power'];
+        }
+    },
+    {
+        dataType: DataAirPower.type,
+        getSampleValue: (sample) => {
+            return sample['Air Power'];
+        }
+    },
+    {
+        dataType: DataGroundTime.type,
+        getSampleValue: (sample) => {
+            return sample['Ground Time'] / 1000;
+        }
+    },
+    {
+        dataType: DataLegStiffness.type,
+        getSampleValue: (sample) => {
+            return sample['Leg Spring Stiffness'];
+        }
+    },
+    {
+        dataType: DataVerticalOscillation.type,
+        getSampleValue: (sample) => {
+            return sample.vertical_oscillation;
+        }
+    },
+    {
+        dataType: DataRightBalance.type,
+        getSampleValue: (sample) => {
+            if (!sample.left_right_balance) {
+                return null;
+            }
+            return sample.left_right_balance.right === true
+                ? sample.left_right_balance.value
+                : 100 - sample.left_right_balance.value;
+        }
+    },
+    // @todo if conservation of data is needed this can be taken of and generated on the fly
+    {
+        dataType: DataLeftBalance.type,
+        getSampleValue: (sample) => {
+            if (!sample.left_right_balance) {
+                return null;
+            }
+            return sample.left_right_balance.right === false
+                ? sample.left_right_balance.value
+                : 100 - sample.left_right_balance.value;
+        }
+    },
+    {
+        dataType: DataStanceTime.type,
+        getSampleValue: (sample) => {
+            return sample.stance_time;
+        }
+    },
+    {
+        dataType: DataStanceTimeBalanceLeft.type,
+        getSampleValue: (sample) => {
+            return sample.stance_time_balance; // The field sample refers to the balance on left leg
+        }
+    },
+    {
+        dataType: DataStepLength.type,
+        getSampleValue: (sample) => {
+            return sample.step_length / 1000;
+        }
+    },
+    {
+        dataType: DataVerticalRatio.type,
+        getSampleValue: (sample) => {
+            return sample.vertical_ratio;
+        }
+    }
+];

package/lib/esm/events/adapters/importers/fit/importer.fit.saris.device.names.d.ts

@@ -0,0 +1,3 @@
+export declare const ImporterFitSarisDeviceNames: {
+    [index: number]: string;
+};

package/lib/esm/events/adapters/importers/fit/importer.fit.saris.device.names.js

@@ -0,0 +1,3 @@
+export const ImporterFitSarisDeviceNames = {
+    22: 'PowerTap Joule GPS+'
+};

package/lib/esm/events/adapters/importers/fit/importer.fit.spec.d.ts

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

package/lib/esm/events/adapters/importers/fit/importer.fit.spec.js

@@ -0,0 +1,326 @@
+import { EventImporterFIT } from './importer.fit';
+describe('EventImporterFIT', () => {
+    describe('Handle device creator', () => {
+        function generateFitDeviceDataObject(manufacturer = null, productId = -1, productName = null) {
+            const data = {};
+            if (manufacturer !== null) {
+                data.manufacturer = manufacturer;
+            }
+            if (productId !== -1) {
+                data.product = productId;
+            }
+            if (productName) {
+                data.product_name = productName;
+            }
+            return {
+                file_ids: [data]
+            };
+        }
+        describe('Recognized', () => {
+            it('should recognize a known Suunto device', done => {
+                const manufacturer = 'suunto';
+                const expectedName = 'Suunto Ambit3 Peak';
+                const productId = 22;
+                const fitDataObject = generateFitDeviceDataObject(manufacturer, productId);
+                // When
+                const creator = EventImporterFIT.getCreatorFromFitDataObject(fitDataObject);
+                // Then
+                expect(creator.isRecognized).toBeTruthy();
+                expect(creator.name).toEqual(expectedName);
+                expect(creator.manufacturer).toEqual(manufacturer);
+                done();
+            });
+            it('should recognize a known Coros device', done => {
+                const manufacturer = 'coros';
+                const expectedName = 'Coros APEX Pro';
+                const productId = 841;
+                const fitDataObject = generateFitDeviceDataObject(manufacturer, productId);
+                // When
+                const creator = EventImporterFIT.getCreatorFromFitDataObject(fitDataObject);
+                // Then
+                expect(creator.isRecognized).toBeTruthy();
+                expect(creator.name).toEqual(expectedName);
+                expect(creator.manufacturer).toEqual(manufacturer);
+                done();
+            });
+            it('should recognize a known Garmin device', done => {
+                const manufacturer = 'garmin';
+                const expectedName = 'Garmin Edge 1000';
+                const productId = 2274;
+                const fitDataObject = generateFitDeviceDataObject(manufacturer, productId);
+                // When
+                const creator = EventImporterFIT.getCreatorFromFitDataObject(fitDataObject);
+                // Then
+                expect(creator.isRecognized).toBeTruthy();
+                expect(creator.name).toEqual(expectedName);
+                expect(creator.manufacturer).toEqual(manufacturer);
+                done();
+            });
+            it('should recognize a known Wahoo device', done => {
+                const manufacturer = 'wahoo_fitness';
+                const expectedName = 'Wahoo ELEMNT BOLT';
+                const productId = 31;
+                const fitDataObject = generateFitDeviceDataObject(manufacturer, productId);
+                // When
+                const creator = EventImporterFIT.getCreatorFromFitDataObject(fitDataObject);
+                // Then
+                expect(creator.isRecognized).toBeTruthy();
+                expect(creator.name).toEqual(expectedName);
+                expect(creator.manufacturer).toEqual(manufacturer);
+                done();
+            });
+            it('should recognize a known hammerhead device', done => {
+                const manufacturer = 'hammerhead';
+                const expectedName = 'Hammerhead Karoo 2';
+                const productId = 2;
+                const fitDataObject = generateFitDeviceDataObject(manufacturer, productId);
+                // When
+                const creator = EventImporterFIT.getCreatorFromFitDataObject(fitDataObject);
+                // Then
+                expect(creator.isRecognized).toBeTruthy();
+                expect(creator.name).toEqual(expectedName);
+                expect(creator.manufacturer).toEqual(manufacturer);
+                done();
+            });
+            it('should recognize a known SRM device', done => {
+                const manufacturer = 'srm';
+                const expectedName = 'Srm PC8';
+                const productId = 8;
+                const fitDataObject = generateFitDeviceDataObject(manufacturer, productId);
+                // When
+                const creator = EventImporterFIT.getCreatorFromFitDataObject(fitDataObject);
+                // Then
+                expect(creator.isRecognized).toBeTruthy();
+                expect(creator.name).toEqual(expectedName);
+                expect(creator.manufacturer).toEqual(manufacturer);
+                done();
+            });
+            it('should recognize a known zwift virtual device', done => {
+                const manufacturer = 'zwift';
+                const expectedName = 'Zwift';
+                const fitDataObject = generateFitDeviceDataObject(manufacturer);
+                // When
+                const creator = EventImporterFIT.getCreatorFromFitDataObject(fitDataObject);
+                // Then
+                expect(creator.isRecognized).toBeTruthy();
+                expect(creator.name).toEqual(expectedName);
+                expect(creator.manufacturer).toEqual(manufacturer);
+                done();
+            });
+            it('should recognize a known Rouvy virtual device', done => {
+                const manufacturer = 'virtualtraining';
+                const expectedName = 'Rouvy';
+                const fitDataObject = generateFitDeviceDataObject(manufacturer, 1);
+                // When
+                const creator = EventImporterFIT.getCreatorFromFitDataObject(fitDataObject);
+                // Then
+                expect(creator.isRecognized).toBeTruthy();
+                expect(creator.name).toEqual(expectedName);
+                expect(creator.manufacturer).toEqual(manufacturer);
+                done();
+            });
+            it('should recognize a known Wahoo SYSTM virtual device', done => {
+                const manufacturer = 'the_sufferfest';
+                const expectedName = 'Wahoo SYSTM';
+                const productId = 1231;
+                const fitDataObject = generateFitDeviceDataObject(manufacturer, productId);
+                // When
+                const creator = EventImporterFIT.getCreatorFromFitDataObject(fitDataObject);
+                // Then
+                expect(creator.isRecognized).toBeTruthy();
+                expect(creator.name).toEqual(expectedName);
+                expect(creator.manufacturer).toEqual(manufacturer);
+                done();
+            });
+            it('should recognize a known development device', done => {
+                const manufacturer = 'development';
+                const expectedName = 'Zwift';
+                const productId = 15706;
+                const fitDataObject = generateFitDeviceDataObject(manufacturer, productId);
+                // When
+                const creator = EventImporterFIT.getCreatorFromFitDataObject(fitDataObject);
+                // Then
+                expect(creator.isRecognized).toBeTruthy();
+                expect(creator.name).toEqual(expectedName);
+                expect(creator.manufacturer).toEqual(manufacturer);
+                done();
+            });
+        });
+        describe('Non recognized', () => {
+            describe('Known manufacturer with unknown productId & known product name', () => {
+                it('should format a non-recognized development device with known productId & unknown product name', done => {
+                    const manufacturer = 'development';
+                    const productId = 42;
+                    const expectedName = 'Unknown';
+                    const fitDataObject = generateFitDeviceDataObject(manufacturer, productId);
+                    // When
+                    const creator = EventImporterFIT.getCreatorFromFitDataObject(fitDataObject);
+                    // Then
+                    expect(creator.isRecognized).toBeTruthy();
+                    expect(creator.name).toEqual(expectedName);
+                    expect(creator.manufacturer).toEqual(manufacturer);
+                    done();
+                });
+            });
+            describe('Known manufacturer with unknown productId & known product name', () => {
+                it('should format a non-recognized Coros device with unknown productId & known product name', done => {
+                    const manufacturer = 'coros';
+                    const productId = Math.random();
+                    const productName = 'COROS REFLEX Fake';
+                    const expectedName = 'Coros REFLEX Fake';
+                    const fitDataObject = generateFitDeviceDataObject(manufacturer, productId, productName);
+                    // When
+                    const creator = EventImporterFIT.getCreatorFromFitDataObject(fitDataObject);
+                    // Then
+                    expect(creator.isRecognized).toBeFalsy();
+                    expect(creator.name).toEqual(expectedName);
+                    expect(creator.manufacturer).toEqual(manufacturer);
+                    done();
+                });
+                it('should format a non-recognized Wahoo device with unknown productId & known product name', done => {
+                    const manufacturer = 'wahoo_fitness';
+                    const productId = Math.random();
+                    const productName = 'Fake';
+                    const expectedName = 'Wahoo Fake';
+                    const fitDataObject = generateFitDeviceDataObject(manufacturer, productId, productName);
+                    // When
+                    const creator = EventImporterFIT.getCreatorFromFitDataObject(fitDataObject);
+                    // Then
+                    expect(creator.isRecognized).toBeFalsy();
+                    expect(creator.name).toEqual(expectedName);
+                    expect(creator.manufacturer).toEqual(manufacturer);
+                    done();
+                });
+            });
+            describe('Known manufacturer with unknown productId & missing product name', () => {
+                it('should format a non-recognized Suunto device with unknown productId & missing product name', done => {
+                    const manufacturer = 'suunto';
+                    const expectedName = 'Suunto';
+                    const productId = Math.random();
+                    const fitDataObject = generateFitDeviceDataObject(manufacturer, productId);
+                    // When
+                    const creator = EventImporterFIT.getCreatorFromFitDataObject(fitDataObject);
+                    // Then
+                    expect(creator.isRecognized).toBeFalsy();
+                    expect(creator.name).toEqual(expectedName);
+                    expect(creator.manufacturer).toEqual(manufacturer);
+                    done();
+                });
+                it('should format a non-recognized Garmin device with unknown productId & missing product name', done => {
+                    const manufacturer = 'garmin';
+                    const expectedName = 'Garmin';
+                    const productId = Math.random();
+                    const fitDataObject = generateFitDeviceDataObject(manufacturer, productId);
+                    // When
+                    const creator = EventImporterFIT.getCreatorFromFitDataObject(fitDataObject);
+                    // Then
+                    expect(creator.isRecognized).toBeFalsy();
+                    expect(creator.name).toEqual(expectedName);
+                    expect(creator.manufacturer).toEqual(manufacturer);
+                    done();
+                });
+                it('should format a non-recognized Wahoo device with unknown productId & missing product name', done => {
+                    const manufacturer = 'wahoo_fitness';
+                    const expectedName = 'Wahoo';
+                    const productId = Math.random();
+                    const fitDataObject = generateFitDeviceDataObject(manufacturer, productId);
+                    // When
+                    const creator = EventImporterFIT.getCreatorFromFitDataObject(fitDataObject);
+                    // Then
+                    expect(creator.isRecognized).toBeFalsy();
+                    expect(creator.name).toEqual(expectedName);
+                    expect(creator.manufacturer).toEqual(manufacturer);
+                    done();
+                });
+            });
+            describe('Known manufacturer with missing productId & missing product name', () => {
+                it('should format a non-recognized Suunto device without productId && product name', done => {
+                    const manufacturer = 'suunto';
+                    const expectedName = 'Suunto';
+                    const fitDataObject = generateFitDeviceDataObject(manufacturer);
+                    // When
+                    const creator = EventImporterFIT.getCreatorFromFitDataObject(fitDataObject);
+                    // Then
+                    expect(creator.isRecognized).toBeFalsy();
+                    expect(creator.name).toEqual(expectedName);
+                    expect(creator.manufacturer).toEqual(manufacturer);
+                    done();
+                });
+                it('should format a non-recognized Garmin device without productId && product name', done => {
+                    const manufacturer = 'garmin';
+                    const expectedName = 'Garmin';
+                    const fitDataObject = generateFitDeviceDataObject(manufacturer);
+                    // When
+                    const creator = EventImporterFIT.getCreatorFromFitDataObject(fitDataObject);
+                    // Then
+                    expect(creator.isRecognized).toBeFalsy();
+                    expect(creator.name).toEqual(expectedName);
+                    expect(creator.manufacturer).toEqual(manufacturer);
+                    done();
+                });
+                it('should format a non-recognized Garmin device without productId && product name', done => {
+                    const manufacturer = 'wahoo_fitness';
+                    const expectedName = 'Wahoo';
+                    const fitDataObject = generateFitDeviceDataObject(manufacturer);
+                    // When
+                    const creator = EventImporterFIT.getCreatorFromFitDataObject(fitDataObject);
+                    // Then
+                    expect(creator.isRecognized).toBeFalsy();
+                    expect(creator.name).toEqual(expectedName);
+                    expect(creator.manufacturer).toEqual(manufacturer);
+                    done();
+                });
+            });
+            describe('Unknown manufacturer with missing productId & missing product name', () => {
+                it('should format a non-recognized Suunto device without productId && product name', done => {
+                    const manufacturer = 'reactive';
+                    const expectedName = 'Reactive';
+                    const fitDataObject = generateFitDeviceDataObject(manufacturer);
+                    // When
+                    const creator = EventImporterFIT.getCreatorFromFitDataObject(fitDataObject);
+                    // Then
+                    expect(creator.isRecognized).toBeFalsy();
+                    expect(creator.name).toEqual(expectedName);
+                    expect(creator.manufacturer).toEqual(manufacturer);
+                    done();
+                });
+                it('should format a non-recognized Garmin device without productId && product name', done => {
+                    const manufacturer = 'high_cadence_fitness';
+                    const expectedName = 'High Cadence Fitness';
+                    const fitDataObject = generateFitDeviceDataObject(manufacturer);
+                    // When
+                    const creator = EventImporterFIT.getCreatorFromFitDataObject(fitDataObject);
+                    // Then
+                    expect(creator.isRecognized).toBeFalsy();
+                    expect(creator.name).toEqual(expectedName);
+                    expect(creator.manufacturer).toEqual(manufacturer);
+                    done();
+                });
+            });
+            describe('Empty manufacturer with missing productId & missing product name', () => {
+                it('should format a non-recognized device without manufacturer, productId && product name (1)', done => {
+                    const manufacturer = 0;
+                    const expectedName = 'Unknown';
+                    const fitDataObject = generateFitDeviceDataObject(manufacturer);
+                    // When
+                    const creator = EventImporterFIT.getCreatorFromFitDataObject(fitDataObject);
+                    // Then
+                    expect(creator.isRecognized).toBeFalsy();
+                    expect(creator.name).toEqual(expectedName);
+                    expect(creator.manufacturer).toEqual(manufacturer);
+                    done();
+                });
+                it('should format a non-recognized device without manufacturer, productId && product name (2)', done => {
+                    const expectedName = 'Unknown';
+                    const fitDataObject = generateFitDeviceDataObject();
+                    // When
+                    const creator = EventImporterFIT.getCreatorFromFitDataObject(fitDataObject);
+                    // Then
+                    expect(creator.isRecognized).toBeFalsy();
+                    expect(creator.name).toEqual(expectedName);
+                    done();
+                });
+            });
+        });
+    });
+});

package/lib/esm/events/adapters/importers/fit/importer.fit.srm.device.names.d.ts

@@ -0,0 +1,3 @@
+export declare const ImporterFitSrmDeviceNames: {
+    [index: number]: string;
+};

package/lib/esm/events/adapters/importers/fit/importer.fit.srm.device.names.js

@@ -0,0 +1,7 @@
+const POWER_CONTROL = 'PC';
+export const ImporterFitSrmDeviceNames = {
+    5: POWER_CONTROL + '5',
+    6: POWER_CONTROL + '6',
+    7: POWER_CONTROL + '7',
+    8: POWER_CONTROL + '8'
+};

package/lib/esm/events/adapters/importers/fit/importer.fit.suunto.device.names.d.ts

@@ -0,0 +1,3 @@
+export declare const ImporterFitSuuntoDeviceNames: {
+    [index: number]: string;
+};

package/lib/esm/events/adapters/importers/fit/importer.fit.suunto.device.names.js

@@ -0,0 +1,15 @@
+import { ImporterSuuntoDeviceNames } from '../suunto/importer.suunto.device.names';
+export const ImporterFitSuuntoDeviceNames = {
+    28: ImporterSuuntoDeviceNames.Brighton,
+    29: ImporterSuuntoDeviceNames.Amsterdam,
+    34: ImporterSuuntoDeviceNames.Ibiza,
+    35: ImporterSuuntoDeviceNames.Lima,
+    36: ImporterSuuntoDeviceNames.Monza,
+    32: ImporterSuuntoDeviceNames.Gdansk,
+    31: ImporterSuuntoDeviceNames.Forssa,
+    30: ImporterSuuntoDeviceNames.Cairo,
+    22: ImporterSuuntoDeviceNames['Ambit3 Peak'],
+    23: ImporterSuuntoDeviceNames['Ambit3 Sport'],
+    24: ImporterSuuntoDeviceNames['Ambit3 Run'],
+    25: ImporterSuuntoDeviceNames['Ambit3 Vertical']
+};

package/lib/esm/events/adapters/importers/fit/importer.fit.wahoo.device.names.d.ts

@@ -0,0 +1,3 @@
+export declare const ImporterFitWahooDeviceNames: {
+    [index: number]: string;
+};

package/lib/esm/events/adapters/importers/fit/importer.fit.wahoo.device.names.js

@@ -0,0 +1,6 @@
+export const ImporterFitWahooDeviceNames = {
+    28: 'ELEMNT',
+    31: 'ELEMNT BOLT',
+    37: 'ELEMNT ROAM',
+    43: 'ELEMNT BOLT'
+};

package/lib/esm/events/adapters/importers/gpx/gx-parser.d.ts

@@ -0,0 +1,4 @@
+export declare class GXParser {
+    constructor(xml: string, domParser?: any);
+    private parseChild;
+}