@sports-alliance/sports-lib 6.0.4 → 6.1.1

package/lib/esm/events/adapters/importers/suunto/importer.suunto.sml.d.ts

@@ -0,0 +1,6 @@
+import { EventInterface } from '../../../event.interface';
+import { ActivityParsingOptions } from '../../../../activities/activity-parsing-options';
+export declare class EventImporterSuuntoSML {
+    static getFromXML(contents: string, options?: ActivityParsingOptions, name?: string): Promise<EventInterface>;
+    static getFromJSONString(jsonString: string, options?: ActivityParsingOptions): Promise<EventInterface>;
+}

package/lib/esm/events/adapters/importers/suunto/importer.suunto.sml.js

@@ -0,0 +1,124 @@
+import { EventImporterSuuntoJSON } from './importer.suunto.json';
+import { isNumber } from '../../../utilities/helpers';
+import { ActivityParsingOptions } from '../../../../activities/activity-parsing-options';
+const parser = require('fast-xml-parser');
+export class EventImporterSuuntoSML {
+    static getFromXML(contents, options = ActivityParsingOptions.DEFAULT, name = 'New Event') {
+        const json = parser.parse(contents).sml;
+        // debugger;
+        //  A few mods here to convert it to compatible json suunto string
+        json.DeviceLog.Samples = json.DeviceLog.Samples.Sample;
+        const samplesWithUTC = json.DeviceLog.Samples.filter((sample) => !!sample.UTC);
+        // Find the first UTC timestamped sample and use it later for start date
+        const startDate = samplesWithUTC.length
+            ? new Date(samplesWithUTC[0].UTC)
+            : new Date(json.DeviceLog.Header.DateTime);
+        // Determine the end date
+        const endDate = samplesWithUTC.length > 1
+            ? samplesWithUTC[samplesWithUTC.length - 1].UTC
+            : new Date(startDate.getTime() + json.DeviceLog.Header.Duration * 1000);
+        // Filter out the old activity type
+        json.DeviceLog.Samples = json.DeviceLog.Samples.filter((sample) => {
+            return !(sample.Events && sample.Events.Activity);
+        });
+        // Convert the events
+        json.DeviceLog.Samples.filter((sample) => !!sample.Events).forEach((sample) => {
+            sample.Events = [sample.Events];
+        });
+        // Inject start and end sample with event
+        json.DeviceLog.Samples.unshift({
+            Events: [
+                {
+                    Activity: { ActivityType: json.DeviceLog.Header.ActivityType }
+                }
+            ],
+            TimeISO8601: startDate.toISOString()
+        });
+        // Add the end time and adjust the start time
+        json.DeviceLog.Header.TimeISO8601 = json.DeviceLog.Header.TimeISO8601 || endDate;
+        // Add the time on the samples
+        json.DeviceLog.Samples.forEach((sample) => {
+            if (sample.TimeISO8601) {
+                return;
+            }
+            if (sample.UTC) {
+                sample.TimeISO8601 = new Date(sample.UTC).toISOString();
+                return;
+            }
+            if (isNumber(sample.Time)) {
+                sample.TimeISO8601 = new Date(startDate.getTime() + sample.Time * 1000).toISOString();
+                return;
+            }
+        });
+        // Convert the RR
+        if (json.DeviceLog['R-R']) {
+            json.DeviceLog['R-R'].Data = json.DeviceLog['R-R'].Data.split(' ').map((dataString) => Number(dataString));
+        }
+        json.DeviceLog.Header.Altitude = json.DeviceLog.Header.Altitude ? [json.DeviceLog.Header.Altitude] : null;
+        json.DeviceLog.Header.HR = json.DeviceLog.Header.HR ? [json.DeviceLog.Header.HR] : null;
+        json.DeviceLog.Header.Cadence = json.DeviceLog.Header.Cadence ? [json.DeviceLog.Header.Cadence] : null;
+        json.DeviceLog.Header.Speed = json.DeviceLog.Header.Speed ? [json.DeviceLog.Header.Speed] : null;
+        json.DeviceLog.Header.Power = json.DeviceLog.Header.Power ? [json.DeviceLog.Header.Power] : null;
+        json.DeviceLog.Header.Temperature = json.DeviceLog.Header.Temperature ? [json.DeviceLog.Header.Temperature] : null;
+        json.DeviceLog.Windows = [{ Window: Object.assign({ Type: 'Activity' }, json.DeviceLog.Header) }];
+        // debugger;
+        return EventImporterSuuntoJSON.getFromJSONString(JSON.stringify(json), options);
+    }
+    static getFromJSONString(jsonString, options = ActivityParsingOptions.DEFAULT) {
+        const json = JSON.parse(jsonString);
+        let samples;
+        // Try to be a hero here
+        try {
+            samples = json.Samples.filter((sample) => !!JSON.parse(sample.Attributes)['suunto/sml'].Sample).map((sample) => {
+                return Object.assign({ TimeISO8601: sample.TimeISO8601 }, JSON.parse(sample.Attributes)['suunto/sml'].Sample);
+            });
+        }
+        catch (e) {
+            samples = json.Samples.filter((sample) => !!sample.Attributes['suunto/sml'].Sample).map((sample) => {
+                return Object.assign({ TimeISO8601: sample.TimeISO8601 }, sample.Attributes['suunto/sml'].Sample);
+            });
+        }
+        let rr;
+        try {
+            rr = {
+                Data: json.Samples.filter((sample) => !!JSON.parse(sample.Attributes)['suunto/sml']['R-R'])
+                    .map((sample) => {
+                    return JSON.parse(sample.Attributes)['suunto/sml']['R-R'];
+                })
+                    .reduce((accu, rrSample) => {
+                    return accu.concat(rrSample.Data.split(',').map((dataString) => Number(dataString)));
+                }, [])
+            };
+        }
+        catch (e) {
+            rr = {
+                Data: json.Samples.filter((sample) => !!sample.Attributes['suunto/sml']['R-R'])
+                    .map((sample) => {
+                    return sample.Attributes['suunto/sml']['R-R'];
+                })
+                    .reduce((accu, rrSample) => {
+                    return accu.concat(rrSample.IBI);
+                }, [])
+            };
+        }
+        // debugger;
+        const suuntoJSON = {
+            DeviceLog: {
+                Header: {},
+                Device: {
+                    Name: 'Suunto unknown',
+                    Info: {
+                        HW: 0,
+                        SW: 0,
+                        SerialNumber: 0
+                    }
+                },
+                Windows: [],
+                Samples: samples,
+                ['R-R']: rr
+            }
+        };
+        // debugger;
+        return EventImporterSuuntoJSON.getFromJSONString(JSON.stringify(suuntoJSON), options);
+    }
+}

