skiz-parser 4.2.4 → 5.0.1

package/README.md

@@ -1,6 +1,6 @@
 # skiz-parser
 
-> Parse a .skiz file exported from Ski Tracks
+Parse a .skiz file exported from Ski Tracks
 
 ## Install
 
@@ -11,10 +11,10 @@ $ npm install skiz-parser
 ## Usage
 
 ```js
-import { promises as fsAsync } from 'fs';
+import { readFile } from 'node:fs/promises';
 import { parseSkizFile } from 'skiz-parser';
 
-const contents = await fsAsync.readFile('./example.skiz');
+const contents = await readFile('./example.skiz');
 const result = await parseSkizFile(contents);
 
 console.log(result);
@@ -23,20 +23,12 @@ console.log(result);
 
 ## API
 
-### parseSkizFile(contents, callback?)
+### parseSkizFile(contents)
 
-Returns a `Promise<object>` with the parsed .skiz file.
-
-Optionally a callback function may be used instead.
+Returns a `Promise<SkizTrack>` with the parsed .skiz file.
 
 #### contents
 
-Type: `Buffer`
+Type: `ArrayBuffer | Buffer`
 
 Contents of a `.skiz` file.
-
-#### callback
-
-Type: `Function`
-
-Optional callback with error as the first argument and the parsed .skiz file as the second.

package/dist/index.d.ts

@@ -0,0 +1,105 @@
+export interface SkizBatteryUsage {
+    level: number;
+    status: string;
+    timestamp: Date;
+}
+export interface SkizRelativeAltitude {
+    pressure: number;
+    relativeAltitude: number;
+    timestamp: Date;
+}
+export interface SkizTrackEvent {
+    end: Date;
+    start: Date;
+    type: string;
+}
+export interface SkizTrackNode {
+    altitude: number;
+    hAccuracy: number;
+    heading: number;
+    latitude: number;
+    longitude: number;
+    timestamp: Date;
+    vAccuracy: number;
+    velocity: number;
+}
+export interface SkizTrackSegmentMetrics {
+    distance: number;
+    finishAltitude: number;
+    maxAltitude: number;
+    maxSlope: number;
+    maxSpeed: number;
+    minAltitude: number;
+    slope: number;
+    speed: number;
+    startAltitude: number;
+    time: number;
+    vertical: number;
+}
+export interface SkizTrackSegment {
+    category: string;
+    comment: string;
+    endTime: Date;
+    link: string;
+    metrics: SkizTrackSegmentMetrics;
+    name: string;
+    number: number;
+    startTime: Date;
+    type: string;
+    uuid: string;
+}
+export interface SkizTrackMetrics {
+    ascentDistance: number;
+    ascents: number;
+    averageAscentSpeed: number;
+    averageDescentSpeed: number;
+    averageSpeed: number;
+    descentDistance: number;
+    descents: number;
+    distance: number;
+    duration: number;
+    finishAltitude: number;
+    laps: number;
+    maxAltitude: number;
+    maxAscentSpeed: number;
+    maxAscentSteepness: number;
+    maxDescentSpeed: number;
+    maxDescentSteepness: number;
+    maxSpeed: number;
+    maxVerticalAscentSpeed: number;
+    maxVerticalDescentSpeed: number;
+    minAltitude: number;
+    movingAverageAscentSpeed: number;
+    movingAverageDescentSpeed: number;
+    movingAverageSpeed: number;
+    profileDistance: number;
+    startAltitude: number;
+    totalAscent: number;
+    totalDescent: number;
+}
+export interface SkizTrack {
+    activity: string;
+    batteryUsage: SkizBatteryUsage[];
+    conditions: string;
+    description: string;
+    duration: number;
+    finish: Date;
+    hidden: boolean;
+    includeInSeason: boolean;
+    name: string;
+    parseObjectId: string;
+    platform: string;
+    rating: number;
+    relativeAltitude: SkizRelativeAltitude[];
+    start: Date;
+    syncIdentifier: string;
+    syncVersion: number;
+    trackEvents: SkizTrackEvent[];
+    trackMetrics: SkizTrackMetrics;
+    trackNodes: SkizTrackNode[];
+    trackSegments: SkizTrackSegment[];
+    tz: string;
+    version: string;
+    weather: string;
+}
+export declare const parseSkizFile: (contents: ArrayBuffer | Buffer) => Promise<SkizTrack>;

package/dist/index.js

@@ -0,0 +1,268 @@
+import { parse as CSVParser } from 'csv-parse';
+import { XMLParser } from 'fast-xml-parser';
+import { fromBuffer } from 'yauzl';
+const xmlParserOptions = {
+    attributeNamePrefix: '',
+    ignoreAttributes: false,
+};
+const convertReadStreamToBuffer = (readStream) => {
+    return new Promise((resolve, reject) => {
+        const chunks = [];
+        readStream
+            .on('error', reject)
+            .on('data', (chunk) => {
+            chunks.push(chunk);
+        })
+            .once('end', () => {
+            resolve(Buffer.concat(chunks));
+        });
+    });
+};
+const openReadStream = (zipFile, entry) => {
+    return new Promise((resolve, reject) => {
+        zipFile.openReadStream(entry, (err, readStream) => {
+            err ? reject(err) : resolve(readStream);
+        });
+    });
+};
+const parseBatteryCsvFile = (readStream) => {
+    const parser = CSVParser();
+    return new Promise((resolve, reject) => {
+        const batteryUsage = [];
+        parser
+            .on('error', reject)
+            .on('readable', () => {
+            let record;
+            while ((record = parser.read()) !== null) {
+                batteryUsage.push({
+                    timestamp: new Date(record[0]),
+                    status: record[1],
+                    level: parseFloat(record[2]),
+                });
+            }
+        })
+            .once('end', () => {
+            resolve(batteryUsage);
+        });
+        readStream.pipe(parser);
+    });
+};
+const parseNodeCsvFile = (readStream) => {
+    const parser = CSVParser();
+    return new Promise((resolve, reject) => {
+        const trackNodes = [];
+        parser
+            .on('error', reject)
+            .on('readable', () => {
+            let record;
+            while ((record = parser.read()) !== null) {
+                trackNodes.push({
+                    timestamp: new Date(parseFloat(record[0]) * 1000.0),
+                    latitude: parseFloat(record[1]),
+                    longitude: parseFloat(record[2]),
+                    altitude: parseFloat(record[3]),
+                    heading: parseFloat(record[4]),
+                    velocity: parseFloat(record[5]),
+                    hAccuracy: parseFloat(record[6]),
+                    vAccuracy: parseFloat(record[7]),
+                });
+            }
+        })
+            .once('end', () => {
+            resolve(trackNodes);
+        });
+        readStream.pipe(parser);
+    });
+};
+const parseRelativeAltitudeSensorCsvFile = (readStream) => {
+    const parser = CSVParser();
+    return new Promise((resolve, reject) => {
+        const relativeAltitude = [];
+        readStream.pipe(parser);
+        parser
+            .on('error', reject)
+            .on('readable', () => {
+            let record;
+            while ((record = parser.read()) !== null) {
+                relativeAltitude.push({
+                    timestamp: new Date(record[0]),
+                    pressure: parseFloat(record[1]),
+                    relativeAltitude: parseFloat(record[2]),
+                });
+            }
+        })
+            .once('end', () => {
+            resolve(relativeAltitude);
+        });
+    });
+};
+const parseSegmentCsvFile = (readStream) => {
+    const parser = CSVParser({ fromLine: 2 });
+    return new Promise((resolve, reject) => {
+        const trackSegments = [];
+        parser
+            .on('error', reject)
+            .on('readable', () => {
+            let record;
+            while ((record = parser.read()) !== null) {
+                trackSegments.push({
+                    startTime: new Date(parseFloat(record[0]) * 1000),
+                    endTime: new Date(parseFloat(record[1]) * 1000),
+                    number: parseInt(record[4], 10),
+                    name: record[5],
+                    comment: record[6],
+                    type: record[7],
+                    category: record[8],
+                    link: record[9],
+                    uuid: record[10],
+                    metrics: {
+                        time: parseFloat(record[11]),
+                        speed: parseFloat(record[12]),
+                        distance: parseFloat(record[13]),
+                        vertical: parseFloat(record[14]),
+                        maxSpeed: parseFloat(record[15]),
+                        slope: parseFloat(record[16]),
+                        maxSlope: parseFloat(record[17]),
+                        minAltitude: parseFloat(record[18]),
+                        maxAltitude: parseFloat(record[19]),
+                        startAltitude: parseFloat(record[20]),
+                        finishAltitude: parseFloat(record[21]),
+                    },
+                });
+            }
+        })
+            .once('end', () => {
+            resolve(trackSegments);
+        });
+        readStream.pipe(parser);
+    });
+};
+const parseTrackXmlFile = async (readStream) => {
+    const buffer = await convertReadStreamToBuffer(readStream);
+    const parser = new XMLParser(xmlParserOptions);
+    const parsed = parser.parse(buffer.toString('utf-8'));
+    const track = parsed.track;
+    const metrics = track.metrics;
+    return {
+        rating: parseInt(track.rating, 10),
+        start: new Date(Date.parse(track.start)),
+        finish: new Date(Date.parse(track.finish)),
+        description: track.description,
+        version: track.version,
+        parseObjectId: track.parseObjectId,
+        tz: track.tz,
+        includeInSeason: track.includeinseason === 'true',
+        syncIdentifier: track.syncIdentifier,
+        conditions: track.conditions,
+        platform: track.platform,
+        weather: track.weather,
+        activity: track.activity,
+        hidden: track.hidden === 'true',
+        duration: parseFloat(track.duration),
+        name: track.name,
+        syncVersion: parseInt(track.syncVersion, 10),
+        trackMetrics: {
+            maxSpeed: metrics.maxspeed,
+            maxDescentSpeed: metrics.maxdescentspeed,
+            maxAscentSpeed: metrics.maxascentspeed,
+            maxDescentSteepness: metrics.maxdescentsteepness,
+            maxAscentSteepness: metrics.maxascentsteepness,
+            maxVerticalDescentSpeed: metrics.maxverticaldescentspeed,
+            maxVerticalAscentSpeed: metrics.maxverticalascentspeed,
+            totalAscent: metrics.totalascent,
+            totalDescent: metrics.totaldescent,
+            maxAltitude: metrics.maxaltitude,
+            minAltitude: metrics.minaltitude,
+            distance: metrics.distance,
+            profileDistance: metrics.profiledistance,
+            descentDistance: metrics.descentdistance,
+            ascentDistance: metrics.ascentdistance,
+            averageSpeed: metrics.averagespeed,
+            averageDescentSpeed: metrics.averagedescentspeed,
+            averageAscentSpeed: metrics.averageascentspeed,
+            movingAverageSpeed: metrics.movingaveragespeed,
+            movingAverageDescentSpeed: metrics.movingaveragedescentspeed,
+            movingAverageAscentSpeed: metrics.movingaverageascentspeed,
+            duration: metrics.duration,
+            startAltitude: metrics.startaltitude,
+            finishAltitude: metrics.finishaltitude,
+            ascents: metrics.ascents,
+            descents: metrics.descents,
+            laps: metrics.laps,
+        },
+    };
+};
+const parseEventsXmlFile = async (readStream) => {
+    const buffer = await convertReadStreamToBuffer(readStream);
+    const parser = new XMLParser(xmlParserOptions);
+    const parsed = parser.parse(buffer.toString('utf-8'));
+    const events = parsed.events.event || [];
+    const trackEvents = events.map((event) => ({
+        start: new Date(Date.parse(event.start)),
+        end: new Date(Date.parse(event.end)),
+        type: event.type,
+    }));
+    return trackEvents;
+};
+export const parseSkizFile = (contents) => {
+    const buffer = contents instanceof ArrayBuffer ? Buffer.from(contents) : contents;
+    return new Promise((resolve, reject) => {
+        fromBuffer(buffer, { lazyEntries: true }, (err, zipFile) => {
+            if (err) {
+                return reject(err);
+            }
+            let skizTrackXml;
+            let batteryUsage;
+            let relativeAltitude;
+            let trackEvents;
+            let trackNodes;
+            let trackSegments;
+            zipFile.readEntry();
+            zipFile
+                .on('error', reject)
+                .on('entry', async (entry) => {
+                if (![
+                    'Battery.csv',
+                    'Events.xml',
+                    'Nodes.csv',
+                    'RelativeAltitudeSensor.csv',
+                    'Segment.csv',
+                    'Track.xml',
+                ].includes(entry.fileName)) {
+                    return zipFile.readEntry();
+                }
+                const readStream = await openReadStream(zipFile, entry);
+                if (entry.fileName === 'Battery.csv') {
+                    batteryUsage = await parseBatteryCsvFile(readStream);
+                }
+                else if (entry.fileName === 'Events.xml') {
+                    trackEvents = await parseEventsXmlFile(readStream);
+                }
+                else if (entry.fileName === 'Nodes.csv') {
+                    trackNodes = await parseNodeCsvFile(readStream);
+                }
+                else if (entry.fileName === 'RelativeAltitudeSensor.csv') {
+                    relativeAltitude =
+                        await parseRelativeAltitudeSensorCsvFile(readStream);
+                }
+                else if (entry.fileName === 'Segment.csv') {
+                    trackSegments = await parseSegmentCsvFile(readStream);
+                }
+                else if (entry.fileName === 'Track.xml') {
+                    skizTrackXml = await parseTrackXmlFile(readStream);
+                }
+                zipFile.readEntry();
+            })
+                .once('end', () => {
+                resolve({
+                    ...skizTrackXml,
+                    batteryUsage,
+                    relativeAltitude,
+                    trackEvents,
+                    trackNodes,
+                    trackSegments,
+                });
+            });
+        });
+    });
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "skiz-parser",
-  "version": "4.2.4",
+  "version": "5.0.1",
   "description": "Parse a .skiz file exported from Ski Tracks",
   "author": "Kirk Eaton <contact@kirkeaton.ca>",
   "bugs": {
@@ -12,23 +12,25 @@
     "yauzl": "3.2.0"
   },
   "devDependencies": {
-    "@kirkeaton/prettier-config": "1.0.2",
-    "@kirkeaton/semantic-release-config": "1.0.1",
+    "@kirkeaton/prettier-config": "1.0.3",
+    "@kirkeaton/semantic-release-config": "1.0.2",
+    "@kirkeaton/tsconfig": "1.0.0",
     "@types/node": "22.10.2",
+    "@types/yauzl": "2.10.3",
     "prettier": "3.4.2",
     "semantic-release": "24.2.0",
-    "tsd": "0.31.2"
+    "tsx": "4.19.2",
+    "typescript": "5.7.2"
   },
   "engines": {
     "node": ">=18"
   },
   "exports": {
-    "types": "./index.d.ts",
-    "default": "./index.js"
+    "types": "./dist/index.d.ts",
+    "default": "./dist/index.js"
   },
   "files": [
-    "index.js",
-    "index.d.ts"
+    "dist"
   ],
   "homepage": "https://github.com/kirkeaton/skiz-parser#readme",
   "keywords": [
@@ -44,7 +46,10 @@
     "url": "git+https://github.com/kirkeaton/skiz-parser.git"
   },
   "scripts": {
-    "test": "node --test && tsd"
+    "build": "pnpm clean && tsc -p tsconfig.build.json",
+    "clean": "rm -rf dist",
+    "prepublishOnly": "pnpm build",
+    "test": "tsx --test"
   },
   "type": "module"
 }

package/index.d.ts

@@ -1,119 +0,0 @@
-export interface SkizBatteryUsage {
-  level: number;
-  status: string;
-  timestamp: Date;
-}
-
-export interface SkizRelativeAltitude {
-  pressure: number;
-  relativeAltitude: number;
-  timestamp: Date;
-}
-
-export interface SkizTrackEvent {
-  end: Date;
-  start: Date;
-  type: string;
-}
-
-export interface SkizTrackNode {
-  altitude: number;
-  hAccuracy: number;
-  heading: number;
-  latitude: number;
-  longitude: number;
-  timestamp: Date;
-  vAccuracy: number;
-  velocity: number;
-}
-
-export interface SkizTrackSegmentMetrics {
-  distance: number;
-  finishAltitude: number;
-  maxAltitude: number;
-  maxSlope: number;
-  maxSpeed: number;
-  minAltitude: number;
-  slope: number;
-  speed: number;
-  startAltitude: number;
-  time: number;
-  vertical: number;
-}
-
-export interface SkizTrackSegment {
-  category: string;
-  comment: string;
-  endTime: Date;
-  link: string;
-  metrics: SkizTrackSegmentMetrics;
-  name: string;
-  number: number;
-  startTime: Date;
-  type: string;
-  uuid: string;
-}
-
-export interface SkizTrackMetrics {
-  ascentDistance: number;
-  ascents: number;
-  averageAscentSpeed: number;
-  averageDescentSpeed: number;
-  averageSpeed: number;
-  descentDistance: number;
-  descents: number;
-  distance: number;
-  duration: number;
-  finishAltitude: number;
-  laps: number;
-  maxAltitude: number;
-  maxAscentSpeed: number;
-  maxAscentSteepness: number;
-  maxDescentSpeed: number;
-  maxDescentSteepness: number;
-  maxSpeed: number;
-  maxVerticalAscentSpeed: number;
-  maxVerticalDescentSpeed: number;
-  minAltitude: number;
-  movingAverageAscentSpeed: number;
-  movingAverageDescentSpeed: number;
-  movingAverageSpeed: number;
-  profileDistance: number;
-  startAltitude: number;
-  totalAscent: number;
-  totalDescent: number;
-}
-
-export interface SkizTrack {
-  activity: string;
-  batteryUsage: SkizBatteryUsage[];
-  conditions: string;
-  description: string;
-  duration: number;
-  finish: Date;
-  hidden: boolean;
-  includeInSeason: boolean;
-  name: string;
-  parseObjectId: string;
-  platform: string;
-  rating: number;
-  relativeAltitude: SkizRelativeAltitude[];
-  start: Date;
-  syncIdentifier: string;
-  syncVersion: number;
-  trackEvents: SkizTrackEvent[];
-  trackMetrics: SkizTrackMetrics;
-  trackNodes: SkizTrackNode[];
-  trackSegments: SkizTrackSegment[];
-  tz: string;
-  version: string;
-  weather: string;
-}
-
-export function parseSkizFile(
-  contents: ArrayBuffer | Buffer
-): Promise<SkizTrack>;
-export function parseSkizFile(
-  contents: ArrayBuffer | Buffer,
-  callback: (err: Error | null, result: SkizTrack) => void
-): void;

package/index.js

@@ -1,299 +0,0 @@
-import { parse as CSVParser } from 'csv-parse';
-import { XMLParser } from 'fast-xml-parser';
-import yauzl from 'yauzl';
-
-const xmlParserOptions = {
-  attributeNamePrefix: '',
-  ignoreAttributes: false,
-};
-
-const convertReadStreamToBuffer = (readStream) => {
-  return new Promise((resolve, reject) => {
-    const chunks = [];
-
-    readStream
-      .on('error', reject)
-      .on('data', (chunk) => {
-        chunks.push(chunk);
-      })
-      .once('end', () => {
-        resolve(Buffer.concat(chunks));
-      });
-  });
-};
-
-const openReadStream = (zipFile, entry) => {
-  return new Promise((resolve, reject) => {
-    zipFile.openReadStream(entry, (err, readStream) => {
-      err ? reject(err) : resolve(readStream);
-    });
-  });
-};
-
-const parseBatteryCsvFile = (readStream) => {
-  const parser = CSVParser();
-
-  return new Promise((resolve, reject) => {
-    const batteryUsage = [];
-
-    parser
-      .on('error', reject)
-      .on('readable', () => {
-        let record;
-
-        while ((record = parser.read()) !== null) {
-          batteryUsage.push({
-            timestamp: new Date(record[0]),
-            status: record[1],
-            level: parseFloat(record[2]),
-          });
-        }
-      })
-      .once('end', () => {
-        resolve({ batteryUsage });
-      });
-
-    readStream.pipe(parser);
-  });
-};
-
-const parseNodeCsvFile = (readStream) => {
-  const parser = CSVParser();
-
-  return new Promise((resolve, reject) => {
-    const trackNodes = [];
-
-    parser
-      .on('error', reject)
-      .on('readable', () => {
-        let record;
-
-        while ((record = parser.read()) !== null) {
-          trackNodes.push({
-            timestamp: new Date(parseFloat(record[0]) * 1000.0),
-            latitude: parseFloat(record[1]),
-            longitude: parseFloat(record[2]),
-            altitude: parseFloat(record[3]),
-            heading: parseFloat(record[4]),
-            velocity: parseFloat(record[5]),
-            hAccuracy: parseFloat(record[6]),
-            vAccuracy: parseFloat(record[7]),
-          });
-        }
-      })
-      .once('end', () => {
-        resolve({ trackNodes });
-      });
-
-    readStream.pipe(parser);
-  });
-};
-
-const parseRelativeAltitudeSensorCsvFile = (readStream) => {
-  const parser = CSVParser();
-
-  return new Promise((resolve, reject) => {
-    const relativeAltitude = [];
-
-    readStream.pipe(parser);
-
-    parser
-      .on('error', reject)
-      .on('readable', (data) => {
-        let record;
-
-        while ((record = parser.read()) !== null) {
-          relativeAltitude.push({
-            timestamp: new Date(record[0]),
-            pressure: parseFloat(record[1]),
-            relativeAltitude: parseFloat(record[2]),
-          });
-        }
-      })
-      .once('end', () => {
-        resolve({ relativeAltitude });
-      });
-  });
-};
-
-const parseSegmentCsvFile = (readStream) => {
-  const parser = CSVParser({ fromLine: 2 });
-
-  return new Promise((resolve, reject) => {
-    const trackSegments = [];
-
-    parser
-      .on('error', reject)
-      .on('readable', () => {
-        let record;
-
-        while ((record = parser.read()) !== null) {
-          trackSegments.push({
-            startTime: new Date(parseFloat(record[0]) * 1000),
-            endTime: new Date(parseFloat(record[1]) * 1000),
-            number: parseInt(record[4], 10),
-            name: record[5],
-            comment: record[6],
-            type: record[7],
-            category: record[8],
-            link: record[9],
-            uuid: record[10],
-            metrics: {
-              time: parseFloat(record[11]),
-              speed: parseFloat(record[12]),
-              distance: parseFloat(record[13]),
-              vertical: parseFloat(record[14]),
-              maxSpeed: parseFloat(record[15]),
-              slope: parseFloat(record[16]),
-              maxSlope: parseFloat(record[17]),
-              minAltitude: parseFloat(record[18]),
-              maxAltitude: parseFloat(record[19]),
-              startAltitude: parseFloat(record[20]),
-              finishAltitude: parseFloat(record[21]),
-            },
-          });
-        }
-      })
-      .once('end', () => {
-        resolve({ trackSegments });
-      });
-
-    readStream.pipe(parser);
-  });
-};
-
-const parseTrackXmlFile = async (readStream) => {
-  const buffer = await convertReadStreamToBuffer(readStream);
-  const parser = new XMLParser(xmlParserOptions);
-  const parsed = parser.parse(buffer.toString('utf-8'));
-
-  const track = parsed.track;
-  const metrics = track.metrics;
-
-  return {
-    rating: parseInt(track.rating, 10),
-    start: new Date(Date.parse(track.start)),
-    finish: new Date(Date.parse(track.finish)),
-    description: track.description,
-    version: track.version,
-    parseObjectId: track.parseObjectId,
-    tz: track.tz,
-    includeInSeason: track.includeinseason === 'true',
-    syncIdentifier: track.syncIdentifier,
-    conditions: track.conditions,
-    platform: track.platform,
-    weather: track.weather,
-    activity: track.activity,
-    hidden: track.hidden === 'true',
-    duration: parseFloat(track.duration),
-    name: track.name,
-    syncVersion: parseInt(track.syncVersion, 10),
-    trackMetrics: {
-      maxSpeed: metrics.maxspeed,
-      maxDescentSpeed: metrics.maxdescentspeed,
-      maxAscentSpeed: metrics.maxascentspeed,
-      maxDescentSteepness: metrics.maxdescentsteepness,
-      maxAscentSteepness: metrics.maxascentsteepness,
-      maxVerticalDescentSpeed: metrics.maxverticaldescentspeed,
-      maxVerticalAscentSpeed: metrics.maxverticalascentspeed,
-      totalAscent: metrics.totalascent,
-      totalDescent: metrics.totaldescent,
-      maxAltitude: metrics.maxaltitude,
-      minAltitude: metrics.minaltitude,
-      distance: metrics.distance,
-      profileDistance: metrics.profiledistance,
-      descentDistance: metrics.descentdistance,
-      ascentDistance: metrics.ascentdistance,
-      averageSpeed: metrics.averagespeed,
-      averageDescentSpeed: metrics.averagedescentspeed,
-      averageAscentSpeed: metrics.averageascentspeed,
-      movingAverageSpeed: metrics.movingaveragespeed,
-      movingAverageDescentSpeed: metrics.movingaveragedescentspeed,
-      movingAverageAscentSpeed: metrics.movingaverageascentspeed,
-      duration: metrics.duration,
-      startAltitude: metrics.startaltitude,
-      finishAltitude: metrics.finishaltitude,
-      ascents: metrics.ascents,
-      descents: metrics.descents,
-      laps: metrics.laps,
-    },
-  };
-};
-
-const parseEventsXmlFile = async (readStream) => {
-  const buffer = await convertReadStreamToBuffer(readStream);
-  const parser = new XMLParser(xmlParserOptions);
-  const parsed = parser.parse(buffer.toString('utf-8'));
-
-  const events = parsed.events.event || [];
-  const trackEvents = events.map((event) => ({
-    start: new Date(Date.parse(event.start)),
-    end: new Date(Date.parse(event.end)),
-    type: event.type,
-  }));
-
-  return { trackEvents };
-};
-
-export const parseSkizFile = (contents, callback) => {
-  const parse = (resolve, reject) => {
-    if (contents instanceof ArrayBuffer) {
-      contents = Buffer.from(contents);
-    }
-
-    yauzl.fromBuffer(contents, { lazyEntries: true }, (err, zipFile) => {
-      if (err) {
-        return reject(err);
-      }
-
-      let data = {};
-
-      zipFile.readEntry();
-
-      zipFile
-        .on('error', reject)
-        .on('entry', async (entry) => {
-          if (
-            ![
-              'Battery.csv',
-              'Events.xml',
-              'Nodes.csv',
-              'RelativeAltitudeSensor.csv',
-              'Segment.csv',
-              'Track.xml',
-            ].includes(entry.fileName)
-          ) {
-            return zipFile.readEntry();
-          }
-
-          const readStream = await openReadStream(zipFile, entry);
-
-          let result;
-          if (entry.fileName === 'Battery.csv') {
-            result = await parseBatteryCsvFile(readStream);
-          } else if (entry.fileName === 'Events.xml') {
-            result = await parseEventsXmlFile(readStream);
-          } else if (entry.fileName === 'Nodes.csv') {
-            result = await parseNodeCsvFile(readStream);
-          } else if (entry.fileName === 'RelativeAltitudeSensor.csv') {
-            result = await parseRelativeAltitudeSensorCsvFile(readStream);
-          } else if (entry.fileName === 'Segment.csv') {
-            result = await parseSegmentCsvFile(readStream);
-          } else if (entry.fileName === 'Track.xml') {
-            result = await parseTrackXmlFile(readStream);
-          }
-
-          data = { ...data, ...result };
-
-          zipFile.readEntry();
-        })
-        .once('end', () => {
-          resolve(data);
-        });
-    });
-  };
-
-  return typeof callback === 'function'
-    ? parse(callback.bind(null, null), callback)
-    : new Promise(parse);
-};