trackswap 0.0.26 → 0.2.0

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,40 @@
+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 convertRoute2Lap;
+    private convertPoints2Lap;
+    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 convertTCXCourseToRoute;
+    private convertTCXCoursePointToRecord;
+    private convertTCXActivityToActivity;
+    private convertTCXLap2Lap;
+    protected convertPoint(point: TrackpointType, idx?: number, lapIdx?: number): ActivityRecordType;
+}

package/dist/activity/encoders.d.ts

@@ -0,0 +1,36 @@
+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 hasValidGpxCoordinates;
+    private countRecordsMissingGpxCoordinates;
+    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 convertRoutesToSyntheticSession;
+    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 validTimestamp;
+    private convertRouteToTCXCourse;
+}

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/builtin-adapters.d.ts

@@ -0,0 +1,52 @@
+import type { FITFileType } from "../FIT/types.js";
+import type { GPX11Type } from "../GPX/types.js";
+import type { TCXFileType } from "../TCX/types.js";
+import { ActivityProcessor } from "../activity/processor.js";
+import type { AdapterDecodeResult, FITCourseAdapter, TrackFormatAdapter } from "./format-adapter.js";
+import type { DecodeOptions, TrackFormat } from "../document.js";
+import type { FileType } from "../types.js";
+export declare function detectBuiltInFormat(input: Buffer): TrackFormat | undefined;
+declare abstract class BuiltInAdapter<TNative> implements TrackFormatAdapter<TNative> {
+    abstract readonly format: TrackFormat;
+    protected readonly activities: ActivityProcessor;
+    constructor(activities: ActivityProcessor);
+    matches(input: Buffer): boolean;
+    abstract decode(input: Buffer, options: DecodeOptions): Promise<AdapterDecodeResult<TNative>>;
+    abstract encodeActivity(activity: FileType): Promise<Buffer>;
+}
+export declare class FITAdapter extends BuiltInAdapter<FITFileType> implements FITCourseAdapter {
+    readonly format: "fit";
+    private decoder?;
+    private encoder?;
+    private getDecoder;
+    private getEncoder;
+    decode(input: Buffer, options: DecodeOptions): Promise<AdapterDecodeResult<FITFileType>>;
+    encodeActivity(activity: FileType): Promise<Buffer>;
+    encodeCourse(activity: FileType): Promise<Buffer>;
+    dispose(): Promise<void>;
+}
+export declare class GPXAdapter extends BuiltInAdapter<GPX11Type> {
+    readonly format: "gpx";
+    private decoder?;
+    private encoder?;
+    private getDecoder;
+    private getEncoder;
+    decode(input: Buffer): Promise<AdapterDecodeResult<GPX11Type>>;
+    encodeActivity(activity: FileType): Promise<Buffer>;
+    dispose(): Promise<void>;
+}
+export declare class TCXAdapter extends BuiltInAdapter<TCXFileType> {
+    readonly format: "tcx";
+    private decoder?;
+    private encoder?;
+    private getDecoder;
+    private getEncoder;
+    decode(input: Buffer): Promise<AdapterDecodeResult<TCXFileType>>;
+    encodeActivity(activity: FileType): Promise<Buffer>;
+    dispose(): Promise<void>;
+}
+export declare function createBuiltInAdapters(): {
+    adapters: TrackFormatAdapter[];
+    activities: ActivityProcessor;
+};
+export {};

package/dist/core/format-adapter.d.ts

@@ -0,0 +1,23 @@
+import type { DecodeOptions, TrackDocumentFacets, TrackDocumentKind, TrackDocumentMetadata, TrackFormat } from "../document.js";
+import type { FITDiagnosticsV1 } from "../FIT/health.js";
+import type { FileType } from "../types.js";
+export interface AdapterDecodeResult<TNative = unknown> {
+    kinds: TrackDocumentKind[];
+    facets: TrackDocumentFacets;
+    metadata?: TrackDocumentMetadata;
+    native: TNative;
+    warnings?: string[];
+    fitDiagnostics?: FITDiagnosticsV1;
+}
+export interface TrackFormatAdapter<TNative = unknown> {
+    readonly format: TrackFormat;
+    matches(input: Buffer): boolean;
+    decode(input: Buffer, options: DecodeOptions): Promise<AdapterDecodeResult<TNative>>;
+    encodeActivity(activity: FileType): Promise<Buffer>;
+    dispose?(): Promise<void> | void;
+}
+export interface FITCourseAdapter extends TrackFormatAdapter {
+    readonly format: "fit";
+    encodeCourse(activity: FileType): Promise<Buffer>;
+}
+export declare function isFITCourseAdapter(adapter: TrackFormatAdapter): adapter is FITCourseAdapter;

