@sports-alliance/sports-lib 7.0.7 → 7.0.9

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

@@ -1,978 +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 { Event } from '../../../event';
-import { Activity } from '../../../../activities/activity';
-import { Lap } from '../../../../laps/lap';
-import { Creator } from '../../../../creators/creator';
-import { ActivityTypes, ActivityTypesMoving } from '../../../../activities/activity.types';
-import { DataDuration } from '../../../../data/data.duration';
-import { DataEnergy } from '../../../../data/data.energy';
-import { DataDistance } from '../../../../data/data.distance';
-import { ImporterFitSuuntoDeviceNames } from './importer.fit.suunto.device.names';
-import { GarminProfileMapper } from './importer.fit.garmin.profile.mapper';
-import { DataPause } from '../../../../data/data.pause';
-import { DataCadenceAvg } from '../../../../data/data.cadence-avg';
-import { DataPowerAvg } from '../../../../data/data.power-avg';
-import { DataSpeedAvg } from '../../../../data/data.speed-avg';
-import { DataCadenceMax } from '../../../../data/data.cadence-max';
-import { DataPowerMax } from '../../../../data/data.power-max';
-import { DataAscent } from '../../../../data/data.ascent';
-import { DataDescent } from '../../../../data/data.descent';
-import { DataHeartRateAvg } from '../../../../data/data.heart-rate-avg';
-import { DataHeartRateMax } from '../../../../data/data.heart-rate-max';
-import { DataSpeedMax } from '../../../../data/data.speed-max';
-import { LapTypes } from '../../../../laps/lap.types';
-import { DataHeartRateMin } from '../../../../data/data.heart-rate-min';
-import { DataPowerMin } from '../../../../data/data.power-min';
-import { DataAerobicTrainingEffect } from '../../../../data/data-aerobic-training-effect';
-import { FITSampleMapper } from './importer.fit.mapper';
-import { isNumber, isNumberOrString } from '../../../utilities/helpers';
-import { EventUtilities } from '../../../utilities/event.utilities';
-import { IBIStream } from '../../../../streams/ibi-stream';
-import { Device } from '../../../../activities/devices/device';
-import { ImporterFitAntPlusDeviceNames } from './importer.fit.ant-plus.device.names';
-import { DataRecoveryTime } from '../../../../data/data.recovery-time';
-import { DataPeakEPOC } from '../../../../data/data.peak-epoc';
-import { DataFeeling } from '../../../../data/data.feeling';
-import { DataTemperatureMax } from '../../../../data/data.temperature-max';
-import { DataTemperatureMin } from '../../../../data/data.temperature-min';
-import { DataTemperatureAvg } from '../../../../data/data.temperature-avg';
-import { DataSpeedMin } from '../../../../data/data.speed-min';
-import { DataCadenceMin } from '../../../../data/data.cadence-min';
-import { DataSWOLF25m } from '../../../../data/data.swolf-25m';
-import { DataDescription } from '../../../../data/data.description';
-import { DataVO2Max } from '../../../../data/data.vo2-max';
-import { IntensityZones } from '../../../../intensity-zones/intensity-zones';
-import { DataHeartRate } from '../../../../data/data.heart-rate';
-import { DataPower } from '../../../../data/data.power';
-import { DataSpeed } from '../../../../data/data.speed';
-import { DataHeartRateZoneOneDuration } from '../../../../data/data.heart-rate-zone-one-duration';
-import { DataHeartRateZoneTwoDuration } from '../../../../data/data.heart-rate-zone-two-duration';
-import { DataHeartRateZoneThreeDuration } from '../../../../data/data.heart-rate-zone-three-duration';
-import { DataHeartRateZoneFourDuration } from '../../../../data/data.heart-rate-zone-four-duration';
-import { DataHeartRateZoneFiveDuration } from '../../../../data/data.heart-rate-zone-five-duration';
-import { DataPowerZoneOneDuration } from '../../../../data/data.power-zone-one-duration';
-import { DataPowerZoneTwoDuration } from '../../../../data/data.power-zone-two-duration';
-import { DataPowerZoneThreeDuration } from '../../../../data/data.power-zone-three-duration';
-import { DataPowerZoneFourDuration } from '../../../../data/data.power-zone-four-duration';
-import { DataPowerZoneFiveDuration } from '../../../../data/data.power-zone-five-duration';
-import { DataSpeedZoneOneDuration } from '../../../../data/data.speed-zone-one-duration';
-import { DataSpeedZoneTwoDuration } from '../../../../data/data.speed-zone-two-duration';
-import { DataSpeedZoneThreeDuration } from '../../../../data/data.speed-zone-three-duration';
-import { DataSpeedZoneFourDuration } from '../../../../data/data.speed-zone-four-duration';
-import { DataSpeedZoneFiveDuration } from '../../../../data/data.speed-zone-five-duration';
-import { EmptyEventLibError } from '../../../../errors/empty-event-sports-libs.error';
-import { DataStartEvent } from '../../../../data/data.start-event';
-import { DataStopEvent } from '../../../../data/data.stop-event';
-import { DataStopAllEvent } from '../../../../data/data.stop-all-event';
-import { DataMovingTime } from '../../../../data/data.moving-time';
-import { ActivityUtilities } from '../../../utilities/activity.utilities';
-import { DataTimerTime } from '../../../../data/data.timer-time';
-import { DataTotalCycles } from '../../../../data/data-total-cycles';
-import { DataPoolLength } from '../../../../data/data.pool-length';
-import { DataActiveLengths } from '../../../../data/data-active-lengths';
-import { DataActiveLap } from '../../../../data/data-active-lap';
-import { DataSWOLF50m } from '../../../../data/data.swolf-50m';
-import { FileType } from '../../file-type.enum';
-import { DataPowerTorqueEffectivenessLeft } from '../../../../data/data.power-torque-effectiveness-left';
-import { DataPowerTorqueEffectivenessRight } from '../../../../data/data.power-torque-effectiveness-right';
-import { DataPowerPedalSmoothnessLeft } from '../../../../data/data.power-pedal-smoothness-left';
-import { DataPowerPedalSmoothnessRight } from '../../../../data/data.power-pedal-smoothness-right';
-import { DataPowerNormalized } from '../../../../data/data.power-normalized';
-import { DataPowerIntensityFactor } from '../../../../data/data.power-intensity-factor';
-import { DataPowerTrainingStressScore } from '../../../../data/data.power-training-stress-score';
-import { DataPowerWork } from '../../../../data/data.power-work';
-import { DataCyclingStandingTime } from '../../../../data/data.cycling-standing-time';
-import { DataCyclingSeatedTime } from '../../../../data/data.cycling-seated-time';
-import { RiderPosition } from '../../../../data/data.cycling-position';
-import { DataRiderPositionChangeEvent } from '../../../../data/data.rider-position-change-event';
-import { DataStanceTime } from '../../../../data/data.stance-time';
-import { DataVerticalOscillation } from '../../../../data/data.vertical-oscillation';
-import { DataVerticalRatio } from '../../../../data/data.vertical-ratio';
-import { DataAvgStrideLength } from '../../../../data/data.avg-stride-length';
-import { DataAnaerobicTrainingEffect } from '../../../../data/data-anaerobic-training-effect';
-import { ImporterFitWahooDeviceNames } from './importer.fit.wahoo.device.names';
-import { ImporterFitCorosDeviceNames } from './importer.fit.coros.device.names';
-import { ImporterFitSrmDeviceNames } from './importer.fit.srm.device.names';
-import { ActivityParsingOptions } from '../../../../activities/activity-parsing-options';
-import { ImporterFitHammerheadDeviceNames } from './importer.fit.hammerhead.device.names';
-import { ImporterFitLezyneDeviceNames } from './importer.fit.lezyne.device.names';
-import { ImporterFitMagellanDeviceNames } from './importer.fit.magellan.device.names';
-import { ImporterFitSarisDeviceNames } from './importer.fit.saris.device.names';
-import { ParsingEventLibError } from '../../../../errors/parsing-event-lib.error';
-import { DataPowerDown } from '../../../../data/data.power-down';
-import { DataPowerUp } from '../../../../data/data.power-up';
-import { ImporterFitDevelopmentDeviceNames } from './importer.fit.development.device.names';
-// eslint-disable-next-line @typescript-eslint/no-var-requires
-// @ts-ignore
-import FitFileParser from 'fit-file-parser';
-// Threshold to detect that session.timestamp are not trustable (when exceeding 15% of session.total_elapsed_time)
-const INVALID_DATES_ELAPSED_TIME_RATIO_THRESHOLD = 1.15;
-export class EventImporterFIT {
-    static getFromArrayBuffer(arrayBuffer_1) {
-        return __awaiter(this, arguments, void 0, function* (arrayBuffer, options = ActivityParsingOptions.DEFAULT, name = 'New Event') {
-            return new Promise((resolve, reject) => {
-                const fitFileParser = new FitFileParser({
-                    force: true,
-                    speedUnit: 'm/s',
-                    lengthUnit: 'm',
-                    temperatureUnit: 'celsius',
-                    elapsedRecordField: false,
-                    mode: 'both'
-                });
-                fitFileParser.parse(arrayBuffer, (error, fitDataObject) => {
-                    var _a;
-                    if (error) {
-                        // For now, assume any error from parser on this file means it's broken/empty in a way we treat as EmptyEventLibError
-                        // to satisfy existing tests. Or ideally we wrap in a generic EventLibError.
-                        // But test expects EmptyEventLibError.
-                        reject(new EmptyEventLibError());
-                        return;
-                    }
-                    if (!fitDataObject || !fitDataObject.sessions) {
-                        reject(new EmptyEventLibError());
-                        return;
-                    }
-                    // Check if we have length data at the top level (new parser behavior or missing mapping)
-                    if (fitDataObject.lengths && fitDataObject.lengths.length > 0) {
-                        (_a = fitDataObject.sessions) === null || _a === void 0 ? void 0 : _a.forEach((session) => {
-                            var _a;
-                            const sessionStartTime = new Date(session.start_time).getTime();
-                            const sessionEndTime = sessionStartTime + (session.total_elapsed_time || 0) * 1000;
-                            session.lengths = fitDataObject.lengths.filter((length) => {
-                                const lengthTime = new Date(length.timestamp || length.start_time).getTime();
-                                return lengthTime >= sessionStartTime && lengthTime < sessionEndTime;
-                            });
-                            // Also distribute to laps
-                            (_a = session.laps) === null || _a === void 0 ? void 0 : _a.forEach((lap) => {
-                                const lapStartTime = new Date(lap.start_time).getTime();
-                                const lapEndTime = lapStartTime + (lap.total_elapsed_time || 0) * 1000;
-                                lap.lengths = fitDataObject.lengths.filter((length) => {
-                                    const lengthTime = new Date(length.timestamp || length.start_time).getTime();
-                                    return lengthTime >= lapStartTime && lengthTime < lapEndTime;
-                                });
-                            });
-                        });
-                    }
-                    // Iterate over the sessions and create their activities
-                    const activities = fitDataObject.sessions.map((sessionObject) => {
-                        // Get the activity from the sessionObject
-                        const activity = this.getActivityFromSessionObject(sessionObject, fitDataObject, options);
-                        // Go over the laps
-                        sessionObject.laps.forEach((sessionLapObject, index) => {
-                            activity.addLap(this.getLapFromSessionLapObject(sessionLapObject, activity, index));
-                        });
-                        // Go over the hr zone info
-                        if (sessionObject.time_in_hr_zone && sessionObject.time_in_hr_zone.length) {
-                            // Add the stats
-                            if (isNumber(sessionObject.time_in_hr_zone[0])) {
-                                activity.addStat(new DataHeartRateZoneOneDuration(sessionObject.time_in_hr_zone[0]));
-                            }
-                            if (isNumber(sessionObject.time_in_hr_zone[1])) {
-                                activity.addStat(new DataHeartRateZoneTwoDuration(sessionObject.time_in_hr_zone[1]));
-                            }
-                            if (isNumber(sessionObject.time_in_hr_zone[2])) {
-                                activity.addStat(new DataHeartRateZoneThreeDuration(sessionObject.time_in_hr_zone[2]));
-                            }
-                            if (isNumber(sessionObject.time_in_hr_zone[3])) {
-                                activity.addStat(new DataHeartRateZoneFourDuration(sessionObject.time_in_hr_zone[3]));
-                            }
-                            if (isNumber(sessionObject.time_in_hr_zone[4])) {
-                                activity.addStat(new DataHeartRateZoneFiveDuration(sessionObject.time_in_hr_zone[4]));
-                            }
-                            const hrIntensityZones = new IntensityZones(DataHeartRate.type);
-                            hrIntensityZones.zone1Duration = sessionObject.time_in_hr_zone[0] || 0;
-                            hrIntensityZones.zone2Duration = sessionObject.time_in_hr_zone[1] || 0;
-                            hrIntensityZones.zone3Duration = sessionObject.time_in_hr_zone[2] || 0;
-                            hrIntensityZones.zone4Duration = sessionObject.time_in_hr_zone[3] || 0;
-                            hrIntensityZones.zone5Duration = sessionObject.time_in_hr_zone[4] || 0;
-                            activity.intensityZones.push(hrIntensityZones);
-                        }
-                        // Go over the power zone info
-                        if (sessionObject.time_in_power_zone && sessionObject.time_in_power_zone.length) {
-                            if (isNumber(sessionObject.time_in_power_zone[0])) {
-                                activity.addStat(new DataPowerZoneOneDuration(sessionObject.time_in_power_zone[0]));
-                            }
-                            if (isNumber(sessionObject.time_in_power_zone[1])) {
-                                activity.addStat(new DataPowerZoneTwoDuration(sessionObject.time_in_power_zone[1]));
-                            }
-                            if (isNumber(sessionObject.time_in_power_zone[2])) {
-                                activity.addStat(new DataPowerZoneThreeDuration(sessionObject.time_in_power_zone[2]));
-                            }
-                            if (isNumber(sessionObject.time_in_power_zone[3])) {
-                                activity.addStat(new DataPowerZoneFourDuration(sessionObject.time_in_power_zone[3]));
-                            }
-                            if (isNumber(sessionObject.time_in_power_zone[4])) {
-                                activity.addStat(new DataPowerZoneFiveDuration(sessionObject.time_in_power_zone[4]));
-                            }
-                            const powerIntensityZones = new IntensityZones(DataPower.type);
-                            powerIntensityZones.zone1Duration = sessionObject.time_in_power_zone[0] || 0;
-                            powerIntensityZones.zone2Duration = sessionObject.time_in_power_zone[1] || 0;
-                            powerIntensityZones.zone3Duration = sessionObject.time_in_power_zone[2] || 0;
-                            powerIntensityZones.zone4Duration = sessionObject.time_in_power_zone[3] || 0;
-                            powerIntensityZones.zone5Duration = sessionObject.time_in_power_zone[4] || 0;
-                            activity.intensityZones.push(powerIntensityZones);
-                        }
-                        // Go over the speed zone info
-                        if (sessionObject.time_in_speed_zone && sessionObject.time_in_speed_zone.length) {
-                            if (isNumber(sessionObject.time_in_speed_zone[0])) {
-                                activity.addStat(new DataSpeedZoneOneDuration(sessionObject.time_in_speed_zone[0]));
-                            }
-                            if (isNumber(sessionObject.time_in_speed_zone[1])) {
-                                activity.addStat(new DataSpeedZoneTwoDuration(sessionObject.time_in_speed_zone[1]));
-                            }
-                            if (isNumber(sessionObject.time_in_speed_zone[2])) {
-                                activity.addStat(new DataSpeedZoneThreeDuration(sessionObject.time_in_speed_zone[2]));
-                            }
-                            if (isNumber(sessionObject.time_in_speed_zone[3])) {
-                                activity.addStat(new DataSpeedZoneFourDuration(sessionObject.time_in_speed_zone[3]));
-                            }
-                            if (isNumber(sessionObject.time_in_speed_zone[4])) {
-                                activity.addStat(new DataSpeedZoneFiveDuration(sessionObject.time_in_speed_zone[4]));
-                            }
-                            const speedIntensityZones = new IntensityZones(DataSpeed.type);
-                            speedIntensityZones.zone1Duration = sessionObject.time_in_speed_zone[0] || 0;
-                            speedIntensityZones.zone2Duration = sessionObject.time_in_speed_zone[1] || 0;
-                            speedIntensityZones.zone3Duration = sessionObject.time_in_speed_zone[2] || 0;
-                            speedIntensityZones.zone4Duration = sessionObject.time_in_speed_zone[3] || 0;
-                            speedIntensityZones.zone5Duration = sessionObject.time_in_speed_zone[4] || 0;
-                            activity.intensityZones.push(speedIntensityZones);
-                        }
-                        // Add the events
-                        fitDataObject.events
-                            .filter((activityEvent) => {
-                            return activityEvent.timestamp >= activity.startDate && activityEvent.timestamp <= activity.endDate;
-                        })
-                            .forEach((activityEvent) => {
-                            if (activityEvent.event === 'timer') {
-                                switch (activityEvent.event_type) {
-                                    case 'start':
-                                        activity.addEvent(new DataStartEvent(activity.getDateIndex(activityEvent.timestamp)));
-                                        break;
-                                    case 'stop':
-                                        activity.addEvent(new DataStopEvent(activity.getDateIndex(activityEvent.timestamp)));
-                                        break;
-                                    case 'stop_all':
-                                        activity.addEvent(new DataStopAllEvent(activity.getDateIndex(activityEvent.timestamp)));
-                                        break;
-                                    default:
-                                        break;
-                                }
-                            }
-                            else if (activityEvent.event === 'power_down') {
-                                activity.addEvent(new DataPowerDown(activity.getDateIndex(activityEvent.timestamp)));
-                            }
-                            else if (activityEvent.event === 'power_up') {
-                                activity.addEvent(new DataPowerUp(activity.getDateIndex(activityEvent.timestamp)));
-                            }
-                            else if (activityEvent.event === 'rider_position_change') {
-                                const positionChange = activityEvent.data;
-                                if (positionChange === RiderPosition.SEATED ||
-                                    positionChange === RiderPosition.STANDING ||
-                                    positionChange === RiderPosition.TRANSITION_TO_SEATED ||
-                                    positionChange === RiderPosition.TRANSITION_TO_STANDING) {
-                                    activity.addEvent(new DataRiderPositionChangeEvent(activity.getDateIndex(activityEvent.timestamp), positionChange));
-                                }
-                            }
-                        });
-                        // Get the samples..
-                        // Test if activity is lengths based
-                        // Indeed when based on lengths, an activity do not provides samples under records object (e.g. Pool swimming activities)
-                        // Note: this is how Strava generate streams for this kind of activities
-                        const isLengthsBased = this.isLengthsBased(sessionObject);
-                        const samples = isLengthsBased
-                            ? this.generateSamplesFromLengths(sessionObject, options)
-                            : fitDataObject.records.filter((record) => {
-                                return record.timestamp >= activity.startDate && record.timestamp <= activity.endDate;
-                            });
-                        // Setup sample info which could be use when getting sample values
-                        const hasPowerMeter = samples.findIndex((sample) => Number.isFinite(isNumber(sample.power) ? sample.power : isNumber(sample.Power) ? sample.Power : sample.RP_Power)) !== -1;
-                        const samplesInfo = { hasPowerMeter: hasPowerMeter };
-                        FITSampleMapper.forEach(sampleMapping => {
-                            // @todo not sure if we need to check for number only ...
-                            const subjectSamples = (samples.filter((sample) => isNumber(sampleMapping.getSampleValue(sample, samplesInfo))));
-                            if (subjectSamples.length) {
-                                // When we create a stream here it has the length of the activity elapsed time (end-start) filled with nulls.
-                                // We keep nulls in order to preserve the array length.
-                                activity.addStream(activity.createStream(sampleMapping.dataType));
-                                subjectSamples.forEach(subjectSample => {
-                                    activity.addDataToStream(sampleMapping.dataType, new Date(subjectSample.timestamp), sampleMapping.getSampleValue(subjectSample, samplesInfo));
-                                });
-                            }
-                        });
-                        return activity;
-                    });
-                    // If there are no activities to parse ....
-                    if (!activities.length) {
-                        reject(new EmptyEventLibError());
-                        return;
-                    }
-                    // Get the HRV to IBI if exist
-                    if (fitDataObject.hrv && fitDataObject.hrv.length) {
-                        activities.forEach((activity) => {
-                            let timeSum = 0;
-                            const ibiData = fitDataObject.hrv
-                                .reduce((ibiArray, hrvRecord) => ibiArray.concat(hrvRecord.time), [])
-                                .map((ibi) => ibi * 1000)
-                                .filter((ibi) => {
-                                // debugger;
-                                // Some Garmin devices return a record of 65.535 (65535) for some reason so exlcude those
-                                if (ibi === 65535) {
-                                    // timeSum += ibi;
-                                    return false;
-                                }
-                                timeSum += ibi;
-                                const ibiDataDate = new Date(activities[0].startDate.getTime() + timeSum);
-                                return ibiDataDate >= activity.startDate && ibiDataDate <= activity.endDate;
-                            });
-                            // set the IBI
-                            activity.addStream(new IBIStream(ibiData));
-                        });
-                    }
-                    // Parse the device infos
-                    if (fitDataObject.device_infos && fitDataObject.device_infos.length) {
-                        activities.forEach(activity => {
-                            activity.creator.devices = this.getDeviceInfos(fitDataObject.device_infos);
-                        });
-                    }
-                    // Create an event
-                    // @todo check if the start and end date can derive from the file
-                    const event = new Event(name, activities[0].startDate, activities[activities.length - 1].endDate, FileType.FIT);
-                    activities.forEach(activity => event.addActivity(activity));
-                    // debugger;
-                    EventUtilities.generateStatsForAll(event);
-                    // debugger;
-                    resolve(event);
-                });
-            });
-        });
-    }
-    /**
-     * Tell if an activity is lengths based (e.g. Pool swimming activities)
-     * @param sessionObject
-     * @private
-     */
-    static isLengthsBased(sessionObject) {
-        var _a;
-        return ((_a = sessionObject.laps) === null || _a === void 0 ? void 0 : _a.filter((lap) => { var _a; return (_a = lap.lengths) === null || _a === void 0 ? void 0 : _a.length; }).length) > 1;
-    }
-    /**
-     * Generate streams samples based on lengths on an activity
-     * When based on lengths, an activity do not provides sample under records object
-     * @param sessionObject
-     * @param options
-     * @private
-     */
-    static generateSamplesFromLengths(sessionObject, options) {
-        if (!this.isLengthsBased(sessionObject)) {
-            throw new ParsingEventLibError('Trying to get samples from activities lengths, but no lengths is available');
-        }
-        let samples = [];
-        // Loop on every laps to catch every lengths where data is (speed, cadence, hr, ...)
-        sessionObject.laps.forEach((lap) => {
-            var _a;
-            // Loop on every laps
-            if ((_a = lap.lengths) === null || _a === void 0 ? void 0 : _a.length) {
-                // Get length in meters from lap total distance and total number of lengths
-                // We will use it to generate the distance stream below
-                const lengthMeters = lap.total_distance / lap.lengths.length;
-                // For each length of every laps build the streams data we will need for a later use
-                lap.lengths.forEach((length) => {
-                    // Resolve start/end date of current length
-                    const lengthStartDate = length.start_time;
-                    const lengthDuration = (length.total_timer_time || length.total_elapsed_time || 0);
-                    const lengthEndDate = new Date(lengthStartDate.getTime() + lengthDuration * 1000);
-                    // We check if length is valid comparing to max activity duration
-                    if (lengthDuration > options.maxActivityDurationDays * 24 * 60 * 60) {
-                        return;
-                    }
-                    if (lengthEndDate.getTime() <= lengthStartDate.getTime()) {
-                        return;
-                    }
-                    // Generate a stream from length start date to end date filled by null values
-                    const streamLength = ActivityUtilities.getDataLength(lengthStartDate, lengthEndDate);
-                    let lengthStream = Array(streamLength).fill(null);
-                    // Define distance step to be used for distance stream
-                    const lengthStepSize = lengthMeters / (lengthStream.length - 1);
-                    // Generate the length stream based on data we have on current length
-                    lengthStream = lengthStream.map((value, index) => {
-                        var _a;
-                        return {
-                            timestamp: new Date(lengthStartDate.getTime() + index * 1000),
-                            distance: (((_a = samples[samples.length - 1]) === null || _a === void 0 ? void 0 : _a.distance) || 0) + lengthStepSize * index,
-                            speed: length.avg_speed || lap.avg_speed,
-                            cadence: length.avg_cadence || length.avg_swimming_cadence || lap.avg_cadence,
-                            heart_rate: length.avg_heart_rate || lap.avg_heart_rate
-                        };
-                    });
-                    // Append to existing samples
-                    samples = samples.concat(lengthStream);
-                });
-            }
-        });
-        return samples;
-    }
-    static getDeviceInfos(deviceInfos) {
-        return deviceInfos.map((deviceInfo) => {
-            const device = new Device(deviceInfo.device_type);
-            device.index = deviceInfo.device_index;
-            device.name = deviceInfo.product_name || ImporterFitAntPlusDeviceNames[deviceInfo.ant_device_number] || deviceInfo.ant_device_number;
-            device.batteryStatus = deviceInfo.battery_status;
-            device.batteryLevel = isNumber(deviceInfo.battery_level) ? deviceInfo.battery_level : deviceInfo.battery_soc;
-            device.batteryVoltage = deviceInfo.battery_voltage;
-            device.manufacturer = deviceInfo.manufacturer;
-            device.serialNumber = deviceInfo.serial_number;
-            device.product = deviceInfo.product;
-            device.swInfo = deviceInfo.software_version;
-            device.hwInfo = deviceInfo.hardware_version;
-            device.antDeviceNumber = deviceInfo.ant_device_number;
-            device.antTransmissionType = deviceInfo.ant_transmission_type;
-            device.antNetwork = deviceInfo.ant_network;
-            device.sourceType = deviceInfo.source_type;
-            device.cumOperatingTime = deviceInfo.cum_operating_time;
-            return device;
-        });
-    }
-    static getLapFromSessionLapObject(sessionLapObject, activity, lapIndex) {
-        var _a, _b, _c;
-        const startDate = (sessionLapObject === null || sessionLapObject === void 0 ? void 0 : sessionLapObject.start_time) ||
-            ((_a = sessionLapObject === null || sessionLapObject === void 0 ? void 0 : sessionLapObject.records[0]) === null || _a === void 0 ? void 0 : _a.timestamp) ||
-            ((sessionLapObject === null || sessionLapObject === void 0 ? void 0 : sessionLapObject.total_elapsed_time) &&
-                new Date(sessionLapObject.timestamp.getTime() - sessionLapObject.total_elapsed_time * 1000)) ||
-            null;
-        const endDate = (sessionLapObject === null || sessionLapObject === void 0 ? void 0 : sessionLapObject.timestamp) ||
-            (((_b = sessionLapObject.records) === null || _b === void 0 ? void 0 : _b.length) > 0 &&
-                ((_c = sessionLapObject.records[sessionLapObject.records.length - 1]) === null || _c === void 0 ? void 0 : _c.timestamp)) ||
-            (sessionLapObject.start_time &&
-                sessionLapObject.total_elapsed_time &&
-                new Date(sessionLapObject.start_time.getTime() + sessionLapObject.total_elapsed_time * 1000)) ||
-            null;
-        const lap = new Lap(startDate, endDate, // Some dont have a timestamp
-        lapIndex + 1, LapTypes[sessionLapObject.lap_trigger] || LapTypes.unknown);
-        // Set the calories
-        if (sessionLapObject.total_calories) {
-            lap.addStat(new DataEnergy(sessionLapObject.total_calories));
-        }
-        // Add stats to the lap
-        this.getStatsFromObject(sessionLapObject, activity, true).forEach(stat => lap.addStat(stat));
-        return lap;
-    }
-    static getActivityFromSessionObject(sessionObject, fitDataObject, options) {
-        /**
-         * Provides start/end date based on records available in given session object first, then in parent fit object
-         */
-        const getStartEndDatesFromRecords = (sessionObject, fitDataObject) => {
-            var _a, _b, _c, _d, _e, _f, _g, _h;
-            let startDate = null;
-            let endDate = null;
-            // Try to get from session first
-            if (((_a = sessionObject === null || sessionObject === void 0 ? void 0 : sessionObject.laps) === null || _a === void 0 ? void 0 : _a.length) > 0 && // Current session has laps
-                ((_b = sessionObject.laps[0].records) === null || _b === void 0 ? void 0 : _b.length) > 0 && // Current session has records in first lap
-                ((_c = sessionObject.laps[sessionObject.laps.length - 1].records) === null || _c === void 0 ? void 0 : _c.length) > 0 // Current session has records in last lap
-            ) {
-                const firstLapRecords = sessionObject.laps[0].records;
-                const firstRecordTimeStamp = (_d = firstLapRecords[0]) === null || _d === void 0 ? void 0 : _d.timestamp;
-                if (firstRecordTimeStamp) {
-                    startDate = firstRecordTimeStamp;
-                }
-                const lastLapRecords = sessionObject.laps[sessionObject.laps.length - 1].records;
-                const lastRecordTimeStamp = (_e = lastLapRecords[lastLapRecords.length - 1]) === null || _e === void 0 ? void 0 : _e.timestamp;
-                if (lastRecordTimeStamp) {
-                    endDate = lastRecordTimeStamp;
-                }
-            }
-            // Then from parent fit object first
-            if ((!startDate || !endDate) && ((_f = fitDataObject.records) === null || _f === void 0 ? void 0 : _f.length)) {
-                startDate = ((_g = fitDataObject.records[0]) === null || _g === void 0 ? void 0 : _g.timestamp) || null;
-                endDate = ((_h = fitDataObject.records[fitDataObject.records.length - 1]) === null || _h === void 0 ? void 0 : _h.timestamp) || null;
-            }
-            return [startDate, endDate];
-        };
-        // For some unknown reasons... the fit provided total_timer_time & total_elapsed_time could be inverted..
-        // Just invert fields if that's the case
-        this.swapTimesIfRequired(sessionObject);
-        // Start finding out total elapsed time from fit dedicated fields
-        const totalElapsedTime = sessionObject.total_elapsed_time || sessionObject.total_timer_time || 0;
-        // Pick start/end date values
-        let startDate = sessionObject.start_time || getStartEndDatesFromRecords(sessionObject, fitDataObject)[0] || null;
-        let endDate = sessionObject.timestamp ||
-            (startDate && totalElapsedTime && new Date(startDate.getTime() + totalElapsedTime * 1000)) ||
-            getStartEndDatesFromRecords(sessionObject, fitDataObject)[1] ||
-            null;
-        // Some fit files have wrong dates for session.timestamp && session.start_time and those miss an elapsed time
-        // Get dates from records in that case
-        if (!totalElapsedTime // Elapsed time missing
-        ) {
-            const [startDateResult, endDateResult] = getStartEndDatesFromRecords(sessionObject, fitDataObject);
-            if (startDateResult) {
-                startDate = startDateResult;
-            }
-            if (endDateResult) {
-                endDate = endDateResult;
-            }
-        }
-        // Now verify the start/end date compliance,
-        // If for some reason this happens, get from records too
-        if (endDate <= startDate) {
-            const [startDateResult, endDateResult] = getStartEndDatesFromRecords(sessionObject, fitDataObject);
-            if (startDateResult) {
-                startDate = startDateResult;
-            }
-            if (endDateResult) {
-                endDate = endDateResult;
-            }
-        }
-        const elapsedTimeFromDates = (+endDate - +startDate) / 1000; // Get elapsed calculated from dates
-        // Test case where sometime elapsed time (calculated from dates) can be very high comparing to computed totalElapsedTime
-        // If elapsed time (calculated from dates) is detected as "strange" then use elapsed time from fit fields instead
-        // @see test case implying 'fixtures/rides/fit/5319808632.fit' fit file
-        if (elapsedTimeFromDates / totalElapsedTime > INVALID_DATES_ELAPSED_TIME_RATIO_THRESHOLD) {
-            if (totalElapsedTime) {
-                endDate = new Date(sessionObject.start_time.getTime() + totalElapsedTime * 1000);
-            }
-        }
-        // Re-test potential updated activity duration against max accepted duration
-        if (+endDate - +startDate > options.maxActivityDurationDays * 24 * 60 * 60 * 1000) {
-            endDate = new Date(sessionObject.start_time.getTime() + totalElapsedTime * 1000);
-        }
-        if (!startDate || !endDate) {
-            throw new ParsingEventLibError('Cannot parse start and end dates');
-        }
-        else {
-            // Create an activity
-            const activity = new Activity(startDate, endDate, this.getActivityTypeFromSessionObject(sessionObject), this.getCreatorFromFitDataObject(fitDataObject), options);
-            // Set the activity stats
-            this.getStatsFromObject(sessionObject, activity, false).forEach(stat => activity.addStat(stat));
-            return activity;
-        }
-    }
-    /**
-     * For some unknown reasons... the fit provided total_timer_time & total_elapsed_time could be inverted..
-     * Just swap them if that's the case
-     */
-    static swapTimesIfRequired(object) {
-        if (isNumber(object.total_timer_time) &&
-            isNumber(object.total_elapsed_time) &&
-            object.total_elapsed_time < object.total_timer_time) {
-            const realTimerTime = object.total_elapsed_time;
-            const realElapsedTime = object.total_timer_time;
-            object.total_timer_time = realTimerTime;
-            object.total_elapsed_time = realElapsedTime;
-        }
-    }
-    static getActivityTypeFromSessionObject(session) {
-        const activityTypeKey = session.sub_sport && session.sub_sport !== 'generic' ? `${session.sport}_${session.sub_sport}` : session.sport;
-        let activityType = ActivityTypes[activityTypeKey];
-        if (!activityType || activityType === ActivityTypes.unknown) {
-            // Fallback to Garmin SDK mappings
-            const sportName = GarminProfileMapper.getSportName(session.sport);
-            const subSportName = session.sub_sport && session.sub_sport !== 'generic'
-                ? GarminProfileMapper.getSubSportName(session.sub_sport)
-                : null;
-            if (sportName || subSportName) {
-                // Try to find in ActivityTypes using the name from Garmin SDK
-                const nameKey = subSportName ? `${sportName}_${subSportName}` : sportName;
-                activityType =
-                    ActivityTypes[nameKey] ||
-                        ActivityTypes[sportName] ||
-                        nameKey;
-            }
-        }
-        return activityType || session.sport || ActivityTypes.unknown;
-    }
-    // @todo move this to a mapper
-    static getStatsFromObject(object, activity, isLap) {
-        const stats = [];
-        // For some unknown reasons... the fit provided total_timer_time & total_elapsed_time could be inverted..
-        // Just invert fields if that's the case
-        this.swapTimesIfRequired(object);
-        // TOTAL ELAPSED TIME on Object (activity, lap...)
-        let elapsedTime = 0;
-        if (isNumber(object.total_elapsed_time)) {
-            elapsedTime = object.total_elapsed_time;
-        }
-        else if ((object.timestamp - object.start_time) / 1000) {
-            elapsedTime = (object.timestamp - object.start_time) / 1000;
-        }
-        // 0 should be not included aha it's not legit to have a 0 for total timer time
-        // And that typically is a device error we should look at the samples
-        // Since start and end date are inclusive for sample size eg at time [0] there can be a value
-        if (!elapsedTime) {
-            elapsedTime = ActivityUtilities.getDataLength(activity.startDate, activity.endDate) - 1;
-        }
-        stats.push(new DataDuration(Math.round(elapsedTime * 100) / 100));
-        // TOTAL TIMER TIME on Object (activity, lap...)
-        let timerTime = 0;
-        if (isNumber(object.total_timer_time)) {
-            timerTime = object.total_timer_time;
-        }
-        // If timer time is unknown then assign elapsedTime value
-        if (!timerTime) {
-            timerTime = elapsedTime;
-        }
-        stats.push(new DataTimerTime(Math.round(timerTime * 100) / 100));
-        // Moving TIME on Object (activity, lap...)
-        let movingTime = 0;
-        if (object.lengths && object.lengths.length > 0) {
-            object.lengths.forEach((lengthVal) => {
-                if (lengthVal.length_type === 'active') {
-                    movingTime += lengthVal.total_timer_time;
-                }
-            });
-        }
-        else if (object.records && object.records.length > 0) {
-            const speedThreshold = ActivityTypesMoving.getSpeedThreshold(activity.type);
-            object.records.forEach((record, index) => {
-                var _a;
-                if ((record.speed || record.enhanced_speed) > speedThreshold) {
-                    const previousRecordTime = ((_a = object.records[index - 1]) === null || _a === void 0 ? void 0 : _a.timestamp) || object.start_time || object.records[0].timestamp;
-                    movingTime += (record.timestamp.getTime() - previousRecordTime.getTime()) / 1000;
-                }
-            });
-        }
-        if (isLap) {
-            // In case we moved (distance > 0) & moving time is invalid, then set it to timer time value
-            if (object.total_distance > 0 && (!movingTime || movingTime > timerTime)) {
-                movingTime = timerTime;
-            }
-        }
-        // Append moving stat only if moving time has been detected
-        // We need that to compute total global moving time later
-        if (movingTime > 0) {
-            stats.push(new DataMovingTime(Math.round(movingTime * 100) / 100));
-        }
-        // Pause TIME on Object (activity, lap...)
-        const pause = elapsedTime > movingTime && movingTime > 0 ? Math.round((elapsedTime - movingTime) * 100) / 100 : 0;
-        stats.push(new DataPause(pause));
-        const getStatValue = (obj, keys) => {
-            for (const key of keys) {
-                if (isNumberOrString(obj[key])) {
-                    return obj[key];
-                }
-            }
-            return null;
-        };
-        const avgSpeed = getStatValue(object, ['enhanced_avg_speed', 'EnhancedAvgSpeed', 'avg_speed', 'AvgSpeed']);
-        const totalDistance = getStatValue(object, ['total_distance', 'TotalDistance']);
-        // Assign is active lap status
-        stats.push(new DataActiveLap(!!(totalDistance || avgSpeed)));
-        if (totalDistance !== null) {
-            stats.push(new DataDistance(totalDistance));
-        }
-        else {
-            stats.push(new DataDistance(0));
-        }
-        // Heart Rate
-        if (isNumberOrString(object.avg_heart_rate)) {
-            stats.push(new DataHeartRateAvg(object.avg_heart_rate));
-        }
-        if (isNumberOrString(object.min_heart_rate)) {
-            stats.push(new DataHeartRateMin(object.min_heart_rate));
-        }
-        if (isNumberOrString(object.max_heart_rate)) {
-            stats.push(new DataHeartRateMax(object.max_heart_rate));
-        }
-        // Cadence
-        if (isNumberOrString(object.avg_cadence)) {
-            stats.push(new DataCadenceAvg(object.avg_cadence));
-        }
-        if (isNumberOrString(object.min_cadence)) {
-            stats.push(new DataCadenceMin(object.min_cadence));
-        }
-        if (isNumberOrString(object.max_cadence)) {
-            stats.push(new DataCadenceMax(object.max_cadence));
-        }
-        // Power
-        if (isNumberOrString(object.avg_power)) {
-            stats.push(new DataPowerAvg(object.avg_power));
-        }
-        if (isNumberOrString(object.min_power)) {
-            stats.push(new DataPowerMin(object.min_power));
-        }
-        if (isNumberOrString(object.max_power)) {
-            stats.push(new DataPowerMax(object.max_power));
-        }
-        if (Number.isFinite(object.normalized_power)) {
-            stats.push(new DataPowerNormalized(object.normalized_power));
-        }
-        if (Number.isFinite(object.intensity_factor)) {
-            stats.push(new DataPowerIntensityFactor(object.intensity_factor));
-        }
-        if (Number.isFinite(object.training_stress_score)) {
-            stats.push(new DataPowerTrainingStressScore(object.training_stress_score));
-        }
-        if (Number.isFinite(object.total_work)) {
-            stats.push(new DataPowerWork(Math.round(object.total_work / 1000)));
-        }
-        if (Number.isFinite(object.avg_left_torque_effectiveness)) {
-            stats.push(new DataPowerTorqueEffectivenessLeft(object.avg_left_torque_effectiveness));
-        }
-        if (Number.isFinite(object.avg_right_torque_effectiveness)) {
-            stats.push(new DataPowerTorqueEffectivenessRight(object.avg_right_torque_effectiveness));
-        }
-        if (Number.isFinite(object.avg_left_pedal_smoothness)) {
-            stats.push(new DataPowerPedalSmoothnessLeft(object.avg_left_pedal_smoothness));
-        }
-        if (Number.isFinite(object.avg_right_pedal_smoothness)) {
-            stats.push(new DataPowerPedalSmoothnessRight(object.avg_right_pedal_smoothness));
-        }
-        // Speed
-        if (avgSpeed !== null) {
-            stats.push(new DataSpeedAvg(avgSpeed));
-        }
-        const minSpeed = getStatValue(object, ['enhanced_min_speed', 'EnhancedMinSpeed', 'min_speed', 'MinSpeed']);
-        if (minSpeed !== null) {
-            stats.push(new DataSpeedMin(minSpeed));
-        }
-        const maxSpeed = getStatValue(object, ['enhanced_max_speed', 'EnhancedMaxSpeed', 'max_speed', 'MaxSpeed']);
-        if (maxSpeed !== null) {
-            stats.push(new DataSpeedMax(maxSpeed));
-        }
-        // Temperature
-        if (isNumberOrString(object.avg_temperature)) {
-            stats.push(new DataTemperatureAvg(object.avg_temperature));
-        }
-        if (isNumberOrString(object.min_temperature)) {
-            stats.push(new DataTemperatureMin(object.min_temperature));
-        }
-        if (isNumberOrString(object.max_temperature)) {
-            stats.push(new DataTemperatureMax(object.max_temperature));
-        }
-        // Ascent
-        const ascent = getStatValue(object, ['total_ascent', 'TotalAscent']);
-        if (ascent !== null) {
-            stats.push(new DataAscent(ascent));
-        }
-        // Descent
-        const descent = getStatValue(object, ['total_descent', 'TotalDescent']);
-        if (descent !== null) {
-            stats.push(new DataDescent(descent));
-        }
-        // Calories
-        if (isNumberOrString(object.total_calories)) {
-            stats.push(new DataEnergy(object.total_calories));
-        }
-        // Total training effect = Aerobic training effect
-        if (isNumberOrString(object.total_training_effect)) {
-            stats.push(new DataAerobicTrainingEffect(object.total_training_effect));
-        }
-        // Total training anaerobic effect
-        if (isNumberOrString(object.total_anaerobic_effect)) {
-            stats.push(new DataAnaerobicTrainingEffect(object.total_anaerobic_effect));
-        }
-        // Vo2Max
-        if (isNumberOrString(object.estimated_vo2_max)) {
-            stats.push(new DataVO2Max(object.estimated_vo2_max));
-        }
-        // Peak Epoc
-        if (isNumberOrString(object.peak_epoc)) {
-            stats.push(new DataPeakEPOC(object.peak_epoc));
-        }
-        // Recovery time
-        if (isNumberOrString(object.recovery_time)) {
-            stats.push(new DataRecoveryTime(object.recovery_time));
-        }
-        // Feeling
-        if (isNumberOrString(object.feeling)) {
-            stats.push(new DataFeeling(object.feeling));
-        }
-        // Pool length
-        if (isNumberOrString(object.pool_length)) {
-            let poolLength = object.pool_length;
-            if (object.pool_length_unit) {
-                poolLength = object.pool_length_unit.match(/metric/i) ? object.pool_length : object.pool_length * 0.9144; // Convert to meters from yards when not metric
-            }
-            stats.push(new DataPoolLength(poolLength));
-        }
-        // Average SWOLF in 25m and 50m pool
-        if ((activity.type === ActivityTypes.Swimming || activity.type === ActivityTypes.OpenWaterSwimming) &&
-            (isNumberOrString(object.avg_speed) || isNumberOrString(object.enhanced_avg_speed)) &&
-            isNumberOrString(object.avg_cadence)) {
-            const avgPace100m = 100 / (object.avg_speed || object.enhanced_avg_speed);
-            if (Number.isFinite(avgPace100m) && Number.isFinite(object.avg_cadence)) {
-                const avgCadence = object.avg_cadence;
-                const swolf25m = ActivityUtilities.computeSwimSwolf(avgPace100m, avgCadence, 25);
-                stats.push(new DataSWOLF25m(swolf25m));
-                const swolf50m = ActivityUtilities.computeSwimSwolf(avgPace100m, avgCadence, 50);
-                stats.push(new DataSWOLF50m(swolf50m));
-            }
-        }
-        // Active lengths
-        if (isNumberOrString(object.num_active_lengths)) {
-            stats.push(new DataActiveLengths(object.num_active_lengths));
-        }
-        // Total cycle
-        if (isNumberOrString(object.total_cycles)) {
-            stats.push(new DataTotalCycles(object.total_cycles));
-        }
-        // Description
-        if (isNumberOrString(object.description)) {
-            stats.push(new DataDescription(object.description));
-        }
-        // Cycling dynamics
-        if (Number.isFinite(object.time_standing)) {
-            const standingTime = Math.round(object.time_standing);
-            stats.push(new DataCyclingStandingTime(standingTime));
-            const seatedTime = Math.round(timerTime - standingTime);
-            stats.push(new DataCyclingSeatedTime(seatedTime));
-        }
-        // Running dynamics
-        if (Number.isFinite(object.avg_stance_time)) {
-            stats.push(new DataStanceTime(object.avg_stance_time));
-        }
-        if (Number.isFinite(object.avg_vertical_oscillation)) {
-            stats.push(new DataVerticalOscillation(object.avg_vertical_oscillation));
-        }
-        if (Number.isFinite(object.avg_vertical_ratio)) {
-            stats.push(new DataVerticalRatio(object.avg_vertical_ratio));
-        }
-        if (Number.isFinite(object.avg_step_length)) {
-            const avgStrideLengthMeters = object.avg_step_length / 1000;
-            stats.push(new DataAvgStrideLength(Math.round(avgStrideLengthMeters * 100) / 100));
-        }
-        return stats;
-    }
-    static getCreatorFromFitDataObject(fitDataObject) {
-        const toStartCase = (str) => {
-            return str.replace(/\w\S*/g, txt => txt.charAt(0).toUpperCase() + txt.substr(1).toLowerCase());
-        };
-        const formatDeviceName = (manufacturer, productName, recognizedName, recognizedBrand, isDevelopment = false) => {
-            let name = '';
-            if (recognizedBrand && recognizedName) {
-                name = `${toStartCase(recognizedBrand)} ${recognizedName}`;
-            }
-            else if (recognizedBrand && !recognizedName && productName) {
-                if (productName.match(new RegExp(`${recognizedBrand}`, 'gi'))) {
-                    productName = productName.replace(new RegExp(`${recognizedBrand}`, 'gi'), '').trim();
-                }
-                name = `${toStartCase(recognizedBrand)} ${productName}`;
-            }
-            else if (recognizedBrand && !recognizedName && !productName) {
-                name = `${toStartCase(recognizedBrand)}`;
-            }
-            else if (manufacturer && !recognizedBrand && !recognizedName && !productName && !isDevelopment) {
-                const formattedManufacturer = manufacturer.replace(new RegExp('[-_]', 'gi'), ' ').trim();
-                name = `${toStartCase(formattedManufacturer)}`;
-            }
-            else if (!recognizedBrand && recognizedName) {
-                name = `${recognizedName}`;
-            }
-            else {
-                name = 'Unknown';
-            }
-            return name;
-        };
-        let creator;
-        let recognizedName = null;
-        const manufacturer = fitDataObject.file_ids[0].manufacturer;
-        const productId = fitDataObject.file_ids[0].product || null;
-        const productName = fitDataObject.file_ids[0].product_name || null;
-        switch (manufacturer) {
-            case 'suunto': {
-                recognizedName = ImporterFitSuuntoDeviceNames[productId];
-                creator = new Creator(formatDeviceName(manufacturer, productName, recognizedName, 'Suunto'), productId);
-                break;
-            }
-            case 'coros': {
-                recognizedName = ImporterFitCorosDeviceNames[productId];
-                creator = new Creator(formatDeviceName(manufacturer, productName, recognizedName, 'Coros'), productId);
-                break;
-            }
-            case 'garmin': {
-                recognizedName = GarminProfileMapper.getDeviceName(productId);
-                creator = new Creator(formatDeviceName(manufacturer, productName, recognizedName, 'Garmin'), productId);
-                break;
-            }
-            case 'wahoo_fitness': {
-                recognizedName = ImporterFitWahooDeviceNames[productId];
-                creator = new Creator(formatDeviceName(manufacturer, productName, recognizedName, 'Wahoo'), productId);
-                break;
-            }
-            case 'hammerhead': {
-                recognizedName = ImporterFitHammerheadDeviceNames[productId];
-                creator = new Creator(formatDeviceName(manufacturer, productName, recognizedName, 'Hammerhead'), productId);
-                break;
-            }
-            case 'lezyne': {
-                recognizedName = ImporterFitLezyneDeviceNames[productId];
-                creator = new Creator(formatDeviceName(manufacturer, productName, recognizedName, 'Lezyne'), productId);
-                break;
-            }
-            case 'magellan': {
-                recognizedName = ImporterFitMagellanDeviceNames[productId];
-                creator = new Creator(formatDeviceName(manufacturer, productName, recognizedName, 'Magellan'), productId);
-                break;
-            }
-            case 'saris': {
-                recognizedName = ImporterFitSarisDeviceNames[productId];
-                creator = new Creator(formatDeviceName(manufacturer, productName, recognizedName, 'Saris'), productId);
-                break;
-            }
-            case 'srm': {
-                recognizedName = ImporterFitSrmDeviceNames[productId];
-                creator = new Creator(formatDeviceName(manufacturer, productName, recognizedName, 'SRM'), productId);
-                break;
-            }
-            case 'zwift': {
-                recognizedName = 'Zwift';
-                creator = new Creator(recognizedName);
-                break;
-            }
-            case 'virtualtraining': {
-                recognizedName = 'Rouvy';
-                creator = new Creator(recognizedName);
-                break;
-            }
-            case 'the_sufferfest': {
-                recognizedName = `Wahoo SYSTM`;
-                creator = new Creator(recognizedName, productId);
-                break;
-            }
-            case 'stryd': {
-                recognizedName = `Stryd`;
-                creator = new Creator(recognizedName, productId, fitDataObject.file_creator.software_version, fitDataObject.file_creator.hardware_version, fitDataObject.file_ids[0].serial_number);
-                break;
-            }
-            case 'development': {
-                recognizedName = ImporterFitDevelopmentDeviceNames[productId];
-                creator = new Creator(formatDeviceName(manufacturer, productName, recognizedName, null, true), productId);
-                creator.isRecognized = typeof recognizedName === 'string' || recognizedName === null;
-                break;
-            }
-            default: {
-                // Try to find if it's a numeric Garmin mapping that was missed
-                const manufacturerName = typeof manufacturer === 'number' ? GarminProfileMapper.getManufacturerName(manufacturer) : manufacturer;
-                if (manufacturerName === 'garmin') {
-                    recognizedName = GarminProfileMapper.getDeviceName(productId);
-                }
-                creator = new Creator(formatDeviceName(manufacturer, productName, recognizedName, manufacturerName === 'garmin' ? 'Garmin' : null), productId);
-            }
-        }
-        creator.manufacturer = manufacturer;
-        creator.isRecognized = creator.isRecognized || !!recognizedName;
-        if (fitDataObject.file_creator && isNumberOrString(fitDataObject.file_creator.hardware_version)) {
-            creator.hwInfo = String(fitDataObject.file_creator.hardware_version);
-        }
-        if (fitDataObject.file_creator && isNumberOrString(fitDataObject.file_creator.software_version)) {
-            creator.swInfo = String(fitDataObject.file_creator.software_version);
-        }
-        else if (fitDataObject.device_info && isNumberOrString(fitDataObject.device_info.software_version)) {
-            creator.swInfo = String(fitDataObject.device_info.software_version);
-        }
-        if (fitDataObject.file_ids[0] && isNumberOrString(fitDataObject.file_ids[0].serial_number)) {
-            creator.serialNumber = fitDataObject.file_ids[0].serial_number;
-        }
-        // If creator name is a number ONLY (e.g. product number), then flag it as 'Unknown'
-        if (Number.isFinite(creator.name) || creator.name.match(/^\d+$/)) {
-            creator.name = `Unknown`;
-        }
-        return creator;
-    }
-}