fit-file-parser 3.1.3 → 4.0.1

package/CHANGELOG.md

@@ -1,5 +1,27 @@
 # Change Log
 
+## 4.0.0
+
+### FIT decoder performance
+
+- Parse `ArrayBuffer` inputs and exact Node.js `Buffer` views directly, avoiding a full copy of the source file.
+- Reuse one parse-local `DataView` instead of allocating temporary views for each supported endian field.
+- Cache standard field metadata and enum/mask lookups on reusable message definitions.
+- Reuse raw field storage for records that share a local message definition.
+- Generate elapsed and timer fields once per record instead of once per decoded field.
+- Skip header and file CRC scans in `force: true` mode, where CRC mismatches are intentionally ignored; strict mode continues to validate both CRCs.
+- Preserve legacy malformed-field zero-padding, field-boundary, developer-field, invalid-value, and offset-buffer behavior.
+
+### Measured benefit
+
+- Suunto 93-hour / 7.5 MB FIT decoding: 1.057 s to 0.375 s, a 64.5% reduction.
+- Garmin 110-hour / 28.6 MB FIT decoding: 3.643 s to 1.241 s, a 65.9% reduction.
+- Input-related array-buffer memory is approximately halved by removing the full source copy:
+  - Suunto: 15.0 MB to 7.5 MB.
+  - Garmin: 57.2 MB to 28.6 MB.
+
+There are no intentional parsed-output or public API changes in this release. Output parity was verified across 162 checked-in fixture/mode combinations, 8,320 generated malformed endian-definition cases, and both private long-duration benchmark files.
+
 ## 3.1.0
 
 - Add the public `FitEncoder` API for writing FIT headers, definitions, data messages, and CRCs.

package/dist/binary.d.ts

@@ -1,8 +1,16 @@
 import type { FitParserOptions } from './fit-parser.js';
+import type { FieldDefinition } from './fit.js';
 import type { MesgNum } from './fit_types.js';
 import { Buffer } from 'buffer';
+export interface MessageTypeDefinition {
+    littleEndian: boolean;
+    globalMessageNumber: number;
+    numberOfFields: number;
+    fieldDefs: FieldDefinition[];
+    rawData?: any[];
+}
 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): {
+export declare function readRecord(blob: Uint8Array, messageTypes: MessageTypeDefinition[], developerFields: any[], startIndex: number, options: FitParserOptions, startDate: number | undefined, pausedTime: number, dataView?: DataView): {
     messageType: MesgNum | '';
     nextIndex: number;
     message?: any;

package/dist/binary.js

@@ -5,6 +5,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;
+    }
+}
 export function addEndian(littleEndian, bytes) {
     let result = 0;
     if (!littleEndian)
@@ -14,7 +37,8 @@ export 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++) {
@@ -23,39 +47,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;
                 }
@@ -66,6 +101,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') {
@@ -117,30 +156,37 @@ function formatByType(data, type, scale, offset) {
             return scale ? data / scale + offset : data;
         default:
             {
-                if (!FIT.types[type]) {
+                const typeMap = FIT.types[type];
+                if (!typeMap) {
                     return data;
                 }
-                // 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]));
+                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.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.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
-                        }
+                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;
@@ -273,8 +319,22 @@ function applyOptions(data, field, options, fields) {
             return data;
     }
 }
-export 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.types.garmin_product[product];
+    if (typeof productName === 'string') {
+        // Keep the raw protocol ID and expose the SDK product name separately.
+        fields.product_name = productName;
+    }
+}
+export 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) {
@@ -298,12 +358,13 @@ export function readRecord(blob, messageTypes, developerFields, startIndex, opti
             ]),
             numberOfFields: numberOfFields + numberOfDeveloperDataFields,
             fieldDefs: [],
+            rawData: [],
         };
         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 { field, type, scale, offset } = message.getAttributes(blob[fDefIndex]);
             const fDef = {
                 type,
                 fDefNo: blob[fDefIndex],
@@ -313,6 +374,9 @@ export function readRecord(blob, messageTypes, developerFields, startIndex, opti
                 baseTypeNo: baseType,
                 name: field,
                 dataType: getFitMessageBaseType(baseType & 15),
+                scale,
+                offset,
+                requiresBoundedDataView: requiresBoundedEndianDataView(type, blob[fDefIndex + 1]),
             };
             mTypeDef.fieldDefs.push(fDef);
         }
@@ -337,6 +401,7 @@ export function readRecord(blob, messageTypes, developerFields, startIndex, opti
                     dataType: getFitMessageBaseType(baseType & 15),
                     scale: devDef.scale || 1,
                     offset: devDef.offset || 0,
+                    requiresBoundedDataView: requiresBoundedEndianDataView(FIT.types.fit_base_type[baseType], size),
                     developerDataIndex: devDataIndex,
                     isDeveloperField: true,
                 };
@@ -349,6 +414,7 @@ export function readRecord(blob, messageTypes, developerFields, startIndex, opti
                 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;
@@ -364,40 +430,58 @@ export function readRecord(blob, messageTypes, developerFields, startIndex, opti
     let readDataFromIndex = startIndex + 1;
     const fields = {};
     const message = 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/binary.d.ts

@@ -1,8 +1,16 @@
 import type { FitParserOptions } from './fit-parser.js';
+import type { FieldDefinition } from './fit.js';
 import type { MesgNum } from './fit_types.js';
 import { Buffer } from 'buffer';
+export interface MessageTypeDefinition {
+    littleEndian: boolean;
+    globalMessageNumber: number;
+    numberOfFields: number;
+    fieldDefs: FieldDefinition[];
+    rawData?: any[];
+}
 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): {
+export declare function readRecord(blob: Uint8Array, messageTypes: MessageTypeDefinition[], developerFields: any[], startIndex: number, options: FitParserOptions, startDate: number | undefined, pausedTime: number, dataView?: DataView): {
     messageType: MesgNum | '';
     nextIndex: number;
     message?: any;