trackswap 0.0.1 → 0.0.3

package/dist/sport/base.d.ts

@@ -0,0 +1,63 @@
+import { IPlugin, IConverterPlugin, IMiddlewarePlugin, BaseConverter, BaseMiddleware, IProcessingContext } from "../core/base.js";
+import { SportFileType, SportPointType, SportRouteSegType, SportTrackType } from "../types.js";
+export interface SportContext extends IProcessingContext {
+    sourceFormat: "gpx" | "fit" | "tcx";
+    sourceData: any;
+    result?: SportFileType;
+    performance: {
+        startTime: number;
+        convertTime?: number;
+        validateTime?: number;
+        endTime?: number;
+    };
+}
+export interface SportEncodingContext extends IProcessingContext {
+    targetFormat: "gpx" | "fit" | "tcx";
+    result?: any;
+    performance: {
+        startTime: number;
+        encodeTime?: number;
+        validateTime?: number;
+        endTime?: number;
+    };
+}
+export interface ISportPlugin extends IPlugin<SportContext> {
+}
+export interface ISportConverterPlugin extends IConverterPlugin<SportContext> {
+}
+export interface ISportMiddlewarePlugin extends IMiddlewarePlugin<SportContext, SportFileType> {
+}
+export interface ISportEncoderPlugin extends IPlugin<SportEncodingContext> {
+    encode(sportData: SportFileType, context: SportEncodingContext): any | undefined;
+    supports(format: string): boolean;
+    priority?: number;
+}
+export declare abstract class BaseSportConverter extends BaseConverter<SportContext> implements ISportConverterPlugin {
+    protected convertPoints(points: any[]): SportPointType[];
+    protected abstract convertPoint(point: any): SportPointType | undefined;
+    protected convertTime(time: Date | string | number | undefined): number | undefined;
+    protected calculateDistance(points: SportPointType[]): number | undefined;
+    protected calculateDuration(points: SportPointType[]): number | undefined;
+}
+export declare abstract class BaseSportEncoder implements ISportEncoderPlugin {
+    abstract name: string;
+    abstract supportedTags: string[];
+    version: string;
+    priority: number;
+    abstract encode(sportData: SportFileType, context: SportEncodingContext): any | undefined;
+    supports(format: string): boolean;
+    initialize(context: SportEncodingContext): Promise<void>;
+    destroy(context: SportEncodingContext): Promise<void>;
+    validate(context: SportEncodingContext): Promise<boolean>;
+    protected convertTimeToDate(time: number | undefined): Date;
+    protected convertTimeToString(time: number | undefined): string;
+    protected ensureValidCoordinates(lat: number, lon: number): boolean;
+    protected round(value: number, precision?: number): number;
+}
+export declare abstract class BaseSportMiddleware extends BaseMiddleware<SportContext, SportFileType> implements ISportMiddlewarePlugin {
+    onError(error: Error, context: SportContext): Promise<void>;
+    protected validateSportFile(sportFile: SportFileType): boolean;
+    protected validateTrack(track: SportTrackType): boolean;
+    protected validateRoute(route: SportRouteSegType): boolean;
+    protected validatePoint(point: SportPointType): boolean;
+}

package/dist/sport/converters.d.ts

@@ -0,0 +1,33 @@
+import { BaseSportConverter, SportContext } from "./base.js";
+import { TokenAST } from "../types.js";
+import { SportFileType, SportPointType } from "../types.js";
+import { WptType } from "../GPX/types.js";
+import { RecordMesgType } from "../FIT/types.js";
+import { TrackpointType } from "../TCX/types.js";
+export declare class GPXToSportConverter extends BaseSportConverter {
+    name: string;
+    supportedTags: string[];
+    convert(ast: TokenAST, context: SportContext): SportFileType | undefined;
+    private convertGPX;
+    protected convertPoint(point: WptType): SportPointType | undefined;
+    private convertWpts2Points;
+    private convertGPXExtensions;
+}
+export declare class FITToSportConverter extends BaseSportConverter {
+    name: string;
+    supportedTags: string[];
+    convert(ast: TokenAST, context: SportContext): SportFileType | undefined;
+    private convertFIT;
+    protected convertPoint(point: RecordMesgType): SportPointType | undefined;
+    private convertFITLap2Trackseg;
+    private convertLap2Points;
+}
+export declare class TCXToSportConverter extends BaseSportConverter {
+    name: string;
+    supportedTags: string[];
+    convert(ast: TokenAST, context: SportContext): SportFileType | undefined;
+    private convertTCX;
+    protected convertPoint(point: TrackpointType): SportPointType | undefined;
+    private convertLap2Trackseg;
+    private convertTCXTrack;
+}