package/dist/core/format-registry.d.ts

@@ -0,0 +1,9 @@
+import type { TrackFormat } from "../document.js";
+import type { TrackFormatAdapter } from "./format-adapter.js";
+export declare class FormatRegistry {
+    private readonly adapters;
+    constructor(adapters: readonly TrackFormatAdapter[]);
+    get(format: TrackFormat): TrackFormatAdapter;
+    detect(input: Buffer): TrackFormat;
+    dispose(): 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/document.d.ts

@@ -0,0 +1,57 @@
+import type { FITDiagnosticsV1, FITDocumentParseOptions, HealthDocumentV1 } from "./FIT/health.js";
+import type { FileType } from "./types.js";
+export type BuiltInTrackFormat = "fit" | "gpx" | "tcx";
+export type TrackFormat = BuiltInTrackFormat | (string & {});
+export type TrackDocumentKind = "activity" | "health" | "course" | "route" | "waypoint" | "workout" | "device" | "unknown" | (string & {});
+export type TrackInput = Buffer | Uint8Array | string;
+export interface DecodeOptions {
+    format?: TrackFormat;
+    includeNative?: boolean;
+    fit?: FITDocumentParseOptions;
+}
+export interface EncodeOptions {
+    format: TrackFormat;
+}
+export interface TranscodeOptions extends EncodeOptions {
+    sourceFormat?: TrackFormat;
+}
+export interface CourseEncodeOptions {
+    sourceFormat?: TrackFormat;
+}
+export interface TrackSourceMetadata {
+    byteLength: number;
+}
+export interface TrackDocumentMetadata {
+    title?: string;
+    creator?: string;
+    createdAt?: Date;
+    fileType?: string | number;
+    manufacturer?: string | number;
+    product?: string | number;
+    productName?: string;
+    serialNumber?: string;
+    softwareVersion?: number;
+}
+export interface TrackDocumentDiagnostics {
+    durationMs: number;
+    warnings: string[];
+    fit?: FITDiagnosticsV1;
+}
+export interface TrackDocumentFacets {
+    activity?: FileType;
+    health?: HealthDocumentV1;
+}
+export interface TrackDocument<TNative = unknown> {
+    schemaVersion: "2";
+    format: TrackFormat;
+    kinds: TrackDocumentKind[];
+    source: TrackSourceMetadata;
+    metadata: TrackDocumentMetadata;
+    facets: TrackDocumentFacets;
+    native?: TNative;
+    diagnostics: TrackDocumentDiagnostics;
+}
+export interface TrackSwapOptions {
+    adapters?: readonly import("./core/format-adapter.js").TrackFormatAdapter[];
+    includeBuiltInAdapters?: boolean;
+}

package/dist/errors.d.ts

@@ -0,0 +1,12 @@
+import type { TrackFormat } from "./document.js";
+export type TrackSwapErrorCode = "FORMAT_UNKNOWN" | "FORMAT_UNSUPPORTED" | "DECODE_FAILED" | "ACTIVITY_NOT_FOUND" | "ENCODE_FAILED" | "ADAPTER_CONFLICT" | "DISPOSED";
+export declare class TrackSwapError extends Error {
+    readonly code: TrackSwapErrorCode;
+    readonly format?: TrackFormat;
+    readonly cause?: unknown;
+    constructor(code: TrackSwapErrorCode, message: string, options?: {
+        format?: TrackFormat;
+        cause?: unknown;
+    });
+}
+export declare function asTrackSwapError(error: unknown, code: TrackSwapErrorCode, message: string, format?: TrackFormat): TrackSwapError;

package/dist/fit-debug.d.ts

@@ -0,0 +1,3 @@
+export declare function fitDebugEnabled(): boolean;
+export declare function fitDebugLog(...args: unknown[]): void;
+export declare function fitDebugWarn(...args: unknown[]): void;