trackswap 0.0.2 → 0.0.4

package/dist/FIT/encoder.js

@@ -1,445 +0,0 @@
-/* global Blob */
-import { Mesg } from "./mesg.js";
-import { crc } from "./crc.js";
-import dayjs from "dayjs";
-const HEADER_LEN = 14;
-const PROTOCOL_VERSION = 0x10; // 1.0
-const PROFILE_VERSION = 2078; // 20.78
-const MAGIC = 0x2e464954; // ".FIT"
-/**
- * FIT 编码器 - 将 FITFileType 数据编码为 FIT 二进制格式
- */
-export class FITEncoder {
-    /**
-     * 构造函数
-     * @param options 编码器选项
-     */
-    constructor(options = {}) {
-        this.localNum = {};
-        this.mesgDefn = [];
-        this.messages = [];
-        this.options = {
-            compact: options.compact ?? true,
-            defaultSport: options.defaultSport ?? "cycling",
-            defaultSubSport: options.defaultSubSport ?? "generic",
-        };
-    }
-    // ==================== 公共接口 ====================
-    /**
-     * 编码 FIT 数据为 Buffer - Activity 文件类型
-     */
-    async encode(fitData) {
-        this.reset();
-        this.buildFITContent(fitData, "activity");
-        return Buffer.from(await this.blob.arrayBuffer());
-    }
-    /**
-     * 编码 FIT 数据为 Buffer - Course 文件类型
-     */
-    async encodeCourse(fitData) {
-        this.reset();
-        this.buildFITContent(fitData, "course");
-        return Buffer.from(await this.blob.arrayBuffer());
-    }
-    /**
-     * 编码 FIT 数据为 Blob
-     */
-    async encodeToBlob(fitData, fileType = "activity") {
-        this.reset();
-        this.buildFITContent(fitData, fileType);
-        return this.blob;
-    }
-    // ==================== 核心构建方法 ====================
-    /**
-     * 重置编码器状态
-     */
-    reset() {
-        this.localNum = {};
-        this.mesgDefn = [];
-        this.messages = [];
-    }
-    /**
-     * 构建 FIT 文件内容
-     */
-    buildFITContent(fitData, fileType) {
-        // 1. 写入文件ID（必须第一个）
-        this.buildFileId(fitData, fileType);
-        // 2. 根据文件类型构建不同的内容
-        if (fileType === "course") {
-            this.buildCourseContent(fitData);
-        }
-        else {
-            this.buildActivityContent(fitData);
-        }
-    }
-    /**
-     * 构建 Activity 文件内容
-     */
-    buildActivityContent(fitData) {
-        const sessions = fitData.sessionMesgs || [];
-        if (sessions.length === 0) {
-            throw new Error("Activity文件必须包含至少一个Session");
-        }
-        // 处理所有sessions
-        let totalSessions = 0;
-        const allEvents = [];
-        const allActivities = [];
-        for (const session of sessions) {
-            // 构建session相关的events
-            if (session.lapMesgs) {
-                this.buildEventsFromLaps(session.lapMesgs, allEvents);
-            }
-            // 构建records
-            if (session.lapMesgs) {
-                for (const lap of session.lapMesgs) {
-                    if (lap.recordMesgs) {
-                        this.buildRecords(lap.recordMesgs);
-                    }
-                }
-            }
-            // 构建laps
-            if (session.lapMesgs) {
-                this.buildLaps(session.lapMesgs);
-            }
-            // 构建session
-            this.buildSession(session);
-            totalSessions++;
-            // 构建activity
-            this.buildActivityFromSession(session, allActivities);
-        }
-        // 写入所有events
-        allEvents.forEach((event) => this.buildEvent(event));
-        // 写入所有activities
-        allActivities.forEach((activity) => this.buildActivity(activity));
-    }
-    /**
-     * 构建 Course 文件内容
-     */
-    buildCourseContent(fitData) {
-        // Course文件的特殊处理逻辑
-        const sessions = fitData.sessionMesgs || [];
-        if (sessions.length === 0) {
-            throw new Error("Course文件必须包含轨迹数据");
-        }
-        const session = sessions[0]; // Course通常只有一个session
-        // 写入course信息
-        this.buildCourse({
-            name: "course",
-            sport: this.options.defaultSport,
-        });
-        // 构建events和records
-        if (session.lapMesgs) {
-            const allRecords = [];
-            // 收集所有records
-            for (const lap of session.lapMesgs) {
-                if (lap.recordMesgs) {
-                    allRecords.push(...lap.recordMesgs);
-                }
-            }
-            // 排序records（按时间戳或距离）
-            allRecords.sort((a, b) => {
-                if (a.timestamp && b.timestamp) {
-                    return (new Date(a.timestamp).getTime() - new Date(b.timestamp).getTime());
-                }
-                return (a.distance || 0) - (b.distance || 0);
-            });
-            // 构建course points和records
-            const startRecord = allRecords[0];
-            const endRecord = allRecords[allRecords.length - 1];
-            // 开始事件
-            if (startRecord.timestamp) {
-                this.buildEvent({
-                    timestamp: startRecord.timestamp,
-                    event: "timer",
-                    eventType: "start",
-                    eventGroup: 0,
-                });
-            }
-            // 写入所有records
-            allRecords.forEach((record) => this.buildRecord(record));
-            // 结束事件
-            if (endRecord.timestamp) {
-                this.buildEvent({
-                    timestamp: endRecord.timestamp,
-                    event: "timer",
-                    eventType: "stop_all",
-                    eventGroup: 0,
-                });
-            }
-            // 写入lap
-            if (session.lapMesgs[0]) {
-                this.buildLap(session.lapMesgs[0]);
-            }
-        }
-    }
-    // ==================== 辅助构建方法 ====================
-    /**
-     * 构建文件ID
-     */
-    buildFileId(fitData, fileType) {
-        const fileId = fitData.fileIdMesgs?.[0] || {};
-        this.writeMesg("file_id", {
-            type: fileType,
-            time_created: fileId.timeCreated
-                ? this.parseTimestamp(fileId.timeCreated)
-                : Date.now(),
-            manufacturer: fileId.manufacturer,
-            product: fileId.product,
-            serial_number: fileId.serialNumber,
-        });
-    }
-    /**
-     * 构建Session
-     */
-    buildSession(session) {
-        this.writeMesg("session", {
-            timestamp: session.timestamp
-                ? this.parseTimestamp(session.timestamp)
-                : undefined,
-            start_time: session.startTime
-                ? this.parseTimestamp(session.startTime)
-                : undefined,
-            total_elapsed_time: session.totalElapsedTime,
-            total_timer_time: session.totalTimerTime,
-            start_position_lat: this.convertToSemicircles(session.startPositionLat),
-            start_position_long: this.convertToSemicircles(session.startPositionLong),
-            total_distance: session.totalDistance,
-            total_ascent: session.totalAscent,
-            total_descent: session.totalDescent,
-            sport: session.sport || this.options.defaultSport,
-            sub_sport: session.subSport || this.options.defaultSubSport,
-            first_lap_index: session.firstLapIndex || 0,
-            num_laps: session.numLaps || session.lapMesgs?.length || 1,
-        });
-    }
-    /**
-     * 构建Laps
-     */
-    buildLaps(laps) {
-        laps.forEach((lap) => this.buildLap(lap));
-    }
-    /**
-     * 构建单个Lap
-     */
-    buildLap(lap) {
-        this.writeMesg("lap", {
-            timestamp: lap.timestamp ? this.parseTimestamp(lap.timestamp) : undefined,
-            start_time: lap.startTime
-                ? this.parseTimestamp(lap.startTime)
-                : undefined,
-            start_position_lat: this.convertToSemicircles(lap.startPositionLat),
-            start_position_long: this.convertToSemicircles(lap.startPositionLong),
-            end_position_lat: this.convertToSemicircles(lap.endPositionLat),
-            end_position_long: this.convertToSemicircles(lap.endPositionLong),
-            total_elapsed_time: lap.totalElapsedTime,
-            total_timer_time: lap.totalTimerTime,
-            total_distance: lap.totalDistance,
-            total_ascent: lap.totalAscent,
-            total_descent: lap.totalDescent,
-        });
-    }
-    /**
-     * 构建Records
-     */
-    buildRecords(records) {
-        records.forEach((record) => this.buildRecord(record));
-    }
-    /**
-     * 构建单个Record
-     */
-    buildRecord(record) {
-        this.writeMesg("record", {
-            timestamp: record.timestamp
-                ? this.parseTimestamp(record.timestamp)
-                : undefined,
-            position_lat: this.convertToSemicircles(record.positionLat),
-            position_long: this.convertToSemicircles(record.positionLong),
-            altitude: record.enhancedAltitude || record.altitude,
-            distance: record.distance,
-            heart_rate: record.heartRate,
-            cadence: record.cadence,
-            speed: record.enhancedSpeed || record.speed,
-            power: record.power,
-        });
-    }
-    /**
-     * 构建Event
-     */
-    buildEvent(event) {
-        this.writeMesg("event", {
-            timestamp: event.timestamp
-                ? this.parseTimestamp(event.timestamp)
-                : undefined,
-            event: event.event,
-            event_type: event.eventType,
-            event_group: event.eventGroup,
-        });
-    }
-    /**
-     * 构建Activity
-     */
-    buildActivity(activity) {
-        this.writeMesg("activity", {
-            timestamp: activity.timestamp
-                ? this.parseTimestamp(activity.timestamp)
-                : undefined,
-            total_timer_time: activity.totalTimerTime,
-            num_sessions: activity.numSessions,
-            type: activity.type,
-            event: activity.event,
-            event_type: activity.eventType,
-            local_timestamp: activity.localTimestamp
-                ? this.parseTimestamp(activity.localTimestamp)
-                : undefined,
-            event_group: activity.eventGroup,
-        });
-    }
-    /**
-     * 构建Course
-     */
-    buildCourse(course) {
-        this.writeMesg("course", {
-            name: course.name,
-            sport: course.sport,
-        });
-    }
-    // ==================== 数据转换和验证方法 ====================
-    /**
-     * 从Laps构建Events
-     */
-    buildEventsFromLaps(laps, events) {
-        laps.forEach((lap, index) => {
-            // 开始事件
-            if (lap.startTime) {
-                events.push({
-                    timestamp: lap.startTime,
-                    event: "timer",
-                    eventType: "start",
-                    eventGroup: index,
-                });
-            }
-            // 结束事件
-            if (lap.timestamp) {
-                events.push({
-                    timestamp: lap.timestamp,
-                    event: "timer",
-                    eventType: index === laps.length - 1 ? "stop_all" : "stop",
-                    eventGroup: index,
-                });
-            }
-        });
-    }
-    /**
-     * 从Session构建Activity
-     */
-    buildActivityFromSession(session, activities) {
-        activities.push({
-            timestamp: session.timestamp,
-            totalTimerTime: session.totalTimerTime,
-            numSessions: 1,
-            type: session.sport || this.options.defaultSport,
-            event: "activity",
-            eventType: "stop",
-            eventGroup: 0,
-        });
-    }
-    /**
-     * 解析时间戳
-     */
-    parseTimestamp(timestamp) {
-        if (typeof timestamp === "number") {
-            return timestamp;
-        }
-        const date = dayjs(timestamp);
-        return date.valueOf();
-    }
-    /**
-     * 转换坐标为半圆单位
-     */
-    convertToSemicircles(coord) {
-        if (coord === undefined || coord === null)
-            return undefined;
-        return Math.round((coord * 2 ** 31) / 180);
-    }
-    /**
-     * 验证必要字段
-     */
-    validateRequiredFields(fitData) {
-        if (!fitData.sessionMesgs || fitData.sessionMesgs.length === 0) {
-            throw new Error("FIT文件必须包含至少一个Session");
-        }
-    }
-    // ==================== 低级别消息写入方法 ====================
-    /**
-     * 写入消息
-     */
-    writeMesg(mesgName, values) {
-        // 过滤掉undefined值
-        const filteredValues = Object.fromEntries(Object.entries(values).filter(([_, value]) => value !== undefined));
-        if (Object.keys(filteredValues).length === 0)
-            return;
-        let localNum = this.localNum[mesgName];
-        if (localNum === undefined) {
-            localNum = this.localNum[mesgName] = Object.keys(this.localNum).length;
-        }
-        const mesg = new Mesg(localNum, mesgName, filteredValues);
-        const mesgDefn = this.mesgDefn[localNum];
-        if (!mesgDefn || !mesg.isSameDefn(mesgDefn)) {
-            this.messages.push(mesg.defnRecord);
-            this.mesgDefn[localNum] = mesg.mesgDefn;
-        }
-        this.messages.push(mesg.dataRecord);
-    }
-    // ==================== 文件生成属性 ====================
-    /**
-     * 获取Blob对象
-     */
-    get blob() {
-        const content = [this.header, ...this.messages, this.trailer];
-        return new Blob(content, { type: "application/octet-stream" });
-    }
-    /**
-     * 获取数据长度
-     */
-    get dataLen() {
-        return this.messages.reduce((len, message) => len + message.byteLength, 0);
-    }
-    /**
-     * 获取数据CRC
-     */
-    get dataCrc() {
-        return this.messages.reduce((dataCrc, message) => crc(message, dataCrc), 0);
-    }
-    /**
-     * 获取文件头
-     */
-    get header() {
-        const dv = new DataView(new ArrayBuffer(HEADER_LEN));
-        dv.setUint8(0, HEADER_LEN);
-        dv.setUint8(1, PROTOCOL_VERSION);
-        dv.setUint16(2, PROFILE_VERSION, true);
-        dv.setUint32(4, this.dataLen, true);
-        dv.setUint32(8, MAGIC);
-        dv.setUint16(12, crc(dv.buffer.slice(0, 12)), true);
-        return dv.buffer;
-    }
-    /**
-     * 获取文件尾
-     */
-    get trailer() {
-        const dv = new DataView(new ArrayBuffer(2));
-        dv.setUint16(0, this.dataCrc, true);
-        return dv.buffer;
-    }
-    // ==================== 兼容性方法 (Deprecated) ====================
-    /**
-     * @deprecated 使用 encode() 替代
-     */
-    async encoder(fitData) {
-        console.warn("encoder() 方法已废弃，请使用 encode() 方法");
-        return this.encode(fitData);
-    }
-}
-export default {
-    FITEncoder,
-};

