@garmin/fitsdk 21.115.1

package/src/stream.js

@@ -0,0 +1,259 @@
+/////////////////////////////////////////////////////////////////////////////////////////////
+// Copyright 2023 Garmin International, Inc.
+// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you
+// may not use this file except in compliance with the Flexible and Interoperable Data
+// Transfer (FIT) Protocol License.
+/////////////////////////////////////////////////////////////////////////////////////////////
+// ****WARNING****  This file is auto-generated!  Do NOT edit this file.
+// Profile Version = 21.115Release
+// Tag = production/release/21.115.00-0-gfe0a7f8
+/////////////////////////////////////////////////////////////////////////////////////////////
+
+
+import FIT from "./fit.js";
+import UtilsInternal from "./utils-internal.js";
+
+class Stream {
+    static LITTLE_ENDIAN = true;
+    static BIG_ENDIAN = false;
+
+    #position = 0;
+    #arrayBuffer = null;
+    #textDecoder = new TextDecoder("utf-8", { fatal: false, ignoreBOM: true });
+    #crcCalculator = null;
+
+    /**
+     * Convenience method for creating a Stream from a byte array
+     * @param {Array<number>} data An array of bytes
+     * @returns {Stream} A new Stream object
+     * @static
+     */
+    static fromByteArray(data) {
+        const buf = new Uint8Array(data);
+        return this.fromArrayBuffer(buf.buffer);
+    }
+
+    /**
+     * Convenience method for creating a Stream from a Node Buffer
+     * @param {Buffer} buffer - Node Buffer of bytes
+     * @returns {Stream} A new Stream object
+     * @static
+     */
+    static fromBuffer(buffer) {
+        const arrayBuffer = buffer.buffer.slice(buffer.byteOffset, buffer.byteOffset + buffer.byteLength);
+        return this.fromArrayBuffer(arrayBuffer);
+    }
+
+    /**
+     * Convenience method for creating a Stream from an ArrayBuffer
+     * @param {ArrayBuffer} arrayBuffer - An ArrayBuffer of bytes
+     * @returns {Stream} A new Stream object
+     * @static
+     */
+    static fromArrayBuffer(arrayBuffer) {
+        const stream = new Stream(arrayBuffer);
+        return stream;
+    }
+
+    /**
+     * Creates a Stream containing a FIT file
+     * @constructor
+     * @param {ArrayBuffer} stream - ArrayBuffer containing a FIT file
+     */
+    constructor(arrayBuffer) {
+        this.#position = 0;
+        this.#arrayBuffer = arrayBuffer;
+    }
+
+    get length() {
+        return this.#arrayBuffer.byteLength;
+    }
+
+    get bytesRead() {
+        return this.#position;
+    }
+
+    get position() {
+        return this.#position;
+    }
+
+    get crcCalculator() {
+        return this.#crcCalculator;
+    }
+
+    set crcCalculator(crcCalculator) {
+        this.#crcCalculator = crcCalculator;
+    }
+
+    reset() {
+        this.seek(0);
+    }
+
+    seek(position) {
+        this.#position = position;
+    }
+
+    slice(begin, end) {
+        return this.#arrayBuffer.slice(begin, end);
+    }
+
+    peekByte() {
+        const arrayBuffer = this.#arrayBuffer.slice(this.#position, this.#position + 1);
+        const dataView = new DataView(arrayBuffer);
+        return dataView.getUint8(0);
+    }
+
+    readByte() {
+        return this.readUInt8();
+    }
+
+    readBytes(size) {
+        if (this.#position + size > this.#arrayBuffer.byteLength) {
+            throw Error(`FIT Runtime Error end of stream at byte ${this.#position}`);
+        }
+
+        const bytes = this.#arrayBuffer.slice(this.#position, this.#position + size);
+        this.#position += size;
+
+        this.#crcCalculator?.addBytes(new Uint8Array(bytes), 0, size);
+
+        return bytes;
+    }
+
+    readUInt8() {
+        return this.readValue(FIT.BaseType.UINT8, 1);
+    }
+
+    readInt8() {
+        return this.readValue(FIT.BaseType.SINT8, 1);
+    }
+
+    readUInt16(opts) {
+        return this.readValue(FIT.BaseType.UINT16, 2, { convertInvalidToNull: false, ...opts });
+    }
+
+    readInt16(opts) {
+        return this.readValue(FIT.BaseType.SINT16, 2, { convertInvalidToNull: false, ...opts });
+    }
+
+    readUInt32(opts) {
+        return this.readValue(FIT.BaseType.UINT32, 4, { convertInvalidToNull: false, ...opts });
+    }
+
+    readInt32(opts) {
+        return this.readValue(FIT.BaseType.SINT32, 4, { convertInvalidToNull: false, ...opts });
+    }
+
+    readUInt64(opts) {
+        return this.readValue(FIT.BaseType.UINT64, 8, { convertInvalidToNull: false, ...opts });
+    }
+
+    readInt64(opts) {
+        return this.readValue(FIT.BaseType.SINT64, 8, { convertInvalidToNull: false, ...opts });
+    }
+
+    readFloat32(opts) {
+        return this.readValue(FIT.BaseType.FLOAT32, 4, { convertInvalidToNull: false, ...opts });
+    }
+
+    readFloat64(opts) {
+        return this.readValue(FIT.BaseType.FLOAT64, 8, { convertInvalidToNull: false, ...opts });
+    }
+
+    readString(strlen) {
+        return this.readValue(FIT.BaseType.STRING, strlen);
+    }
+
+    readValue(baseType, size, { endianness = Stream.LITTLE_ENDIAN, convertInvalidToNull = true } = {}) {
+        const baseTypeSize = FIT.BaseTypeDefinitions[baseType].size;
+        const baseTypeInvalid = FIT.BaseTypeDefinitions[baseType].invalid;
+
+        const arrayBuffer = this.readBytes(size);
+
+        if (size % baseTypeSize !== 0) {
+            return convertInvalidToNull ? null : baseTypeInvalid;
+        }
+
+        if (baseType === FIT.BaseType.STRING) {
+            const string = this.#textDecoder.decode(arrayBuffer).replace(/\uFFFD/g, "");
+            const strings = string.split('\0');
+
+            while (strings[strings.length - 1] === "") {
+                strings.pop();
+            }
+
+            if (strings.length === 0) {
+                return null;
+            }
+
+            return strings.length === 1 ? strings[0] : strings;
+        }
+
+        const dataView = new DataView(arrayBuffer);
+        let values = [];
+
+        const count = size / baseTypeSize;
+
+        for (let i = 0; i < count; i++) {
+
+            switch (baseType) {
+                case FIT.BaseType.BYTE:
+                case FIT.BaseType.ENUM:
+                case FIT.BaseType.UINT8:
+                case FIT.BaseType.UINT8Z:
+                    values.push(dataView.getUint8(i * baseTypeSize));
+                    break;
+
+                case FIT.BaseType.SINT8:
+                    values.push(dataView.getInt8(i * baseTypeSize));
+                    break;
+
+                case FIT.BaseType.UINT16:
+                case FIT.BaseType.UINT16Z:
+                    values.push(dataView.getUint16(i * baseTypeSize, endianness));
+                    break;
+
+                case FIT.BaseType.SINT16:
+                    values.push(dataView.getInt16(i * baseTypeSize, endianness));
+                    break;
+
+                case FIT.BaseType.UINT32:
+                case FIT.BaseType.UINT32Z:
+                    values.push(dataView.getUint32(i * baseTypeSize, endianness));
+                    break;
+
+                case FIT.BaseType.SINT32:
+                    values.push(dataView.getInt32(i * baseTypeSize, endianness));
+                    break;
+
+                case FIT.BaseType.UINT64:
+                case FIT.BaseType.UINT64Z:
+                    values.push(dataView.getBigUint64(i * baseTypeSize, endianness));
+                    break;
+                case FIT.BaseType.SINT64:
+                    values.push(dataView.getBigInt64(i * baseTypeSize, endianness));
+                    break;
+
+                case FIT.BaseType.FLOAT32:
+                    values.push(dataView.getFloat32(i * baseTypeSize, endianness));
+                    break;
+
+                case FIT.BaseType.FLOAT64:
+                    values.push(dataView.getFloat64(i * baseTypeSize, endianness));
+                    break;
+            }
+        }
+
+        if (baseType === FIT.BaseType.BYTE) {
+            return UtilsInternal.onlyInvalidValues(values, baseTypeInvalid) ? null : values;
+        }
+
+        if (convertInvalidToNull) {
+            values = values.map(value => value === baseTypeInvalid ? null : value);
+        }
+
+        return UtilsInternal.sanitizeValues(values);
+    }
+}
+
+export default Stream;