package/dist/sport/encoders.d.ts

@@ -0,0 +1,34 @@
+import { BaseSportEncoder, SportEncodingContext } from "./base.js";
+import { SportFileType } from "../types.js";
+import { GPX11Type } from "../GPX/types.js";
+import { FITFileType } from "../FIT/types.js";
+import { TCXFileType } from "../TCX/types.js";
+export declare class SportToGPXEncoder extends BaseSportEncoder {
+    name: string;
+    supportedTags: string[];
+    encode(sportData: SportFileType, context: SportEncodingContext): GPX11Type | undefined;
+    private convertPoints2Wpts;
+    private convertRoute2GPXRoute;
+    private convertTrack2GPXTrack;
+    private extractGPXExtensions;
+}
+export declare class SportToFITEncoder extends BaseSportEncoder {
+    name: string;
+    supportedTags: string[];
+    encode(sportData: SportFileType, context: SportEncodingContext): FITFileType | undefined;
+    private convertTrack2FITSession;
+    private convertSeg2FITLap;
+    private convertPoint2FITRecord;
+    private convertRoute2FITCourse;
+    private convertPoints2FITLap;
+}
+export declare class SportToTCXEncoder extends BaseSportEncoder {
+    name: string;
+    supportedTags: string[];
+    encode(sportData: SportFileType, context: SportEncodingContext): TCXFileType | undefined;
+    private convertTrack2TCXActivity;
+    private convertSeg2TCXLap;
+    private convertPoints2TCXTrack;
+    private convertPoint2TCXTrackpoint;
+    private convertRoute2TCXCourse;
+}

package/dist/sport/index.d.ts

@@ -0,0 +1,17 @@
+export * from "./base.js";
+export * from "./converters.js";
+export * from "./encoders.js";
+export * from "./processor.js";
+import { GPXToSportConverter, FITToSportConverter, TCXToSportConverter } from "./converters.js";
+import { SportToGPXEncoder, SportToFITEncoder, SportToTCXEncoder } from "./encoders.js";
+import { SportProcessor } from "./processor.js";
+declare const _default: {
+    GPXToSportConverter: typeof GPXToSportConverter;
+    FITToSportConverter: typeof FITToSportConverter;
+    TCXToSportConverter: typeof TCXToSportConverter;
+    SportToGPXEncoder: typeof SportToGPXEncoder;
+    SportToFITEncoder: typeof SportToFITEncoder;
+    SportToTCXEncoder: typeof SportToTCXEncoder;
+    SportProcessor: typeof SportProcessor;
+};
+export default _default;

package/dist/sport/processor.d.ts

@@ -0,0 +1,19 @@
+import { ISportConverterPlugin, ISportEncoderPlugin } from "./base.js";
+import { SportFileType } from "../types.js";
+import { GPX11Type } from "../GPX/types.js";
+import { FITFileType } from "../FIT/types.js";
+import { TCXFileType } from "../TCX/types.js";
+export declare class SportProcessor {
+    private converters;
+    private encoders;
+    constructor();
+    private registerDefaultConverters;
+    private registerDefaultEncoders;
+    registerConverter(converter: ISportConverterPlugin): void;
+    registerEncoder(encoder: ISportEncoderPlugin): void;
+    convertToSport(sourceData: GPX11Type | FITFileType | TCXFileType, sourceFormat: "gpx" | "fit" | "tcx"): Promise<SportFileType>;
+    encodeSport(sportData: SportFileType, targetFormat: "gpx" | "fit" | "tcx"): Promise<GPX11Type | FITFileType | TCXFileType>;
+    private findConverter;
+    private findEncoder;
+    destroy(): Promise<void>;
+}

package/dist/types.d.ts

