@sports-alliance/sports-lib 7.0.8 → 7.0.9

package/lib/esm/events/adapters/importers/gpx/importer.gpx.integration.spec.js

@@ -1,44 +0,0 @@
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-import * as fs from 'fs';
-import * as path from 'path';
-import { DOMParser } from '@xmldom/xmldom';
-import { EventImporterGPX } from './importer.gpx';
-describe('EventImporterGPX Integration', () => {
-    // Go up 5 levels from src/events/adapters/importers/gpx -> sports-lib root
-    const samplesDir = path.resolve(__dirname, '../../../../../samples/gpx');
-    it('should parse all sample gpx files', () => __awaiter(void 0, void 0, void 0, function* () {
-        if (!fs.existsSync(samplesDir)) {
-            console.warn(`Samples directory not found at ${samplesDir}. Skipping integration tests.`);
-            return;
-        }
-        const files = fs.readdirSync(samplesDir).filter(f => f.endsWith('.gpx'));
-        if (files.length === 0) {
-            console.warn('No .gpx files found in samples directory.');
-            return;
-        }
-        console.log(`Found ${files.length} .gpx files to test:`, files);
-        for (const file of files) {
-            const filePath = path.join(samplesDir, file);
-            const fileString = fs.readFileSync(filePath, 'utf-8');
-            try {
-                // Pass DOMParser constructor as 2nd argument
-                const event = yield EventImporterGPX.getFromString(fileString, DOMParser, undefined, file);
-                expect(event).toBeDefined();
-                expect(event.getActivities().length).toBeGreaterThan(0);
-                console.log(`✅ Successfully parsed ${file}`);
-            }
-            catch (error) {
-                console.error(`❌ Failed to parse ${file}:`, error);
-                throw error;
-            }
-        }
-    }));
-});

package/lib/esm/events/adapters/importers/gpx/importer.gpx.js

