fit-file-parser 1.20.0 → 2.0.0

package/dist/binary.js

@@ -1,47 +1,27 @@
-'use strict';
-
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-exports.addEndian = addEndian;
-exports.readRecord = readRecord;
-exports.getArrayBuffer = getArrayBuffer;
-exports.calculateCRC = calculateCRC;
-
-var _fit = require('./fit');
-
-var _messages = require('./messages');
-
-var _buffer = require('buffer');
-
-function addEndian(littleEndian, bytes) {
-    var result = 0;
-    if (!littleEndian) bytes.reverse();
-    for (var i = 0; i < bytes.length; i++) {
-        result += bytes[i] << (i << 3) >>> 0;
+import { Buffer } from 'node:buffer';
+import { FIT } from './fit.js';
+import { getFitMessage, getFitMessageBaseType } from './messages.js';
+const CompressedLocalMsgNumMask = 0x60;
+const CompressedHeaderMask = 0x80;
+const GarminTimeOffset = 631065600000;
+let monitoring_timestamp = 0;
+export function addEndian(littleEndian, bytes) {
+    let result = 0;
+    if (!littleEndian)
+        bytes.reverse();
+    for (let i = 0; i < bytes.length; i++) {
+        result += (bytes[i] << (i << 3)) >>> 0;
     }
-
     return result;
 }
-
-var timestamp = 0;
-var lastTimeOffset = 0;
-var CompressedTimeMask = 31;
-var CompressedLocalMesgNumMask = 0x60;
-var CompressedHeaderMask = 0x80;
-var GarminTimeOffset = 631065600000;
-var monitoring_timestamp = 0;
-
 function readData(blob, fDef, startIndex, options) {
-    if (fDef.endianAbility === true) {
-        var temp = [];
-        for (var i = 0; i < fDef.size; i++) {
+    if (fDef.endianAbility) {
+        const temp = [];
+        for (let i = 0; i < fDef.size; i++) {
             temp.push(blob[startIndex + i]);
         }
-
-        var buffer = new Uint8Array(temp).buffer;
-        var dataView = new DataView(buffer);
-
+        const { buffer } = new Uint8Array(temp);
+        const dataView = new DataView(buffer);
         try {
             switch (fDef.type) {
                 case 'sint16':
@@ -58,56 +38,54 @@ function readData(blob, fDef, startIndex, options) {
                     return dataView.getFloat32(0, fDef.littleEndian);
                 case 'float64':
                     return dataView.getFloat64(0, fDef.littleEndian);
-                case 'uint32_array':
-                    var array32 = [];
-                    for (var _i = 0; _i < fDef.size; _i += 4) {
-                        array32.push(dataView.getUint32(_i, fDef.littleEndian));
+                case 'uint32_array': {
+                    const array32 = [];
+                    for (let i = 0; i < fDef.size; i += 4) {
+                        array32.push(dataView.getUint32(i, fDef.littleEndian));
                     }
                     return array32;
-                case 'uint16_array':
-                    var array = [];
-                    for (var _i2 = 0; _i2 < fDef.size; _i2 += 2) {
-                        array.push(dataView.getUint16(_i2, fDef.littleEndian));
+                }
+                case 'uint16_array': {
+                    const array = [];
+                    for (let i = 0; i < fDef.size; i += 2) {
+                        array.push(dataView.getUint16(i, fDef.littleEndian));
                     }
                     return array;
+                }
             }
-        } catch (e) {
+        }
+        catch (e) {
             if (!options.force) {
                 throw e;
             }
         }
-
         return addEndian(fDef.littleEndian, temp);
     }
-
     if (fDef.type === 'string') {
-        var _temp = [];
-        for (var _i3 = 0; _i3 < fDef.size; _i3++) {
-            if (blob[startIndex + _i3]) {
-                _temp.push(blob[startIndex + _i3]);
+        const temp = [];
+        for (let i = 0; i < fDef.size; i++) {
+            if (blob[startIndex + i]) {
+                temp.push(blob[startIndex + i]);
             }
         }
-        return new _buffer.Buffer.from(_temp).toString('utf-8');
+        return Buffer.from(temp).toString('utf-8');
     }
-
     if (fDef.type === 'byte_array') {
-        var _temp2 = [];
-        for (var _i4 = 0; _i4 < fDef.size; _i4++) {
-            _temp2.push(blob[startIndex + _i4]);
+        const temp = [];
+        for (let i = 0; i < fDef.size; i++) {
+            temp.push(blob[startIndex + i]);
         }
-        return _temp2;
+        return temp;
     }
-
     return blob[startIndex];
 }
-
 function formatByType(data, type, scale, offset) {
     switch (type) {
         case 'date_time':
         case 'local_date_time':
             return new Date(data * 1000 + GarminTimeOffset);
         case 'sint32':
-            return data * _fit.FIT.scConst;
+            return data * FIT.scConst;
         case 'uint8':
         case 'sint16':
         case 'uint32':
@@ -115,37 +93,37 @@ function formatByType(data, type, scale, offset) {
             return scale ? data / scale + offset : data;
         case 'uint32_array':
         case 'uint16_array':
-            return data.map(function (dataItem) {
-                return scale ? dataItem / scale + offset : dataItem;
-            });
+            return data.map((dataItem) => scale ? dataItem / scale + offset : dataItem);
         default:
-            if (!_fit.FIT.types[type]) {
-                return data;
-            }
-            // Quick check for a mask
-            var values = [];
-            for (var key in _fit.FIT.types[type]) {
-                if (_fit.FIT.types[type].hasOwnProperty(key)) {
-                    values.push(_fit.FIT.types[type][key]);
+            {
+                if (!FIT.types[type]) {
+                    return data;
                 }
-            }
-            if (values.indexOf('mask') === -1) {
-                return _fit.FIT.types[type][data];
-            }
-            var dataItem = {};
-            for (var key in _fit.FIT.types[type]) {
-                if (_fit.FIT.types[type].hasOwnProperty(key)) {
-                    if (_fit.FIT.types[type][key] === 'mask') {
-                        dataItem.value = data & key;
-                    } else {
-                        dataItem[_fit.FIT.types[type][key]] = !!((data & key) >> 7); // Not sure if we need the >> 7 and casting to boolean but from all the masked props of fields so far this seems to be the case
+                // Quick check for a mask
+                const values = [];
+                for (const key in FIT.types[type]) {
+                    if (key in FIT.types[type]) {
+                        values.push(String(FIT.types[type][key]));
                     }
                 }
+                if (!values.includes('mask')) {
+                    return FIT.types[type][data];
+                }
+                const dataItem = {};
+                for (const key in FIT.types[type]) {
+                    if (key in FIT.types[type]) {
+                        if (FIT.types[type][key] === 'mask') {
+                            dataItem.value = data & Number(key);
+                        }
+                        else {
+                            dataItem[FIT.types[type][key]] = !!((data & Number(key)) >> 7); // Not sure if we need the >> 7 and casting to boolean but from all the masked props of fields so far this seems to be the case
+                        }
+                    }
+                }
+                return dataItem;
             }
-            return dataItem;
     }
 }
-
 function isInvalidValue(data, type) {
     switch (type) {
         case 'enum':
@@ -167,6 +145,7 @@ function isInvalidValue(data, type) {
         case 'float32':
             return data === 0xFFFFFFFF;
         case 'float64':
+            // eslint-disable-next-line no-loss-of-precision
             return data === 0xFFFFFFFFFFFFFFFF;
         case 'uint8z':
             return data === 0x00;
@@ -177,8 +156,10 @@ function isInvalidValue(data, type) {
         case 'byte':
             return data === 0xFF;
         case 'sint64':
+            // eslint-disable-next-line no-loss-of-precision
             return data === 0x7FFFFFFFFFFFFFFF;
         case 'uint64':
+            // eslint-disable-next-line no-loss-of-precision
             return data === 0xFFFFFFFFFFFFFFFF;
         case 'uint64z':
             return data === 0x0000000000000000;
@@ -186,12 +167,11 @@ function isInvalidValue(data, type) {
             return false;
     }
 }
-
-function convertTo(data, unitsList, speedUnit) {
-    var unitObj = _fit.FIT.options[unitsList][speedUnit];
-    return unitObj ? data * unitObj.multiplier + unitObj.offset : data;
+function convertTo(data, unitsList, unitName) {
+    const options = FIT.options[unitsList];
+    const unit = options[unitName];
+    return unit ? data * unit.multiplier + unit.offset : data;
 }
-
 function applyOptions(data, field, options) {
     switch (field) {
         case 'speed':
@@ -240,205 +220,185 @@ function applyOptions(data, field, options) {
             return data;
     }
 }
-
-function readRecord(blob, messageTypes, developerFields, startIndex, options, startDate, pausedTime) {
-    var recordHeader = blob[startIndex];
-    var localMessageType = recordHeader & 15;
-
+export function readRecord(blob, messageTypes, developerFields, startIndex, options, startDate, pausedTime) {
+    const recordHeader = blob[startIndex];
+    let localMessageType = recordHeader & 15;
     if ((recordHeader & CompressedHeaderMask) === CompressedHeaderMask) {
-        //compressed timestamp
-
-        var timeoffset = recordHeader & CompressedTimeMask;
-        timestamp += timeoffset - lastTimeOffset & CompressedTimeMask;
-        lastTimeOffset = timeoffset;
-
-        localMessageType = (recordHeader & CompressedLocalMesgNumMask) >> 5;
-    } else if ((recordHeader & 64) === 64) {
+        // compressed timestamp
+        localMessageType = (recordHeader & CompressedLocalMsgNumMask) >> 5;
+    }
+    else if ((recordHeader & 64) === 64) {
         // is definition message
         // startIndex + 1 is reserved
-
-        var hasDeveloperData = (recordHeader & 32) === 32;
-        var lEnd = blob[startIndex + 2] === 0;
-        var numberOfFields = blob[startIndex + 5];
-        var numberOfDeveloperDataFields = hasDeveloperData ? blob[startIndex + 5 + numberOfFields * 3 + 1] : 0;
-
-        var mTypeDef = {
+        const hasDeveloperData = (recordHeader & 32) === 32;
+        const lEnd = blob[startIndex + 2] === 0;
+        const numberOfFields = blob[startIndex + 5];
+        const numberOfDeveloperDataFields = hasDeveloperData
+            ? blob[startIndex + 5 + numberOfFields * 3 + 1]
+            : 0;
+        const mTypeDef = {
             littleEndian: lEnd,
-            globalMessageNumber: addEndian(lEnd, [blob[startIndex + 3], blob[startIndex + 4]]),
+            globalMessageNumber: addEndian(lEnd, [
+                blob[startIndex + 3],
+                blob[startIndex + 4],
+            ]),
             numberOfFields: numberOfFields + numberOfDeveloperDataFields,
-            fieldDefs: []
+            fieldDefs: [],
         };
-
-        var _message = (0, _messages.getFitMessage)(mTypeDef.globalMessageNumber);
-
-        for (var i = 0; i < numberOfFields; i++) {
-            var fDefIndex = startIndex + 6 + i * 3;
-            var baseType = blob[fDefIndex + 2];
-
-            var _message$getAttribute = _message.getAttributes(blob[fDefIndex]),
-                field = _message$getAttribute.field,
-                type = _message$getAttribute.type;
-
-            var fDef = {
-                type: type,
+        const message = getFitMessage(mTypeDef.globalMessageNumber);
+        for (let i = 0; i < numberOfFields; i++) {
+            const fDefIndex = startIndex + 6 + i * 3;
+            const baseType = blob[fDefIndex + 2];
+            const { field, type } = message.getAttributes(blob[fDefIndex]);
+            const fDef = {
+                type,
                 fDefNo: blob[fDefIndex],
                 size: blob[fDefIndex + 1],
                 endianAbility: (baseType & 128) === 128,
                 littleEndian: lEnd,
                 baseTypeNo: baseType & 15,
                 name: field,
-                dataType: (0, _messages.getFitMessageBaseType)(baseType & 15)
+                dataType: getFitMessageBaseType(baseType & 15),
             };
-
             mTypeDef.fieldDefs.push(fDef);
         }
-
         // numberOfDeveloperDataFields = 0 so it wont crash here and wont loop
-        for (var _i5 = 0; _i5 < numberOfDeveloperDataFields; _i5++) {
+        for (let i = 0; i < numberOfDeveloperDataFields; i++) {
             // If we fail to parse then try catch
             try {
-                var _fDefIndex = startIndex + 6 + numberOfFields * 3 + 1 + _i5 * 3;
-
-                var fieldNum = blob[_fDefIndex];
-                var size = blob[_fDefIndex + 1];
-                var devDataIndex = blob[_fDefIndex + 2];
-
-                var devDef = developerFields[devDataIndex][fieldNum];
-
-                var _baseType = devDef.fit_base_type_id;
-
-                var _fDef = {
-                    type: _fit.FIT.types.fit_base_type[_baseType],
+                const fDefIndex = startIndex + 6 + numberOfFields * 3 + 1 + i * 3;
+                const fieldNum = blob[fDefIndex];
+                const size = blob[fDefIndex + 1];
+                const devDataIndex = blob[fDefIndex + 2];
+                const devDef = developerFields[devDataIndex][fieldNum];
+                const baseType = devDef.fit_base_type_id;
+                const fDef = {
+                    type: FIT.types.fit_base_type[baseType],
                     fDefNo: fieldNum,
-                    size: size,
-                    endianAbility: (_baseType & 128) === 128,
+                    size,
+                    endianAbility: (baseType & 128) === 128,
                     littleEndian: lEnd,
-                    baseTypeNo: _baseType & 15,
+                    baseTypeNo: baseType & 15,
                     name: devDef.field_name,
-                    dataType: (0, _messages.getFitMessageBaseType)(_baseType & 15),
+                    dataType: getFitMessageBaseType(baseType & 15),
                     scale: devDef.scale || 1,
                     offset: devDef.offset || 0,
                     developerDataIndex: devDataIndex,
-                    isDeveloperField: true
+                    isDeveloperField: true,
                 };
-
-                mTypeDef.fieldDefs.push(_fDef);
-            } catch (e) {
+                mTypeDef.fieldDefs.push(fDef);
+            }
+            catch (e) {
                 if (options.force) {
                     continue;
                 }
                 throw e;
             }
         }
-
         messageTypes[localMessageType] = mTypeDef;
-
-        var nextIndex = startIndex + 6 + mTypeDef.numberOfFields * 3;
-        var nextIndexWithDeveloperData = nextIndex + 1;
-
+        const nextIndex = startIndex + 6 + mTypeDef.numberOfFields * 3;
+        const nextIndexWithDeveloperData = nextIndex + 1;
         return {
             messageType: 'definition',
-            nextIndex: hasDeveloperData ? nextIndexWithDeveloperData : nextIndex
+            nextIndex: hasDeveloperData ? nextIndexWithDeveloperData : nextIndex,
         };
     }
-
-    var messageType = messageTypes[localMessageType] || messageTypes[0];
-
+    const messageType = messageTypes[localMessageType] || messageTypes[0];
     // TODO: handle compressed header ((recordHeader & 128) == 128)
-
     // uncompressed header
-    var messageSize = 0;
-    var readDataFromIndex = startIndex + 1;
-    var fields = {};
-    var message = (0, _messages.getFitMessage)(messageType.globalMessageNumber);
-
-    for (var _i6 = 0; _i6 < messageType.fieldDefs.length; _i6++) {
-        var _fDef2 = messageType.fieldDefs[_i6];
-        var data = readData(blob, _fDef2, readDataFromIndex, options);
-
-        if (!isInvalidValue(data, _fDef2.type)) {
-            if (_fDef2.isDeveloperField) {
-
-                var field = _fDef2.name;
-                var type = _fDef2.type;
-                var scale = _fDef2.scale;
-                var offset = _fDef2.offset;
-
-                fields[_fDef2.name] = applyOptions(formatByType(data, type, scale, offset), field, options);
-            } else {
-                var _message$getAttribute2 = message.getAttributes(_fDef2.fDefNo),
-                    _field = _message$getAttribute2.field,
-                    _type = _message$getAttribute2.type,
-                    _scale = _message$getAttribute2.scale,
-                    _offset = _message$getAttribute2.offset;
-
-                if (_field !== 'unknown' && _field !== '' && _field !== undefined) {
-                    fields[_field] = applyOptions(formatByType(data, _type, _scale, _offset), _field, options);
+    let messageSize = 0;
+    let readDataFromIndex = startIndex + 1;
+    const fields = {};
+    const message = getFitMessage(messageType.globalMessageNumber);
+    for (let i = 0; i < messageType.fieldDefs.length; i++) {
+        const fDef = messageType.fieldDefs[i];
+        const data = readData(blob, fDef, readDataFromIndex, options);
+        if (!isInvalidValue(data, fDef.type)) {
+            if (fDef.isDeveloperField) {
+                const field = fDef.name;
+                const { type } = fDef;
+                const { scale } = fDef;
+                const { offset } = fDef;
+                fields[fDef.name] = applyOptions(formatByType(data, type, scale, offset), field, options);
+            }
+            else {
+                const { field, type, scale, offset } = message.getAttributes(fDef.fDefNo);
+                if (field !== 'unknown' && field !== '' && field !== undefined) {
+                    fields[field] = applyOptions(formatByType(data, type, scale, offset), field, options);
                 }
             }
-
             if (message.name === 'record' && options.elapsedRecordField) {
-                fields.elapsed_time = (fields.timestamp - startDate) / 1000;
+                fields.elapsed_time = (fields.timestamp - (startDate || 0)) / 1000;
                 fields.timer_time = fields.elapsed_time - pausedTime;
             }
         }
-
-        readDataFromIndex += _fDef2.size;
-        messageSize += _fDef2.size;
+        readDataFromIndex += fDef.size;
+        messageSize += fDef.size;
     }
-
     if (message.name === 'field_description') {
-        developerFields[fields.developer_data_index] = developerFields[fields.developer_data_index] || [];
+        developerFields[fields.developer_data_index]
+            = developerFields[fields.developer_data_index] || [];
         developerFields[fields.developer_data_index][fields.field_definition_number] = fields;
     }
-
     if (message.name === 'monitoring') {
-        //we need to keep the raw timestamp value so we can calculate subsequent timestamp16 fields
+        // TODO weirdly uses global variables?
+        // we need to keep the raw timestamp value so we can calculate subsequent timestamp16 fields
         if (fields.timestamp) {
             monitoring_timestamp = fields.timestamp;
             fields.timestamp = new Date(fields.timestamp * 1000 + GarminTimeOffset);
         }
         if (fields.timestamp16 && !fields.timestamp) {
-            monitoring_timestamp += fields.timestamp16 - (monitoring_timestamp & 0xFFFF) & 0xFFFF;
-            //fields.timestamp = monitoring_timestamp;
+            monitoring_timestamp
+                += (fields.timestamp16 - (monitoring_timestamp & 0xFFFF)) & 0xFFFF;
+            // fields.timestamp = monitoring_timestamp;
             fields.timestamp = new Date(monitoring_timestamp * 1000 + GarminTimeOffset);
         }
     }
-
-    var result = {
+    return {
         messageType: message.name,
         nextIndex: startIndex + messageSize + 1,
-        message: fields
+        message: fields,
     };
-
-    return result;
 }
-
-function getArrayBuffer(buffer) {
+export function getArrayBuffer(buffer) {
     if (buffer instanceof ArrayBuffer) {
         return buffer;
     }
-    var ab = new ArrayBuffer(buffer.length);
-    var view = new Uint8Array(ab);
-    for (var i = 0; i < buffer.length; ++i) {
+    const ab = new ArrayBuffer(buffer.length);
+    const view = new Uint8Array(ab);
+    for (let i = 0; i < buffer.length; ++i) {
         view[i] = buffer[i];
     }
     return ab;
 }
-
-function calculateCRC(blob, start, end) {
-    var crcTable = [0x0000, 0xCC01, 0xD801, 0x1400, 0xF001, 0x3C00, 0x2800, 0xE401, 0xA001, 0x6C00, 0x7800, 0xB401, 0x5000, 0x9C01, 0x8801, 0x4400];
-
-    var crc = 0;
-    for (var i = start; i < end; i++) {
-        var byteVal = blob[i];
-        var tmp = crcTable[crc & 0xF];
-        crc = crc >> 4 & 0x0FFF;
+export function calculateCRC(blob, start, end) {
+    const crcTable = [
+        0x0000,
+        0xCC01,
+        0xD801,
+        0x1400,
+        0xF001,
+        0x3C00,
+        0x2800,
+        0xE401,
+        0xA001,
+        0x6C00,
+        0x7800,
+        0xB401,
+        0x5000,
+        0x9C01,
+        0x8801,
+        0x4400,
+    ];
+    let crc = 0;
+    for (let i = start; i < end; i++) {
+        const byteVal = blob[i];
+        let tmp = crcTable[crc & 0xF];
+        crc = (crc >> 4) & 0x0FFF;
         crc = crc ^ tmp ^ crcTable[byteVal & 0xF];
         tmp = crcTable[crc & 0xF];
-        crc = crc >> 4 & 0x0FFF;
-        crc = crc ^ tmp ^ crcTable[byteVal >> 4 & 0xF];
+        crc = (crc >> 4) & 0x0FFF;
+        crc = crc ^ tmp ^ crcTable[(byteVal >> 4) & 0xF];
     }
-
     return crc;
-}
+}

package/dist/fit-parser.d.ts

@@ -0,0 +1,19 @@
+import type { Buffer } from 'node:buffer';
+import type { ParsedFit } from './types.js';
+export interface FitParserOptions {
+    force?: boolean;
+    speedUnit?: string;
+    lengthUnit?: string;
+    temperatureUnit?: string;
+    elapsedRecordField?: boolean;
+    pressureUnit?: string;
+    mode?: 'list' | 'cascade' | 'both';
+}
+type FitParserCallback = (error: string | undefined, data: ParsedFit | undefined) => void;
+export default class FitParser {
+    private readonly options;
+    constructor(options?: FitParserOptions);
+    parseAsync(content: ArrayBuffer | Buffer<ArrayBuffer>): Promise<ParsedFit>;
+    parse(content: ArrayBuffer | Buffer<ArrayBuffer>, callback: FitParserCallback): void;
+}
+export {};