package/src/utils-hr-mesg.js

@@ -0,0 +1,175 @@
+/////////////////////////////////////////////////////////////////////////////////////////////
+// Copyright 2023 Garmin International, Inc.
+// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you
+// may not use this file except in compliance with the Flexible and Interoperable Data
+// Transfer (FIT) Protocol License.
+/////////////////////////////////////////////////////////////////////////////////////////////
+// ****WARNING****  This file is auto-generated!  Do NOT edit this file.
+// Profile Version = 21.115Release
+// Tag = production/release/21.115.00-0-gfe0a7f8
+/////////////////////////////////////////////////////////////////////////////////////////////
+
+
+import Utils from "./utils.js";
+
+const mergeHeartRates = (hrMesgs, recordMesgs) => {
+
+    if (hrMesgs == null || recordMesgs == null ||
+        hrMesgs.length == 0 || recordMesgs.length == 0) {
+        return;
+    }
+
+    const heartrates = expandHeartRates(hrMesgs);
+
+    let heartrateIndex = 0;
+    let recordRangeStartTime = null;
+
+    for (let i = 0; i < recordMesgs.length; ++i) {
+        const recordMesg = recordMesgs[i];
+
+        let hrSum = 0;
+        let hrSumCount = 0;
+
+        const recordRangeEndTime = secondsSinceFitEpoch(recordMesg.timestamp);
+
+        if (recordRangeStartTime == null) {
+            recordRangeStartTime = recordRangeEndTime;
+        }
+
+        if (recordRangeStartTime === recordRangeEndTime) {
+            recordRangeStartTime--;
+            heartrateIndex = (heartrateIndex >= 1) ? heartrateIndex - 1 : 0;
+        }
+
+        let findingInRangeHrMesgs = true;
+        while (findingInRangeHrMesgs && (heartrateIndex < heartrates.length)) {
+
+            const heartrate = heartrates[heartrateIndex];
+
+            // Check if the heartrate timestamp is gt record start time
+            // and if the heartrate timestamp is lte to record end time
+            if (heartrate.timestamp > recordRangeStartTime
+                && heartrate.timestamp <= recordRangeEndTime) {
+                hrSum += heartrate.heartRate;
+                hrSumCount++;
+            }
+            // Check if the heartrate timestamp exceeds the record time
+            else if (heartrate.timestamp > recordRangeEndTime) {
+                findingInRangeHrMesgs = false;
+
+                if (hrSumCount > 0) {
+                    // Update record's heart rate value
+                    const avgHR = Math.round(hrSum / hrSumCount);
+                    recordMesg.heartRate = avgHR;
+
+                }
+                // Reset HR average accumulators
+                hrSum = 0;
+                hrSumCount = 0;
+
+                recordRangeStartTime = recordRangeEndTime;
+
+                // Breaks out of findingInRangeHrMesgs while loop w/o incrementing heartrateIndex
+                break;
+            }
+
+            heartrateIndex++;
+        }
+    }
+}
+
+const expandHeartRates = (hrMesgs) => {
+    const GAP_INCREMENT_MILLISECONDS = 250;
+    const GAP_INCREMENT_SECONDS = GAP_INCREMENT_MILLISECONDS / 1000.0;
+    const GAP_MAX_MILLISECONDS = 5000;
+    const GAP_MAX_STEPS = GAP_MAX_MILLISECONDS / GAP_INCREMENT_MILLISECONDS;
+
+    if (hrMesgs == null || hrMesgs.length == 0) {
+        return [];
+    }
+
+    let anchorEventTimestamp = 0.0;
+    let anchorTimestamp = null;
+
+    const heartrates = [];
+    hrMesgs.forEach(hrMesg => {
+        if (hrMesg == null) {
+            throwError("HR mesg must not be null");
+        }
+
+        const eventTimestamps = Array.isArray(hrMesg.eventTimestamp) ? hrMesg.eventTimestamp : [hrMesg.eventTimestamp];
+        const filteredBpms = Array.isArray(hrMesg.filteredBpm) ? hrMesg.filteredBpm : [hrMesg.filteredBpm];
+
+        // Update HR timestamp anchor, if present
+        if (hrMesg.timestamp != null) {
+            anchorTimestamp = secondsSinceFitEpoch(hrMesg.timestamp);
+
+            if (hrMesg.fractionalTimestamp != null) {
+                anchorTimestamp += hrMesg.fractionalTimestamp;
+            }
+
+            if (eventTimestamps.length == 1) {
+                anchorEventTimestamp = eventTimestamps[0];
+            } else {
+                throwError("anchor HR mesg must have 1 event_timestamp");
+            }
+        }
+
+        if (anchorTimestamp == null || anchorEventTimestamp == null) {
+            // We cannot process any HR messages if we have not received a timestamp anchor
+            throwError("no anchor timestamp received in a HR mesg before delta HR mesgs");
+        } else if (eventTimestamps.length != filteredBpms.length) {
+            throwError("HR mesg with mismatching event timestamp and filtered bpm");
+        }
+
+        for (let i = 0; i < eventTimestamps.length; i++) {
+            let eventTimestamp = eventTimestamps[i];
+
+            // Check to see if the event timestamp rolled over
+            if (eventTimestamp < anchorEventTimestamp) {
+                if ((anchorEventTimestamp - eventTimestamp) > (0x400000)) {
+                    eventTimestamp += (0x400000);
+                } else {
+                    throwError("anchor event_timestamp is greater than subsequent event_timestamp. This does not allow for correct delta calculation.");
+                }
+            }
+
+            const currentHr = { timestamp: anchorTimestamp, heartRate: filteredBpms[i] };
+            currentHr.timestamp += (eventTimestamp - anchorEventTimestamp);
+
+            // Carry the previous HR value forward across the gap to the current
+            // HR value for up to 5 Seconds (5000ms) in 250ms increments
+            if (heartrates.length > 0) {
+                const previousHR = heartrates[heartrates.length - 1];
+                let gapInMilliseconds = Math.abs(currentHr.timestamp - previousHR.timestamp) * 1000;
+                let step = 1;
+                while (gapInMilliseconds > GAP_INCREMENT_MILLISECONDS && step <= GAP_MAX_STEPS) {
+                    const gapHR = { timestamp: previousHR.timestamp, heartRate: previousHR.heartRate };
+                    gapHR.timestamp += (GAP_INCREMENT_SECONDS * step);
+                    heartrates.push(gapHR);
+
+                    gapInMilliseconds -= GAP_INCREMENT_MILLISECONDS;
+                    step++;
+                }
+            }
+
+            heartrates.push(currentHr);
+        }
+    });
+
+    return heartrates;
+}
+
+const secondsSinceFitEpoch = (timestamp) => {
+    if (timestamp instanceof Date) {
+        return (timestamp.getTime() - Utils.FIT_EPOCH_MS) / 1000;
+    }
+
+    return timestamp;
+}
+
+const throwError = (error = "") => {
+    throw Error(`FIT Runtime Error ${error}`.trimEnd());
+}
+
+export default { mergeHeartRates, expandHeartRates };