@@ -1,3 +1,5 @@
+import { LapMesgType, RecordMesgType, SessionMesgType, UserProfileMesgType } from "./FIT/types.js";
+import { IntensityType, TriggerMethodType } from "./TCX/types.js";
 export interface Token {
     type: "open" | "close" | "text";
     tag: string;
@@ -13,22 +15,98 @@ export interface TokenAST {
 export interface AttributeType {
     [key: string]: string;
 }
-/**
- * The latitude of the point. Decimal degrees, WGS84 datum.
- * @type {number} -90.0 <= value <= 90.0
- */
 export type LatitudeType = number;
-/**
- * The longitude of the point. Decimal degrees, WGS84 datum.
- * @type {number} -180.0 <= value < 180.0
- */
 export type LongitudeType = number;
-/**
- * Used for bearing, heading, course. Units are decimal degrees, true (not magnetic).
- * @type {number} 0.0 <= value < 360.0
-
- */
 export type DegreesType = number;
 export interface ExtensionsType {
     [key: string]: string | number | undefined | ExtensionsType;
 }
+export interface SportFileType {
+    metadata?: {
+        originType: "GPX" | "FIT" | "TCX" | "HIJSON";
+        fileName?: string;
+        fileType?: string;
+        creator?: string;
+        date?: string;
+    };
+    points?: SportPointType[];
+    routes?: SportRouteSegType[];
+    tracks?: SportTrackType[];
+    __fit__UserProfileMesgs?: UserProfileMesgType[];
+}
+export interface SportPointType {
+    lat: LatitudeType;
+    lon: LongitudeType;
+    ele?: number;
+    time?: number;
+    heart?: number;
+    distance?: number;
+    accumulatedPower?: number;
+    speed?: number;
+    power?: number;
+    cadence?: number;
+    temperature?: number;
+    enhancedAltitude?: number;
+    enhancedSpeed?: number;
+    __fit__RecordMesgType?: RecordMesgType;
+    magvar?: DegreesType;
+    geoidheight?: number;
+    name?: string;
+    cmt?: string;
+    desc?: string;
+    src?: string;
+    sym?: string;
+    type?: string;
+    sat?: string;
+    hdop?: number;
+    vdop?: number;
+    pdop?: number;
+    ageofdgpsdata?: number;
+    dgpsid?: DegreesType;
+    turn?: number;
+    extensions?: ExtensionsType;
+}
+export interface SportTrackType {
+    name?: string;
+    sport?: string;
+    trackseg?: SportRouteSegType[];
+    extensions?: ExtensionsType;
+    startTime?: number;
+    startLat?: LatitudeType;
+    startLon?: LongitudeType;
+    duration?: number;
+    distance?: number;
+    endTime?: number;
+    endLat?: LatitudeType;
+    endLon?: LongitudeType;
+    __fit__sessionMesgType?: SessionMesgType;
+}
+export interface SportRouteSegType {
+    name?: string;
+    sport?: string;
+    points?: SportPointType[];
+    duration?: number;
+    distance?: number;
+    startTime?: number;
+    endTime?: number;
+    avgHeartRateBpm?: number;
+    maxHeartRateBpm?: number;
+    avgSpeed?: number;
+    maxSpeed?: number;
+    avgCadenceBpm?: number;
+    maxCadenceBpm?: number;
+    avgPower?: number;
+    maxPower?: number;
+    avgTemperature?: number;
+    maxTemperature?: number;
+    avgAltitude?: number;
+    maxEnhancedAltitude?: number;
+    totalAscent?: number;
+    totalDescent?: number;
+    calories?: number;
+    __tcx__Intensity?: IntensityType;
+    __tcx__TriggerMethod?: TriggerMethodType;
+    __tcx__Notes?: string;
+    __tcx__Extensions?: any;
+    __fit__lapMesgType?: LapMesgType;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "trackswap",
-  "version": "0.0.1",
+  "version": "0.0.3",
   "description": "A powerful and flexible GPX parser and encoder library for Node.js and TypeScript. TrackSwap provides comprehensive support for GPX 1.1 format with advanced features like plugin system, middleware support, and optimized performance.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -11,15 +11,29 @@
     }
   },
   "files": [
-    "dist/**/*",
+    "dist/index.js",
+    "dist/index.d.ts",
+    "dist/TrackSwap.d.ts",
+    "dist/types.d.ts",
+    "dist/**/*.d.ts",
     "README.md",
     "LICENSE"
   ],
   "scripts": {
     "dev": "ts-node src/index.ts",
-    "build": "tsc",
+    "clean": "rm -rf dist",
+    "build": "npm run clean && npm run build:types && npm run build:prod && npm run build:optimize",
+    "build:types": "tsc --emitDeclarationOnly",
+    "build:prod": "NODE_ENV=production node build.config.js",
+    "build:dev": "npm run clean && npm run build:types && NODE_ENV=development node build.config.js",
+    "build:optimize": "node scripts/optimize-dist.js",
+    "build:js": "esbuild src/index.ts --bundle --platform=node --target=node14 --format=esm --outfile=dist/index.js --minify --sourcemap",
+    "build:tsc": "tsc && npm run minify",
+    "minify": "terser dist/**/*.js --compress --mangle --output dist/index.min.js --source-map",
+    "analyze": "NODE_ENV=production ANALYZE=true node build.config.js",
     "start": "node dist/index.js",
     "test:gpx": "cd example/gpx && rm -f output* test_*.json *_report.json *_encoded.xml && node test.js",
+    "test:fit": "cd example/FIT && rm -rf output && node test.js",
     "prepublishOnly": "npm run build"
   },
   "keywords": [
@@ -37,27 +51,31 @@
     "geospatial",
     "trackswap"
   ],
-  "author": "buerber1016",
+  "author": "berber1016",
   "license": "MIT",
   "type": "module",
   "repository": {
     "type": "git",
-    "url": "https://github.com/buerber1016/trackswap.git"
+    "url": "https://github.com/berber1016/trackswap.git"
   },
-  "homepage": "https://github.com/buerber1016/trackswap#readme",
+  "homepage": "https://github.com/berber1016/trackswap#readme",
   "bugs": {
-    "url": "https://github.com/buerber1016/trackswap/issues"
+    "url": "https://github.com/berber1016/trackswap/issues"
   },
   "engines": {
     "node": ">=14.0.0"
   },
   "devDependencies": {
     "@types/node": "^22.15.24",
+    "esbuild": "^0.19.12",
+    "terser": "^5.27.0",
     "ts-node": "^10.9.2",
     "typescript": "^5.8.3"
   },
   "dependencies": {
+    "@garmin/fitsdk": "^21.171.0",
     "dayjs": "^1.11.13",
+    "geolib": "^3.3.4",
     "htmlparser2": "^10.0.0"
   }
 }

