@garmin/fitsdk 21.141.0 → 21.161.0

package/src/mesg-definition.js

@@ -0,0 +1,269 @@
+/////////////////////////////////////////////////////////////////////////////////////////////
+// Copyright 2025 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.161.0Release
+// Tag = production/release/21.161.0-0-g58854c0
+/////////////////////////////////////////////////////////////////////////////////////////////
+
+
+import FIT from "./fit.js";
+import Profile from "./profile.js";
+
+const textEncoder = new TextEncoder();
+
+class MesgDefinition {
+    globalMesgNumber;
+    localMesgNum;
+    fieldDefinitions = [];
+    developerFieldDefinitions = [];
+
+    constructor(mesgNum, mesg, { fieldDescriptions = null, } = {}) {
+        try {
+            if (mesg == null) {
+                throw new Error("mesg is missing or null");
+            }
+
+            if (mesgNum == null) {
+                throw new Error("mesgNum is missing or null");
+            }
+
+            const mesgProfile = Profile.messages[mesgNum];
+
+            if (mesgProfile == null) {
+                throw new Error(`mesgNum: ${mesgNum} could not be found in the Profile`);
+            }
+
+            this.globalMesgNumber = mesgNum;
+            this.localMesgNum = 0;
+
+            Object.keys(mesg).forEach((fieldName) => {
+                if (mesg[fieldName] == null) {
+                    return;
+                }
+
+                const fieldProfile = Object.entries(mesgProfile.fields).find(([, fieldProfile,]) => {
+                    return fieldProfile.name === fieldName;
+                });
+
+                if (fieldProfile == null) {
+                    return;
+                }
+
+                const baseType = FIT.FieldTypeToBaseType[fieldProfile[1].baseType];
+                const baseTypeDef = FIT.BaseTypeDefinitions[baseType];
+
+                this.fieldDefinitions.push({
+                    name: fieldName,
+                    num: fieldProfile[1].num,
+                    size: this.#fieldSize(mesg[fieldName], baseTypeDef),
+                    baseType: baseType,
+                    type: fieldProfile[1].type,
+                    scale: fieldProfile[1].scale,
+                    offset: fieldProfile[1].offset,
+                });
+            });
+
+            Object.keys(mesg.developerFields ?? {})?.sort()?.forEach((key) => {
+                const { developerDataIdMesg, fieldDescriptionMesg, } = this.#fieldDescriptionForKey(fieldDescriptions, key);
+
+                const baseTypeDef = FIT.BaseTypeDefinitions[fieldDescriptionMesg.fitBaseTypeId];
+
+                this.developerFieldDefinitions.push({
+                    key,
+                    baseType: fieldDescriptionMesg.fitBaseTypeId,
+                    fieldDefinitionNumber: fieldDescriptionMesg.fieldDefinitionNumber,
+                    size: this.#fieldSize(mesg.developerFields[key], baseTypeDef),
+                    developerDataIndex: developerDataIdMesg.developerDataIndex,
+                });
+            });
+
+            if (this.fieldDefinitions.length === 0) {
+                throw new Error("No valid fields were found in the message");
+            }
+
+            if (this.fieldDefinitions.some((fieldDefinition) => {
+                return fieldDefinition.size > FIT.MAX_FIELD_SIZE;
+            })) {
+                throw new Error(`Some field sizes are greater than ${FIT.MAX_FIELD_SIZE}`, { cause: this.fieldDefinitions, });
+            }
+        }
+        catch (error) {
+            throw new Error(
+                "Could not construct MesgDefinition from Message", {
+                cause: {
+                    cause: {
+                        message: error.message,
+                        cause: error.cause,
+                    },
+                },
+            }
+            );
+        }
+    }
+
+    write(outputStream) {
+        // Header
+        let headerByte = FIT.MESG_DEFINITION_MASK | (this.localMesgNum & FIT.LOCAL_MESG_NUM_MASK);
+        if (this.developerFieldDefinitions.length > 0) {
+            headerByte |= FIT.DEV_DATA_MASK;
+        }
+
+        outputStream.writeUInt8(headerByte);
+
+        // Reserved Byte
+        outputStream.writeUInt8(0x00);
+
+        // Architecture
+        outputStream.writeUInt8(FIT.ARCH_LITTLE_ENDIAN);
+
+        // Global Message Number
+        outputStream.writeUInt16(this.globalMesgNumber);
+
+        // Field Count
+        outputStream.writeUInt8(this.fieldDefinitions.length);
+
+        // Field Definitions
+        this.fieldDefinitions.forEach((fieldDefinition) => {
+            outputStream.writeUInt8(fieldDefinition.num);
+            outputStream.writeUInt8(fieldDefinition.size);
+            outputStream.writeUInt8(fieldDefinition.baseType);
+        });
+
+        // Developer Field Definitions
+        if (this.developerFieldDefinitions.length > 0) {
+            outputStream.writeUInt8(this.developerFieldDefinitions.length);
+
+            this.developerFieldDefinitions.forEach((developerFieldDefinition) => {
+                outputStream.writeUInt8(developerFieldDefinition.fieldDefinitionNumber);
+                outputStream.writeUInt8(developerFieldDefinition.size);
+                outputStream.writeUInt8(developerFieldDefinition.developerDataIndex);
+            });
+        }
+    }
+
+    equals(other) {
+        if (this.globalMessageNumber !== other.globalMessageNumber
+            || this.fieldDefinitions.length !== other.fieldDefinitions.length
+            || this.developerFieldDefinitions.length !== other.developerFieldDefinitions.length) {
+            return false;
+        }
+
+        // Field Definitions
+        for (let i = 0; i < this.fieldDefinitions.length; i++) {
+            const lhs = this.fieldDefinitions[i];
+
+            if (null == other.fieldDefinitions.find((rhs) => {
+                return lhs.num === rhs.num
+                    && lhs.size === rhs.size
+                    && lhs.baseType === rhs.baseType;
+            })) {
+                return false;
+            }
+        }
+
+        // Developer Field Definitions
+        for (let i = 0; i < this.developerFieldDefinitions.length; i++) {
+            const lhs = this.developerFieldDefinitions[i];
+
+            if (null == other.developerFieldDefinitions.find((rhs) => {
+                return lhs.fieldDefinitionNumber === rhs.fieldDefinitionNumber
+                    && lhs.size === rhs.size
+                    && lhs.developerDataIndex === rhs.developerDataIndex;
+            })) {
+                return false;
+            }
+        }
+
+        return true;
+    }
+
+    #fieldSize(value, baseTypeDef) {
+        const values = Array.isArray(value) ? value : [value,];
+
+        if (baseTypeDef.type === FIT.BaseType.STRING) {
+            const size = values.reduce(
+                (accumulator, currentValue) => {
+                    return accumulator + textEncoder.encode(currentValue).length + 1;
+                },
+                0
+            );
+
+            return size;
+        }
+
+        return baseTypeDef.size * values.length;
+    };
+
+    /**
+     * Look up the field description for the key, and validate the required fields.
+     */
+    #fieldDescriptionForKey(fieldDescriptions, key) {
+        try {
+            if (fieldDescriptions == null) {
+                throw new Error("no developer data field descriptions provided", {
+                    cause: {
+                        fieldDescriptions,
+                    },
+                });
+            }
+
+            const { developerDataIdMesg, fieldDescriptionMesg, } = fieldDescriptions?.[key] ?? {};
+
+            if (developerDataIdMesg == null || fieldDescriptionMesg == null) {
+                throw new Error(`could not find a developer field description for key ${key}`);
+            }
+
+            const errors = [];
+
+            if (fieldDescriptionMesg.fitBaseTypeId == null) {
+                errors.push(`fieldDescriptionMesg fitBaseTypeId is ${fieldDescriptionMesg.fitBaseTypeId}`);
+            }
+            if (fieldDescriptionMesg.fieldDefinitionNumber == null) {
+                errors.push(`fieldDescriptionMesg fieldDefinitionNumber is ${fieldDescriptionMesg.fieldDefinitionNumber}`);
+            }
+            if (fieldDescriptionMesg.developerDataIndex == null) {
+                errors.push(`fieldDescriptionMesg developerDataIndex is ${fieldDescriptionMesg.developerDataIndex}`);
+            }
+            if (developerDataIdMesg.developerDataIndex == null) {
+                errors.push(`developerDataIdMesg developerDataIndex is ${developerDataIdMesg.developerDataIndex}`);
+            }
+
+            if (developerDataIdMesg.developerDataIndex !== fieldDescriptionMesg.developerDataIndex) {
+                errors.push("developerDataIndex values do not match in fieldDescription"
+                    + ` ${developerDataIdMesg.developerDataIndex} != ${fieldDescriptionMesg.developerDataIndex}`
+                );
+            }
+
+            if (errors.length > 0) {
+                throw new Error("missing or invalid values in the fieldDescription,", {
+                    cause: {
+                        developerDataIdMesg,
+                        fieldDescriptionMesg,
+                        cause: errors,
+                    },
+                });
+            }
+
+            return { key, developerDataIdMesg, fieldDescriptionMesg, };
+        }
+        catch (error) {
+            throw new Error(
+                `invalid field description for key ${key}`, {
+                cause: {
+                    key,
+                    cause: {
+                        message: error.message,
+                        cause: error.cause,
+                    },
+                },
+            }
+            );
+        }
+    }
+}
+
+export default MesgDefinition;

