trackswap 0.0.26 → 0.0.27

package/dist/TrackSwap.d.ts

@@ -0,0 +1,53 @@
+import { GPXDecoder, GPXEncoder } from "./GPX/index.js";
+import { GPX11Type } from "./GPX/types.js";
+import { FITDecoder, FITEncoder } from "./FIT/index.js";
+import { FITFileType } from "./FIT/types.js";
+import { TCXDecoder, TCXEncoder } from "./TCX/index.js";
+import { TCXFileType } from "./TCX/types.js";
+import { ActivityProcessor } from "./activity/processor.js";
+import { FileType } from "./types.js";
+export declare class TrackSwap {
+    private gpxDecoder;
+    private gpxEncoder;
+    private fitDecoder;
+    private fitEncoder;
+    private tcxDecoder;
+    private tcxEncoder;
+    private activityProcessor;
+    constructor();
+    parseGPX(buffer: Buffer): Promise<GPX11Type | undefined>;
+    parseGPXString(xmlString: string): Promise<GPX11Type | undefined>;
+    encodeGPX(gpxData: GPX11Type): Promise<Buffer>;
+    encodeGPXString(gpxData: GPX11Type): string;
+    parseFIT(buffer: Buffer): Promise<FITFileType | undefined>;
+    encodeFIT(fitData: FITFileType): Promise<Buffer>;
+    encodeFITCourse(buffer: Buffer): Promise<Buffer>;
+    convertFITToCourse(buffer: Buffer): Promise<Buffer>;
+    convertToFITCourse(buffer: Buffer, sourceType?: "gpx" | "fit" | "tcx"): Promise<Buffer>;
+    private buildCoursePlanFromActivityFile;
+    private resolveCourseName;
+    private toEnumValue;
+    parseTCXString(xmlString: string): Promise<TCXFileType>;
+    parseTCX(buffer: Buffer): Promise<TCXFileType>;
+    encodeTCX(tcxData: TCXFileType): Promise<Buffer>;
+    encodeTCXString(tcxData: TCXFileType): Promise<string>;
+    convertGPXToActivity(gpxData: GPX11Type): Promise<FileType>;
+    convertFITToActivity(fitData: FITFileType): Promise<FileType>;
+    convertTCXToActivity(tcxData: TCXFileType): Promise<FileType>;
+    convertActivityToGPX(file: FileType): Promise<GPX11Type>;
+    convertActivityToFIT(file: FileType): Promise<FITFileType>;
+    convertActivityToTCX(file: FileType): Promise<TCXFileType>;
+    convertFile(sourceFile: Buffer, targetType: "gpx" | "fit" | "tcx", sourceType?: "gpx" | "fit" | "tcx"): Promise<Buffer>;
+    detectFormat(buffer: Buffer): "gpx" | "fit" | "tcx" | "unknown";
+    parseFile(buffer: Buffer, sourceType?: "gpx" | "fit" | "tcx"): Promise<GPX11Type | FITFileType | TCXFileType | undefined>;
+    parseToActivity(buffer: Buffer, sourceType?: "gpx" | "fit" | "tcx"): Promise<FileType | undefined>;
+    getActivityProcessor(): ActivityProcessor;
+    getGPXDecoder(): GPXDecoder;
+    getGPXEncoder(): GPXEncoder;
+    getFITDecoder(): FITDecoder;
+    getFITEncoder(): FITEncoder;
+    getTCXDecoder(): TCXDecoder;
+    getTCXEncoder(): TCXEncoder;
+    destroy(): Promise<void>;
+}
+export default TrackSwap;

package/dist/activity/base.d.ts

