trackswap 0.0.25 → 0.0.27

package/dist/TrackSwap.d.ts

@@ -21,7 +21,12 @@ export declare class TrackSwap {
     encodeGPXString(gpxData: GPX11Type): string;
     parseFIT(buffer: Buffer): Promise<FITFileType | undefined>;
     encodeFIT(fitData: FITFileType): Promise<Buffer>;
-    encodeFITCourse(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>;

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>;
+}