@sports-alliance/sports-lib 6.0.4 → 6.1.1

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

@@ -0,0 +1,36 @@
+export class GXParser {
+    constructor(xml, domParser = null) {
+        domParser = domParser || DOMParser;
+        const parser = new domParser();
+        const root = parser.parseFromString(xml, 'text/xml');
+        return this.parseChild(root.documentElement);
+    }
+    parseChild(elm) {
+        const attrs = {};
+        const attributes = elm.attributes;
+        for (let i = 0; i < attributes.length; i++) {
+            const attr = attributes[i];
+            if (attr && attr.value) {
+                attrs[attr.name] = attr.value;
+            }
+        }
+        if (elm.childNodes) {
+            const children = elm.childNodes;
+            for (let i = 0; i < children.length; i++) {
+                const child = children[i];
+                const name = child.localName;
+                if (!name) {
+                    continue;
+                }
+                if (!attrs[name]) {
+                    attrs[name] = [];
+                }
+                attrs[name].push(this.parseChild(child));
+            }
+        }
+        if (Object.keys(attrs).length === 0) {
+            return elm.textContent;
+        }
+        return attrs;
+    }
+}

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

@@ -0,0 +1,5 @@
+import { EventInterface } from '../../../event.interface';
+import { ActivityParsingOptions } from '../../../../activities/activity-parsing-options';
+export declare class EventImporterGPX {
+    static getFromString(gpx: string, domParser?: any, options?: ActivityParsingOptions, name?: string): Promise<EventInterface>;
+}

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,142 @@
+import { DataLatitudeDegrees } from '../../../../data/data.latitude-degrees';
+import { DataAltitude } from '../../../../data/data.altitude';
+import { DataHeartRate } from '../../../../data/data.heart-rate';
+import { DataCadence } from '../../../../data/data.cadence';
+import { DataTemperature } from '../../../../data/data.temperature';
+import { DataDistance } from '../../../../data/data.distance';
+import { DataSeaLevelPressure } from '../../../../data/data.sea-level-pressure';
+import { DataSpeed } from '../../../../data/data.speed';
+import { DataVerticalSpeed } from '../../../../data/data.vertical-speed';
+import { DataPower } from '../../../../data/data.power';
+import { DataLongitudeDegrees } from '../../../../data/data.longitude-degrees';
+import { isNumberOrString } from '../../../utilities/helpers';
+export const GPXSampleMapper = [
+    {
+        dataType: DataLatitudeDegrees.type,
+        getSampleValue: sample => Number(sample.lat)
+    },
+    {
+        dataType: DataLongitudeDegrees.type,
+        getSampleValue: sample => Number(sample.lon)
+    },
+    {
+        dataType: DataAltitude.type,
+        getSampleValue: sample => (sample.ele ? Number(sample.ele[0]) : null)
+    },
+    {
+        dataType: DataHeartRate.type,
+        getSampleValue: sample => {
+            // debugger;
+            if (!sample.extensions || !sample.extensions.length) {
+                return null;
+            }
+            if (sample.extensions[0].heartrate && isNumberOrString(sample.extensions[0].heartrate[0])) {
+                return Number(sample.extensions[0].heartrate[0]);
+            }
+            if (sample.extensions[0].TrackPointExtension &&
+                sample.extensions[0].TrackPointExtension[0] &&
+                sample.extensions[0].TrackPointExtension[0].hr) {
+                return Number(sample.extensions[0].TrackPointExtension[0].hr[0]);
+            }
+            return null;
+        }
+    },
+    {
+        dataType: DataCadence.type,
+        getSampleValue: sample => {
+            // debugger;
+            if (!sample.extensions || !sample.extensions.length) {
+                return null;
+            }
+            if (sample.extensions[0].cadence && isNumberOrString(sample.extensions[0].cadence[0])) {
+                return Number(sample.extensions[0].cadence[0]);
+            }
+            if (sample.extensions[0].TrackPointExtension &&
+                sample.extensions[0].TrackPointExtension[0] &&
+                sample.extensions[0].TrackPointExtension[0].cad) {
+                return Number(sample.extensions[0].TrackPointExtension[0].cad[0]);
+            }
+            return null;
+        }
+    },
+    {
+        dataType: DataTemperature.type,
+        getSampleValue: sample => {
+            // debugger;
+            if (!sample.extensions || !sample.extensions.length) {
+                return null;
+            }
+            if (sample.extensions[0].temp && isNumberOrString(sample.extensions[0].temp[0])) {
+                return Number(sample.extensions[0].temp[0]);
+            }
+            if (sample.extensions[0].TrackPointExtension &&
+                sample.extensions[0].TrackPointExtension[0] &&
+                sample.extensions[0].TrackPointExtension[0].atemp) {
+                return Number(sample.extensions[0].TrackPointExtension[0].atemp[0]);
+            }
+            return null;
+        }
+    },
+    {
+        dataType: DataDistance.type,
+        getSampleValue: sample => {
+            if (!sample.extensions || !sample.extensions.length) {
+                return null;
+            }
+            if (sample.extensions[0].distance && isNumberOrString(sample.extensions[0].distance[0])) {
+                return Number(sample.extensions[0].distance[0]);
+            }
+            return null;
+        }
+    },
+    {
+        dataType: DataSeaLevelPressure.type,
+        getSampleValue: sample => {
+            if (!sample.extensions || !sample.extensions.length) {
+                return null;
+            }
+            if (sample.extensions[0].seaLevelPressure && isNumberOrString(sample.extensions[0].seaLevelPressure[0])) {
+                return Number(sample.extensions[0].seaLevelPressure[0]);
+            }
+            return null;
+        }
+    },
+    {
+        dataType: DataSpeed.type,
+        getSampleValue: sample => {
+            if (!sample.extensions || !sample.extensions.length) {
+                return null;
+            }
+            if (sample.extensions[0].speed && isNumberOrString(sample.extensions[0].speed[0])) {
+                return Number(sample.extensions[0].speed[0]);
+            }
+            return null;
+        }
+    },
+    {
+        dataType: DataVerticalSpeed.type,
+        getSampleValue: sample => {
+            if (!sample.extensions || !sample.extensions.length) {
+                return null;
+            }
+            if (sample.extensions[0].verticalSpeed && isNumberOrString(sample.extensions[0].verticalSpeed[0])) {
+                return Number(sample.extensions[0].verticalSpeed[0]);
+            }
+            return null;
+        }
+    },
+    {
+        dataType: DataPower.type,
+        getSampleValue: (sample, sampleInfo) => {
+            var _a;
+            let watts = null;
+            if (((_a = sample.extensions) === null || _a === void 0 ? void 0 : _a.length) && sample.extensions[0].power && isNumberOrString(sample.extensions[0].power[0])) {
+                watts = Number(sample.extensions[0].power[0]);
+            }
+            // Ensure power stream compliance when in some cases power sample field could be missing even if others samples have it
+            // Just set watts to 0 when this happen
+            // Case example: ride file "7555261629.gpx"  from integration tests
+            return (sampleInfo === null || sampleInfo === void 0 ? void 0 : sampleInfo.hasPowerMeter) ? watts || 0 : null;
+        }
+    }
+];

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

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

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

