trackswap 0.0.1 → 0.0.2

package/dist/FIT/base.d.ts

@@ -0,0 +1,91 @@
+import { IPlugin } from "../core/base.js";
+import { FITContext, FITDecoderMesgs, FITFileType } from "./types.js";
+/**
+ * FIT 消息转换器插件接口
+ */
+export interface IFITMessageConverter extends IPlugin<FITContext> {
+    /** 支持的消息类型 */
+    supportedMessageTypes: string[];
+    /** 转换消息 */
+    convertMessages(messages: any[], context: FITContext): any;
+    /** 是否支持该消息类型 */
+    supports(messageType: string): boolean;
+    /** 优先级 */
+    priority?: number;
+}
+/**
+ * FIT 数据结构化插件接口
+ */
+export interface IFITStructurePlugin extends IPlugin<FITContext> {
+    /** 结构化数据 */
+    structureData(messages: FITDecoderMesgs, context: FITContext): Partial<FITFileType>;
+    /** 优先级 */
+    priority?: number;
+}
+/**
+ * FIT 中间件插件接口
+ */
+export interface IFITMiddlewarePlugin extends IPlugin<FITContext> {
+    /** 优先级 */
+    priority?: number;
+    /** 在解析阶段执行 */
+    onParse?(buffer: Buffer, context: FITContext): Promise<Buffer> | Buffer;
+    /** 在消息提取阶段执行 */
+    onExtractMessages?(messages: FITDecoderMesgs, context: FITContext): Promise<FITDecoderMesgs> | FITDecoderMesgs;
+    /** 在数据结构化阶段执行 */
+    onStructure?(result: Partial<FITFileType>, context: FITContext): Promise<Partial<FITFileType>> | Partial<FITFileType>;
+    /** 在完成阶段执行 */
+    onComplete?(result: FITFileType, context: FITContext): Promise<FITFileType> | FITFileType;
+    /** 错误处理 */
+    onError?(error: Error, context: FITContext): Promise<void> | void;
+}
+/**
+ * FIT 消息转换器基类
+ */
+export declare abstract class BaseFITMessageConverter implements IFITMessageConverter {
+    abstract name: string;
+    abstract supportedMessageTypes: string[];
+    version: string;
+    priority: number;
+    abstract convertMessages(messages: any[], context: FITContext): any;
+    supports(messageType: string): boolean;
+    initialize(context: FITContext): Promise<void>;
+    destroy(context: FITContext): Promise<void>;
+    validate(context: FITContext): Promise<boolean>;
+    protected parseTimestamp(timestamp: string | undefined): Date | undefined;
+    protected calculateDuration(startTime?: string, endTime?: string): number;
+    protected filterMessagesByTimeRange(messages: any[], startTime: string, endTime: string, tolerance?: number): any[];
+    protected groupMessagesByLap(records: any[], laps: any[]): Array<{
+        lap: any;
+        records: any[];
+    }>;
+}
+/**
+ * FIT 数据结构化插件基类
+ */
+export declare abstract class BaseFITStructurePlugin implements IFITStructurePlugin {
+    abstract name: string;
+    version: string;
+    priority: number;
+    abstract structureData(messages: FITDecoderMesgs, context: FITContext): Partial<FITFileType>;
+    initialize(context: FITContext): Promise<void>;
+    destroy(context: FITContext): Promise<void>;
+    validate(context: FITContext): Promise<boolean>;
+}
+/**
+ * FIT 中间件基类
+ */
+export declare abstract class BaseFITMiddleware implements IFITMiddlewarePlugin {
+    abstract name: string;
+    version: string;
+    description: string;
+    priority: number;
+    initialize(context: FITContext): Promise<void>;
+    destroy(context: FITContext): Promise<void>;
+    validate(context: FITContext): Promise<boolean>;
+    onParse(buffer: Buffer, context: FITContext): Promise<Buffer>;
+    onExtractMessages(messages: FITDecoderMesgs, context: FITContext): Promise<FITDecoderMesgs>;
+    onStructure(result: Partial<FITFileType>, context: FITContext): Promise<Partial<FITFileType>>;
+    onComplete(result: FITFileType, context: FITContext): Promise<FITFileType>;
+    onError(error: Error, context: FITContext): Promise<void>;
+}

package/dist/FIT/base.js