package/src/utils-internal.js

@@ -0,0 +1,35 @@
+/////////////////////////////////////////////////////////////////////////////////////////////
+// Copyright 2023 Garmin International, Inc.
+// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you
+// may not use this file except in compliance with the Flexible and Interoperable Data
+// Transfer (FIT) Protocol License.
+/////////////////////////////////////////////////////////////////////////////////////////////
+// ****WARNING****  This file is auto-generated!  Do NOT edit this file.
+// Profile Version = 21.115Release
+// Tag = production/release/21.115.00-0-gfe0a7f8
+/////////////////////////////////////////////////////////////////////////////////////////////
+
+
+const sanitizeValues = (values) => {
+    if (onlyNullValues(values)) {
+        return null;
+    }
+
+    return values.length === 1 ? values[0] : values;
+}
+
+const onlyNullValues = (values) => values.reduce((state, value) => value != null ? false : state, true);
+
+const onlyInvalidValues = (rawFieldValue, invalidValue) => {
+    if (Array.isArray(rawFieldValue)) {
+        return rawFieldValue.reduce((state, value) => value != invalidValue ? false : state, true);
+    }
+
+    return rawFieldValue === invalidValue;
+}
+
+export default {
+    sanitizeValues,
+    onlyNullValues,
+    onlyInvalidValues
+};