package/src/output-stream.js

@@ -0,0 +1,220 @@
+/////////////////////////////////////////////////////////////////////////////////////////////
+// Copyright 2025 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.161.0Release
+// Tag = production/release/21.161.0-0-g58854c0
+/////////////////////////////////////////////////////////////////////////////////////////////
+
+
+import FIT from "./fit.js";
+
+const ONE_MEGABYTE = 1048576;
+const TEN_MEGABYTES = ONE_MEGABYTE * 10;
+const HALF_MEGABYTE = ONE_MEGABYTE / 2;
+
+class OutputStream {
+    #arrayBuffer = null;
+    #dataView = null;
+    #byteOffset = 0;
+    #resizeByBytes = 0;
+    #baseTypeDefinitions = null;
+    #textEncoder = new TextEncoder();
+
+    /**
+     * Creates an OutputStream
+     * @constructor
+     * @param {Object=} [options] - Read options (optional)
+     * @param {Number} [options.initialByteLength=0.5MB] - (optional, default 0.5 MB)
+     * @param {Number} [options.maxByteLength=2MB] - (optional, default 2 MB)
+     * @param {Number} [options.resizeByBytes=0.5MB] - (optional, default 0.5 MB)
+     */
+    constructor({
+        initialByteLength = HALF_MEGABYTE,
+        maxByteLength = TEN_MEGABYTES,
+        resizeByBytes = HALF_MEGABYTE,
+    } = {}) {
+        this.#arrayBuffer = new ArrayBuffer(initialByteLength, { maxByteLength, });
+        this.#dataView = new DataView(this.#arrayBuffer);
+
+        this.#resizeByBytes = resizeByBytes;
+
+        this.#baseTypeDefinitions = {
+            [FIT.BaseType.ENUM]: { setValue: this.#dataView.setUint8.bind(this.#dataView), size: 1, mask: 0xFF, },
+            [FIT.BaseType.UINT8]: { setValue: this.#dataView.setUint8.bind(this.#dataView), size: 1, mask: 0xFF, },
+            [FIT.BaseType.UINT16]: { setValue: this.#dataView.setUint16.bind(this.#dataView), size: 2, mask: 0xFFFF, },
+            [FIT.BaseType.UINT32]: { setValue: this.#dataView.setUint32.bind(this.#dataView), size: 4, mask: 0xFFFFFFFF, },
+            [FIT.BaseType.UINT64]: { setValue: this.#dataView.setBigUint64.bind(this.#dataView), size: 8, mask: 0xFFFFFFFFFFFFFFFFn, },
+            [FIT.BaseType.SINT8]: { setValue: this.#dataView.setInt8.bind(this.#dataView), size: 1, mask: 0xFF, },
+            [FIT.BaseType.SINT16]: { setValue: this.#dataView.setInt16.bind(this.#dataView), size: 2, mask: 0xFFFF, },
+            [FIT.BaseType.SINT32]: { setValue: this.#dataView.setInt32.bind(this.#dataView), size: 4, mask: 0xFFFFFFFF, },
+            [FIT.BaseType.SINT64]: { setValue: this.#dataView.setBigInt64.bind(this.#dataView), size: 8, mask: 0xFFFFFFFFFFFFFFFFn, },
+            [FIT.BaseType.FLOAT32]: { setValue: this.#dataView.setFloat32.bind(this.#dataView), size: 4, },
+            [FIT.BaseType.FLOAT64]: { setValue: this.#dataView.setFloat64.bind(this.#dataView), size: 8, },
+            [FIT.BaseType.UINT8Z]: { setValue: this.#dataView.setUint8.bind(this.#dataView), size: 1, mask: 0xFF, },
+            [FIT.BaseType.UINT16Z]: { setValue: this.#dataView.setUint16.bind(this.#dataView), size: 2, mask: 0xFFFF, },
+            [FIT.BaseType.UINT32Z]: { setValue: this.#dataView.setUint32.bind(this.#dataView), size: 4, mask: 0xFFFFFFFF, },
+            [FIT.BaseType.UINT64Z]: { setValue: this.#dataView.setBigUint64.bind(this.#dataView), size: 8, mask: 0xFFFFFFFFFFFFFFFFn, },
+            [FIT.BaseType.BYTE]: { setValue: this.#dataView.setUint8.bind(this.#dataView), size: 1, mask: 0xFF, },
+        };
+    }
+
+    get length() {
+        return this.#byteOffset;
+    }
+    get uint8Array() {
+        return new Uint8Array(this.#arrayBuffer.slice(0, this.#byteOffset));
+    }
+
+    writeUInt8(value) {
+        return this.write(value, FIT.BaseType.UINT8);
+    }
+
+    writeUInt16(value) {
+        return this.write(value, FIT.BaseType.UINT16);
+    }
+
+    writeUInt32(value) {
+        return this.write(value, FIT.BaseType.UINT32);
+    }
+
+    writeUInt64(value) {
+        return this.write(value, FIT.BaseType.UINT64);
+    }
+
+    writeSInt8(value) {
+        return this.write(value, FIT.BaseType.SINT8);
+    }
+
+    writeSInt16(value) {
+        return this.write(value, FIT.BaseType.SINT16);
+    }
+
+    writeSInt32(value) {
+        return this.write(value, FIT.BaseType.SINT32);
+    }
+
+    writeSInt64(value) {
+        return this.write(value, FIT.BaseType.SINT64);
+    }
+
+    writeFloat32(value) {
+        return this.write(value, FIT.BaseType.FLOAT32);
+    }
+
+    writeFloat64(value) {
+        return this.write(value, FIT.BaseType.FLOAT64);
+    }
+
+    writeUInt8z(value) {
+        return this.write(value, FIT.BaseType.UINT8Z);
+    }
+
+    writeUInt16z(value) {
+        return this.write(value, FIT.BaseType.UINT16Z);
+    }
+
+    writeUInt32z(value) {
+        return this.write(value, FIT.BaseType.UINT32Z);
+    }
+
+    writeUInt64z(value) {
+        return this.write(value, FIT.BaseType.UINT64Z);
+    }
+
+    writeByte(value) {
+        return this.write(value, FIT.BaseType.BYTE);
+    }
+
+    writeString(text) {
+        const bytes = this.#textEncoder.encode(text);
+
+        this.#resizeIfNeeded(bytes.byteLength);
+
+        const uint8Array = new Uint8Array(this.#arrayBuffer, this.#byteOffset, bytes.byteLength);
+        uint8Array.set(bytes);
+
+        this.#byteOffset += bytes.byteLength;
+
+        // Add a null terminator
+        this.writeUInt8(0);
+
+        return this;
+    }
+
+    write(value, baseType) {
+        if (baseType === FIT.BaseType.STRING) {
+            return this.writeString(value);
+        }
+
+        this.#setValues(baseType, value);
+
+        return;
+    }
+
+    set(typedarray, targetOffset = 0) {
+        this.#resizeIfNeeded(typedarray.byteLength + targetOffset);
+
+        const uint8Array = new Uint8Array(this.#arrayBuffer);
+        uint8Array.set(typedarray, targetOffset);
+
+        this.#byteOffset = Math.max(this.#byteOffset, typedarray.byteLength + targetOffset);
+
+        return this;
+    }
+
+    [Symbol.iterator]() {
+        let start = 0;
+        const end = this.#byteOffset;
+        const dataView = this.#dataView;
+
+        return {
+            next() {
+                if (start < end) {
+                    return { value: dataView.getUint8(start++), done: false, };
+                }
+                else {
+                    return { done: true, };
+                }
+            },
+        };
+    }
+
+    #setValues(baseType, value) {
+        const values = Array.isArray(value) ? value : [value,];
+
+        values.forEach((value) => {
+            return this.#setValue(baseType, value);
+        });
+    }
+
+    #setValue(baseType, value) {
+        const def = this.#baseTypeDefinitions[baseType];
+
+        this.#resizeIfNeeded(def.size);
+
+        const val = def.mask == null ? value : value & def.mask;
+
+        def.setValue(this.#byteOffset, val, true);
+        this.#byteOffset += def.size;
+
+        return this;
+    }
+
+    #resizeIfNeeded(byteCount = 1) {
+        if (this.#arrayBuffer.byteLength - this.#byteOffset >= byteCount) {
+            return;
+        }
+
+        if (!this.#arrayBuffer.resizable) {
+            throw new Error("Can not resize OutputStream. Set a larger initial size.");
+        }
+
+        this.#arrayBuffer.resize(this.#arrayBuffer.byteLength + Math.max(this.#resizeByBytes, byteCount));
+    }
+}
+
+export default OutputStream;