@@ -0,0 +1,101 @@
+// ============ 基础工具类 ============
+/**
+ * FIT 消息转换器基类
+ */
+export class BaseFITMessageConverter {
+    constructor() {
+        this.version = "1.0.0";
+        this.priority = 100;
+    }
+    supports(messageType) {
+        return this.supportedMessageTypes.includes(messageType);
+    }
+    async initialize(context) {
+        context.metadata.set(`plugin:${this.name}:initialized`, true);
+    }
+    async destroy(context) {
+        context.metadata.delete(`plugin:${this.name}:initialized`);
+    }
+    async validate(context) {
+        return true;
+    }
+    // ============ FIT 特定工具方法 ============
+    parseTimestamp(timestamp) {
+        if (!timestamp)
+            return undefined;
+        const date = new Date(timestamp);
+        return isNaN(date.getTime()) ? undefined : date;
+    }
+    calculateDuration(startTime, endTime) {
+        if (!startTime || !endTime)
+            return 0;
+        const start = new Date(startTime).getTime();
+        const end = new Date(endTime).getTime();
+        return Math.max(0, (end - start) / 1000); // 返回秒数
+    }
+    filterMessagesByTimeRange(messages, startTime, endTime, tolerance = 2000 // 默认2秒容错
+    ) {
+        const start = new Date(startTime).getTime();
+        const end = new Date(endTime).getTime();
+        return messages.filter((message) => {
+            if (!message.timestamp)
+                return false;
+            const messageTime = new Date(message.timestamp).getTime();
+            return messageTime >= start - tolerance && messageTime <= end + tolerance;
+        });
+    }
+    groupMessagesByLap(records, laps) {
+        return laps.map((lap) => {
+            const lapRecords = this.filterMessagesByTimeRange(records, lap.startTime, lap.timestamp);
+            return { lap, records: lapRecords };
+        });
+    }
+}
+/**
+ * FIT 数据结构化插件基类
+ */
+export class BaseFITStructurePlugin {
+    constructor() {
+        this.version = "1.0.0";
+        this.priority = 100;
+    }
+    async initialize(context) {
+        context.metadata.set(`plugin:${this.name}:initialized`, true);
+    }
+    async destroy(context) {
+        context.metadata.delete(`plugin:${this.name}:initialized`);
+    }
+    async validate(context) {
+        return true;
+    }
+}
+/**
+ * FIT 中间件基类
+ */
+export class BaseFITMiddleware {
+    constructor() {
+        this.version = "1.0.0";
+        this.description = "";
+        this.priority = 100;
+    }
+    async initialize(context) { }
+    async destroy(context) { }
+    async validate(context) {
+        return true;
+    }
+    async onParse(buffer, context) {
+        return buffer;
+    }
+    async onExtractMessages(messages, context) {
+        return messages;
+    }
+    async onStructure(result, context) {
+        return result;
+    }
+    async onComplete(result, context) {
+        return result;
+    }
+    async onError(error, context) {
+        console.error(`FIT中间件 ${this.name} 处理错误:`, error);
+    }
+}

package/dist/FIT/crc.d.ts

@@ -0,0 +1 @@
+export declare function crc(buffer: ArrayBuffer | Uint8Array, initial?: number): number;

package/dist/FIT/crc.js

@@ -0,0 +1,16 @@
+// prettier-ignore
+const crc_table = [
+    0x0000, 0xcc01, 0xd801, 0x1400, 0xf001, 0x3c00, 0x2800, 0xe401,
+    0xa001, 0x6c00, 0x7800, 0xb401, 0x5000, 0x9c01, 0x8801, 0x4400
+];
+const update_nibble = (crc, nibble) => ((crc >>> 4) ^ crc_table[(crc & 0xf) ^ nibble]) & 0xffff;
+const update_nibbles = (crc, lo, hi) => update_nibble(update_nibble(crc, lo), hi);
+const update = (crc, byte) => update_nibbles(crc, byte & 0xf, byte >>> 4);
+export function crc(buffer, initial = 0) {
+    let crcValue = initial;
+    const uint8Array = buffer instanceof ArrayBuffer ? new Uint8Array(buffer) : buffer;
+    for (let i = 0; i < uint8Array.length; i++) {
+        crcValue = update(crcValue, uint8Array[i]);
+    }
+    return crcValue;
+}

package/dist/FIT/decoder.d.ts