@@ -1,102 +0,0 @@
-import { Activity } from '../../../../activities/activity';
-import { Creator } from '../../../../creators/creator';
-import { Event } from '../../../event';
-import { ActivityTypes, StravaGPXTypes } from '../../../../activities/activity.types';
-import { GPXSampleMapper } from './importer.gpx.mapper';
-import { isNumberOrString } from '../../../utilities/helpers';
-import { EventUtilities } from '../../../utilities/event.utilities';
-import { GXParser } from './gx-parser';
-import { DataDuration } from '../../../../data/data.duration';
-import { DataTimerTime } from '../../../../data/data.timer-time';
-import { FileType } from '../../file-type.enum';
-import { ActivityParsingOptions } from '../../../../activities/activity-parsing-options';
-import { EmptyEventLibError } from '../../../../errors/empty-event-sports-libs.error';
-export class EventImporterGPX {
-    static getFromString(gpx, domParser, options = ActivityParsingOptions.DEFAULT, name = 'New Event') {
-        return new Promise((resolve, reject) => {
-            // debugger
-            const parsedGPX = new GXParser(gpx, domParser);
-            const track = parsedGPX.trk || parsedGPX.rte;
-            if (!(track === null || track === void 0 ? void 0 : track.length)) {
-                reject(new EmptyEventLibError());
-            }
-            const activities = track.reduce((activities, trackOrRoute) => {
-                var _a, _b;
-                // Get the samples
-                let samples = [];
-                let isActivity = false;
-                if (trackOrRoute.trkseg) {
-                    samples = trackOrRoute.trkseg.reduce((trkptArray, trkseg) => {
-                        if (!trkseg.trkpt) {
-                            return trkptArray;
-                        }
-                        return trkptArray.concat(trkseg.trkpt);
-                    }, []);
-                    // Determine if it's a route. The samples will most probably be missing the time
-                    isActivity = !!((_a = samples[0]) === null || _a === void 0 ? void 0 : _a.time);
-                }
-                else if (trackOrRoute.rtept) {
-                    samples = trackOrRoute.rtept;
-                }
-                // Sort the points if its only an activity
-                if (isActivity) {
-                    // Filter samples having time data only for upcoming sort
-                    samples = samples.filter(sample => {
-                        return !!sample.time;
-                    });
-                    // Sort samples !
-                    samples.sort((sampleA, sampleB) => {
-                        return +new Date(sampleA.time[0]) - +new Date(sampleB.time[0]);
-                    });
-                }
-                // Create an activity. Set the dates depending on route etc
-                const startDate = new Date(isActivity ? samples[0].time[0] : new Date());
-                // @todo for routes add a separate parser
-                const endDate = isActivity
-                    ? new Date(samples[samples.length - 1].time[0])
-                    : new Date(startDate.getTime() + (samples.length > 0 ? samples.length - 1 : 0) * 1000);
-                let activityType = isActivity ? ActivityTypes.unknown : ActivityTypes.route;
-                if (trackOrRoute.type && ActivityTypes[trackOrRoute.type]) {
-                    activityType = ActivityTypes[trackOrRoute.type];
-                }
-                else if (trackOrRoute.type && trackOrRoute.type[0] && parsedGPX.creator.match(/StravaGPX/gi) !== null) {
-                    const stravaGpxTypeId = parseInt(trackOrRoute.type[0], 10);
-                    const typeFound = StravaGPXTypes.map.get(stravaGpxTypeId);
-                    if (typeFound) {
-                        activityType = typeFound;
-                    }
-                }
-                const activityName = ((_b = trackOrRoute.name) === null || _b === void 0 ? void 0 : _b[0]) || '';
-                const activity = new Activity(startDate, endDate, activityType, new Creator(parsedGPX.creator, undefined, parsedGPX.version), options, activityName);
-                // Setup sample info which could be use when getting sample values
-                const hasPowerMeter = samples.findIndex(sample => { var _a; return (_a = sample.extensions) === null || _a === void 0 ? void 0 : _a.find((ext) => { var _a; return (_a = ext.power) === null || _a === void 0 ? void 0 : _a.length; }); }) !== -1;
-                const samplesInfo = { hasPowerMeter: hasPowerMeter };
-                // Match
-                GPXSampleMapper.forEach(sampleMapping => {
-                    const subjectSamples = (samples.filter((sample) => isNumberOrString(sampleMapping.getSampleValue(sample, samplesInfo))));
-                    if (subjectSamples.length) {
-                        activity.addStream(activity.createStream(sampleMapping.dataType));
-                        subjectSamples.forEach((subjectSample, index) => {
-                            activity.addDataToStream(sampleMapping.dataType, isActivity ? new Date(subjectSample.time[0]) : new Date(activity.startDate.getTime() + index * 1000), sampleMapping.getSampleValue(subjectSample, samplesInfo));
-                        });
-                    }
-                });
-                // Compute moving time, timer time and elapsed time
-                const elapsedTime = (activity.endDate.getTime() - activity.startDate.getTime()) / 1000;
-                const timerTime = elapsedTime;
-                // Apply stats
-                activity.addStat(new DataDuration(elapsedTime));
-                activity.addStat(new DataTimerTime(timerTime));
-                activities.push(activity);
-                return activities;
-            }, []);
-            const event = new Event(name, activities[0].startDate, activities[activities.length - 1].endDate, FileType.GPX);
-            activities.forEach(activity => {
-                event.addActivity(activity);
-            });
-            // generate global stats
-            EventUtilities.generateStatsForAll(event);
-            resolve(event);
-        });
-    }
-}

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

