fit-file-parser 3.1.3 → 4.0.1

package/dist/cjs/binary.js

@@ -11,6 +11,29 @@ const CompressedLocalMsgNumMask = 0x60;
 const CompressedHeaderMask = 0x80;
 const GarminTimeOffset = 631065600000;
 let monitoring_timestamp = 0;
+const InvalidFieldData = Symbol('invalid FIT field data');
+const formatTypeMetadata = new Map();
+function requiresBoundedEndianDataView(type, size) {
+    switch (type) {
+        case 'sint16':
+        case 'uint16':
+        case 'uint16z':
+            return size < 2;
+        case 'sint32':
+        case 'uint32':
+        case 'uint32z':
+        case 'float32':
+            return size < 4;
+        case 'float64':
+            return size < 8;
+        case 'uint16_array':
+            return size % 2 !== 0;
+        case 'uint32_array':
+            return size % 4 !== 0;
+        default:
+            return false;
+    }
+}
 function addEndian(littleEndian, bytes) {
     let result = 0;
     if (!littleEndian)
@@ -20,7 +43,8 @@ function addEndian(littleEndian, bytes) {
     }
     return result;
 }
-function readData(blob, fDef, startIndex, options) {
+function readData(blob, dataView, fDef, startIndex, options) {
+    var _a;
     if (fDef.type === 'uint8_array') {
         const array8 = [];
         for (let i = 0; i < fDef.size; i++) {
@@ -29,39 +53,50 @@ function readData(blob, fDef, startIndex, options) {
         return array8;
     }
     if (fDef.endianAbility) {
-        const temp = [];
-        for (let i = 0; i < fDef.size; i++) {
-            temp.push(blob[startIndex + i]);
+        const requiresBoundedDataView = (_a = fDef.requiresBoundedDataView) !== null && _a !== void 0 ? _a : (fDef.requiresBoundedDataView = requiresBoundedEndianDataView(fDef.type, fDef.size));
+        let fieldDataView = dataView;
+        let fieldStartIndex = startIndex;
+        if (startIndex < 0
+            || startIndex + fDef.size > blob.length
+            || startIndex + fDef.size > dataView.byteLength) {
+            const paddedField = new Uint8Array(fDef.size);
+            for (let index = 0; index < fDef.size; index++) {
+                paddedField[index] = blob[startIndex + index];
+            }
+            fieldDataView = new DataView(paddedField.buffer);
+            fieldStartIndex = 0;
+        }
+        else if (requiresBoundedDataView) {
+            fieldDataView = new DataView(dataView.buffer, dataView.byteOffset + startIndex, fDef.size);
+            fieldStartIndex = 0;
         }
-        const { buffer } = new Uint8Array(temp);
-        const dataView = new DataView(buffer);
         try {
             switch (fDef.type) {
                 case 'sint16':
-                    return dataView.getInt16(0, fDef.littleEndian);
+                    return fieldDataView.getInt16(fieldStartIndex, fDef.littleEndian);
                 case 'uint16':
                 case 'uint16z':
-                    return dataView.getUint16(0, fDef.littleEndian);
+                    return fieldDataView.getUint16(fieldStartIndex, fDef.littleEndian);
                 case 'sint32':
-                    return dataView.getInt32(0, fDef.littleEndian);
+                    return fieldDataView.getInt32(fieldStartIndex, fDef.littleEndian);
                 case 'uint32':
                 case 'uint32z':
-                    return dataView.getUint32(0, fDef.littleEndian);
+                    return fieldDataView.getUint32(fieldStartIndex, fDef.littleEndian);
                 case 'float32':
-                    return dataView.getFloat32(0, fDef.littleEndian);
+                    return fieldDataView.getFloat32(fieldStartIndex, fDef.littleEndian);
                 case 'float64':
-                    return dataView.getFloat64(0, fDef.littleEndian);
+                    return fieldDataView.getFloat64(fieldStartIndex, fDef.littleEndian);
                 case 'uint32_array': {
                     const array32 = [];
                     for (let i = 0; i < fDef.size; i += 4) {
-                        array32.push(dataView.getUint32(i, fDef.littleEndian));
+                        array32.push(fieldDataView.getUint32(fieldStartIndex + i, fDef.littleEndian));
                     }
                     return array32;
                 }
                 case 'uint16_array': {
                     const array16 = [];
                     for (let i = 0; i < fDef.size; i += 2) {
-                        array16.push(dataView.getUint16(i, fDef.littleEndian));
+                        array16.push(fieldDataView.getUint16(fieldStartIndex + i, fDef.littleEndian));
                     }
                     return array16;
                 }
@@ -72,6 +107,10 @@ function readData(blob, fDef, startIndex, options) {
                 throw e;
             }
         }
+        const temp = [];
+        for (let i = 0; i < fDef.size; i++) {
+            temp.push(blob[startIndex + i]);
+        }
         return addEndian(fDef.littleEndian, temp);
     }
     if (fDef.type === 'string') {
@@ -123,30 +162,37 @@ function formatByType(data, type, scale, offset) {
             return scale ? data / scale + offset : data;
         default:
             {
-                if (!fit_js_1.FIT.types[type]) {
+                const typeMap = fit_js_1.FIT.types[type];
+                if (!typeMap) {
                     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]));
+                let metadata = formatTypeMetadata.get(type);
+                if (!metadata) {
+                    const entries = [];
+                    let hasMask = false;
+                    for (const key in typeMap) {
+                        if (key in typeMap) {
+                            const value = typeMap[key];
+                            entries.push([key, value]);
+                            if (String(value) === 'mask') {
+                                hasMask = true;
+                            }
+                        }
                     }
+                    metadata = { entries, hasMask, typeMap };
+                    formatTypeMetadata.set(type, metadata);
                 }
-                if (!values.includes('mask')) {
-                    const typeMap = fit_js_1.FIT.types[type];
-                    const mapped = typeMap[String(data)];
+                if (!metadata.hasMask) {
+                    const mapped = metadata.typeMap[String(data)];
                     return mapped === undefined ? data : mapped;
                 }
                 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
-                        }
+                for (const [key, value] of metadata.entries) {
+                    if (value === 'mask') {
+                        dataItem.value = data & Number(key);
+                    }
+                    else {
+                        dataItem[value] = !!((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;
@@ -279,8 +325,22 @@ function applyOptions(data, field, options, fields) {
             return data;
     }
 }
-function readRecord(blob, messageTypes, developerFields, startIndex, options, startDate, pausedTime) {
-    var _a, _b;
+function applyGarminProductName(fields) {
+    if (fields.product_name !== undefined || fields.manufacturer !== 'garmin') {
+        return;
+    }
+    const product = fields.product;
+    if (typeof product !== 'number') {
+        return;
+    }
+    const productName = fit_js_1.FIT.types.garmin_product[product];
+    if (typeof productName === 'string') {
+        // Keep the raw protocol ID and expose the SDK product name separately.
+        fields.product_name = productName;
+    }
+}
+function readRecord(blob, messageTypes, developerFields, startIndex, options, startDate, pausedTime, dataView = new DataView(blob.buffer, blob.byteOffset, blob.byteLength)) {
+    var _a, _b, _c, _d, _e;
     const recordHeader = blob[startIndex];
     let localMessageType = recordHeader & 15;
     if ((recordHeader & CompressedHeaderMask) === CompressedHeaderMask) {
@@ -304,12 +364,13 @@ function readRecord(blob, messageTypes, developerFields, startIndex, options, st
             ]),
             numberOfFields: numberOfFields + numberOfDeveloperDataFields,
             fieldDefs: [],
+            rawData: [],
         };
         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 { field, type, scale, offset } = message.getAttributes(blob[fDefIndex]);
             const fDef = {
                 type,
                 fDefNo: blob[fDefIndex],
@@ -319,6 +380,9 @@ function readRecord(blob, messageTypes, developerFields, startIndex, options, st
                 baseTypeNo: baseType,
                 name: field,
                 dataType: (0, messages_js_1.getFitMessageBaseType)(baseType & 15),
+                scale,
+                offset,
+                requiresBoundedDataView: requiresBoundedEndianDataView(type, blob[fDefIndex + 1]),
             };
             mTypeDef.fieldDefs.push(fDef);
         }
@@ -343,6 +407,7 @@ function readRecord(blob, messageTypes, developerFields, startIndex, options, st
                     dataType: (0, messages_js_1.getFitMessageBaseType)(baseType & 15),
                     scale: devDef.scale || 1,
                     offset: devDef.offset || 0,
+                    requiresBoundedDataView: requiresBoundedEndianDataView(fit_js_1.FIT.types.fit_base_type[baseType], size),
                     developerDataIndex: devDataIndex,
                     isDeveloperField: true,
                 };
@@ -355,6 +420,7 @@ function readRecord(blob, messageTypes, developerFields, startIndex, options, st
                 throw e;
             }
         }
+        mTypeDef.rawData = Array.from({ length: mTypeDef.fieldDefs.length }, () => InvalidFieldData);
         messageTypes[localMessageType] = mTypeDef;
         const nextIndex = startIndex + 6 + mTypeDef.numberOfFields * 3;
         const nextIndexWithDeveloperData = nextIndex + 1;
@@ -370,40 +436,58 @@ function readRecord(blob, messageTypes, developerFields, startIndex, options, st
     let readDataFromIndex = startIndex + 1;
     const fields = {};
     const message = (0, messages_js_1.getFitMessage)(messageType.globalMessageNumber);
-    const rawFields = [];
+    const rawData = (_a = messageType.rawData) !== null && _a !== void 0 ? _a : (messageType.rawData = Array.from({ length: messageType.fieldDefs.length }, () => InvalidFieldData));
+    let validFieldCount = 0;
     for (let i = 0; i < messageType.fieldDefs.length; i++) {
         const fDef = messageType.fieldDefs[i];
-        const data = readData(blob, fDef, readDataFromIndex, options);
+        const data = readData(blob, dataView, fDef, readDataFromIndex, options);
         if (!isInvalidValue(data, fDef.type) && !isInvalidBaseTypeValue(data, fDef.baseTypeNo)) {
-            rawFields.push({ fDef, data });
+            rawData[i] = data;
+            validFieldCount++;
+        }
+        else {
+            rawData[i] = InvalidFieldData;
         }
         readDataFromIndex += fDef.size;
         messageSize += fDef.size;
     }
-    for (const { fDef, data } of rawFields) {
-        const { field } = fDef.isDeveloperField ? { field: fDef.name } : message.getAttributes(fDef.fDefNo);
+    for (let i = 0; i < messageType.fieldDefs.length; i++) {
+        const data = rawData[i];
+        if (data === InvalidFieldData) {
+            continue;
+        }
+        const fDef = messageType.fieldDefs[i];
+        const field = fDef.name;
         if (field !== 'unknown' && field !== '' && field !== undefined) {
             fields[field] = data;
         }
     }
-    for (const { fDef, data } of rawFields) {
+    for (let i = 0; i < messageType.fieldDefs.length; i++) {
+        const data = rawData[i];
+        if (data === InvalidFieldData) {
+            continue;
+        }
+        const fDef = messageType.fieldDefs[i];
         if (fDef.isDeveloperField) {
             const field = fDef.name;
             const { type } = fDef;
-            const scale = (_a = fDef.scale) !== null && _a !== void 0 ? _a : null;
-            const offset = (_b = fDef.offset) !== null && _b !== void 0 ? _b : 0;
+            const scale = (_b = fDef.scale) !== null && _b !== void 0 ? _b : null;
+            const offset = (_c = fDef.offset) !== null && _c !== void 0 ? _c : 0;
             fields[fDef.name] = applyOptions(formatByType(data, type, scale, offset), field, options, fields);
         }
         else {
-            const { field, type, scale, offset } = message.getAttributes(fDef.fDefNo);
+            const { name: field, type } = fDef;
+            const scale = (_d = fDef.scale) !== null && _d !== void 0 ? _d : null;
+            const offset = (_e = fDef.offset) !== null && _e !== void 0 ? _e : 0;
             if (field !== 'unknown' && field !== '' && field !== undefined) {
                 fields[field] = applyOptions(formatByType(data, type, scale, offset), field, options, fields);
             }
         }
-        if (message.name === 'record' && options.elapsedRecordField) {
-            fields.elapsed_time = (fields.timestamp - (startDate || 0)) / 1000;
-            fields.timer_time = fields.elapsed_time - pausedTime;
-        }
+    }
+    applyGarminProductName(fields);
+    if (validFieldCount > 0 && message.name === 'record' && options.elapsedRecordField) {
+        fields.elapsed_time = (fields.timestamp - (startDate || 0)) / 1000;
+        fields.timer_time = fields.elapsed_time - pausedTime;
     }
     if (message.name === 'field_description') {
         developerFields[fields.developer_data_index]

package/dist/cjs/fit-parser.js

@@ -32,7 +32,10 @@ class FitParser {
     }
     parse(content, callback) {
         var _a;
-        const blob = new Uint8Array((0, binary_js_1.getArrayBuffer)(content));
+        const blob = content instanceof ArrayBuffer
+            ? new Uint8Array(content)
+            : new Uint8Array(content.buffer, content.byteOffset, content.byteLength);
+        const dataView = new DataView(blob.buffer, blob.byteOffset, blob.byteLength);
         if (blob.length < 12) {
             callback('File to small to be a FIT file', undefined);
             if (!this.options.force) {
@@ -56,27 +59,25 @@ class FitParser {
                 return;
             }
         }
-        if (headerLength === 14) {
+        if (headerLength === 14 && !this.options.force) {
             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;
-                }
+                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) {
+        if (!this.options.force) {
+            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
                 return;
             }
         }
@@ -120,7 +121,7 @@ class FitParser {
         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);
+            const { nextIndex, messageType, message } = (0, binary_js_1.readRecord)(blob, messageTypes, developerFields, loopIndex, this.options, startDate, pausedTime, dataView);
             loopIndex = nextIndex;
             switch (messageType) {
                 case 'lap':

package/dist/cjs/fit.d.ts

@@ -8,8 +8,9 @@ export interface FieldDefinition {
     baseTypeNo: number;
     name: string;
     dataType: string;
-    scale?: number;
+    scale?: number | null;
     offset?: number;
+    requiresBoundedDataView?: boolean;
     developerDataIndex?: number;
     isDeveloperField?: boolean;
 }