@@ -0,0 +1,62 @@
+import { IPlugin, IConverterPlugin, IMiddlewarePlugin, BaseConverter, BaseMiddleware, IProcessingContext } from "../core/base.js";
+import { ActivityType, ActivityRecordType, ActivityLapType, TokenAST, FileType } from "../types.js";
+export interface ActivityContext extends IProcessingContext {
+    sourceFormat: string;
+    sourceData: any;
+    result?: FileType;
+    performance: {
+        startTime: number;
+        convertTime?: number;
+        endTime?: number;
+    };
+}
+export interface ActivityEncodingContext extends IProcessingContext {
+    targetFormat: string;
+    result?: any;
+    performance: {
+        startTime: number;
+        encodeTime?: number;
+        endTime?: number;
+    };
+}
+export interface IActivityPlugin extends IPlugin {
+}
+export interface IActivityConverterPlugin extends IConverterPlugin {
+    convert(ast: TokenAST, context: ActivityContext): FileType | undefined;
+}
+export interface IActivityMiddlewarePlugin extends IMiddlewarePlugin {
+    process(context: ActivityContext): Promise<void>;
+}
+export interface IActivityEncoderPlugin extends IPlugin<ActivityEncodingContext> {
+    encode(file: FileType, context: ActivityEncodingContext): any | undefined;
+    supports(format: string): boolean;
+    priority?: number;
+}
+export declare abstract class BaseActivityConverter extends BaseConverter<ActivityContext> implements IActivityConverterPlugin {
+    protected convertPoints(points: any[]): ActivityRecordType[];
+    protected abstract convertPoint(point: any): ActivityRecordType | undefined;
+    protected convertTime(time: Date | string | number | undefined): number | undefined;
+}
+export declare abstract class BaseActivityEncoder implements IActivityEncoderPlugin {
+    abstract name: string;
+    abstract supportedTags: string[];
+    version: string;
+    priority: number;
+    abstract encode(file: FileType, context: ActivityEncodingContext): any | undefined;
+    supports(format: string): boolean;
+    initialize(context: ActivityEncodingContext): Promise<void>;
+    destroy(context: ActivityEncodingContext): Promise<void>;
+    validate(context: ActivityEncodingContext): 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 BaseActivityMiddleware extends BaseMiddleware<ActivityContext, ActivityType> implements IActivityMiddlewarePlugin {
+    abstract process(context: ActivityContext): Promise<void>;
+    onError(error: Error, context: ActivityContext): Promise<void>;
+    protected validateActivityFile(file: FileType): boolean;
+    protected validateActivity(activity: ActivityType): boolean;
+    protected validateRoute(route: ActivityLapType): boolean;
+    protected validatePoint(point: ActivityRecordType): boolean;
+}

package/dist/activity/converters.d.ts

@@ -0,0 +1,36 @@
+import { BaseActivityConverter, ActivityContext } from "./base.js";
+import { FileType, TokenAST } from "../types.js";
+import { ActivityRecordType } from "../types.js";
+import { WptType } from "../GPX/types.js";
+import { RecordMesgType } from "../FIT/types.js";
+import { TrackpointType } from "../TCX/types.js";
+export declare class GPXToActivityConverter extends BaseActivityConverter {
+    name: string;
+    supportedTags: string[];
+    convert(ast: TokenAST, context: ActivityContext): FileType | undefined;
+    private convertGPX;
+    protected convertPoint(point: WptType, idx?: number, lapIdx?: number): ActivityRecordType;
+    private convertTrk2Activity;
+    private convertTrackSeg2Lap;
+    private convertWpts2Points;
+    private convertGPXExtensions;
+    private autoNumber;
+}
+export declare class FITToActivityConverter extends BaseActivityConverter {
+    name: string;
+    supportedTags: string[];
+    convert(ast: TokenAST, context: ActivityContext): FileType | undefined;
+    private convertFIT;
+    protected convertPoint(point: RecordMesgType, idx?: number, lapIdx?: number): ActivityRecordType | undefined;
+    private convertFITLap2Trackseg;
+    private convertLap2Points;
+}
+export declare class TCXToActivityConverter extends BaseActivityConverter {
+    name: string;
+    supportedTags: string[];
+    convert(ast: TokenAST, context: ActivityContext): FileType | undefined;
+    private convertTCX;
+    private convertTCXActivityToActivity;
+    private convertTCXLap2Lap;
+    protected convertPoint(point: TrackpointType, idx?: number, lapIdx?: number): ActivityRecordType;
+}

package/dist/activity/encoders.d.ts

@@ -0,0 +1,32 @@
+import { BaseActivityEncoder, ActivityEncodingContext } from "./base.js";
+import { FileType } from "../types.js";
+import { GPX11Type } from "../GPX/types.js";
+import { FITFileType } from "../FIT/types.js";
+import { TCXFileType } from "../TCX/types.js";
+export declare class ActivityToGPXEncoder extends BaseActivityEncoder {
+    name: string;
+    supportedTags: string[];
+    encode(file: FileType, context: ActivityEncodingContext): GPX11Type | undefined;
+    private convertRecords2Wpts;
+    private convertRoute2GPXRoute;
+    private convertActivity2GPXTrack;
+    private extractGPXExtensions;
+}
+export declare class ActivityToFITEncoder extends BaseActivityEncoder {
+    name: string;
+    supportedTags: string[];
+    encode(file: FileType, context: ActivityEncodingContext): FITFileType | undefined;
+    private convertActivity2FITSession;
+    private convertLap2FITLap;
+    private convertPoint2FITRecord;
+}
+export declare class ActivityToTCXEncoder extends BaseActivityEncoder {
+    name: string;
+    supportedTags: string[];
+    encode(file: FileType, context: ActivityEncodingContext): TCXFileType | undefined;
+    private convertActivity2TCXActivity;
+    private convertLap2TCXLap;
+    private convertRecords2TCXTrack;
+    private convertPoint2TCXTrackpoint;
+    private convertRoute2TCXCourse;
+}

package/dist/activity/index.d.ts

@@ -0,0 +1,17 @@
+export * from "./base.js";
+export * from "./converters.js";
+export * from "./encoders.js";
+export * from "./processor.js";
+import { GPXToActivityConverter, FITToActivityConverter, TCXToActivityConverter } from "./converters.js";
+import { ActivityToGPXEncoder, ActivityToFITEncoder, ActivityToTCXEncoder } from "./encoders.js";
+import { ActivityProcessor } from "./processor.js";
+declare const _default: {
+    GPXToActivityConverter: typeof GPXToActivityConverter;
+    FITToActivityConverter: typeof FITToActivityConverter;
+    TCXToActivityConverter: typeof TCXToActivityConverter;
+    ActivityToGPXEncoder: typeof ActivityToGPXEncoder;
+    ActivityToFITEncoder: typeof ActivityToFITEncoder;
+    ActivityToTCXEncoder: typeof ActivityToTCXEncoder;
+    ActivityProcessor: typeof ActivityProcessor;
+};
+export default _default;

package/dist/activity/metrics/MetricsCalculator.d.ts

@@ -0,0 +1,18 @@
+import { ActivityType, ActivityLapType, ActivityRecordType } from "../../types.js";
+interface MetricsRecordsResult extends Partial<ActivityLapType> {
+    records: ActivityRecordType[];
+}
+interface MetricsLapsResult extends Partial<ActivityType> {
+    timestamp: Date;
+    laps: ActivityLapType[];
+}
+export declare class MetricsAggregator {
+    calculateRecordsAggMetrics(records: ActivityRecordType[]): MetricsRecordsResult | undefined;
+    calculateLapAggMetrics(laps: ActivityLapType[]): MetricsLapsResult | undefined;
+    private preprocessRecords;
+    private calculatePointDistanceByPosition;
+    private calculateInstantSpeed;
+    private calculateAccumulatedPower;
+    private calculateElevationChanges;
+}
+export {};

package/dist/activity/metrics/index.d.ts

@@ -0,0 +1 @@
+export * from "./MetricsCalculator.js";

package/dist/activity/processor.d.ts

@@ -0,0 +1,19 @@
+import { IActivityConverterPlugin, IActivityEncoderPlugin } from "./base.js";
+import { FileType } from "../types.js";
+import { GPX11Type } from "../GPX/types.js";
+import { FITFileType } from "../FIT/types.js";
+import { TCXFileType } from "../TCX/types.js";
+export declare class ActivityProcessor {
+    private converters;
+    private encoders;
+    constructor();
+    private registerDefaultConverters;
+    private registerDefaultEncoders;
+    registerConverter(converter: IActivityConverterPlugin): void;
+    registerEncoder(encoder: IActivityEncoderPlugin): void;
+    convertToActivity(sourceData: GPX11Type | FITFileType | TCXFileType, sourceFormat: "gpx" | "fit" | "tcx"): Promise<FileType>;
+    encodeActivity(file: FileType, targetFormat: "gpx" | "fit" | "tcx"): Promise<GPX11Type | FITFileType | TCXFileType>;
+    private findConverter;
+    private findEncoder;
+    destroy(): Promise<void>;
+}

package/dist/core/base.d.ts

@@ -0,0 +1,73 @@
+import { ExtensionsType, Token, TokenAST } from "../types.js";
+export interface IPlugin<TContext = any> {
+    name: string;
+    version?: string;
+    description?: string;
+    dependencies?: string[];
+    supportedTags?: string[];
+    initialize?(context: TContext): Promise<void> | void;
+    destroy?(context: TContext): Promise<void> | void;
+    validate?(context: TContext): Promise<boolean> | boolean;
+}
+export interface IConverterPlugin<TContext = any> extends IPlugin<TContext> {
+    convert(ast: TokenAST, context: TContext): any | undefined;
+    supports(tag: string): boolean;
+    priority?: number;
+}
+export interface IMiddlewarePlugin<TContext = any, TResult = any> extends IPlugin<TContext> {
+    priority?: number;
+    onTokenize?(tokens: Token[], context: TContext): Promise<Token[]> | Token[];
+    onAstGenerate?(ast: TokenAST, context: TContext): Promise<TokenAST> | TokenAST;
+    onConvert?(result: any, context: TContext): Promise<any> | any;
+    onComplete?(result: TResult, context: TContext): Promise<TResult> | TResult;
+    onError?(error: Error, context: TContext): Promise<void> | void;
+}
+export interface IProcessingContext {
+    metadata: Map<string, any>;
+    errors: Error[];
+    warnings: string[];
+    stats: {
+        startTime: number;
+        endTime?: number;
+        processedTokens: number;
+        convertedElements: number;
+    };
+    userData?: Record<string, any>;
+}
+export declare abstract class BaseConverter<TContext extends IProcessingContext = IProcessingContext> implements IConverterPlugin<TContext> {
+    abstract name: string;
+    abstract supportedTags: string[];
+    version: string;
+    priority: number;
+    abstract convert(ast: TokenAST, context: TContext): any | undefined;
+    supports(tag: string): boolean;
+    initialize(context: TContext): Promise<void>;
+    destroy(context: TContext): Promise<void>;
+    validate(context: TContext): Promise<boolean>;
+    protected parseFloat(value: string | number | undefined): number | undefined;
+    protected parseInt(value: string | number | undefined): number;
+    protected parseString(value: string | number | undefined): string;
+    protected parseBoolean(value: string | boolean | undefined): boolean;
+    protected parseDate(value: string | undefined): Date | undefined;
+    protected hasRequiredAttributes(ast: TokenAST, required: string[]): boolean;
+    protected extractAttributes<U extends Record<string, any>>(ast: TokenAST, target: U, mapping: Record<string, keyof U>): void;
+    protected processChildren<U extends Record<string, any>>(ast: TokenAST, target: U, processors: Record<string, (child: TokenAST, target: U) => void>): void;
+    protected getChildValue(ast: TokenAST, tag: string): string | undefined;
+    protected getChildByTag(ast: TokenAST, tag: string): TokenAST | undefined;
+    protected getChildrenByTag(ast: TokenAST, tag: string): TokenAST[];
+    protected convertExtensions(extensionsAST: TokenAST): ExtensionsType;
+    protected convertExtensionContent(extension: TokenAST): any;
+}
+export declare abstract class BaseMiddleware<TContext extends IProcessingContext = IProcessingContext, TResult = any> implements IMiddlewarePlugin<TContext, TResult> {
+    abstract name: string;
+    version: string;
+    description: string;
+    initialize(context: TContext): Promise<void>;
+    destroy(context: TContext): Promise<void>;
+    validate(context: TContext): Promise<boolean>;
+    onTokenize(tokens: Token[], context: TContext): Promise<Token[]>;
+    onAstGenerate(ast: TokenAST, context: TContext): Promise<TokenAST>;
+    onConvert(result: any, context: TContext): Promise<any>;
+    onComplete(result: TResult, context: TContext): Promise<TResult>;
+    onError(error: Error, context: TContext): Promise<void>;
+}

package/dist/core/index.d.ts

@@ -0,0 +1,2 @@
+export { IPlugin, IConverterPlugin, IMiddlewarePlugin, IProcessingContext, BaseConverter, BaseMiddleware, } from "./base.js";
+export { XMLUtils } from "./xml-utils.js";

package/dist/core/xml-utils.d.ts

@@ -0,0 +1,17 @@
+import { Token } from "../types.js";
+export declare class XMLUtils {
+    static tokenizeXML(xmlContent: string): Token[];
+    static compressXML(xmlContent: string): string;
+    static formatXML(xmlContent: string, indentSize?: number): string;
+    static validateXML(xmlContent: string): {
+        isValid: boolean;
+        error?: string;
+    };
+    static extractXMLDeclaration(xmlContent: string): {
+        version?: string;
+        encoding?: string;
+        standalone?: string;
+    };
+    static escapeXML(text: string): string;
+    static unescapeXML(text: string): string;
+}

package/dist/index.d.ts

@@ -0,0 +1,8 @@
+export * from "./types.js";
+export { FITDecoder, FITEncoder, encodeCourse, buildCourseMesgs, type CoursePlan, type CourseRecordPoint, type CourseCuePoint, type CourseFitMesg, } from "./FIT/index.js";
+export { GPXDecoder, GPXEncoder, registerDefaultMiddlewares, PipelineStage, } from "./GPX/index.js";
+export { TCXDecoder, TCXEncoder } from "./TCX/index.js";
+export * from "./activity/index.js";
+import { TrackSwap } from "./TrackSwap.js";
+export { TrackSwap } from "./TrackSwap.js";
+export default TrackSwap;

package/dist/types.d.ts

@@ -0,0 +1,75 @@
+import { LapMesgType, LengthMesgType, RecordMesgType, SessionMesgType } from "./FIT/types.js";
+export interface Token {
+    type: "open" | "close" | "text";
+    tag: string;
+    attributes?: AttributeType;
+    value?: string | number;
+}
+export interface TokenAST {
+    tag: string;
+    attributes?: AttributeType;
+    children?: TokenAST[];
+    value?: string | number;
+}
+export interface AttributeType {
+    [key: string]: string;
+}
+export type LatitudeType = number;
+export type LongitudeType = number;
+export type DegreesType = number;
+export interface ExtensionsType {
+    [key: string]: string | number | undefined | ExtensionsType;
+}
+export interface FileType {
+    metadata?: {
+        originType: "GPX" | "FIT" | "TCX" | "HIJSON";
+        fileName?: string;
+        fileType?: string;
+    };
+    points?: ActivityRecordType[];
+    routes?: ActivityLapType[];
+    activities?: ActivityType[];
+    userProfile?: UserProfileType;
+}
+export interface UserProfileType {
+    name?: string;
+    weight?: number;
+    gender?: string;
+    age?: number;
+    height?: number;
+    language?: string;
+    defaultMaxBikingHeartRate?: number;
+    defaultMaxHeartRate?: number;
+    hrSetting?: string;
+    speedSetting?: string;
+    distSetting?: string;
+    powerSetting?: string;
+    activityClass?: number;
+    positionSetting?: string;
+    temperatureSetting?: string;
+    elevSetting?: string;
+    weightSetting?: string;
+}
+export interface ActivityType extends SessionMesgType {
+    index: number;
+    endTime?: Date;
+    laps?: ActivityLapType[];
+}
+export interface ActivityRecordType extends RecordMesgType {
+    lapIndex: number;
+    index: number;
+    hdop?: number;
+    vdop?: number;
+    pdop?: number;
+    turn?: number;
+    description?: number;
+}
+export interface ActivityLengthType extends LengthMesgType {
+    index: number;
+}
+export interface ActivityLapType extends LapMesgType {
+    index: number;
+    endTime?: Date;
+    records: ActivityRecordType[];
+    lengths: ActivityLengthType[];
+}

package/package.json

@@ -1,15 +1,15 @@
 {
   "name": "trackswap",
-  "version": "0.0.26",
+  "version": "0.0.27",
   "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.cjs",
   "module": "dist/index.js",
   "types": "dist/index.d.ts",
   "exports": {
     ".": {
+      "types": "./dist/index.d.ts",
       "import": "./dist/index.js",
-      "require": "./dist/index.cjs",
-      "types": "./dist/index.d.ts"
+      "require": "./dist/index.cjs"
     }
   },
   "files": [
@@ -26,11 +26,12 @@
     "dev": "ts-node src/index.ts",
     "clean": "rm -rf dist",
     "build": "npm run clean && npm run build:types && npm run build:esm && npm run build:cjs && npm run build:optimize",
-    "build:types": "tsc --emitDeclarationOnly",
+    "build:types": "tsc -p tsconfig.types.json",
     "build:esm": "NODE_ENV=production node build.config.js",
     "build:cjs": "NODE_ENV=production FORMAT=cjs 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",
+    "verify:types": "node -e \"const fs=require('fs'); const files=['dist/index.d.ts','dist/TrackSwap.d.ts','dist/types.d.ts']; const missing=files.filter((f)=>!fs.existsSync(f)); if(missing.length){console.error('Missing type artifacts:', missing.join(', ')); process.exit(1);} console.log('Type artifacts verified');\"",
     "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",
@@ -38,7 +39,7 @@
     "start": "node dist/index.js",
     "test:gpx": "cd example/gpx && rm -f output* *.json *_encoded.xml && node test.js",
     "test:fit": "cd example/FIT && rm -rf output && node test.js",
-    "prepublishOnly": "npm run build"
+    "prepublishOnly": "npm run build && npm run verify:types"
   },
   "keywords": [
     "gpx",