@@ -1,142 +0,0 @@
-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 { DataSeaLevelPressure } from '../../../../data/data.sea-level-pressure';
-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 { isNumberOrString } from '../../../utilities/helpers';
-export const GPXSampleMapper = [
-    {
-        dataType: DataLatitudeDegrees.type,
-        getSampleValue: sample => Number(sample.lat)
-    },
-    {
-        dataType: DataLongitudeDegrees.type,
-        getSampleValue: sample => Number(sample.lon)
-    },
-    {
-        dataType: DataAltitude.type,
-        getSampleValue: sample => (sample.ele ? Number(sample.ele[0]) : null)
-    },
-    {
-        dataType: DataHeartRate.type,
-        getSampleValue: sample => {
-            // debugger;
-            if (!sample.extensions || !sample.extensions.length) {
-                return null;
-            }
-            if (sample.extensions[0].heartrate && isNumberOrString(sample.extensions[0].heartrate[0])) {
-                return Number(sample.extensions[0].heartrate[0]);
-            }
-            if (sample.extensions[0].TrackPointExtension &&
-                sample.extensions[0].TrackPointExtension[0] &&
-                sample.extensions[0].TrackPointExtension[0].hr) {
-                return Number(sample.extensions[0].TrackPointExtension[0].hr[0]);
-            }
-            return null;
-        }
-    },
-    {
-        dataType: DataCadence.type,
-        getSampleValue: sample => {
-            // debugger;
-            if (!sample.extensions || !sample.extensions.length) {
-                return null;
-            }
-            if (sample.extensions[0].cadence && isNumberOrString(sample.extensions[0].cadence[0])) {
-                return Number(sample.extensions[0].cadence[0]);
-            }
-            if (sample.extensions[0].TrackPointExtension &&
-                sample.extensions[0].TrackPointExtension[0] &&
-                sample.extensions[0].TrackPointExtension[0].cad) {
-                return Number(sample.extensions[0].TrackPointExtension[0].cad[0]);
-            }
-            return null;
-        }
-    },
-    {
-        dataType: DataTemperature.type,
-        getSampleValue: sample => {
-            // debugger;
-            if (!sample.extensions || !sample.extensions.length) {
-                return null;
-            }
-            if (sample.extensions[0].temp && isNumberOrString(sample.extensions[0].temp[0])) {
-                return Number(sample.extensions[0].temp[0]);
-            }
-            if (sample.extensions[0].TrackPointExtension &&
-                sample.extensions[0].TrackPointExtension[0] &&
-                sample.extensions[0].TrackPointExtension[0].atemp) {
-                return Number(sample.extensions[0].TrackPointExtension[0].atemp[0]);
-            }
-            return null;
-        }
-    },
-    {
-        dataType: DataDistance.type,
-        getSampleValue: sample => {
-            if (!sample.extensions || !sample.extensions.length) {
-                return null;
-            }
-            if (sample.extensions[0].distance && isNumberOrString(sample.extensions[0].distance[0])) {
-                return Number(sample.extensions[0].distance[0]);
-            }
-            return null;
-        }
-    },
-    {
-        dataType: DataSeaLevelPressure.type,
-        getSampleValue: sample => {
-            if (!sample.extensions || !sample.extensions.length) {
-                return null;
-            }
-            if (sample.extensions[0].seaLevelPressure && isNumberOrString(sample.extensions[0].seaLevelPressure[0])) {
-                return Number(sample.extensions[0].seaLevelPressure[0]);
-            }
-            return null;
-        }
-    },
-    {
-        dataType: DataSpeed.type,
-        getSampleValue: sample => {
-            if (!sample.extensions || !sample.extensions.length) {
-                return null;
-            }
-            if (sample.extensions[0].speed && isNumberOrString(sample.extensions[0].speed[0])) {
-                return Number(sample.extensions[0].speed[0]);
-            }
-            return null;
-        }
-    },
-    {
-        dataType: DataVerticalSpeed.type,
-        getSampleValue: sample => {
-            if (!sample.extensions || !sample.extensions.length) {
-                return null;
-            }
-            if (sample.extensions[0].verticalSpeed && isNumberOrString(sample.extensions[0].verticalSpeed[0])) {
-                return Number(sample.extensions[0].verticalSpeed[0]);
-            }
-            return null;
-        }
-    },
-    {
-        dataType: DataPower.type,
-        getSampleValue: (sample, sampleInfo) => {
-            var _a;
-            let watts = null;
-            if (((_a = sample.extensions) === null || _a === void 0 ? void 0 : _a.length) && sample.extensions[0].power && isNumberOrString(sample.extensions[0].power[0])) {
-                watts = Number(sample.extensions[0].power[0]);
-            }
-            // 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 "7555261629.gpx"  from integration tests
-            return (sampleInfo === null || sampleInfo === void 0 ? void 0 : sampleInfo.hasPowerMeter) ? watts || 0 : null;
-        }
-    }
-];

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

