fit-file-parser 3.0.1 → 3.1.0

package/dist/fit-encoder.js

@@ -0,0 +1,350 @@
+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. */
+export 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 || (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.
+ */
+export 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;
+    }
+}

package/dist/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/fit-parser.js

@@ -1,5 +1,6 @@
 import { calculateCRC, getArrayBuffer, readRecord } from './binary.js';
 import { mapDataIntoLap, mapDataIntoSession } from './helper.js';
+export { FitBaseType, FitEncoder } from './fit-encoder.js';
 export default class FitParser {
     constructor(options = {}) {
         this.options = {

package/dist/fit.js

@@ -3731,6 +3731,7 @@ export const FIT = {
                 offset: 0,
                 units: '',
             },
+            7: { field: 'sub_sport', type: 'sub_sport', scale: null, offset: 0, units: '' },
         },
         32: {
             name: 'course_point',
@@ -6146,6 +6147,33 @@ export const 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/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/package.json

@@ -1,7 +1,7 @@
 {
   "name": "fit-file-parser",
   "type": "module",
-  "version": "3.0.1",
+  "version": "3.1.0",
   "private": false,
   "description": "Parse your .FIT files easily, directly from JS (Garmin, Polar, Suunto)",
   "author": {
@@ -32,6 +32,13 @@
     "garmin",
     "parse"
   ],
+  "files": [
+    "dist/",
+    "README.md",
+    "LICENSE",
+    "CHANGELOG.md",
+    "CONTRIBUTORS.md"
+  ],
   "exports": {
     ".": {
       "types": "./dist/fit-parser.d.ts",
@@ -75,4 +82,4 @@
     "typescript": "^5.9.3",
     "vitest": "^4.0.13"
   }
-}
+}

package/.agent/rules/fit-parser-dev.md

@@ -1,35 +0,0 @@
-# FIT Parser Development Rules
-
-You are working on the `fit-parser` library. Follow these rules strictly to ensure correctness and stability.
-
-## Core Principles
-
-1.  **Trust the Official SDK**:
-    *   Always verify Message IDs and Field IDs against the Official Garmin FIT SDK (`@garmin/fitsdk`).
-    *   **NEVER** guess or reuse existing IDs if they seem wrong (e.g., Message 140 vs 285).
-    *   If `@garmin/fitsdk` is available in `node_modules`, use it as the source of truth.
-
-2.  **Investigation First**:
-    *   If a field is missing, use `npm run inspect <file>` or `npm run probe <file> <value>` BEFORE modifying code.
-    *   Confirm the field exists in the file and identify its raw value.
-
-3.  **Testing is Mandatory**:
-    *   Every new message or field definition MUST have a corresponding test case in `test/`.
-    *   Test against real FIT files whenever possible (use `examples/` directory).
-    *   Use `npm run test` to verify changes.
-
-4.  **Code Generation**:
-    *   `src/fit_types.ts` is AUTO-GENERATED.
-    *   If you modify `src/fit.ts`, you **MUST** run `npm run codegen` to update types.
-    *   Do not edit `src/fit_types.ts` manually.
-
-## Workflow checklist
-
-When adding a new message or fixing a field:
-
-- [ ] Locate official Message ID in Garmin SDK
-- [ ] Locate Field IDs and Types in Garmin SDK
-- [ ] Update `src/fit.ts` with new definition
-- [ ] Run `npm run codegen`
-- [ ] Add/Update test in `test/`
-- [ ] Run `npm run build && npm run test`

package/.agent/skills/add-fit-message/SKILL.md

@@ -1,29 +0,0 @@
----
-name: add-fit-message
-description: Add a new FIT message or update an existing one
----
-
-# Add/Update FIT Message
-
-## Prerequisites
-
-- Identify Message ID (e.g., 285 for Jump)
-- Identify Field IDs and Types from Garmin SDK
-
-## Steps
-
-1.  **Modify `src/fit.ts`** - Add message definition
-2.  **Run `npm run codegen`** - Updates `src/fit_types.ts`
-3.  **Add Test** - Create test in `test/`
-4.  **Verify** - Run `npm run build && npm run test`
-
-## Example Entry
-
-```typescript
-285: {
-  name: 'jump',
-  253: { field: 'timestamp', type: 'date_time', scale: null, offset: 0, units: 's' },
-  0: { field: 'distance', type: 'float32', scale: null, offset: 0, units: 'm' },
-  5: { field: 'position_lat', type: 'sint32', scale: null, offset: 0, units: 'semicircles' },
-}
-```

package/.agent/workflows/fit-workflows.md

@@ -1,28 +0,0 @@
----
-description: common fit-parser development workflows
----
-
-# Inspect FIT File
-
-// turbo
-1. node scripts/inspect_fit.js <path_to_fit_file> [message_key]
-
-# Probe FIT File for Value
-
-// turbo
-1. node scripts/deep_probe.js <path_to_fit_file> <value> [tolerance]
-
-# Run Tests
-
-// turbo
-1. npm run build && npm run test
-
-# Add New Message
-
-1. Locate Message ID in `@garmin/fitsdk/src/profile.js`
-2. Update `src/fit.ts` with message definition
-// turbo
-3. npm run codegen
-4. Add test in `test/`
-// turbo
-5. npm run build && npm run test

package/.editorconfig

@@ -1,3 +0,0 @@
-[*]
-indent_style = space
-indent_size = 2

package/.github/workflows/ci.yml

@@ -1,40 +0,0 @@
-name: CI
-
-on:
-  push:
-    branches: [master]
-  pull_request:
-    branches: [master]
-
-jobs:
-  build:
-    runs-on: ubuntu-latest
-
-    strategy:
-      matrix:
-        node-version: [20.x, 22.x, 24.x, 25.x]
-
-    steps:
-      - uses: actions/checkout@v6
-      - name: Use Node.js ${{ matrix.node-version }}
-        uses: actions/setup-node@v6
-        with:
-          node-version: ${{ matrix.node-version }}
-          cache: npm
-          cache-dependency-path: package-lock.json
-      - run: npm ci
-      - run: npm run build
-      - run: npm run test -- --coverage
-      - run: npm run lint
-        if: matrix.node-version == '25.x'
-      - run: npm run type-check
-        if: matrix.node-version == '25.x'
-      - run: |
-          npm run codegen
-          if git diff --exit-code src/fit_types.ts; then
-            echo "✓ src/fit_types.ts is unchanged after codegen"
-          else
-            echo "✗ src/fit_types.ts has been modified - please commit the changes"
-            exit 1
-          fi
-        if: matrix.node-version == '25.x'

package/.vscode/extensions.json

@@ -1,6 +0,0 @@
-{
-    "recommendations": [
-        "dbaeumer.vscode-eslint",
-        "zixuanchen.vitest-explorer"
-    ]
-}

package/.vscode/launch.json

@@ -1,27 +0,0 @@
-{
-    "version": "0.2.0",
-    "configurations": [
-        {
-            "name": "Run Dev (Codegen Watcher)",
-            "type": "node",
-            "request": "launch",
-            "runtimeExecutable": "npm",
-            "runtimeArgs": [
-                "run",
-                "dev"
-            ],
-            "console": "integratedTerminal"
-        },
-        {
-            "type": "node",
-            "request": "launch",
-            "name": "Debug Vitest",
-            "program": "${workspaceFolder}/node_modules/vitest/vitest.mjs",
-            "args": [
-                "run"
-            ],
-            "console": "integratedTerminal",
-            "internalConsoleOptions": "neverOpen"
-        }
-    ]
-}