fit-file-parser 2.0.5 → 2.1.1

package/dist/cjs/binary.d.ts

@@ -0,0 +1,11 @@
+import type { FitParserOptions } from './fit-parser.js';
+import type { MesgNum } from './fit_types.js';
+import { Buffer } from 'buffer';
+export declare function addEndian(littleEndian: boolean, bytes: number[]): number;
+export declare function readRecord(blob: Uint8Array, messageTypes: any[], developerFields: any[], startIndex: number, options: FitParserOptions, startDate: number | undefined, pausedTime: number): {
+    messageType: MesgNum | '';
+    nextIndex: number;
+    message?: any;
+};
+export declare function getArrayBuffer(buffer: ArrayBuffer | Buffer): ArrayBuffer;
+export declare function calculateCRC(blob: Uint8Array, start: number, end: number): number;

package/dist/cjs/binary.js

@@ -0,0 +1,410 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addEndian = addEndian;
+exports.readRecord = readRecord;
+exports.getArrayBuffer = getArrayBuffer;
+exports.calculateCRC = calculateCRC;
+const buffer_1 = require("buffer");
+const fit_js_1 = require("./fit.js");
+const messages_js_1 = require("./messages.js");
+const CompressedLocalMsgNumMask = 0x60;
+const CompressedHeaderMask = 0x80;
+const GarminTimeOffset = 631065600000;
+let monitoring_timestamp = 0;
+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;
+}
+function readData(blob, fDef, startIndex, options) {
+    if (fDef.endianAbility) {
+        const temp = [];
+        for (let i = 0; i < fDef.size; i++) {
+            temp.push(blob[startIndex + i]);
+        }
+        const { buffer } = new Uint8Array(temp);
+        const dataView = new DataView(buffer);
+        try {
+            switch (fDef.type) {
+                case 'sint16':
+                    return dataView.getInt16(0, fDef.littleEndian);
+                case 'uint16':
+                case 'uint16z':
+                    return dataView.getUint16(0, fDef.littleEndian);
+                case 'sint32':
+                    return dataView.getInt32(0, fDef.littleEndian);
+                case 'uint32':
+                case 'uint32z':
+                    return dataView.getUint32(0, fDef.littleEndian);
+                case 'float32':
+                    return dataView.getFloat32(0, fDef.littleEndian);
+                case 'float64':
+                    return dataView.getFloat64(0, 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': {
+                    const array = [];
+                    for (let i = 0; i < fDef.size; i += 2) {
+                        array.push(dataView.getUint16(i, fDef.littleEndian));
+                    }
+                    return array;
+                }
+            }
+        }
+        catch (e) {
+            if (!options.force) {
+                throw e;
+            }
+        }
+        return addEndian(fDef.littleEndian, temp);
+    }
+    if (fDef.type === 'string') {
+        const temp = [];
+        for (let i = 0; i < fDef.size; i++) {
+            if (blob[startIndex + i]) {
+                temp.push(blob[startIndex + i]);
+            }
+        }
+        return buffer_1.Buffer.from(temp).toString('utf-8');
+    }
+    if (fDef.type === 'byte_array') {
+        const temp = [];
+        for (let i = 0; i < fDef.size; i++) {
+            temp.push(blob[startIndex + i]);
+        }
+        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_js_1.FIT.scConst;
+        case 'uint8':
+        case 'sint16':
+        case 'uint32':
+        case 'uint16':
+            return scale ? data / scale + offset : data;
+        case 'uint32_array':
+        case 'uint16_array':
+            return data.map((dataItem) => scale ? dataItem / scale + offset : dataItem);
+        default:
+            {
+                if (!fit_js_1.FIT.types[type]) {
+                    return data;
+                }
+                // Quick check for a mask
+                const values = [];
+                for (const key in fit_js_1.FIT.types[type]) {
+                    if (key in fit_js_1.FIT.types[type]) {
+                        values.push(String(fit_js_1.FIT.types[type][key]));
+                    }
+                }
+                if (!values.includes('mask')) {
+                    return fit_js_1.FIT.types[type][data];
+                }
+                const dataItem = {};
+                for (const key in fit_js_1.FIT.types[type]) {
+                    if (key in fit_js_1.FIT.types[type]) {
+                        if (fit_js_1.FIT.types[type][key] === 'mask') {
+                            dataItem.value = data & Number(key);
+                        }
+                        else {
+                            dataItem[fit_js_1.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;
+            }
+    }
+}
+function isInvalidValue(data, type) {
+    switch (type) {
+        case 'enum':
+            return data === 0xFF;
+        case 'sint8':
+            return data === 0x7F;
+        case 'uint8':
+            return data === 0xFF;
+        case 'sint16':
+            return data === 0x7FFF;
+        case 'uint16':
+            return data === 0xFFFF;
+        case 'sint32':
+            return data === 0x7FFFFFFF;
+        case 'uint32':
+            return data === 0xFFFFFFFF;
+        case 'string':
+            return data === 0x00;
+        case 'float32':
+            return data === 0xFFFFFFFF;
+        case 'float64':
+            // eslint-disable-next-line no-loss-of-precision
+            return data === 0xFFFFFFFFFFFFFFFF;
+        case 'uint8z':
+            return data === 0x00;
+        case 'uint16z':
+            return data === 0x0000;
+        case 'uint32z':
+            return data === 0x000000;
+        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;
+        default:
+            return false;
+    }
+}
+function convertTo(data, unitsList, unitName) {
+    const options = fit_js_1.FIT.options[unitsList];
+    const unit = options[unitName];
+    return unit ? data * unit.multiplier + unit.offset : data;
+}
+function applyOptions(data, field, options) {
+    switch (field) {
+        case 'speed':
+        case 'enhanced_speed':
+        case 'vertical_speed':
+        case 'avg_speed':
+        case 'max_speed':
+        case 'speed_1s':
+        case 'ball_speed':
+        case 'enhanced_avg_speed':
+        case 'enhanced_max_speed':
+        case 'avg_pos_vertical_speed':
+        case 'max_pos_vertical_speed':
+        case 'avg_neg_vertical_speed':
+        case 'max_neg_vertical_speed':
+            return convertTo(data, 'speedUnits', options.speedUnit);
+        case 'distance':
+        case 'total_distance':
+        case 'enhanced_avg_altitude':
+        case 'enhanced_min_altitude':
+        case 'enhanced_max_altitude':
+        case 'enhanced_altitude':
+        case 'height':
+        case 'odometer':
+        case 'avg_stroke_distance':
+        case 'min_altitude':
+        case 'avg_altitude':
+        case 'max_altitude':
+        case 'total_ascent':
+        case 'total_descent':
+        case 'altitude':
+        case 'cycle_length':
+        case 'auto_wheelsize':
+        case 'custom_wheelsize':
+        case 'gps_accuracy':
+            return convertTo(data, 'lengthUnits', options.lengthUnit);
+        case 'temperature':
+        case 'avg_temperature':
+        case 'max_temperature':
+            return convertTo(data, 'temperatureUnits', options.temperatureUnit);
+        case 'pressure':
+        case 'start_pressure':
+        case 'end_pressure':
+            return convertTo(data, 'pressureUnits', options.pressureUnit);
+        default:
+            return data;
+    }
+}
+function readRecord(blob, messageTypes, developerFields, startIndex, options, startDate, pausedTime) {
+    const recordHeader = blob[startIndex];
+    let localMessageType = recordHeader & 15;
+    if ((recordHeader & CompressedHeaderMask) === CompressedHeaderMask) {
+        // compressed timestamp
+        localMessageType = (recordHeader & CompressedLocalMsgNumMask) >> 5;
+    }
+    else if ((recordHeader & 64) === 64) {
+        // is definition message
+        // startIndex + 1 is reserved
+        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],
+            ]),
+            numberOfFields: numberOfFields + numberOfDeveloperDataFields,
+            fieldDefs: [],
+        };
+        const message = (0, messages_js_1.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_js_1.getFitMessageBaseType)(baseType & 15),
+            };
+            mTypeDef.fieldDefs.push(fDef);
+        }
+        // numberOfDeveloperDataFields = 0 so it wont crash here and wont loop
+        for (let i = 0; i < numberOfDeveloperDataFields; i++) {
+            // If we fail to parse then try catch
+            try {
+                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_js_1.FIT.types.fit_base_type[baseType],
+                    fDefNo: fieldNum,
+                    size,
+                    endianAbility: (baseType & 128) === 128,
+                    littleEndian: lEnd,
+                    baseTypeNo: baseType & 15,
+                    name: devDef.field_name,
+                    dataType: (0, messages_js_1.getFitMessageBaseType)(baseType & 15),
+                    scale: devDef.scale || 1,
+                    offset: devDef.offset || 0,
+                    developerDataIndex: devDataIndex,
+                    isDeveloperField: true,
+                };
+                mTypeDef.fieldDefs.push(fDef);
+            }
+            catch (e) {
+                if (options.force) {
+                    continue;
+                }
+                throw e;
+            }
+        }
+        messageTypes[localMessageType] = mTypeDef;
+        const nextIndex = startIndex + 6 + mTypeDef.numberOfFields * 3;
+        const nextIndexWithDeveloperData = nextIndex + 1;
+        return {
+            messageType: 'definition',
+            nextIndex: hasDeveloperData ? nextIndexWithDeveloperData : nextIndex,
+        };
+    }
+    const messageType = messageTypes[localMessageType] || messageTypes[0];
+    // TODO: handle compressed header ((recordHeader & 128) == 128)
+    // uncompressed header
+    let messageSize = 0;
+    let readDataFromIndex = startIndex + 1;
+    const fields = {};
+    const message = (0, messages_js_1.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 || 0)) / 1000;
+                fields.timer_time = fields.elapsed_time - pausedTime;
+            }
+        }
+        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][fields.field_definition_number] = fields;
+    }
+    if (message.name === 'monitoring') {
+        // 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;
+            fields.timestamp = new Date(monitoring_timestamp * 1000 + GarminTimeOffset);
+        }
+    }
+    return {
+        messageType: message.name,
+        nextIndex: startIndex + messageSize + 1,
+        message: fields,
+    };
+}
+function getArrayBuffer(buffer) {
+    if (buffer instanceof ArrayBuffer) {
+        return buffer;
+    }
+    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) {
+    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];
+    }
+    return crc;
+}