@@ -0,0 +1,83 @@
+import { IFITMessageConverter, IFITStructurePlugin, IFITMiddlewarePlugin } from "./base.js";
+import { FITFileType } from "./types.js";
+/**
+ * FIT 解码器 - 遵循 GPX 风格的插件架构
+ */
+export declare class FITDecoder {
+    private converterPlugins;
+    private registeredPlugins;
+    private structurePlugins;
+    private middlewarePlugins;
+    private processors;
+    private initialized;
+    private defaultPluginsRegistered;
+    constructor();
+    /**
+     * 初始化流水线 - 注册固定的核心处理器
+     */
+    private initializePipeline;
+    /**
+     * 自动注册默认插件
+     */
+    private registerDefaultPlugins;
+    /**
+     * 为指定消息类型添加转换器，按优先级排序
+     */
+    private addConverterForMessageType;
+    /**
+     * 添加结构化插件
+     */
+    private addStructurePlugin;
+    /**
+     * 注册消息转换器插件
+     */
+    registerMessageConverter(plugin: IFITMessageConverter): Promise<void>;
+    /**
+     * 注册结构化插件
+     */
+    registerStructurePlugin(plugin: IFITStructurePlugin): Promise<void>;
+    /**
+     * 注册中间件插件
+     */
+    registerMiddleware(plugin: IFITMiddlewarePlugin): Promise<void>;
+    /**
+     * 获取消息类型转换器（返回优先级最高的）
+     */
+    getConverter(messageType: string): IFITMessageConverter | undefined;
+    /**
+     * 获取指定消息类型的所有转换器（按优先级排序）
+     */
+    getConverters(messageType: string): IFITMessageConverter[];
+    /**
+     * 移除插件
+     */
+    unregisterPlugin(pluginName: string): boolean;
+    /**
+     * 初始化解码器
+     */
+    initialize(): Promise<void>;
+    /**
+     * 销毁解码器
+     */
+    destroy(): Promise<void>;
+    /**
+     * 创建解码上下文
+     */
+    private createContext;
+    /**
+     * 执行中间件钩子
+     */
+    private executeMiddlewareHook;
+    /**
+     * 主解析方法 - 固定的流水线 + 灵活的中间件
+     */
+    parseByBuffer(buffer: Buffer, options?: {
+        skipValidation?: boolean;
+        enableStats?: boolean;
+        userData?: Record<string, any>;
+    }): Promise<FITFileType>;
+}
+declare const _default: {
+    FITDecoder: typeof FITDecoder;
+};
+export default _default;

package/dist/FIT/decoder.js