@@ -1,71 +0,0 @@
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-import { EventImporterGPX } from './importer.gpx';
-import xmldom from '@xmldom/xmldom';
-describe('importer.gpx', () => {
-    it('parses gpx without name', () => __awaiter(void 0, void 0, void 0, function* () {
-        const gpxString = `<?xml version="1.0" encoding="UTF-8"?>
-        <gpx creator="Garmin Connect" version="1.1"
-          xsi:schemaLocation="http://www.topografix.com/GPX/1/1 http://www.topografix.com/GPX/11.xsd"
-          xmlns:ns3="http://www.garmin.com/xmlschemas/TrackPointExtension/v1"
-          xmlns="http://www.topografix.com/GPX/1/1"
-          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:ns2="http://www.garmin.com/xmlschemas/GpxExtensions/v3">
-          <metadata>
-            <link href="connect.garmin.com">
-              <text>Garmin Connect</text>
-            </link>
-            <time>2019-09-29T13:58:25.000Z</time>
-          </metadata>
-          <trk>
-            <type>road_biking</type>
-          </trk>
-        </gpx> `;
-        const result = yield EventImporterGPX.getFromString(gpxString, xmldom.DOMParser);
-        expect(result.getFirstActivity().name).toEqual('');
-    }));
-    it('parses gpx with name', () => __awaiter(void 0, void 0, void 0, function* () {
-        const gpxString = `<?xml version="1.0" encoding="UTF-8"?>
-        <gpx creator="Garmin Connect" version="1.1"
-          xsi:schemaLocation="http://www.topografix.com/GPX/1/1 http://www.topografix.com/GPX/11.xsd"
-          xmlns:ns3="http://www.garmin.com/xmlschemas/TrackPointExtension/v1"
-          xmlns="http://www.topografix.com/GPX/1/1"
-          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:ns2="http://www.garmin.com/xmlschemas/GpxExtensions/v3">
-          <metadata>
-            <link href="connect.garmin.com">
-              <text>Garmin Connect</text>
-            </link>
-            <time>2019-09-29T13:58:25.000Z</time>
-          </metadata>
-          <trk>
-            <name>Meylan Road Cycling</name>
-            <type>road_biking</type>
-          </trk>
-        </gpx> `;
-        const result = yield EventImporterGPX.getFromString(gpxString, xmldom.DOMParser);
-        expect(result.getFirstActivity().name).toEqual('Meylan Road Cycling');
-    }));
-    it('parses route.gpx from samples', () => __awaiter(void 0, void 0, void 0, function* () {
-        const fs = yield import('fs');
-        const path = yield import('path');
-        const samplesDir = path.resolve(__dirname, '../../../../../samples/gpx');
-        const filePath = path.join(samplesDir, 'route.gpx');
-        const fileString = fs.readFileSync(filePath, 'utf-8');
-        const result = yield EventImporterGPX.getFromString(fileString, xmldom.DOMParser);
-        expect(result.getActivities().length).toBeGreaterThan(0);
-        const activity = result.getFirstActivity();
-        expect(activity.type).toEqual('Route');
-        const distance = activity.getStat('Distance');
-        expect(distance).toBeDefined();
-        expect(distance.getValue()).toBeGreaterThan(0);
-        // Check if the number of samples matches the number of points in the GPX
-        const latStream = activity.getStream('Latitude');
-        expect(latStream.getData().length).toBe(2987); // I counted 2987 rtept earlier
-    }));
-});

package/lib/esm/events/adapters/importers/json/importer.json.js