package/dist/cjs/fit-parser.d.ts

@@ -0,0 +1,19 @@
+import type { Buffer } from 'buffer';
+import type { ParsedFit } from './fit_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 {};

package/dist/cjs/fit-parser.js

@@ -0,0 +1,242 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const binary_js_1 = require("./binary.js");
+const helper_js_1 = require("./helper.js");
+class FitParser {
+    constructor(options = {}) {
+        this.options = {
+            force: options.force != null ? options.force : true,
+            speedUnit: options.speedUnit || 'm/s',
+            lengthUnit: options.lengthUnit || 'm',
+            temperatureUnit: options.temperatureUnit || 'celsius',
+            elapsedRecordField: options.elapsedRecordField || false,
+            pressureUnit: options.pressureUnit || 'bar',
+            mode: options.mode || 'list',
+        };
+    }
+    parseAsync(content) {
+        return new Promise((resolve, reject) => {
+            this.parse(content, (error, data) => {
+                if (error) {
+                    reject(error);
+                }
+                else if (data) {
+                    resolve(data);
+                }
+            });
+        });
+    }
+    parse(content, callback) {
+        var _a;
+        const blob = new Uint8Array((0, binary_js_1.getArrayBuffer)(content));
+        if (blob.length < 12) {
+            callback('File to small to be a FIT file', undefined);
+            if (!this.options.force) {
+                return;
+            }
+        }
+        const headerLength = blob[0];
+        if (headerLength !== 14 && headerLength !== 12) {
+            callback('Incorrect header size', undefined);
+            if (!this.options.force) {
+                return;
+            }
+        }
+        let fileTypeString = '';
+        for (let i = 8; i < 12; i++) {
+            fileTypeString += String.fromCharCode(blob[i]);
+        }
+        if (fileTypeString !== '.FIT') {
+            callback('Missing \'.FIT\' in header', undefined);
+            if (!this.options.force) {
+                return;
+            }
+        }
+        if (headerLength === 14) {
+            const crcHeader = blob[12] + (blob[13] << 8);
+            const crcHeaderCalc = (0, binary_js_1.calculateCRC)(blob, 0, 12);
+            if (crcHeader !== crcHeaderCalc) {
+                // callback('Header CRC mismatch', {});
+                // TODO: fix Header CRC check
+                if (!this.options.force) {
+                    return;
+                }
+            }
+        }
+        const protocolVersion = blob[1];
+        const profileVersion = blob[2] + (blob[3] << 8);
+        const dataLength = blob[4] + (blob[5] << 8) + (blob[6] << 16) + (blob[7] << 24);
+        const crcStart = dataLength + headerLength;
+        const crcFile = blob[crcStart] + (blob[crcStart + 1] << 8);
+        const crcFileCalc = (0, binary_js_1.calculateCRC)(blob, headerLength === 12 ? 0 : headerLength, crcStart);
+        if (crcFile !== crcFileCalc) {
+            // callback('File CRC mismatch', {});
+            // TODO: fix File CRC check
+            if (!this.options.force) {
+                return;
+            }
+        }
+        const fitObj = {
+            profileVersion,
+            protocolVersion,
+        };
+        let sessions = [];
+        let laps = [];
+        const records = [];
+        const events = [];
+        const hr_zone = [];
+        const power_zone = [];
+        const hrv = [];
+        const device_infos = [];
+        const applications = [];
+        const fieldDescriptions = [];
+        const dive_gases = [];
+        const course_points = [];
+        const sports = [];
+        const monitors = [];
+        const stress = [];
+        const definitions = [];
+        const file_ids = [];
+        const monitor_info = [];
+        const lengths = [];
+        const tank_updates = [];
+        const tank_summaries = [];
+        let loopIndex = headerLength;
+        const messageTypes = [];
+        const developerFields = [];
+        const isModeCascade = this.options.mode === 'cascade';
+        const isCascadeNeeded = isModeCascade || this.options.mode === 'both';
+        let startDate;
+        let lastStopTimestamp;
+        let pausedTime = 0;
+        while (loopIndex < crcStart) {
+            const { nextIndex, messageType, message } = (0, binary_js_1.readRecord)(blob, messageTypes, developerFields, loopIndex, this.options, startDate, pausedTime);
+            loopIndex = nextIndex;
+            switch (messageType) {
+                case 'lap':
+                    laps.push(message);
+                    break;
+                case 'session':
+                    sessions.push(message);
+                    break;
+                case 'event':
+                    if (message.event === 'timer') {
+                        if (message.event_type === 'stop_all') {
+                            lastStopTimestamp = message.timestamp;
+                        }
+                        else if (message.event_type === 'start' && lastStopTimestamp) {
+                            pausedTime += (message.timestamp - lastStopTimestamp) / 1000;
+                        }
+                    }
+                    events.push(message);
+                    break;
+                case 'length':
+                    lengths.push(message);
+                    break;
+                case 'hrv':
+                    hrv.push(message);
+                    break;
+                case 'hr_zone':
+                    hr_zone.push(message);
+                    break;
+                case 'power_zone':
+                    power_zone.push(message);
+                    break;
+                case 'record':
+                    if (!startDate) {
+                        startDate = message.timestamp;
+                        message.elapsed_time = 0;
+                        message.timer_time = 0;
+                    }
+                    records.push(message);
+                    break;
+                case 'field_description':
+                    fieldDescriptions.push(message);
+                    break;
+                case 'device_info':
+                    device_infos.push(message);
+                    break;
+                case 'developer_data_id':
+                    applications.push(message);
+                    break;
+                case 'dive_gas':
+                    dive_gases.push(message);
+                    break;
+                case 'course_point':
+                    course_points.push(message);
+                    break;
+                case 'sport':
+                    sports.push(message);
+                    break;
+                case 'file_id':
+                    if (message) {
+                        file_ids.push(message);
+                    }
+                    break;
+                case 'definition':
+                    if (message) {
+                        definitions.push(message);
+                    }
+                    break;
+                case 'monitoring':
+                    monitors.push(message);
+                    break;
+                case 'monitoring_info':
+                    monitor_info.push(message);
+                    break;
+                case 'stress_level':
+                    stress.push(message);
+                    break;
+                case 'software':
+                    fitObj.software = message;
+                    break;
+                case 'tank_update':
+                    tank_updates.push(message);
+                    break;
+                case 'tank_summary':
+                    tank_summaries.push(message);
+                    break;
+                default:
+                    if (messageType !== '') {
+                        fitObj[messageType] = message;
+                    }
+                    break;
+            }
+        }
+        fitObj.hr_zone = hr_zone;
+        fitObj.power_zone = power_zone;
+        fitObj.dive_gases = dive_gases;
+        fitObj.course_points = course_points;
+        fitObj.sports = sports;
+        fitObj.monitors = monitors;
+        fitObj.stress = stress;
+        fitObj.file_ids = file_ids;
+        fitObj.monitor_info = monitor_info;
+        fitObj.definitions = definitions;
+        fitObj.tank_updates = tank_updates;
+        fitObj.tank_summaries = tank_summaries;
+        if (isCascadeNeeded) {
+            laps = (0, helper_js_1.mapDataIntoLap)(laps, 'records', records);
+            laps = (0, helper_js_1.mapDataIntoLap)(laps, 'lengths', lengths);
+            sessions = (0, helper_js_1.mapDataIntoSession)(sessions, laps);
+            fitObj.activity = Object.assign(Object.assign({}, ((_a = fitObj.activity) !== null && _a !== void 0 ? _a : {})), { // ugly but we assume the activity was parsed correctly with all other members correctly
+                sessions,
+                events,
+                hrv,
+                device_infos, developer_data_ids: applications, field_descriptions: fieldDescriptions, sports });
+        }
+        if (!isModeCascade) {
+            fitObj.sessions = sessions;
+            fitObj.laps = laps;
+            fitObj.lengths = lengths;
+            fitObj.records = records;
+            fitObj.events = events;
+            fitObj.device_infos = device_infos;
+            fitObj.developer_data_ids = applications;
+            fitObj.field_descriptions = fieldDescriptions;
+            fitObj.hrv = hrv;
+        }
+        callback(undefined, fitObj);
+    }
+}
+exports.default = FitParser;