@@ -0,0 +1,54 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { EventImporterGPX } from './importer.gpx';
+import xmldom from '@xmldom/xmldom';
+describe('importer.gpx', () => {
+    it('parses gpx without name', () => __awaiter(void 0, void 0, void 0, function* () {
+        const gpxString = `<?xml version="1.0" encoding="UTF-8"?>
+        <gpx creator="Garmin Connect" version="1.1"
+          xsi:schemaLocation="http://www.topografix.com/GPX/1/1 http://www.topografix.com/GPX/11.xsd"
+          xmlns:ns3="http://www.garmin.com/xmlschemas/TrackPointExtension/v1"
+          xmlns="http://www.topografix.com/GPX/1/1"
+          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:ns2="http://www.garmin.com/xmlschemas/GpxExtensions/v3">
+          <metadata>
+            <link href="connect.garmin.com">
+              <text>Garmin Connect</text>
+            </link>
+            <time>2019-09-29T13:58:25.000Z</time>
+          </metadata>
+          <trk>
+            <type>road_biking</type>
+          </trk>
+        </gpx> `;
+        const result = yield EventImporterGPX.getFromString(gpxString, xmldom.DOMParser);
+        expect(result.getFirstActivity().name).toEqual('');
+    }));
+    it('parses gpx with name', () => __awaiter(void 0, void 0, void 0, function* () {
+        const gpxString = `<?xml version="1.0" encoding="UTF-8"?>
+        <gpx creator="Garmin Connect" version="1.1"
+          xsi:schemaLocation="http://www.topografix.com/GPX/1/1 http://www.topografix.com/GPX/11.xsd"
+          xmlns:ns3="http://www.garmin.com/xmlschemas/TrackPointExtension/v1"
+          xmlns="http://www.topografix.com/GPX/1/1"
+          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:ns2="http://www.garmin.com/xmlschemas/GpxExtensions/v3">
+          <metadata>
+            <link href="connect.garmin.com">
+              <text>Garmin Connect</text>
+            </link>
+            <time>2019-09-29T13:58:25.000Z</time>
+          </metadata>
+          <trk>
+            <name>Meylan Road Cycling</name>
+            <type>road_biking</type>
+          </trk>
+        </gpx> `;
+        const result = yield EventImporterGPX.getFromString(gpxString, xmldom.DOMParser);
+        expect(result.getFirstActivity().name).toEqual('Meylan Road Cycling');
+    }));
+});

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