@@ -1,160 +0,0 @@
-import { Event } from '../../../event';
-import { Activity } from '../../../../activities/activity';
-import { Lap } from '../../../../laps/lap';
-import { Creator } from '../../../../creators/creator';
-import { IntensityZones } from '../../../../intensity-zones/intensity-zones';
-import { DynamicDataLoader } from '../../../../data/data.store';
-import { LapTypes } from '../../../../laps/lap.types';
-import { ActivityTypes } from '../../../../activities/activity.types';
-import { Stream } from '../../../../streams/stream';
-import { DataIBI } from '../../../../data/data.ibi';
-import { IBIStream } from '../../../../streams/ibi-stream';
-import { Device } from '../../../../activities/devices/device';
-import { DataTime } from '../../../../data/data.time';
-export class EventImporterJSON {
-    static getEventFromJSON(json) {
-        const event = new Event(json.name, new Date(json.startDate), new Date(json.endDate), json.srcFileType, json.privacy, json.description || undefined, json.isMerge || false);
-        Object.keys(json.stats).forEach((statName) => {
-            event.addStat(DynamicDataLoader.getDataInstanceFromDataType(statName, json.stats[statName]));
-        });
-        return event;
-    }
-    static getCreatorFromJSON(json) {
-        const creator = new Creator(json.name || 'Unknown Device');
-        if (json.hwInfo) {
-            creator.hwInfo = json.hwInfo;
-        }
-        if (json.swInfo) {
-            creator.swInfo = json.swInfo;
-        }
-        if (json.serialNumber) {
-            creator.serialNumber = json.serialNumber;
-        }
-        if (json.manufacturer) {
-            creator.manufacturer = json.manufacturer;
-        }
-        if (json.isRecognized) {
-            creator.isRecognized = json.isRecognized;
-        }
-        if (json.productId) {
-            creator.productId = json.productId;
-        }
-        if (json.devices && json.devices.length) {
-            json.devices.forEach(jsonDevice => creator.devices.push(this.getDeviceFromJSON(jsonDevice)));
-        }
-        return creator;
-    }
-    static getDeviceFromJSON(json) {
-        const device = new Device(json.type);
-        if (json.index) {
-            device.index = json.index;
-        }
-        if (json.name) {
-            device.name = json.name;
-        }
-        if (json.batteryStatus) {
-            device.batteryStatus = json.batteryStatus;
-        }
-        if (json.batteryLevel) {
-            device.batteryLevel = json.batteryLevel;
-        }
-        if (json.batteryVoltage) {
-            device.batteryVoltage = json.batteryVoltage;
-        }
-        if (json.manufacturer) {
-            device.manufacturer = json.manufacturer;
-        }
-        if (json.serialNumber) {
-            device.serialNumber = json.serialNumber;
-        }
-        if (json.product) {
-            device.product = json.product;
-        }
-        if (json.swInfo) {
-            device.swInfo = json.swInfo;
-        }
-        if (json.hwInfo) {
-            device.hwInfo = json.hwInfo;
-        }
-        if (json.antDeviceNumber) {
-            device.antDeviceNumber = json.antDeviceNumber;
-        }
-        if (json.antTransmissionType) {
-            device.antTransmissionType = json.antTransmissionType;
-        }
-        if (json.antNetwork) {
-            device.antNetwork = json.antNetwork;
-        }
-        if (json.sourceType) {
-            device.sourceType = json.sourceType;
-        }
-        if (json.cumOperatingTime) {
-            device.cumOperatingTime = json.cumOperatingTime;
-        }
-        return device;
-    }
-    static getLapFromJSON(json, lapIndex) {
-        const lap = new Lap(new Date(json.startDate), new Date(json.endDate), lapIndex + 1, LapTypes[json.type]);
-        Object.keys(json.stats).forEach((statName) => {
-            lap.addStat(DynamicDataLoader.getDataInstanceFromDataType(statName, json.stats[statName]));
-        });
-        return lap;
-    }
-    static getStreamFromJSON(json) {
-        if (json.type === DataIBI.type) {
-            return new IBIStream(json.data);
-        }
-        return new Stream(json.type, json.data);
-    }
-    static getIntensityZonesFromJSON(json) {
-        const zones = new IntensityZones(json.type);
-        zones.zone1Duration = json.zone1Duration;
-        zones.zone2Duration = json.zone2Duration;
-        zones.zone2LowerLimit = json.zone2LowerLimit;
-        zones.zone3Duration = json.zone3Duration;
-        zones.zone3LowerLimit = json.zone3LowerLimit;
-        zones.zone4Duration = json.zone4Duration;
-        zones.zone4LowerLimit = json.zone4LowerLimit;
-        zones.zone5Duration = json.zone5Duration;
-        zones.zone5LowerLimit = json.zone5LowerLimit;
-        return zones;
-    }
-    static getActivityEventFromJSON(json) {
-        return (DynamicDataLoader.getDataInstanceFromDataType(Object.keys(json)[0], Object.values(json)[0]));
-    }
-    static getActivityFromJSON(json) {
-        const activity = new Activity(new Date(json.startDate), new Date(json.endDate), ActivityTypes[json.type], EventImporterJSON.getCreatorFromJSON(json.creator));
-        Object.keys(json.stats).forEach((statName) => {
-            activity.addStat(DynamicDataLoader.getDataInstanceFromDataType(statName, json.stats[statName]));
-        });
-        json.laps.forEach((lapJSON, index) => {
-            activity.addLap(EventImporterJSON.getLapFromJSON(lapJSON, index));
-        });
-        if (Array.isArray(json.streams)) {
-            json.streams.forEach((streamJson) => {
-                if (streamJson.type === DataTime.type) {
-                    return;
-                }
-                activity.addStream(EventImporterJSON.getStreamFromJSON(streamJson));
-            });
-        }
-        else {
-            Object.keys(json.streams).forEach(streamKey => {
-                const streamJson = {
-                    type: streamKey,
-                    data: json.streams[streamKey]
-                };
-                activity.addStream(EventImporterJSON.getStreamFromJSON(streamJson));
-            });
-        }
-        json.intensityZones.forEach(intensityZonesJSON => {
-            activity.intensityZones.push(EventImporterJSON.getIntensityZonesFromJSON(intensityZonesJSON));
-        });
-        if (json.events) {
-            json.events.forEach(activityEvent => {
-                activity.addEvent(this.getActivityEventFromJSON(activityEvent));
-            });
-        }
-        return activity;
-    }
-}