package/dist/GPX/base.js

@@ -1,83 +0,0 @@
-// ============ 基础工具类 ============
-/**
- * 基础转换器抽象类
- */
-export class BaseConverter {
-    constructor() {
-        this.version = "1.0.0";
-        this.priority = 100;
-    }
-    supports(tag) {
-        return this.supportedTags.includes(tag);
-    }
-    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;
-    }
-    // 工具方法
-    parseFloat(value) {
-        if (typeof value === "number")
-            return value;
-        if (typeof value === "string")
-            return parseFloat(value) || 0;
-        return 0;
-    }
-    parseString(value) {
-        return String(value || "");
-    }
-    hasRequiredAttributes(ast, required) {
-        return required.every((attr) => ast.attributes?.[attr]);
-    }
-    extractAttributes(ast, target, mapping) {
-        if (!ast.attributes)
-            return;
-        Object.entries(ast.attributes).forEach(([key, value]) => {
-            const targetKey = mapping[key];
-            if (targetKey && targetKey in target) {
-                target[targetKey] = this.parseFloat(value);
-            }
-        });
-    }
-    processChildren(ast, target, processors) {
-        ast.children?.forEach((child) => {
-            const processor = processors[child.tag];
-            if (processor) {
-                processor(child, target);
-            }
-        });
-    }
-}
-/**
- * 基础中间件抽象类
- */
-export class BaseMiddleware {
-    constructor() {
-        this.version = "1.0.0";
-        this.description = "";
-    }
-    async initialize(context) { }
-    async destroy(context) { }
-    async validate(context) {
-        return true;
-    }
-    async onTokenize(tokens, context) {
-        return tokens;
-    }
-    async onAstGenerate(ast, context) {
-        return ast;
-    }
-    async onConvert(result, context) {
-        return result;
-    }
-    async onComplete(result, context) {
-        return result;
-    }
-    async onError(error, context) {
-        console.error(`中间件 ${this.name} 处理错误:`, error);
-    }
-}