@@ -0,0 +1,26 @@
+import { EventInterface } from '../../../event.interface';
+import { IntensityZones } from '../../../../intensity-zones/intensity-zones';
+import { ActivityInterface } from '../../../../activities/activity.interface';
+import { EventJSONInterface } from '../../../event.json.interface';
+import { CreatorJSONInterface } from '../../../../creators/creator.json.interface';
+import { CreatorInterface } from '../../../../creators/creator.interface';
+import { LapJSONInterface } from '../../../../laps/lap.json.interface';
+import { LapInterface } from '../../../../laps/lap.interface';
+import { ActivityJSONInterface } from '../../../../activities/activity.json.interface';
+import { IntensityZonesJSONInterface } from '../../../../intensity-zones/intensity-zones.json.interface';
+import { StreamInterface } from '../../../../streams/stream.interface';
+import { StreamJSONInterface } from '../../../../streams/stream';
+import { DeviceJsonInterface } from '../../../../activities/devices/device.json.interface';
+import { DeviceInterface } from '../../../../activities/devices/device.interface';
+import { DataJSONInterface } from '../../../../data/data.json.interface';
+import { DataEvent } from '../../../../data/data.event';
+export declare class EventImporterJSON {
+    static getEventFromJSON(json: EventJSONInterface): EventInterface;
+    static getCreatorFromJSON(json: CreatorJSONInterface): CreatorInterface;
+    static getDeviceFromJSON(json: DeviceJsonInterface): DeviceInterface;
+    static getLapFromJSON(json: LapJSONInterface, lapIndex: number): LapInterface;
+    static getStreamFromJSON(json: StreamJSONInterface): StreamInterface;
+    static getIntensityZonesFromJSON(json: IntensityZonesJSONInterface): IntensityZones;
+    static getActivityEventFromJSON(json: DataJSONInterface): DataEvent;
+    static getActivityFromJSON(json: ActivityJSONInterface): ActivityInterface;
+}

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

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

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

@@ -0,0 +1,3 @@
+export interface SampleInfo {
+    hasPowerMeter: boolean;
+}

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

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