package/dist/FIT/index.js

@@ -1,13 +0,0 @@
-// ============ 核心类和接口 ============
-export { FITDecoder } from "./decoder.js";
-export { FITEncoder } from "./encoder.js";
-// ============ 基础架构 ============
-export { BaseFITMessageConverter, BaseFITStructurePlugin, BaseFITMiddleware, } from "./base.js";
-// ============ 默认插件 ============
-export { SessionStructurePlugin, CourseStructurePlugin, FileHeaderPlugin, } from "./plugins.js";
-// ============ 类型定义 ============
-export * from "./types.js";
-// ============ 默认导出 ============
-import { FITDecoder } from "./decoder.js";
-import { FITEncoder } from "./encoder.js";
-export default { FITDecoder, FITEncoder };

package/dist/FIT/mesg.js

@@ -1,208 +0,0 @@
-import { types, encodedStrlen } from "./types/index.js";
-import { MesgNum } from "./types/mesg_num.js";
-const mesgDefns = {
-    file_id: {
-        mesgNum: MesgNum.FILE_ID,
-        fieldDefns: [
-            { name: "type", number: 0, type: "enum_file" },
-            { name: "time_created", number: 4, type: "date_time" },
-        ],
-    },
-    session: {
-        mesgNum: MesgNum.SESSION,
-        fieldDefns: [
-            { name: "timestamp", number: 253, type: "date_time" },
-            { name: "start_time", number: 2, type: "date_time" },
-            { name: "total_elapsed_time", number: 7, type: "seconds" },
-            { name: "total_timer_time", number: 8, type: "seconds" },
-            { name: "start_position_lat", number: 3, type: "semicircles" },
-            { name: "start_position_long", number: 4, type: "semicircles" },
-            { name: "total_distance", number: 9, type: "distance" },
-            { name: "total_ascent", number: 21, type: "uint16" },
-            { name: "total_descent", number: 22, type: "uint16" },
-            { name: "sport", number: 5, type: "enum_sport" },
-            { name: "sub_sport", number: 6, type: "enum_sub_sport" },
-            { name: "first_lap_index", number: 11, type: "uint16" },
-            { name: "num_laps", number: 26, type: "uint16" },
-        ],
-    },
-    lap: {
-        mesgNum: MesgNum.LAP,
-        fieldDefns: [
-            { name: "timestamp", number: 253, type: "date_time" },
-            { name: "start_time", number: 2, type: "date_time" },
-            { name: "start_position_lat", number: 3, type: "semicircles" },
-            { name: "start_position_long", number: 4, type: "semicircles" },
-            { name: "end_position_lat", number: 5, type: "semicircles" },
-            { name: "end_position_long", number: 6, type: "semicircles" },
-            { name: "total_elapsed_time", number: 7, type: "seconds" },
-            { name: "total_timer_time", number: 8, type: "seconds" },
-            { name: "total_distance", number: 9, type: "distance" },
-            { name: "total_ascent", number: 21, type: "uint16" },
-            { name: "total_descent", number: 22, type: "uint16" },
-        ],
-    },
-    record: {
-        mesgNum: MesgNum.RECORD,
-        fieldDefns: [
-            { name: "timestamp", number: 253, type: "date_time" },
-            { name: "position_lat", number: 0, type: "semicircles" },
-            { name: "position_long", number: 1, type: "semicircles" },
-            { name: "altitude", number: 2, type: "altitude" },
-            { name: "distance", number: 5, type: "distance" },
-            { name: "heart_rate", number: 3, type: "uint8" },
-            { name: "cadence", number: 4, type: "uint8" },
-            { name: "speed", number: 6, type: "speed" },
-            { name: "power", number: 7, type: "uint16" },
-        ],
-    },
-    event: {
-        mesgNum: MesgNum.EVENT,
-        fieldDefns: [
-            { name: "timestamp", number: 253, type: "date_time" },
-            { name: "event", number: 0, type: "enum_event" },
-            { name: "event_type", number: 1, type: "enum_event_type" },
-            { name: "event_group", number: 4, type: "uint8" },
-        ],
-    },
-    course: {
-        mesgNum: MesgNum.COURSE,
-        fieldDefns: [
-            { name: "name", number: 5, type: "string" },
-            { name: "sport", number: 4, type: "enum_sport" },
-            { name: "sub_sport", number: 7, type: "enum_sub_sport" },
-        ],
-    },
-    activity: {
-        mesgNum: MesgNum.ACTIVITY,
-        fieldDefns: [
-            { name: "timestamp", number: 253, type: "date_time" },
-            { name: "total_timer_time", number: 0, type: "seconds" },
-            { name: "num_sessions", number: 1, type: "uint16" },
-            { name: "type", number: 2, type: "enum_activity" },
-            { name: "event", number: 3, type: "enum_event" },
-            { name: "event_type", number: 4, type: "enum_event_type" },
-            { name: "local_timestamp", number: 5, type: "date_time" },
-            { name: "event_group", number: 6, type: "uint8" },
-        ],
-    },
-    course_point: {
-        mesgNum: MesgNum.COURSE_POINT,
-        fieldDefns: [
-            { name: "timestamp", number: 1, type: "date_time" },
-            { name: "position_lat", number: 2, type: "semicircles" },
-            { name: "position_long", number: 3, type: "semicircles" },
-            { name: "distance", number: 4, type: "distance" },
-            { name: "type", number: 5, type: "enum_course_point" },
-        ],
-    },
-};
-/**
- * 将 fieldDefns 和 fieldValues 转换为 fields 对象
- */
-const fields = (fieldDefns, fieldValues) => {
-    return fieldDefns
-        .map((fieldDefn) => ({ ...fieldDefn, value: fieldValues[fieldDefn.name] }))
-        .filter(({ value }) => value !== undefined);
-};
-export class Mesg {
-    static check(mesgName, mesgNum, fieldDefns, values) {
-        if (mesgNum === undefined) {
-            throw new Error(`Message '${mesgName}' not known`);
-        }
-        if (fieldDefns === undefined) {
-            throw new Error(`Message '${mesgName}' has no field definitions`);
-        }
-        const fieldNames = fieldDefns.map((fieldDefn) => fieldDefn.name);
-        const unknownFields = Object.keys(values).filter((fieldName) => !fieldNames.includes(fieldName));
-        if (unknownFields.length) {
-            throw new Error(`Message '${mesgName}' has no field definitions named '${unknownFields}'`);
-        }
-    }
-    constructor(localNum, mesgName, values) {
-        const mesgDefn = mesgDefns[mesgName];
-        if (!mesgDefn) {
-            throw new Error(`Unknown message type: ${mesgName}`);
-        }
-        const { mesgNum, fieldDefns } = mesgDefn;
-        Mesg.check(mesgName, mesgNum, fieldDefns, values);
-        this.localNum = localNum;
-        this.mesgNum = mesgNum;
-        this.fields = fields(fieldDefns, values);
-    }
-    /**
-     * 获取 defns，并获取了 size
-     */
-    get mesgDefn() {
-        const fieldDefns = this.fields.map(({ number, type, value }) => {
-            const typeInfo = types[type];
-            if (!typeInfo) {
-                throw new Error(`Unknown type: ${type}`);
-            }
-            const { size, baseType } = typeInfo;
-            if (type === "string") {
-                return { number, size: encodedStrlen(value), baseType };
-            }
-            return { number, size, baseType };
-        });
-        return {
-            localNum: this.localNum,
-            mesgNum: this.mesgNum,
-            fieldDefns,
-        };
-    }
-    isSameDefn(mesgDefn) {
-        const isSameFieldDefn = (defn1, defn2) => defn1.number === defn2.number &&
-            defn1.size === defn2.size &&
-            defn1.baseType === defn2.baseType;
-        const areSameFieldDefns = (defns1, defns2) => defns1.length === defns2.length &&
-            defns1.every((defn1, i) => isSameFieldDefn(defn1, defns2[i]));
-        const { localNum, mesgNum, fieldDefns } = this.mesgDefn;
-        return (mesgNum === mesgDefn.mesgNum &&
-            localNum === mesgDefn.localNum &&
-            areSameFieldDefns(fieldDefns, mesgDefn.fieldDefns));
-    }
-    get defnRecord() {
-        const { localNum, mesgNum, fieldDefns } = this.mesgDefn;
-        const recordLen = 6 + 3 * fieldDefns.length;
-        const dv = new DataView(new ArrayBuffer(recordLen));
-        dv.setUint8(0, 0x40 | localNum);
-        dv.setUint8(2, 1); // big endian
-        dv.setUint16(3, mesgNum);
-        dv.setUint8(5, fieldDefns.length);
-        let offset = 6;
-        for (const fieldDefn of fieldDefns) {
-            dv.setUint8(offset++, fieldDefn.number);
-            dv.setUint8(offset++, fieldDefn.size);
-            dv.setUint8(offset++, fieldDefn.baseType);
-        }
-        return dv.buffer;
-    }
-    get dataRecord() {
-        const { fieldDefns } = this.mesgDefn;
-        const recordLen = 1 +
-            fieldDefns.reduce((len, { size }) => len + size, 0);
-        const dv = new DataView(new ArrayBuffer(recordLen));
-        dv.setUint8(0, this.localNum);
-        let offset = 1;
-        for (const { number, type, value } of this.fields) {
-            const typeInfo = types[type];
-            if (!typeInfo) {
-                throw new Error(`Unknown type: ${type}`);
-            }
-            const { size, setValue } = typeInfo;
-            let mappedValue;
-            if ("mapValue" in typeInfo) {
-                mappedValue = typeInfo.mapValue(value);
-            }
-            else {
-                mappedValue = value;
-            }
-            if (setValue) {
-                setValue.call(dv, offset, mappedValue);
-            }
-            offset += size;
-        }
-        return dv.buffer;
-    }
-}