package/lib/esm/events/adapters/importers/sample-info.interface.js

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

package/lib/esm/events/adapters/importers/suunto/importer.suunto.activity.ids.js

@@ -1,85 +0,0 @@
-export var ImporterSuuntoActivityIds;
-(function (ImporterSuuntoActivityIds) {
-    ImporterSuuntoActivityIds[ImporterSuuntoActivityIds["Not specified sport"] = 1] = "Not specified sport";
-    ImporterSuuntoActivityIds[ImporterSuuntoActivityIds["Multisport"] = 2] = "Multisport";
-    ImporterSuuntoActivityIds[ImporterSuuntoActivityIds["Run"] = 3] = "Run";
-    ImporterSuuntoActivityIds[ImporterSuuntoActivityIds["Cycling"] = 4] = "Cycling";
-    ImporterSuuntoActivityIds[ImporterSuuntoActivityIds["MountainBiking"] = 5] = "MountainBiking";
-    ImporterSuuntoActivityIds[ImporterSuuntoActivityIds["Swimming"] = 6] = "Swimming";
-    ImporterSuuntoActivityIds[ImporterSuuntoActivityIds["Skating"] = 8] = "Skating";
-    ImporterSuuntoActivityIds[ImporterSuuntoActivityIds["Aerobics"] = 9] = "Aerobics";
-    ImporterSuuntoActivityIds[ImporterSuuntoActivityIds["YogaPilates"] = 10] = "YogaPilates";
-    ImporterSuuntoActivityIds[ImporterSuuntoActivityIds["Trekking"] = 11] = "Trekking";
-    ImporterSuuntoActivityIds[ImporterSuuntoActivityIds["Walking"] = 12] = "Walking";
-    ImporterSuuntoActivityIds[ImporterSuuntoActivityIds["Sailing"] = 13] = "Sailing";
-    ImporterSuuntoActivityIds[ImporterSuuntoActivityIds["Kayaking"] = 14] = "Kayaking";
-    ImporterSuuntoActivityIds[ImporterSuuntoActivityIds["Rowing"] = 15] = "Rowing";
-    ImporterSuuntoActivityIds[ImporterSuuntoActivityIds["Climbing"] = 16] = "Climbing";
-    ImporterSuuntoActivityIds[ImporterSuuntoActivityIds["Indoorcycling"] = 17] = "Indoorcycling";
-    ImporterSuuntoActivityIds[ImporterSuuntoActivityIds["Circuit training"] = 18] = "Circuit training";
-    ImporterSuuntoActivityIds[ImporterSuuntoActivityIds["Triathlon"] = 19] = "Triathlon";
-    ImporterSuuntoActivityIds[ImporterSuuntoActivityIds["Alpine skiing"] = 20] = "Alpine skiing";
-    ImporterSuuntoActivityIds[ImporterSuuntoActivityIds["Snowboarding"] = 21] = "Snowboarding";
-    ImporterSuuntoActivityIds[ImporterSuuntoActivityIds["Crosscountry skiing"] = 22] = "Crosscountry skiing";
-    ImporterSuuntoActivityIds[ImporterSuuntoActivityIds["Weight training"] = 23] = "Weight training";
-    ImporterSuuntoActivityIds[ImporterSuuntoActivityIds["Basketball"] = 24] = "Basketball";
-    ImporterSuuntoActivityIds[ImporterSuuntoActivityIds["Soccer"] = 25] = "Soccer";
-    ImporterSuuntoActivityIds[ImporterSuuntoActivityIds["Ice Hockey"] = 26] = "Ice Hockey";
-    ImporterSuuntoActivityIds[ImporterSuuntoActivityIds["Volleyball"] = 27] = "Volleyball";
-    ImporterSuuntoActivityIds[ImporterSuuntoActivityIds["Football"] = 28] = "Football";
-    ImporterSuuntoActivityIds[ImporterSuuntoActivityIds["Softball"] = 29] = "Softball";
-    ImporterSuuntoActivityIds[ImporterSuuntoActivityIds["Cheerleading"] = 30] = "Cheerleading";
-    ImporterSuuntoActivityIds[ImporterSuuntoActivityIds["Baseball"] = 31] = "Baseball";
-    ImporterSuuntoActivityIds[ImporterSuuntoActivityIds["Tennis"] = 33] = "Tennis";
-    ImporterSuuntoActivityIds[ImporterSuuntoActivityIds["Badminton"] = 34] = "Badminton";
-    ImporterSuuntoActivityIds[ImporterSuuntoActivityIds["Table tennis"] = 35] = "Table tennis";
-    ImporterSuuntoActivityIds[ImporterSuuntoActivityIds["Racquet ball"] = 36] = "Racquet ball";
-    ImporterSuuntoActivityIds[ImporterSuuntoActivityIds["Squash"] = 37] = "Squash";
-    ImporterSuuntoActivityIds[ImporterSuuntoActivityIds["Combat sport"] = 38] = "Combat sport";
-    ImporterSuuntoActivityIds[ImporterSuuntoActivityIds["Boxing"] = 39] = "Boxing";
-    ImporterSuuntoActivityIds[ImporterSuuntoActivityIds["Floorball"] = 40] = "Floorball";
-    ImporterSuuntoActivityIds[ImporterSuuntoActivityIds["Scuba diving"] = 51] = "Scuba diving";
-    ImporterSuuntoActivityIds[ImporterSuuntoActivityIds["Free diving"] = 52] = "Free diving";
-    ImporterSuuntoActivityIds[ImporterSuuntoActivityIds["Snorkeling"] = 53] = "Snorkeling";
-    ImporterSuuntoActivityIds[ImporterSuuntoActivityIds["Surfing"] = 54] = "Surfing";
-    ImporterSuuntoActivityIds[ImporterSuuntoActivityIds["Swimrun"] = 55] = "Swimrun";
-    ImporterSuuntoActivityIds[ImporterSuuntoActivityIds["Duathlon"] = 56] = "Duathlon";
-    ImporterSuuntoActivityIds[ImporterSuuntoActivityIds["Aquathlon"] = 57] = "Aquathlon";
-    ImporterSuuntoActivityIds[ImporterSuuntoActivityIds["Adventure Racing"] = 61] = "Adventure Racing";
-    ImporterSuuntoActivityIds[ImporterSuuntoActivityIds["Bowling"] = 62] = "Bowling";
-    ImporterSuuntoActivityIds[ImporterSuuntoActivityIds["Cricket"] = 63] = "Cricket";
-    ImporterSuuntoActivityIds[ImporterSuuntoActivityIds["Crosstrainer"] = 64] = "Crosstrainer";
-    ImporterSuuntoActivityIds[ImporterSuuntoActivityIds["Dancing"] = 65] = "Dancing";
-    ImporterSuuntoActivityIds[ImporterSuuntoActivityIds["Golf"] = 66] = "Golf";
-    ImporterSuuntoActivityIds[ImporterSuuntoActivityIds["Gymnastics"] = 67] = "Gymnastics";
-    ImporterSuuntoActivityIds[ImporterSuuntoActivityIds["Handball"] = 68] = "Handball";
-    ImporterSuuntoActivityIds[ImporterSuuntoActivityIds["Horseback riding"] = 69] = "Horseback riding";
-    ImporterSuuntoActivityIds[ImporterSuuntoActivityIds["Ice Skating"] = 70] = "Ice Skating";
-    ImporterSuuntoActivityIds[ImporterSuuntoActivityIds["Indoor Rowing"] = 71] = "Indoor Rowing";
-    ImporterSuuntoActivityIds[ImporterSuuntoActivityIds["Canoeing"] = 72] = "Canoeing";
-    ImporterSuuntoActivityIds[ImporterSuuntoActivityIds["Motorsports"] = 73] = "Motorsports";
-    ImporterSuuntoActivityIds[ImporterSuuntoActivityIds["Mountaineering"] = 74] = "Mountaineering";
-    ImporterSuuntoActivityIds[ImporterSuuntoActivityIds["Orienteering"] = 75] = "Orienteering";
-    ImporterSuuntoActivityIds[ImporterSuuntoActivityIds["Rugby"] = 76] = "Rugby";
-    ImporterSuuntoActivityIds[ImporterSuuntoActivityIds["Ski Touring"] = 78] = "Ski Touring";
-    ImporterSuuntoActivityIds[ImporterSuuntoActivityIds["Stretching"] = 79] = "Stretching";
-    ImporterSuuntoActivityIds[ImporterSuuntoActivityIds["Telemark skiing"] = 80] = "Telemark skiing";
-    ImporterSuuntoActivityIds[ImporterSuuntoActivityIds["Track and Field"] = 81] = "Track and Field";
-    ImporterSuuntoActivityIds[ImporterSuuntoActivityIds["Trail Running"] = 82] = "Trail Running";
-    ImporterSuuntoActivityIds[ImporterSuuntoActivityIds["Open water swimming"] = 83] = "Open water swimming";
-    ImporterSuuntoActivityIds[ImporterSuuntoActivityIds["Nordic walking"] = 84] = "Nordic walking";
-    ImporterSuuntoActivityIds[ImporterSuuntoActivityIds["Snow shoeing"] = 85] = "Snow shoeing";
-    ImporterSuuntoActivityIds[ImporterSuuntoActivityIds["Windsurfing/Surfing"] = 86] = "Windsurfing/Surfing";
-    ImporterSuuntoActivityIds[ImporterSuuntoActivityIds["Kettlebell"] = 87] = "Kettlebell";
-    ImporterSuuntoActivityIds[ImporterSuuntoActivityIds["Roller skiing"] = 88] = "Roller skiing";
-    ImporterSuuntoActivityIds[ImporterSuuntoActivityIds["Standup paddling (SUP)"] = 89] = "Standup paddling (SUP)";
-    ImporterSuuntoActivityIds[ImporterSuuntoActivityIds["Cross fit"] = 90] = "Cross fit";
-    ImporterSuuntoActivityIds[ImporterSuuntoActivityIds["Kitesurfing/Kiting"] = 91] = "Kitesurfing/Kiting";
-    ImporterSuuntoActivityIds[ImporterSuuntoActivityIds["Paragliding"] = 92] = "Paragliding";
-    ImporterSuuntoActivityIds[ImporterSuuntoActivityIds["Treadmill"] = 93] = "Treadmill";
-    ImporterSuuntoActivityIds[ImporterSuuntoActivityIds["Frisbee"] = 94] = "Frisbee";
-    ImporterSuuntoActivityIds[ImporterSuuntoActivityIds["Indoor training"] = 95] = "Indoor training";
-    ImporterSuuntoActivityIds[ImporterSuuntoActivityIds["Hiking"] = 96] = "Hiking";
-    ImporterSuuntoActivityIds[ImporterSuuntoActivityIds["Fishing"] = 97] = "Fishing";
-    ImporterSuuntoActivityIds[ImporterSuuntoActivityIds["Hunting"] = 98] = "Hunting";
-})(ImporterSuuntoActivityIds || (ImporterSuuntoActivityIds = {}));

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

@@ -1,26 +0,0 @@
-export const ImporterSuuntoDeviceNames = {
-    Athens: '0',
-    Paris: '1',
-    Berlin: '2',
-    Tokyo: '3',
-    Rome: '4',
-    Monza: '5',
-    Moscow: '6',
-    Kyoto: '7',
-    Lisbon: '8',
-    Ibiza: '9',
-    IbizaC: '9',
-    Lima: '9 Baroless',
-    Amsterdam: 'Spartan Ultra',
-    Brighton: 'Spartan Sport',
-    Cairo: 'Spartan WHR',
-    Forssa: 'Spartan Trainer',
-    Gdansk: 'Spartan WHR Baro',
-    'Spartan Sport Wrist HR Baro': 'Spartan WHR Baro',
-    Helsinki: '3 Fitness',
-    Ambit2: 'Ambit2',
-    'Ambit3 Sport': 'Ambit3 Sport',
-    'Ambit3 Peak': 'Ambit3 Peak',
-    'Ambit3 Run': 'Ambit3 Run',
-    'Ambit3 Vertical': 'Ambit3 Vertical'
-};