package/src/utils.js

@@ -0,0 +1,31 @@
+/////////////////////////////////////////////////////////////////////////////////////////////
+// Copyright 2023 Garmin International, Inc.
+// Licensed under the Flexible and Interoperable Data Transfer (FIT) Protocol License; you
+// may not use this file except in compliance with the Flexible and Interoperable Data
+// Transfer (FIT) Protocol License.
+/////////////////////////////////////////////////////////////////////////////////////////////
+// ****WARNING****  This file is auto-generated!  Do NOT edit this file.
+// Profile Version = 21.115Release
+// Tag = production/release/21.115.00-0-gfe0a7f8
+/////////////////////////////////////////////////////////////////////////////////////////////
+
+
+/**
+ * The millisecond offset between UNIX and FIT Epochs (631065600000).
+ * @const {number}
+ */
+const FIT_EPOCH_MS = 631065600000;
+
+/**
+ * Convert a FIT DateTime to a JavaScript Date
+ * @param {number} datetime - Seconds since FIT EPOCH
+ * @returns {Date} A JavaScript Date object
+ */
+const convertDateTimeToDate = (datetime) => {
+    return new Date((datetime ?? 0) * 1000 + FIT_EPOCH_MS);
+};
+
+export default {
+    FIT_EPOCH_MS,
+    convertDateTimeToDate,
+};