fit-file-parser 3.0.1 → 3.1.0

package/CHANGELOG.md

@@ -1,5 +1,10 @@
 # Change Log
 
+## 3.1.0
+
+- Add the public `FitEncoder` API for writing FIT headers, definitions, data messages, and CRCs.
+- Preserve the `course.sub_sport` field while parsing FIT course files.
+
 <a name="1.5.4"></a>
 
 ## [1.5.4](https://github.com/jimmykane/fit-parser/compare/v1.0.0...v1.5.3) (2019-03-01)

package/README.md

@@ -57,6 +57,31 @@ const buffer = await fs.readFile('./example.fit')
 const fitObject = await fitParser.parseAsync(buffer)
 ```
 
+## Encoding
+
+`FitEncoder` writes FIT headers, message definitions, data messages, and CRCs.
+It is profile-agnostic: callers provide profile field identifiers and values in
+their raw FIT representation (including any scale or offset). Scalar 64-bit
+values use `bigint`; strings and numeric arrays use exact-size raw
+`Uint8Array` values.
+
+```javascript
+import { FitBaseType, FitEncoder } from 'fit-file-parser'
+
+const encoder = new FitEncoder()
+encoder.writeMessage(0, [
+  { number: 0, size: 1, baseType: FitBaseType.Enum, value: 6 }, // FileId.type = course
+  { number: 4, size: 4, baseType: FitBaseType.Uint32, value: FitEncoder.toFitTimestamp(new Date()) },
+])
+
+const fitBytes = encoder.close()
+```
+
+Use a distinct local message number (the optional third `writeMessage`
+argument) for each recurring message shape to avoid redundant definitions.
+The encoder validates field definitions and numeric ranges before writing, so
+an exception never leaves a partial message in the output.
+
 ## Development
 
 To build the project, run:

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

@@ -0,0 +1,68 @@
+/** FIT definition base-type bytes, including the endian flag where required. */
+export declare enum FitBaseType {
+    Enum = 0,
+    Sint8 = 1,
+    Uint8 = 2,
+    String = 7,
+    Uint8z = 10,
+    Byte = 13,
+    Sint16 = 131,
+    Uint16 = 132,
+    Sint32 = 133,
+    Uint32 = 134,
+    Float32 = 136,
+    Float64 = 137,
+    Uint16z = 139,
+    Uint32z = 140,
+    Sint64 = 142,
+    Uint64 = 143,
+    Uint64z = 144
+}
+export interface FitEncoderField {
+    number: number;
+    size: number;
+    baseType: FitBaseType | number;
+    value: number | bigint | Uint8Array;
+}
+export interface FitEncoderOptions {
+    protocolVersion?: number;
+    profileVersion?: number;
+}
+/**
+ * A generic FIT binary encoder. Callers supply profile-specific field
+ * definitions and already-scaled field values. Numeric arrays, strings, and
+ * variable-length field values are supplied as raw `Uint8Array` values.
+ */
+export declare class FitEncoder {
+    private readonly data;
+    private readonly activeDefinitions;
+    private readonly protocolVersion;
+    private readonly profileVersion;
+    constructor(options?: FitEncoderOptions);
+    writeMessage(globalMessageNumber: number, fields: FitEncoderField[], localMessageNumber?: number): this;
+    close(): Uint8Array;
+    static string(value: string): Uint8Array;
+    static toFitTimestamp(date: Date): number;
+    static calculateCRC(bytes: ArrayLike<number>): number;
+    private validateMessage;
+    private validateField;
+    private assertNumberInRange;
+    private assertBigIntInRange;
+    private getUnsignedMaximum;
+    private getFieldDefinition;
+    private writeDefinition;
+    private writeFieldValue;
+    private getBaseTypeSize;
+    private isSupportedBaseType;
+    private writeUInt8;
+    private writeUInt16;
+    private writeInt8;
+    private writeInt16;
+    private writeUInt32;
+    private writeInt32;
+    private writeUInt64;
+    private writeInt64;
+    private writeFloat32;
+    private writeFloat64;
+    private static assertIntegerInRange;
+}

package/dist/cjs/fit-encoder.js

@@ -0,0 +1,354 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FitEncoder = exports.FitBaseType = void 0;
+const FIT_HEADER_SIZE = 14;
+const FIT_EPOCH_MS = 631065600000;
+const UINT8_MAX = 0xFF;
+const UINT16_MAX = 0xFFFF;
+const UINT32_MAX = 0xFFFFFFFF;
+const BIGINT_ZERO = BigInt(0);
+const BIGINT_EIGHT = BigInt(8);
+const BIGINT_BYTE_MASK = BigInt(0xFF);
+const UINT64_MAX = BigInt('18446744073709551615');
+const UINT64_MODULUS = BigInt('18446744073709551616');
+const SINT8_MIN = -0x80;
+const SINT8_MAX = 0x7F;
+const SINT16_MIN = -0x8000;
+const SINT16_MAX = 0x7FFF;
+const SINT32_MIN = -0x80000000;
+const SINT32_MAX = 0x7FFFFFFF;
+const SINT64_MIN = BigInt('-9223372036854775808');
+const SINT64_MAX = BigInt('9223372036854775807');
+/** FIT definition base-type bytes, including the endian flag where required. */
+var FitBaseType;
+(function (FitBaseType) {
+    FitBaseType[FitBaseType["Enum"] = 0] = "Enum";
+    FitBaseType[FitBaseType["Sint8"] = 1] = "Sint8";
+    FitBaseType[FitBaseType["Uint8"] = 2] = "Uint8";
+    FitBaseType[FitBaseType["String"] = 7] = "String";
+    FitBaseType[FitBaseType["Uint8z"] = 10] = "Uint8z";
+    FitBaseType[FitBaseType["Byte"] = 13] = "Byte";
+    FitBaseType[FitBaseType["Sint16"] = 131] = "Sint16";
+    FitBaseType[FitBaseType["Uint16"] = 132] = "Uint16";
+    FitBaseType[FitBaseType["Sint32"] = 133] = "Sint32";
+    FitBaseType[FitBaseType["Uint32"] = 134] = "Uint32";
+    FitBaseType[FitBaseType["Float32"] = 136] = "Float32";
+    FitBaseType[FitBaseType["Float64"] = 137] = "Float64";
+    FitBaseType[FitBaseType["Uint16z"] = 139] = "Uint16z";
+    FitBaseType[FitBaseType["Uint32z"] = 140] = "Uint32z";
+    FitBaseType[FitBaseType["Sint64"] = 142] = "Sint64";
+    FitBaseType[FitBaseType["Uint64"] = 143] = "Uint64";
+    FitBaseType[FitBaseType["Uint64z"] = 144] = "Uint64z";
+})(FitBaseType || (exports.FitBaseType = FitBaseType = {}));
+/**
+ * A generic FIT binary encoder. Callers supply profile-specific field
+ * definitions and already-scaled field values. Numeric arrays, strings, and
+ * variable-length field values are supplied as raw `Uint8Array` values.
+ */
+class FitEncoder {
+    constructor(options = {}) {
+        var _a, _b;
+        this.data = [];
+        this.activeDefinitions = new Map();
+        this.protocolVersion = FitEncoder.assertIntegerInRange((_a = options.protocolVersion) !== null && _a !== void 0 ? _a : 2, 0, UINT8_MAX, 'FIT protocol version');
+        this.profileVersion = FitEncoder.assertIntegerInRange((_b = options.profileVersion) !== null && _b !== void 0 ? _b : 21188, 0, UINT16_MAX, 'FIT profile version');
+    }
+    writeMessage(globalMessageNumber, fields, localMessageNumber = 0) {
+        this.validateMessage(globalMessageNumber, fields, localMessageNumber);
+        const definitionSignature = JSON.stringify({
+            globalMessageNumber,
+            fields: fields.map(field => this.getFieldDefinition(field)),
+        });
+        if (this.activeDefinitions.get(localMessageNumber) !== definitionSignature) {
+            this.writeDefinition(localMessageNumber, globalMessageNumber, fields);
+            this.activeDefinitions.set(localMessageNumber, definitionSignature);
+        }
+        this.writeUInt8(localMessageNumber);
+        fields.forEach(field => this.writeFieldValue(field));
+        return this;
+    }
+    close() {
+        if (this.data.length > UINT32_MAX) {
+            throw new RangeError('FIT data section cannot exceed 4294967295 bytes');
+        }
+        const header = [
+            FIT_HEADER_SIZE,
+            this.protocolVersion,
+            this.profileVersion & UINT8_MAX,
+            (this.profileVersion >>> 8) & UINT8_MAX,
+            this.data.length & UINT8_MAX,
+            (this.data.length >>> 8) & UINT8_MAX,
+            (this.data.length >>> 16) & UINT8_MAX,
+            (this.data.length >>> 24) & UINT8_MAX,
+            0x2E,
+            0x46,
+            0x49,
+            0x54,
+        ];
+        const headerCRC = FitEncoder.calculateCRC(header);
+        const output = header.concat([headerCRC & UINT8_MAX, (headerCRC >>> 8) & UINT8_MAX], this.data);
+        const fileCRC = FitEncoder.calculateCRC(output);
+        output.push(fileCRC & UINT8_MAX, (fileCRC >>> 8) & UINT8_MAX);
+        return new Uint8Array(output);
+    }
+    static string(value) {
+        const bytes = new TextEncoder().encode(value);
+        if (bytes.length > UINT8_MAX - 1) {
+            throw new RangeError('FIT string fields can contain at most 254 UTF-8 bytes plus the null terminator');
+        }
+        const output = new Uint8Array(bytes.length + 1);
+        output.set(bytes);
+        return output;
+    }
+    static toFitTimestamp(date) {
+        if (!(date instanceof Date) || Number.isNaN(date.getTime())) {
+            throw new TypeError('FIT timestamp requires a valid Date');
+        }
+        const timestamp = Math.floor((date.getTime() - FIT_EPOCH_MS) / 1000);
+        return FitEncoder.assertIntegerInRange(timestamp, 0, UINT32_MAX, 'FIT timestamp');
+    }
+    static calculateCRC(bytes) {
+        let crc = 0;
+        for (let index = 0; index < bytes.length; index++) {
+            let value = crc ^ bytes[index];
+            for (let bit = 0; bit < 8; bit++) {
+                value = value & 1 ? (value >>> 1) ^ 0xA001 : value >>> 1;
+            }
+            crc = value;
+        }
+        return crc;
+    }
+    validateMessage(globalMessageNumber, fields, localMessageNumber) {
+        FitEncoder.assertIntegerInRange(globalMessageNumber, 0, UINT16_MAX, 'FIT global message number');
+        FitEncoder.assertIntegerInRange(localMessageNumber, 0, 0x0F, 'FIT local message number');
+        if (!Array.isArray(fields) || fields.length > UINT8_MAX) {
+            throw new RangeError('FIT message definitions support between 0 and 255 fields');
+        }
+        fields.forEach(field => this.validateField(field));
+    }
+    validateField(field) {
+        if (!field || typeof field !== 'object') {
+            throw new TypeError('FIT field definitions must be objects');
+        }
+        FitEncoder.assertIntegerInRange(field.number, 0, UINT8_MAX, 'FIT field number');
+        FitEncoder.assertIntegerInRange(field.size, 1, UINT8_MAX, 'FIT field size');
+        FitEncoder.assertIntegerInRange(field.baseType, 0, UINT8_MAX, 'FIT base type');
+        if (!this.isSupportedBaseType(field.baseType)) {
+            throw new RangeError(`Unsupported FIT base type ${field.baseType}`);
+        }
+        if (field.value instanceof Uint8Array) {
+            if (field.value.length !== field.size) {
+                throw new RangeError(`FIT field ${field.number} expected ${field.size} bytes, received ${field.value.length}`);
+            }
+            const baseTypeSize = this.getBaseTypeSize(field.baseType);
+            if (baseTypeSize && field.size % baseTypeSize !== 0) {
+                throw new RangeError(`FIT field ${field.number} size must be a multiple of ${baseTypeSize}`);
+            }
+            return;
+        }
+        const baseTypeSize = this.getBaseTypeSize(field.baseType);
+        if (baseTypeSize === undefined || field.size !== baseTypeSize) {
+            throw new RangeError(`FIT field ${field.number} has an invalid size for base type ${field.baseType}`);
+        }
+        switch (field.baseType) {
+            case FitBaseType.Sint64:
+                this.assertBigIntInRange(field.value, SINT64_MIN, SINT64_MAX, field.number);
+                return;
+            case FitBaseType.Uint64:
+            case FitBaseType.Uint64z:
+                this.assertBigIntInRange(field.value, BIGINT_ZERO, UINT64_MAX, field.number);
+                return;
+            case FitBaseType.Sint8:
+                this.assertNumberInRange(field.value, SINT8_MIN, SINT8_MAX, field.number);
+                return;
+            case FitBaseType.Sint16:
+                this.assertNumberInRange(field.value, SINT16_MIN, SINT16_MAX, field.number);
+                return;
+            case FitBaseType.Sint32:
+                this.assertNumberInRange(field.value, SINT32_MIN, SINT32_MAX, field.number);
+                return;
+            case FitBaseType.Float32:
+                if (typeof field.value !== 'number' || !Number.isFinite(field.value)) {
+                    throw new RangeError(`FIT field ${field.number} requires a finite numeric value`);
+                }
+                if (!Number.isFinite(Math.fround(field.value))) {
+                    throw new RangeError(`FIT field ${field.number} must be representable as a finite float32`);
+                }
+                return;
+            case FitBaseType.Float64:
+                if (typeof field.value !== 'number' || !Number.isFinite(field.value)) {
+                    throw new RangeError(`FIT field ${field.number} requires a finite numeric value`);
+                }
+                return;
+            default:
+                this.assertNumberInRange(field.value, 0, this.getUnsignedMaximum(field.baseType), field.number);
+        }
+    }
+    assertNumberInRange(value, minimum, maximum, fieldNumber) {
+        if (typeof value !== 'number'
+            || !Number.isInteger(value)
+            || value < minimum
+            || value > maximum) {
+            throw new RangeError(`FIT field ${fieldNumber} must be an integer between ${minimum} and ${maximum}`);
+        }
+    }
+    assertBigIntInRange(value, minimum, maximum, fieldNumber) {
+        if (typeof value !== 'bigint' || value < minimum || value > maximum) {
+            throw new RangeError(`FIT field ${fieldNumber} must be a bigint between ${minimum} and ${maximum}`);
+        }
+    }
+    getUnsignedMaximum(baseType) {
+        switch (baseType) {
+            case FitBaseType.Enum:
+            case FitBaseType.Uint8:
+            case FitBaseType.Uint8z:
+            case FitBaseType.Byte:
+                return UINT8_MAX;
+            case FitBaseType.Uint16:
+            case FitBaseType.Uint16z:
+                return UINT16_MAX;
+            case FitBaseType.Uint32:
+            case FitBaseType.Uint32z:
+                return UINT32_MAX;
+            default:
+                throw new RangeError(`Unsupported FIT base type ${baseType}`);
+        }
+    }
+    getFieldDefinition(field) {
+        return { number: field.number, size: field.size, baseType: field.baseType };
+    }
+    writeDefinition(localMessageNumber, globalMessageNumber, fields) {
+        this.writeUInt8(0x40 | localMessageNumber);
+        this.writeUInt8(0);
+        this.writeUInt8(0);
+        this.writeUInt16(globalMessageNumber);
+        this.writeUInt8(fields.length);
+        fields.forEach((field) => {
+            this.writeUInt8(field.number);
+            this.writeUInt8(field.size);
+            this.writeUInt8(field.baseType);
+        });
+    }
+    writeFieldValue(field) {
+        if (field.value instanceof Uint8Array) {
+            field.value.forEach(value => this.writeUInt8(value));
+            return;
+        }
+        switch (field.baseType) {
+            case FitBaseType.Enum:
+            case FitBaseType.Uint8:
+            case FitBaseType.Uint8z:
+            case FitBaseType.Byte:
+                this.writeUInt8(field.value);
+                return;
+            case FitBaseType.Sint8:
+                this.writeInt8(field.value);
+                return;
+            case FitBaseType.Uint16:
+            case FitBaseType.Uint16z:
+                this.writeUInt16(field.value);
+                return;
+            case FitBaseType.Sint16:
+                this.writeInt16(field.value);
+                return;
+            case FitBaseType.Uint32:
+            case FitBaseType.Uint32z:
+                this.writeUInt32(field.value);
+                return;
+            case FitBaseType.Sint32:
+                this.writeInt32(field.value);
+                return;
+            case FitBaseType.Float32:
+                this.writeFloat32(field.value);
+                return;
+            case FitBaseType.Float64:
+                this.writeFloat64(field.value);
+                return;
+            case FitBaseType.Sint64:
+                this.writeInt64(field.value);
+                return;
+            case FitBaseType.Uint64:
+            case FitBaseType.Uint64z:
+                this.writeUInt64(field.value);
+                return;
+            default:
+                throw new Error(`Unsupported FIT base type ${field.baseType}`);
+        }
+    }
+    getBaseTypeSize(baseType) {
+        switch (baseType) {
+            case FitBaseType.Enum:
+            case FitBaseType.Sint8:
+            case FitBaseType.Uint8:
+            case FitBaseType.Uint8z:
+            case FitBaseType.Byte:
+                return 1;
+            case FitBaseType.Sint16:
+            case FitBaseType.Uint16:
+            case FitBaseType.Uint16z:
+                return 2;
+            case FitBaseType.Sint32:
+            case FitBaseType.Uint32:
+            case FitBaseType.Uint32z:
+            case FitBaseType.Float32:
+                return 4;
+            case FitBaseType.Float64:
+            case FitBaseType.Sint64:
+            case FitBaseType.Uint64:
+            case FitBaseType.Uint64z:
+                return 8;
+            default:
+                return undefined;
+        }
+    }
+    isSupportedBaseType(baseType) {
+        return (baseType === FitBaseType.String
+            || this.getBaseTypeSize(baseType) !== undefined);
+    }
+    writeUInt8(value) {
+        this.data.push(value);
+    }
+    writeUInt16(value) {
+        this.data.push(value & UINT8_MAX, (value >>> 8) & UINT8_MAX);
+    }
+    writeInt8(value) {
+        this.writeUInt8(value < 0 ? 0x100 + value : value);
+    }
+    writeInt16(value) {
+        this.writeUInt16(value < 0 ? 0x10000 + value : value);
+    }
+    writeUInt32(value) {
+        this.data.push(value & UINT8_MAX, Math.floor(value / 0x100) & UINT8_MAX, Math.floor(value / 0x10000) & UINT8_MAX, Math.floor(value / 0x1000000) & UINT8_MAX);
+    }
+    writeInt32(value) {
+        this.writeUInt32(value < 0 ? 0x100000000 + value : value);
+    }
+    writeUInt64(value) {
+        for (let byteIndex = BIGINT_ZERO; byteIndex < BIGINT_EIGHT; byteIndex++) {
+            this.writeUInt8(Number((value >> (byteIndex * BIGINT_EIGHT)) & BIGINT_BYTE_MASK));
+        }
+    }
+    writeInt64(value) {
+        this.writeUInt64(value < BIGINT_ZERO ? UINT64_MODULUS + value : value);
+    }
+    writeFloat32(value) {
+        const bytes = new Uint8Array(4);
+        new DataView(bytes.buffer).setFloat32(0, value, true);
+        bytes.forEach(byte => this.writeUInt8(byte));
+    }
+    writeFloat64(value) {
+        const bytes = new Uint8Array(8);
+        new DataView(bytes.buffer).setFloat64(0, value, true);
+        bytes.forEach(byte => this.writeUInt8(byte));
+    }
+    static assertIntegerInRange(value, minimum, maximum, label) {
+        if (typeof value !== 'number'
+            || !Number.isInteger(value)
+            || value < minimum
+            || value > maximum) {
+            throw new RangeError(`${label} must be an integer between ${minimum} and ${maximum}`);
+        }
+        return value;
+    }
+}
+exports.FitEncoder = FitEncoder;

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

@@ -1,5 +1,7 @@
 import type { Buffer } from 'buffer';
 import type { ParsedFit } from './fit_types.js';
+export { FitBaseType, FitEncoder } from './fit-encoder.js';
+export type { FitEncoderField, FitEncoderOptions } from './fit-encoder.js';
 export interface FitParserOptions {
     force?: boolean;
     speedUnit?: string;
@@ -16,4 +18,3 @@ export default class FitParser {
     parseAsync(content: ArrayBuffer | Buffer<ArrayBuffer>): Promise<ParsedFit>;
     parse(content: ArrayBuffer | Buffer<ArrayBuffer>, callback: FitParserCallback): void;
 }
-export {};

package/dist/cjs/fit-parser.js

@@ -1,7 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.FitEncoder = exports.FitBaseType = void 0;
 const binary_js_1 = require("./binary.js");
 const helper_js_1 = require("./helper.js");
+var fit_encoder_js_1 = require("./fit-encoder.js");
+Object.defineProperty(exports, "FitBaseType", { enumerable: true, get: function () { return fit_encoder_js_1.FitBaseType; } });
+Object.defineProperty(exports, "FitEncoder", { enumerable: true, get: function () { return fit_encoder_js_1.FitEncoder; } });
 class FitParser {
     constructor(options = {}) {
         this.options = {

package/dist/cjs/fit.js

@@ -3734,6 +3734,7 @@ exports.FIT = {
                 offset: 0,
                 units: '',
             },
+            7: { field: 'sub_sport', type: 'sub_sport', scale: null, offset: 0, units: '' },
         },
         32: {
             name: 'course_point',
@@ -6149,6 +6150,33 @@ exports.FIT = {
             23: 'u_turn',
             24: 'segment_start',
             25: 'segment_end',
+            27: 'campsite',
+            28: 'aid_station',
+            29: 'rest_area',
+            30: 'general_distance',
+            31: 'service',
+            32: 'energy_gel',
+            33: 'sports_drink',
+            34: 'mile_marker',
+            35: 'checkpoint',
+            36: 'shelter',
+            37: 'meeting_spot',
+            38: 'overlook',
+            39: 'toilet',
+            40: 'shower',
+            41: 'gear',
+            42: 'sharp_curve',
+            43: 'steep_incline',
+            44: 'tunnel',
+            45: 'bridge',
+            46: 'obstacle',
+            47: 'crossing',
+            48: 'store',
+            49: 'transition',
+            50: 'navaid',
+            51: 'transport',
+            52: 'alert',
+            53: 'info',
         },
         manufacturer: {
             0: 0,

package/dist/cjs/fit_types.d.ts

@@ -69,7 +69,7 @@ export type Goal = 'time' | 'distance' | 'calories' | 'frequency' | 'steps' | 'a
 export type GoalRecurrence = 'off' | 'daily' | 'weekly' | 'monthly' | 'yearly' | 'custom';
 export type GoalSource = 'auto' | 'community' | 'user';
 export type Schedule = 'workout' | 'course';
-export type CoursePoint = 'generic' | 'summit' | 'valley' | 'water' | 'food' | 'danger' | 'left' | 'right' | 'straight' | 'first_aid' | 'fourth_category' | 'third_category' | 'second_category' | 'first_category' | 'hors_category' | 'sprint' | 'left_fork' | 'right_fork' | 'middle_fork' | 'slight_left' | 'sharp_left' | 'slight_right' | 'sharp_right' | 'u_turn' | 'segment_start' | 'segment_end';
+export type CoursePoint = 'generic' | 'summit' | 'valley' | 'water' | 'food' | 'danger' | 'left' | 'right' | 'straight' | 'first_aid' | 'fourth_category' | 'third_category' | 'second_category' | 'first_category' | 'hors_category' | 'sprint' | 'left_fork' | 'right_fork' | 'middle_fork' | 'slight_left' | 'sharp_left' | 'slight_right' | 'sharp_right' | 'u_turn' | 'segment_start' | 'segment_end' | 'campsite' | 'aid_station' | 'rest_area' | 'general_distance' | 'service' | 'energy_gel' | 'sports_drink' | 'mile_marker' | 'checkpoint' | 'shelter' | 'meeting_spot' | 'overlook' | 'toilet' | 'shower' | 'gear' | 'sharp_curve' | 'steep_incline' | 'tunnel' | 'bridge' | 'obstacle' | 'crossing' | 'store' | 'transition' | 'navaid' | 'transport' | 'alert' | 'info';
 export type Manufacturer = '0' | 'garmin' | 'garmin_fr405_antfs' | 'zephyr' | 'dayton' | 'idt' | 'srm' | 'quarq' | 'ibike' | 'saris' | 'spark_hk' | 'tanita' | 'echowell' | 'dynastream_oem' | 'nautilus' | 'dynastream' | 'timex' | 'metrigear' | 'xelic' | 'beurer' | 'cardiosport' | 'a_and_d' | 'hmm' | 'suunto' | 'thita_elektronik' | 'gpulse' | 'clean_mobile' | 'pedal_brain' | 'peaksware' | 'saxonar' | 'lemond_fitness' | 'dexcom' | 'wahoo_fitness' | 'octane_fitness' | 'archinoetics' | 'the_hurt_box' | 'citizen_systems' | 'magellan' | 'osynce' | 'holux' | 'concept2' | 'one_giant_leap' | 'ace_sensor' | 'brim_brothers' | 'xplova' | 'perception_digital' | 'bf1systems' | 'pioneer' | 'spantec' | 'metalogics' | '4iiiis' | 'seiko_epson' | 'seiko_epson_oem' | 'ifor_powell' | 'maxwell_guider' | 'star_trac' | 'breakaway' | 'alatech_technology_ltd' | 'mio_technology_europe' | 'rotor' | 'geonaute' | 'id_bike' | 'specialized' | 'wtek' | 'physical_enterprises' | 'north_pole_engineering' | 'bkool' | 'cateye' | 'stages_cycling' | 'sigmasport' | 'tomtom' | 'peripedal' | 'wattbike' | 'moxy' | 'ciclosport' | 'powerbahn' | 'acorn_projects_aps' | 'lifebeam' | 'bontrager' | 'wellgo' | 'scosche' | 'magura' | 'woodway' | 'elite' | 'nielsen_kellerman' | 'dk_city' | 'tacx' | 'direction_technology' | 'magtonic' | '1partcarbon' | 'inside_ride_technologies' | 'sound_of_motion' | 'stryd' | 'icg' | 'mipulse' | 'bsx_athletics' | 'look' | 'campagnolo_srl' | 'body_bike_smart' | 'praxisworks' | 'limits_technology' | 'topaction_technology' | 'cosinuss' | 'fitcare' | 'magene' | 'giant_manufacturing_co' | 'tigrasport' | 'salutron' | 'technogym' | 'bryton_sensors' | 'latitude_limited' | 'soaring_technology' | 'igpsport' | 'thinkrider' | 'gopher_sport' | 'waterrower' | 'orangetheory' | 'inpeak' | 'kinetic' | 'johnson_health_tech' | 'polar_electro' | 'seesense' | 'nci_technology' | 'development' | 'healthandlife' | 'lezyne' | 'scribe_labs' | 'zwift' | 'watteam' | 'recon' | 'favero_electronics' | 'dynovelo' | 'strava' | 'precor' | 'bryton' | 'sram' | 'navman' | 'cobi' | 'spivi' | 'mio_magellan' | 'evesports' | 'sensitivus_gauge' | 'podoon' | 'life_time_fitness' | 'falco_e_motors' | 'minoura' | 'cycliq' | 'luxottica' | 'trainer_road' | 'the_sufferfest' | 'fullspeedahead' | 'virtualtraining' | 'feedbacksports' | 'omata' | 'vdo' | 'magneticdays' | 'hammerhead' | 'kinetic_by_kurt' | 'shapelog' | 'dabuziduo' | 'jetblack' | 'coros' | 'virtugo' | 'velosense' | 'actigraphcorp';
 export type GarminProduct = 'hrm_bike' | 'hrm1' | 'axh01' | 'axb01' | 'axb02' | 'hrm2ss' | 'dsi_alf02' | 'hrm3ss' | 'hrm_run_single_byte_product_id' | 'bsm' | 'bcm' | 'axs01' | 'hrm_tri_single_byte_product_id' | 'fr225_single_byte_product_id' | 'fr301_china' | 'fr301_japan' | 'fr301_korea' | 'fr301_taiwan' | 'fr405' | 'fr50' | 'fr405_japan' | 'fr60' | 'dsi_alf01' | 'fr310xt' | 'edge500' | 'fr110' | 'edge800' | 'edge500_taiwan' | 'edge500_japan' | 'chirp' | 'fr110_japan' | 'edge200' | 'fr910xt' | 'edge800_taiwan' | 'edge800_japan' | 'alf04' | 'fr610' | 'fr210_japan' | 'vector_ss' | 'vector_cp' | 'edge800_china' | 'edge500_china' | 'fr610_japan' | 'edge500_korea' | 'fr70' | 'fr310xt_4t' | 'amx' | 'fr10' | 'edge800_korea' | 'swim' | 'fr910xt_china' | 'fenix' | 'edge200_taiwan' | 'edge510' | 'edge810' | 'tempe' | 'fr910xt_japan' | 'fr620' | 'fr220' | 'fr910xt_korea' | 'fr10_japan' | 'edge810_japan' | 'virb_elite' | 'edge_touring' | 'edge510_japan' | 'hrm_tri' | 'hrm_run' | 'fr920xt' | 'edge510_asia' | 'edge810_china' | 'edge810_taiwan' | 'edge1000' | 'vivo_fit' | 'virb_remote' | 'vivo_ki' | 'fr15' | 'vivo_active' | 'edge510_korea' | 'fr620_japan' | 'fr620_china' | 'fr220_japan' | 'fr220_china' | 'approach_s6' | 'vivo_smart' | 'fenix2' | 'epix' | 'fenix3' | 'edge1000_taiwan' | 'edge1000_japan' | 'fr15_japan' | 'edge520' | 'edge1000_china' | 'fr620_russia' | 'fr220_russia' | 'vector_s' | 'edge1000_korea' | 'fr920xt_taiwan' | 'fr920xt_china' | 'fr920xt_japan' | 'virbx' | 'vivo_smart_apac' | 'etrex_touch' | 'edge25' | 'fr25' | 'vivo_fit2' | 'fr225' | 'fr630' | 'fr230' | 'fr735xt' | 'vivo_active_apac' | 'vector_2' | 'vector_2s' | 'virbxe' | 'fr620_taiwan' | 'fr220_taiwan' | 'truswing' | 'fenix3_china' | 'fenix3_twn' | 'varia_headlight' | 'varia_taillight_old' | 'edge_explore_1000' | 'fr225_asia' | 'varia_radar_taillight' | 'varia_radar_display' | 'edge20' | 'd2_bravo' | 'approach_s20' | 'varia_remote' | 'hrm4_run' | 'vivo_active_hr' | 'vivo_smart_hr' | 'vivo_move' | 'varia_vision' | 'vivo_fit3' | 'fenix3_hr' | 'virb_ultra_30' | 'index_smart_scale' | 'fr235' | 'fenix3_chronos' | 'oregon7xx' | 'rino7xx' | 'nautix' | 'edge_820' | 'edge_explore_820' | 'fenix5s' | 'd2_bravo_titanium' | 'varia_ut800' | 'running_dynamics_pod' | 'fenix5x' | 'vivo_fit_jr' | 'fr935' | 'fenix5' | 'descent' | 'sdm4' | 'edge_remote' | 'training_center' | 'connectiq_simulator' | 'android_antplus_plugin' | 'connect';
 export type AntplusDeviceType = 'antfs' | 'bike_power' | 'environment_sensor_legacy' | 'multi_sport_speed_distance' | 'control' | 'fitness_equipment' | 'blood_pressure' | 'geocache_node' | 'light_electric_vehicle' | 'env_sensor' | 'racquet' | 'control_hub' | 'muscle_oxygen' | 'shifting' | 'bike_light_main' | 'bike_light_shared' | 'exd' | 'bike_radar' | 'bike_aero' | 'weight_scale' | 'heart_rate' | 'bike_speed_cadence' | 'bike_cadence' | 'bike_speed' | 'stride_speed_distance';

package/dist/fit-encoder.d.ts

@@ -0,0 +1,68 @@
+/** FIT definition base-type bytes, including the endian flag where required. */
+export declare enum FitBaseType {
+    Enum = 0,
+    Sint8 = 1,
+    Uint8 = 2,
+    String = 7,
+    Uint8z = 10,
+    Byte = 13,
+    Sint16 = 131,
+    Uint16 = 132,
+    Sint32 = 133,
+    Uint32 = 134,
+    Float32 = 136,
+    Float64 = 137,
+    Uint16z = 139,
+    Uint32z = 140,
+    Sint64 = 142,
+    Uint64 = 143,
+    Uint64z = 144
+}
+export interface FitEncoderField {
+    number: number;
+    size: number;
+    baseType: FitBaseType | number;
+    value: number | bigint | Uint8Array;
+}
+export interface FitEncoderOptions {
+    protocolVersion?: number;
+    profileVersion?: number;
+}
+/**
+ * A generic FIT binary encoder. Callers supply profile-specific field
+ * definitions and already-scaled field values. Numeric arrays, strings, and
+ * variable-length field values are supplied as raw `Uint8Array` values.
+ */
+export declare class FitEncoder {
+    private readonly data;
+    private readonly activeDefinitions;
+    private readonly protocolVersion;
+    private readonly profileVersion;
+    constructor(options?: FitEncoderOptions);
+    writeMessage(globalMessageNumber: number, fields: FitEncoderField[], localMessageNumber?: number): this;
+    close(): Uint8Array;
+    static string(value: string): Uint8Array;
+    static toFitTimestamp(date: Date): number;
+    static calculateCRC(bytes: ArrayLike<number>): number;
+    private validateMessage;
+    private validateField;
+    private assertNumberInRange;
+    private assertBigIntInRange;
+    private getUnsignedMaximum;
+    private getFieldDefinition;
+    private writeDefinition;
+    private writeFieldValue;
+    private getBaseTypeSize;
+    private isSupportedBaseType;
+    private writeUInt8;
+    private writeUInt16;
+    private writeInt8;
+    private writeInt16;
+    private writeUInt32;
+    private writeInt32;
+    private writeUInt64;
+    private writeInt64;
+    private writeFloat32;
+    private writeFloat64;
+    private static assertIntegerInRange;
+}