@@ -0,0 +1,323 @@
+import { ParseProcessor, ExtractProcessor, StructureProcessor, CompleteProcessor, FITPipelineStage, } from "./processor.js";
+import { SessionStructurePlugin, CourseStructurePlugin, FileHeaderPlugin, } from "./plugins.js";
+/**
+ * FIT 解码器 - 遵循 GPX 风格的插件架构
+ */
+export class FITDecoder {
+    constructor() {
+        this.converterPlugins = new Map();
+        this.registeredPlugins = new Set(); // 跟踪已注册的插件名
+        this.structurePlugins = [];
+        this.middlewarePlugins = [];
+        this.processors = []; // 固定的核心处理器
+        this.initialized = false;
+        this.defaultPluginsRegistered = false;
+        this.initializePipeline();
+    }
+    /**
+     * 初始化流水线 - 注册固定的核心处理器
+     */
+    initializePipeline() {
+        // 固定的核心处理器，不允许用户修改
+        this.processors = [
+            new ParseProcessor(),
+            new ExtractProcessor((messageType) => this.getConverters(messageType)),
+            new StructureProcessor(() => this.structurePlugins),
+            new CompleteProcessor(),
+        ];
+        console.log("🔧 FIT核心流水线处理器已初始化 (固定不可修改)");
+    }
+    /**
+     * 自动注册默认插件
+     */
+    async registerDefaultPlugins() {
+        if (this.defaultPluginsRegistered)
+            return;
+        const defaultStructurePlugins = [
+            new FileHeaderPlugin(),
+            new SessionStructurePlugin(),
+            new CourseStructurePlugin(),
+        ];
+        for (const plugin of defaultStructurePlugins) {
+            this.addStructurePlugin(plugin);
+            this.registeredPlugins.add(plugin.name);
+        }
+        this.defaultPluginsRegistered = true;
+        console.log("✅ 默认FIT结构化插件已自动注册 (FileHeader, Session, Course等)");
+    }
+    /**
+     * 为指定消息类型添加转换器，按优先级排序
+     */
+    addConverterForMessageType(messageType, converter) {
+        if (!this.converterPlugins.has(messageType)) {
+            this.converterPlugins.set(messageType, []);
+        }
+        const converters = this.converterPlugins.get(messageType);
+        converters.push(converter);
+        // 按优先级排序（数字越小优先级越高）
+        converters.sort((a, b) => (a.priority || 100) - (b.priority || 100));
+    }
+    /**
+     * 添加结构化插件
+     */
+    addStructurePlugin(plugin) {
+        this.structurePlugins.push(plugin);
+        // 按优先级排序
+        this.structurePlugins.sort((a, b) => (a.priority || 100) - (b.priority || 100));
+    }
+    /**
+     * 注册消息转换器插件
+     */
+    async registerMessageConverter(plugin) {
+        // 检查插件是否已注册
+        if (this.registeredPlugins.has(plugin.name)) {
+            throw new Error(`消息转换器插件 ${plugin.name} 已存在`);
+        }
+        // 注册支持的消息类型
+        plugin.supportedMessageTypes.forEach((messageType) => {
+            this.addConverterForMessageType(messageType, plugin);
+        });
+        this.registeredPlugins.add(plugin.name);
+        // 显示优先级信息
+        const priorityInfo = plugin.priority !== undefined ? ` (优先级: ${plugin.priority})` : "";
+        console.log(`📦 已注册FIT消息转换器: ${plugin.name}${priorityInfo}, 支持消息类型: ${plugin.supportedMessageTypes.join(", ")}`);
+        // 显示消息类型的转换器优先级顺序
+        plugin.supportedMessageTypes.forEach((messageType) => {
+            const converters = this.converterPlugins.get(messageType) || [];
+            const converterNames = converters.map((c) => `${c.name}(${c.priority || 100})`);
+            console.log(`   📋 消息类型 "${messageType}" 转换器优先级: ${converterNames.join(" > ")}`);
+        });
+    }
+    /**
+     * 注册结构化插件
+     */
+    async registerStructurePlugin(plugin) {
+        if (this.registeredPlugins.has(plugin.name)) {
+            throw new Error(`结构化插件 ${plugin.name} 已存在`);
+        }
+        this.addStructurePlugin(plugin);
+        this.registeredPlugins.add(plugin.name);
+        const priorityInfo = plugin.priority !== undefined ? ` (优先级: ${plugin.priority})` : "";
+        console.log(`🏗️ 已注册FIT结构化插件: ${plugin.name}${priorityInfo}`);
+    }
+    /**
+     * 注册中间件插件
+     */
+    async registerMiddleware(plugin) {
+        const existingIndex = this.middlewarePlugins.findIndex((p) => p.name === plugin.name);
+        if (existingIndex !== -1) {
+            this.middlewarePlugins[existingIndex] = plugin;
+            console.log(`🔄 已更新FIT中间件: ${plugin.name}`);
+        }
+        else {
+            this.middlewarePlugins.push(plugin);
+            // 按优先级排序
+            this.middlewarePlugins.sort((a, b) => (a.priority || 100) - (b.priority || 100));
+            console.log(`🔌 已注册FIT中间件: ${plugin.name}`);
+        }
+        // 显示中间件支持的钩子
+        const hooks = [];
+        if (plugin.onParse)
+            hooks.push("onParse");
+        if (plugin.onExtractMessages)
+            hooks.push("onExtractMessages");
+        if (plugin.onStructure)
+            hooks.push("onStructure");
+        if (plugin.onComplete)
+            hooks.push("onComplete");
+        if (plugin.onError)
+            hooks.push("onError");
+        if (hooks.length > 0) {
+            console.log(`   🎣 支持的钩子: ${hooks.join(", ")}`);
+        }
+    }
+    /**
+     * 获取消息类型转换器（返回优先级最高的）
+     */
+    getConverter(messageType) {
+        const converters = this.converterPlugins.get(messageType);
+        return converters && converters.length > 0 ? converters[0] : undefined;
+    }
+    /**
+     * 获取指定消息类型的所有转换器（按优先级排序）
+     */
+    getConverters(messageType) {
+        return this.converterPlugins.get(messageType) || [];
+    }
+    /**
+     * 移除插件
+     */
+    unregisterPlugin(pluginName) {
+        if (!this.registeredPlugins.has(pluginName)) {
+            console.warn(`FIT插件 ${pluginName} 不存在`);
+            return false;
+        }
+        // 从消息转换器中移除
+        for (const [messageType, converters] of this.converterPlugins) {
+            const index = converters.findIndex((plugin) => plugin.name === pluginName);
+            if (index !== -1) {
+                converters.splice(index, 1);
+                if (converters.length === 0) {
+                    this.converterPlugins.delete(messageType);
+                }
+            }
+        }
+        // 从结构化插件中移除
+        const structureIndex = this.structurePlugins.findIndex((plugin) => plugin.name === pluginName);
+        if (structureIndex !== -1) {
+            this.structurePlugins.splice(structureIndex, 1);
+        }
+        // 从中间件中移除
+        const middlewareIndex = this.middlewarePlugins.findIndex((plugin) => plugin.name === pluginName);
+        if (middlewareIndex !== -1) {
+            this.middlewarePlugins.splice(middlewareIndex, 1);
+        }
+        this.registeredPlugins.delete(pluginName);
+        console.log(`🗑️ 已移除FIT插件: ${pluginName}`);
+        return true;
+    }
+    /**
+     * 初始化解码器
+     */
+    async initialize() {
+        if (this.initialized)
+            return;
+        // 首先注册默认插件
+        await this.registerDefaultPlugins();
+        const context = this.createContext();
+        // 初始化所有插件
+        const allPlugins = [
+            ...Array.from(this.converterPlugins.values()).flat(),
+            ...this.structurePlugins,
+            ...this.middlewarePlugins,
+        ];
+        for (const plugin of allPlugins) {
+            try {
+                await plugin.initialize?.(context);
+            }
+            catch (error) {
+                console.error(`FIT插件 ${plugin.name} 初始化失败:`, error);
+            }
+        }
+        this.initialized = true;
+    }
+    /**
+     * 销毁解码器
+     */
+    async destroy() {
+        if (!this.initialized)
+            return;
+        const context = this.createContext();
+        // 销毁所有插件
+        const allPlugins = [
+            ...Array.from(this.converterPlugins.values()).flat(),
+            ...this.structurePlugins,
+            ...this.middlewarePlugins,
+        ];
+        for (const plugin of allPlugins) {
+            try {
+                await plugin.destroy?.(context);
+            }
+            catch (error) {
+                console.error(`FIT插件 ${plugin.name} 销毁失败:`, error);
+            }
+        }
+        this.initialized = false;
+    }
+    /**
+     * 创建解码上下文
+     */
+    createContext() {
+        return {
+            metadata: new Map(),
+            errors: [],
+            warnings: [],
+            stats: {
+                startTime: Date.now(),
+                processedTokens: 0,
+                convertedElements: 0,
+            },
+            performance: {
+                startTime: Date.now(),
+            },
+        };
+    }
+    /**
+     * 执行中间件钩子
+     */
+    async executeMiddlewareHook(hookName, data, context) {
+        let result = data;
+        for (const middleware of this.middlewarePlugins) {
+            const hook = middleware[hookName];
+            if (hook) {
+                try {
+                    result = (await hook.call(middleware, result, context)) || result;
+                }
+                catch (error) {
+                    context.errors.push(error);
+                    await middleware.onError?.(error, context);
+                }
+            }
+        }
+        return result;
+    }
+    /**
+     * 主解析方法 - 固定的流水线 + 灵活的中间件
+     */
+    async parseByBuffer(buffer, options = {}) {
+        await this.initialize();
+        let context = this.createContext();
+        context.rawData = buffer;
+        context.userData = options.userData;
+        // 在上下文中传递解码器实例引用
+        context.metadata.set("decoder", this);
+        try {
+            // 固定的流水线阶段顺序执行
+            for (const processor of this.processors) {
+                try {
+                    // 1. 执行核心处理器
+                    context = await processor.process(context);
+                    // 2. 根据阶段执行对应的中间件钩子
+                    switch (processor.stage) {
+                        case FITPipelineStage.PARSE:
+                            if (context.rawData) {
+                                context.rawData = await this.executeMiddlewareHook("onParse", context.rawData, context);
+                            }
+                            break;
+                        case FITPipelineStage.EXTRACT:
+                            if (context.rawMessages) {
+                                context.rawMessages = await this.executeMiddlewareHook("onExtractMessages", context.rawMessages, context);
+                            }
+                            break;
+                        case FITPipelineStage.STRUCTURE:
+                            if (context.result) {
+                                context.result = await this.executeMiddlewareHook("onStructure", context.result, context);
+                            }
+                            break;
+                        case FITPipelineStage.COMPLETE:
+                            if (context.result) {
+                                context.result = await this.executeMiddlewareHook("onComplete", context.result, context);
+                            }
+                            break;
+                    }
+                }
+                catch (error) {
+                    context.errors.push(error);
+                    // 执行错误处理中间件
+                    for (const middleware of this.middlewarePlugins) {
+                        await middleware.onError?.(error, context);
+                    }
+                    console.error(`FIT流水线阶段 ${processor.stage} 处理失败:`, error);
+                }
+            }
+            return context.result || {};
+        }
+        catch (error) {
+            console.error("FIT解析失败:", error);
+            throw error;
+        }
+    }
+}
+export default {
+    FITDecoder,
+};