package/lib/esm/events/adapters/importers/tcx/importer.tcx.d.ts

@@ -0,0 +1,20 @@
+import { EventInterface } from '../../../event.interface';
+import { ActivityParsingOptions } from '../../../../activities/activity-parsing-options';
+export declare class EventImporterTCX {
+    /**
+     * Returns active or rest state of a lap. This is pretty use-full on swim pool activities which are decomposed of many active or rest laps
+     */
+    static isActiveLap(lapElement: HTMLElement): boolean;
+    static getFromXML(xml: Document, options?: ActivityParsingOptions, name?: string): Promise<EventInterface>;
+    private static updateActivityTypeCaseIndoor;
+    /**
+     * Extract activity stats from laps retrieved
+     */
+    private static extractAndAssignActivityStatsFromLaps;
+    /**
+     * Extract activity stats provided by the root tcx file
+     */
+    private static extractAndAssignActivityStatsFromTcxRootDef;
+    private static getCreator;
+    private static getLaps;
+}

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

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

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

@@ -0,0 +1,46 @@
+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 { EventImporterTCX } from './importer.tcx';
+describe('EventImporterTCX Integration', () => {
+    // Go up 5 levels from src/events/adapters/importers/tcx -> sports-lib root
+    const samplesDir = path.resolve(__dirname, '../../../../../samples/tcx');
+    it('should parse all sample tcx 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('.tcx'));
+        if (files.length === 0) {
+            console.warn('No .tcx files found in samples directory.');
+            return;
+        }
+        console.log(`Found ${files.length} .tcx files to test:`, files);
+        const parser = new DOMParser();
+        for (const file of files) {
+            const filePath = path.join(samplesDir, file);
+            const fileString = fs.readFileSync(filePath, 'utf-8');
+            try {
+                // Parse string to XML Document
+                const xmlDoc = parser.parseFromString(fileString, 'text/xml');
+                const event = yield EventImporterTCX.getFromXML(xmlDoc, 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/tcx/importer.tcx.js

@@ -0,0 +1,442 @@
+import { Event } from '../../../event';
+import { Activity } from '../../../../activities/activity';
+import { Creator } from '../../../../creators/creator';
+import { Lap } from '../../../../laps/lap';
+import { DataEnergy } from '../../../../data/data.energy';
+import { DataDuration } from '../../../../data/data.duration';
+import { DataDistance } from '../../../../data/data.distance';
+import { DataPause } from '../../../../data/data.pause';
+import { DataSpeedMax } from '../../../../data/data.speed-max';
+import { DataHeartRateAvg } from '../../../../data/data.heart-rate-avg';
+import { DataHeartRateMax } from '../../../../data/data.heart-rate-max';
+import { ActivityTypes, ActivityTypesMoving } from '../../../../activities/activity.types';
+import { DataSpeedAvg } from '../../../../data/data.speed-avg';
+import { LapTypes } from '../../../../laps/lap.types';
+import { ImporterSuuntoDeviceNames } from '../suunto/importer.suunto.device.names';
+import { TCXSampleMapper } from './importer.tcx.mapper';
+import { EventUtilities } from '../../../utilities/event.utilities';
+import { convertSpeedToPace, isNumber } from '../../../utilities/helpers';
+import { DataMovingTime } from '../../../../data/data.moving-time';
+import { DataTimerTime } from '../../../../data/data.timer-time';
+import { findLapExtensionValue, findTrackPointExtensionValue } from './utils.tcx';
+import { DataTotalCycles } from '../../../../data/data-total-cycles';
+import { DataPaceAvg } from '../../../../data/data.pace-avg';
+import { ActivityUtilities } from '../../../utilities/activity.utilities';
+import { DataPowerAvg } from '../../../../data/data.power-avg';
+import { DataPowerMax } from '../../../../data/data.power-max';
+import { DataCadenceAvg } from '../../../../data/data.cadence-avg';
+import { DataActiveLap } from '../../../../data/data-active-lap';
+import { DataSWOLF25m } from '../../../../data/data.swolf-25m';
+import { DataSWOLF50m } from '../../../../data/data.swolf-50m';
+import { FileType } from '../../file-type.enum';
+import { DataCadence } from '../../../../data/data.cadence';
+import { ActivityParsingOptions } from '../../../../activities/activity-parsing-options';
+export class EventImporterTCX {
+    /**
+     * Returns active or rest state of a lap. This is pretty use-full on swim pool activities which are decomposed of many active or rest laps
+     */
+    static isActiveLap(lapElement) {
+        const lapHasDistance = lapElement.getElementsByTagName('DistanceMeters').length > 0;
+        const lapHasMaxSpeed = lapElement.getElementsByTagName('MaximumSpeed').length > 0;
+        let lapDistance = 0;
+        let lapMaxSpeed = 0;
+        if (lapHasDistance) {
+            lapDistance = Number(lapElement.getElementsByTagName('DistanceMeters')[0].textContent);
+        }
+        if (lapHasMaxSpeed) {
+            lapMaxSpeed = Number(lapElement.getElementsByTagName('MaximumSpeed')[0].textContent);
+        }
+        return lapDistance > 0 || lapMaxSpeed > 0;
+    }
+    static getFromXML(xml, options = ActivityParsingOptions.DEFAULT, name = 'New Event') {
+        return new Promise((resolve, reject) => {
+            // Activities
+            const activities = Array.from(xml.getElementsByTagName('TrainingCenterDatabase')[0].getElementsByTagName('Activity')).map(activityElement => {
+                var _a;
+                // Getting activity type
+                const activityType = ActivityTypes[activityElement.getAttribute('Sport') || 'unknown'];
+                // TCX begins with laps, get them
+                const laps = this.getLaps(activityElement.getElementsByTagName('Lap'), activityType);
+                // Create activity
+                const startDate = new Date(activityElement.getElementsByTagName('Lap')[0].getAttribute('StartTime'));
+                const endDate = laps[laps.length - 1].endDate;
+                let activity = new Activity(startDate, endDate, activityType, this.getCreator(activityElement.getElementsByTagName('Creator')[0]), options);
+                // Extract activity stats from laps retrieved
+                activity = this.extractAndAssignActivityStatsFromLaps(laps, activity);
+                // Extract activity stats provided by the root tcx file
+                activity = this.extractAndAssignActivityStatsFromTcxRootDef(activityElement, activity);
+                // Creates a array of track points elements
+                let hasGpsData = false;
+                const trackPointElements = Array.from(activityElement.getElementsByTagName('Lap')).reduce((trackPointElementArray, lapElement) => {
+                    Array.from(lapElement.getElementsByTagName('Trackpoint')).forEach(trackPointElement => {
+                        trackPointElementArray.push(trackPointElement);
+                        if (!hasGpsData) {
+                            hasGpsData = !!trackPointElement.getElementsByTagName('Position')[0];
+                        }
+                    });
+                    return trackPointElementArray;
+                }, []);
+                // Update activity type to indoor when no GPS data detected
+                activity = this.updateActivityTypeCaseIndoor(hasGpsData, activity);
+                if (!((_a = activity.getDistance()) === null || _a === void 0 ? void 0 : _a.getValue()) &&
+                    trackPointElements.length &&
+                    trackPointElements[trackPointElements.length - 1].getElementsByTagName('DistanceMeters')[0]) {
+                    // If the distance from laps is 0 and there is a last track-point with distance use that
+                    activity.setDistance(new DataDistance(Number(trackPointElements[trackPointElements.length - 1].getElementsByTagName('DistanceMeters')[0].textContent)));
+                }
+                // Setup sample info which could be use when getting sample values
+                const hasPowerMeter = trackPointElements.findIndex(trackPointElement => Number.isFinite(findTrackPointExtensionValue(trackPointElement.childNodes, 'Watts'))) !== -1;
+                const samplesInfo = { hasPowerMeter: hasPowerMeter };
+                TCXSampleMapper.forEach(sampleMapping => {
+                    // Should check the children
+                    const subjectTrackPointElements = trackPointElements.filter((element) => {
+                        return isNumber(sampleMapping.getSampleValue(element, samplesInfo));
+                    });
+                    if (subjectTrackPointElements.length) {
+                        if (activity.hasStreamData(sampleMapping.dataType)) {
+                            return;
+                        }
+                        activity.addStream(activity.createStream(sampleMapping.dataType));
+                        subjectTrackPointElements.forEach((subjectTrackPointElement) => {
+                            activity.addDataToStream(sampleMapping.dataType, new Date(subjectTrackPointElement.getElementsByTagName('Time')[0].textContent), sampleMapping.getSampleValue(subjectTrackPointElement, samplesInfo));
+                        });
+                    }
+                });
+                return activity;
+            });
+            // Init the event
+            const event = new Event(name, activities[0].startDate, activities[activities.length - 1].endDate, FileType.TCX);
+            activities.forEach(activity => event.addActivity(activity));
+            EventUtilities.generateStatsForAll(event);
+            resolve(event);
+        });
+    }
+    static updateActivityTypeCaseIndoor(hasGpsData, activity) {
+        if (!hasGpsData) {
+            switch (activity.type) {
+                case ActivityTypes.Running:
+                    activity.type = ActivityTypes.IndoorRunning;
+                    break;
+                case ActivityTypes.Cycling:
+                    activity.type = ActivityTypes.IndoorCycling;
+                    break;
+                case ActivityTypes.Rowing:
+                    activity.type = ActivityTypes.IndoorRowing;
+                    break;
+            }
+        }
+        return activity;
+    }
+    /**
+     * Extract activity stats from laps retrieved
+     */
+    static extractAndAssignActivityStatsFromLaps(laps, activity) {
+        // Go over the laps and start filling up the stats and creating the points
+        laps.forEach((lap) => {
+            var _a, _b, _c, _d, _e, _f;
+            if (lap.getDuration().getValue() === 0) {
+                return;
+            }
+            // Append duration to whole activity
+            if (((_a = lap.getDuration()) === null || _a === void 0 ? void 0 : _a.getValue()) > 0) {
+                if (!activity.getDuration()) {
+                    activity.setDuration(new DataDuration(0));
+                }
+                activity.getDuration().setValue(activity.getDuration().getValue() + lap.getDuration().getValue());
+            }
+            // Append timer time to whole activity
+            if (((_b = lap.getTimer()) === null || _b === void 0 ? void 0 : _b.getValue()) > 0) {
+                if (!activity.getTimer()) {
+                    activity.setTimer(new DataTimerTime(0));
+                }
+                activity.getTimer().setValue(activity.getTimer().getValue() + lap.getTimer().getValue());
+            }
+            // Append moving time to whole activity
+            if (((_c = lap.getMovingTime()) === null || _c === void 0 ? void 0 : _c.getValue()) > 0) {
+                if (!activity.getMovingTime()) {
+                    activity.setMovingTime(new DataMovingTime(0));
+                }
+                activity.getMovingTime().setValue(activity.getMovingTime().getValue() + lap.getMovingTime().getValue());
+            }
+            // Append pause time to whole activity
+            if (((_d = lap.getPause()) === null || _d === void 0 ? void 0 : _d.getValue()) > 0) {
+                if (!activity.getPause()) {
+                    activity.setPause(new DataPause(0));
+                }
+                activity.getPause().setValue(activity.getPause().getValue() + lap.getPause().getValue());
+            }
+            // Append distance to whole activity
+            if (((_e = lap.getDistance()) === null || _e === void 0 ? void 0 : _e.getValue()) > 0) {
+                if (!activity.getDistance()) {
+                    activity.setDistance(new DataDistance(0));
+                }
+                activity.getDistance().setValue(activity.getDistance().getValue() + lap.getDistance().getValue());
+            }
+            // Append energy to whole activity
+            if (((_f = lap.getStat(DataEnergy.type)) === null || _f === void 0 ? void 0 : _f.getValue()) > 0) {
+                if (!activity.getStat(DataEnergy.type)) {
+                    activity.addStat(new DataEnergy(0));
+                }
+                activity.addStat(new DataEnergy(activity.getStat(DataEnergy.type).getValue() +
+                    lap.getStat(DataEnergy.type).getValue()));
+            }
+            activity.addLap(lap);
+        });
+        // Looping on laps to assign stats to activity
+        if (laps === null || laps === void 0 ? void 0 : laps.length) {
+            // Getting avg speed/pace from laps:
+            const lapAvgSpeeds = laps
+                .filter(lap => { var _a; return ((_a = lap.getStat(DataSpeedAvg.type)) === null || _a === void 0 ? void 0 : _a.getValue()) >= 0; })
+                .map(lap => { var _a; return (_a = lap.getStat(DataSpeedAvg.type)) === null || _a === void 0 ? void 0 : _a.getValue(); });
+            if (lapAvgSpeeds.length) {
+                const avgSpeed = ActivityUtilities.getAverage(lapAvgSpeeds);
+                if (avgSpeed > 0) {
+                    activity.addStat(new DataSpeedAvg(avgSpeed));
+                    activity.addStat(new DataPaceAvg(convertSpeedToPace(avgSpeed)));
+                }
+            }
+            // Cycles
+            const lapTotalsCycles = laps
+                .map(lap => { var _a; return ((_a = lap.getStat(DataTotalCycles.type)) === null || _a === void 0 ? void 0 : _a.getValue()) || 0; })
+                .filter(count => count > 0);
+            if (lapTotalsCycles.length) {
+                const lapTotalCycles = ActivityUtilities.getSum(lapTotalsCycles);
+                if (lapTotalCycles > 0) {
+                    activity.addStat(new DataTotalCycles(lapTotalCycles));
+                }
+            }
+            // Avg cadence
+            const lapDataCadenceAverages = laps
+                .map(lap => { var _a; return ((_a = lap.getStat(DataCadenceAvg.type)) === null || _a === void 0 ? void 0 : _a.getValue()) || 0; })
+                .filter(cad => cad > 0);
+            if (lapDataCadenceAverages.length) {
+                const dataCadenceAvg = ActivityUtilities.getAverage(lapDataCadenceAverages);
+                if (dataCadenceAvg > 0) {
+                    activity.addStat(new DataCadenceAvg(Math.round(dataCadenceAvg)));
+                }
+            }
+        }
+        return activity;
+    }
+    /**
+     * Extract activity stats provided by the root tcx file
+     */
+    static extractAndAssignActivityStatsFromTcxRootDef(activityElement, activity) {
+        var _a, _b;
+        if (!(((_a = activity.getStat(DataEnergy.type)) === null || _a === void 0 ? void 0 : _a.getValue()) > 0) &&
+            activityElement.getElementsByTagName('Calories')[0]) {
+            const calories = Number(activityElement.getElementsByTagName('Calories')[0].textContent);
+            if (calories > 0) {
+                activity.addStat(new DataEnergy(calories));
+            }
+        }
+        if (!(((_b = activity.getStat(DataDistance.type)) === null || _b === void 0 ? void 0 : _b.getValue()) > 0) &&
+            activityElement.getElementsByTagName('DistanceMeters')[0]) {
+            activity.addStat(new DataDistance(Number(activityElement.getElementsByTagName('DistanceMeters')[0].textContent)));
+        }
+        if (activityElement.getElementsByTagName('MaximumSpeed')[0]) {
+            activity.addStat(new DataSpeedMax(Number(activityElement.getElementsByTagName('MaximumSpeed')[0].textContent)));
+        }
+        return activity;
+    }
+    static getCreator(creatorElement) {
+        const creator = new Creator('Unknown Device');
+        if (!creatorElement) {
+            return creator;
+        }
+        // Try to see if its a listed Suunto Device name
+        if (creatorElement.getElementsByTagName('Name')[0]) {
+            creator.name =
+                ImporterSuuntoDeviceNames[creatorElement.getElementsByTagName('Name')[0].textContent] ||
+                    creatorElement.getElementsByTagName('Name')[0].textContent ||
+                    creator.name;
+        }
+        if (creatorElement.getElementsByTagName('Version')[0]) {
+            creator.swInfo = creatorElement.getElementsByTagName('Version')[0].textContent;
+        }
+        return creator;
+    }
+    static getLaps(lapElements, activityType) {
+        return Array.from(lapElements).reduce((lapArray, lapElement, lapIndex) => {
+            var _a, _b, _c, _d, _e, _f, _g, _h, _j;
+            // Calculating lap time data (moving time, timer time, elapsed time...)
+            const speedThreshold = ActivityTypesMoving.getSpeedThreshold(activityType);
+            let movingTime = 0;
+            let elapsedTime = 0;
+            const timerTime = lapElement.getElementsByTagName('TotalTimeSeconds').length
+                ? Number(lapElement.getElementsByTagName('TotalTimeSeconds')[0].textContent)
+                : 0;
+            // Loop on track-points to detect moving speed
+            const trackSpeeds = [];
+            const trackElements = Array.from(lapElement.getElementsByTagName('Track'));
+            trackElements.forEach(trackElement => {
+                var _a;
+                const trackPointsElements = Array.from(trackElement.getElementsByTagName('Trackpoint'));
+                if (!(trackPointsElements === null || trackPointsElements === void 0 ? void 0 : trackPointsElements.length)) {
+                    return;
+                }
+                // Setting lap elapsed time from first and last track point
+                const firstTrackPoint = trackPointsElements[0];
+                const lastTrackPoint = trackPointsElements[trackPointsElements.length - 1];
+                // Assign elapsed time if time available on first and last point
+                if ((_a = lastTrackPoint === null || lastTrackPoint === void 0 ? void 0 : lastTrackPoint.getElementsByTagName('Time')) === null || _a === void 0 ? void 0 : _a.length) {
+                    elapsedTime =
+                        (new Date(lastTrackPoint.getElementsByTagName('Time')[0].textContent).getTime() -
+                            new Date(firstTrackPoint.getElementsByTagName('Time')[0].textContent).getTime()) /
+                            1000;
+                }
+                // Parsing each track points to determine moving speed
+                trackPointsElements.forEach((trackPointElement, index) => {
+                    // Skipping first record to be able to get delta with previous one
+                    if (index === 0) {
+                        return;
+                    }
+                    // Getting current time of track point
+                    const currentTime = new Date(trackPointElement.getElementsByTagName('Time')[0].textContent).getTime();
+                    const previousTime = new Date(trackPointsElements[index - 1].getElementsByTagName('Time')[0].textContent).getTime();
+                    const seconds = (currentTime - previousTime) / 1000;
+                    let speed = findTrackPointExtensionValue(trackPointElement.childNodes, 'Speed');
+                    // Try to get m/s using delta distance if speed extension is missing
+                    if (speed === null) {
+                        // If distance available on track point, then compute speed with it
+                        if (trackPointElement.getElementsByTagName('DistanceMeters').length &&
+                            trackPointsElements[index - 1].getElementsByTagName('DistanceMeters').length) {
+                            const currentDistance = Number(trackPointElement.getElementsByTagName('DistanceMeters')[0].textContent);
+                            const previousDistance = Number(trackPointsElements[index - 1].getElementsByTagName('DistanceMeters')[0].textContent);
+                            const meters = currentDistance - previousDistance;
+                            speed = meters / seconds;
+                            trackSpeeds.push(speed);
+                        }
+                    }
+                    else {
+                        trackSpeeds.push(speed);
+                    }
+                    // We track moving time only if speed available on track points and upper than threshold
+                    if (speed !== null && speed > speedThreshold) {
+                        movingTime += seconds;
+                    }
+                });
+            });
+            // Active or rest lap?
+            const isActiveLap = this.isActiveLap(lapElement);
+            // If no moving time detected, try to detect from active laps
+            if (movingTime === 0) {
+                // Lap is considered as active. Track moving time..
+                if (isActiveLap) {
+                    movingTime = timerTime;
+                }
+            }
+            // If elapsed time not defined or lower than timer time then use timer time as elapsed time
+            if (!elapsedTime || timerTime > elapsedTime) {
+                elapsedTime = timerTime;
+            }
+            // Now creating the lap
+            const startDate = new Date(lapElement.getAttribute('StartTime'));
+            const endDate = new Date(startDate);
+            endDate.setSeconds(endDate.getSeconds() + elapsedTime);
+            const lap = new Lap(startDate, endDate, lapIndex + 1, LapTypes.AutoLap);
+            // Add elapsed & timer stats to lap
+            lap.addStat(new DataDuration(elapsedTime));
+            lap.addStat(new DataTimerTime(Math.round(timerTime * 10) / 10));
+            // Append moving stat only if moving time has been detected
+            // We need that to compute total global moving time later
+            if (movingTime > 0) {
+                lap.addStat(new DataMovingTime(Math.round(movingTime * 10) / 10));
+            }
+            // Pause TIME on Object (activity, lap...)
+            const pause = elapsedTime > movingTime ? Math.round((elapsedTime - movingTime) * 100) / 100 : 0;
+            lap.setPause(new DataPause(pause));
+            // Assign is active lap status
+            lap.addStat(new DataActiveLap(isActiveLap));
+            if (lapElement.getElementsByTagName('TriggerMethod')[0]) {
+                lap.type = LapTypes[lapElement.getElementsByTagName('TriggerMethod')[0].textContent];
+            }
+            if (lapElement.getElementsByTagName('Calories')[0]) {
+                lap.addStat(new DataEnergy(Number(lapElement.getElementsByTagName('Calories')[0].textContent)));
+            }
+            // Create a stats (required TCX fields)
+            lap.addStat(new DataDistance(0));
+            if (lapElement.getElementsByTagName('DistanceMeters')[0]) {
+                lap.addStat(new DataDistance(Number(lapElement.getElementsByTagName('DistanceMeters')[0].textContent)));
+            }
+            // Optionals
+            if (trackSpeeds.length) {
+                const maxSpeed = ActivityUtilities.getMax(trackSpeeds);
+                lap.addStat(new DataSpeedMax(maxSpeed));
+            }
+            else if (lapElement.getElementsByTagName('MaximumSpeed')[0]) {
+                const maxSpeed = Number(lapElement.getElementsByTagName('MaximumSpeed')[0].textContent);
+                lap.addStat(new DataSpeedMax(maxSpeed));
+            }
+            if (lapElement.getElementsByTagName('AverageHeartRateBpm')[0]) {
+                const value = ((_b = (_a = lapElement.getElementsByTagName('AverageHeartRateBpm')[0]) === null || _a === void 0 ? void 0 : _a.getElementsByTagName('Value')[0]) === null || _b === void 0 ? void 0 : _b.textContent) ||
+                    ((_c = lapElement.getElementsByTagName('AverageHeartRateBpm')[0]) === null || _c === void 0 ? void 0 : _c.textContent);
+                if (value) {
+                    lap.addStat(new DataHeartRateAvg(Number(value)));
+                }
+            }
+            if (lapElement.getElementsByTagName('MaximumHeartRateBpm')[0]) {
+                const value = ((_e = (_d = lapElement.getElementsByTagName('MaximumHeartRateBpm')[0]) === null || _d === void 0 ? void 0 : _d.getElementsByTagName('Value')[0]) === null || _e === void 0 ? void 0 : _e.textContent) ||
+                    ((_f = lapElement.getElementsByTagName('MaximumHeartRateBpm')[0]) === null || _f === void 0 ? void 0 : _f.textContent);
+                if (value) {
+                    lap.addStat(new DataHeartRateMax(Number(value)));
+                }
+            }
+            if (lapElement.getElementsByTagName('Cadence')[0]) {
+                lap.addStat(new DataCadence(Number(lapElement.getElementsByTagName('Cadence')[0].textContent)));
+            }
+            // Fetching activity lap speed from records or from extensions if exists according https://www8.garmin.com/xmlschemas/ActivityExtensionv2.xsd schema
+            const lapAvgSpeed = trackSpeeds.length
+                ? ActivityUtilities.getAverage(trackSpeeds)
+                : findLapExtensionValue(lapElement.childNodes, 'AvgSpeed');
+            if (lapAvgSpeed !== null) {
+                lap.addStat(new DataSpeedAvg(lapAvgSpeed));
+                lap.addStat(new DataPaceAvg(convertSpeedToPace(lapAvgSpeed)));
+            }
+            // Cycles
+            const lapTotalCycle = findLapExtensionValue(lapElement.childNodes, 'Steps');
+            if (lapTotalCycle !== null) {
+                lap.addStat(new DataTotalCycles(lapTotalCycle));
+            }
+            // Avg Watts
+            const lapAvgWatts = findLapExtensionValue(lapElement.childNodes, 'AvgWatts');
+            if (lapAvgWatts !== null) {
+                lap.addStat(new DataPowerAvg(lapAvgWatts));
+            }
+            // Max Watts
+            const lapMaxWatts = findLapExtensionValue(lapElement.childNodes, 'MaxWatts');
+            if (lapMaxWatts !== null) {
+                lap.addStat(new DataPowerMax(lapMaxWatts));
+            }
+            // AvgRunCadence
+            const lapAvgRunCadence = findLapExtensionValue(lapElement.childNodes, 'AvgRunCadence');
+            if (lapAvgRunCadence !== null) {
+                lap.addStat(new DataCadenceAvg(lapAvgRunCadence));
+            }
+            // Try to set avg cadence from total cycle if not set on swimming activities only
+            if (isActiveLap &&
+                (activityType === ActivityTypes.Swimming || activityType === ActivityTypes.OpenWaterSwimming) &&
+                !((_g = lap.getStat(DataCadenceAvg.type)) === null || _g === void 0 ? void 0 : _g.getValue()) &&
+                timerTime &&
+                lapTotalCycle) {
+                const lapAvgCadence = Math.round((lapTotalCycle / timerTime) * 60);
+                lap.addStat(new DataCadenceAvg(lapAvgCadence));
+            }
+            // Average SWOLF in 25m and 50m pool
+            if (isActiveLap &&
+                (activityType === ActivityTypes.Swimming || activityType === ActivityTypes.OpenWaterSwimming) &&
+                ((_h = lap.getStat(DataCadenceAvg.type)) === null || _h === void 0 ? void 0 : _h.getValue()) > 0 &&
+                ((_j = lap.getStat(DataSpeedAvg.type)) === null || _j === void 0 ? void 0 : _j.getValue()) > 0) {
+                const avgCadence = lap.getStat(DataCadenceAvg.type).getValue();
+                const avgSpeed = lap.getStat(DataSpeedAvg.type).getValue();
+                const avgPace100m = 100 / avgSpeed;
+                const swolf25m = ActivityUtilities.computeSwimSwolf(avgPace100m, avgCadence, 25);
+                lap.addStat(new DataSWOLF25m(swolf25m));
+                const swolf50m = ActivityUtilities.computeSwimSwolf(avgPace100m, avgCadence, 50);
+                lap.addStat(new DataSWOLF50m(swolf50m));
+            }
+            lapArray.push(lap);
+            return lapArray;
+        }, []);
+    }
+}

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

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