trackswap 0.0.27 → 0.2.1

package/dist/FIT/health.d.ts

@@ -0,0 +1,121 @@
+import { BaseFITStructurePlugin } from "./base.js";
+import type { FITContext } from "./types.js";
+export type FITPrimaryKind = 'activity' | 'health' | 'workout' | 'course' | 'device' | 'unknown';
+export type HealthMetricCode = 'heart_rate_bpm' | 'resting_heart_rate_bpm' | 'resting_heart_rate_7_day_bpm' | 'steps' | 'distance_m' | 'active_time_s' | 'active_energy_kcal' | 'total_energy_kcal' | 'stress_level' | 'respiration_rate_bpm' | 'spo2_percent' | 'body_battery_level' | 'body_battery_charged' | 'body_battery_drained' | 'hrv_rmssd_ms' | 'temperature_c' | 'skin_temperature_deviation_c' | 'skin_temperature_7_day_deviation_c' | 'skin_temperature_nightly_c' | 'ascent_m' | 'descent_m' | `vendor:${string}`;
+export type HealthValueStatus = 'valid' | 'invalid' | 'off_wrist' | 'motion' | 'low_confidence' | 'gap' | 'unknown';
+export type HealthMessagePointerV1 = {
+    messageName: string;
+    messageIndex: number;
+    fieldName?: string;
+    developerField?: boolean;
+};
+export type HealthPointV1 = {
+    metric: HealthMetricCode;
+    timestamp: Date;
+    localTimestamp?: string;
+    offsetSeconds?: number;
+    value?: number;
+    unit: string;
+    status: HealthValueStatus;
+    quality?: number;
+    aggregation?: 'instant' | 'mean' | 'min' | 'max' | 'sum' | 'latest';
+    source: HealthMessagePointerV1;
+    attributes?: Record<string, string | number | boolean | null>;
+};
+export type HealthIntervalV1 = {
+    metric: HealthMetricCode;
+    startTime: Date;
+    endTime: Date;
+    localStartTime?: string;
+    offsetSeconds?: number;
+    value?: number;
+    unit: string;
+    status: HealthValueStatus;
+    activityType?: string;
+    intensity?: string;
+    source: HealthMessagePointerV1;
+    attributes?: Record<string, string | number | boolean | null>;
+};
+export type HealthSummaryV1 = {
+    summaryType: 'daily' | 'sleep' | 'hrv_status' | 'monitoring_window' | 'device';
+    externalId: string;
+    calendarDate?: string;
+    startTime?: Date;
+    endTime?: Date;
+    offsetSeconds?: number;
+    metrics: Record<string, number | string | boolean | null>;
+    source: HealthMessagePointerV1;
+};
+export type HealthSessionSegmentV1 = {
+    segmentType: 'awake' | 'light' | 'deep' | 'rem' | 'unmeasurable' | 'sleeping' | `vendor:${string}`;
+    startTime: Date;
+    endTime: Date;
+    status: HealthValueStatus;
+    source: HealthMessagePointerV1;
+};
+export type HealthSessionV1 = {
+    sessionType: 'sleep' | 'nap' | 'health_snapshot' | `vendor:${string}`;
+    externalId: string;
+    startTime: Date;
+    endTime: Date;
+    startOffsetSeconds?: number;
+    endOffsetSeconds?: number;
+    calendarDate?: string;
+    deleted?: boolean;
+    segments: HealthSessionSegmentV1[];
+    metrics: Record<string, number | string | boolean | null>;
+    source: HealthMessagePointerV1;
+    attributes?: Record<string, string | number | boolean | null>;
+};
+export type FITDiagnosticWarningV1 = {
+    code: string;
+    message: string;
+    source?: HealthMessagePointerV1;
+};
+export type FITDiagnosticsV1 = {
+    sdkProfileVersion?: string;
+    parserVersion: string;
+    messageCounts: Record<string, number>;
+    recognizedMessageCounts: Record<string, number>;
+    unknownMessageCounts: Record<string, number>;
+    invalidValueCounts: Record<string, number>;
+    warnings: FITDiagnosticWarningV1[];
+    unknownMessages?: Record<string, unknown[]>;
+};
+export type HealthDocumentV1 = {
+    schemaVersion: '1';
+    observedStart?: Date;
+    observedEnd?: Date;
+    timezone: {
+        strategy: 'explicit_offset' | 'timestamp_correlation' | 'inferred' | 'unknown';
+        offsets: Array<{
+            at: Date;
+            offsetSeconds: number;
+        }>;
+    };
+    points: HealthPointV1[];
+    intervals: HealthIntervalV1[];
+    summaries: HealthSummaryV1[];
+    sessions: HealthSessionV1[];
+    diagnostics: FITDiagnosticsV1;
+};
+export type FITDocumentParseOptions = {
+    includeUnknownMessages?: boolean;
+    includeDeveloperFields?: boolean;
+    strict?: boolean;
+    health?: {
+        reconstructIntervals?: boolean;
+        retainCumulativeValues?: boolean;
+    };
+};
+export type FITMessages = Record<string, unknown[] | undefined>;
+export declare const TRACKSWAP_HEALTH_PARSER_VERSION = "trackswap-0.2.0-health-ir-v1";
+export declare function detectFITKinds(messages: FITMessages): FITPrimaryKind[];
+export declare function buildHealthDocumentFromMessages(messages: FITMessages, options?: FITDocumentParseOptions, environment?: {
+    sdkProfileVersion?: string;
+}): HealthDocumentV1;
+export declare class HealthStructurePlugin extends BaseFITStructurePlugin {
+    name: string;
+    priority: number;
+    structureData(messages: FITMessages, context: FITContext): Partial<import("./types.js").FITFileType>;
+}

package/dist/FIT/index.d.ts

@@ -2,6 +2,8 @@ export { FITDecoder } from "./decoder.js";
 export { FITEncoder } from "./encoder.js";
 export { IFITMessageConverter, IFITStructurePlugin, IFITMiddlewarePlugin, BaseFITMessageConverter, BaseFITStructurePlugin, BaseFITMiddleware, } from "./base.js";
 export { SessionStructurePlugin, CourseStructurePlugin, FileHeaderPlugin, } from "./plugins.js";
+export { HealthStructurePlugin, buildHealthDocumentFromMessages, detectFITKinds, TRACKSWAP_HEALTH_PARSER_VERSION, } from "./health.js";
+export type { FITDocumentParseOptions, FITPrimaryKind, FITDiagnosticsV1, HealthDocumentV1, HealthIntervalV1, HealthMetricCode, HealthPointV1, HealthSessionSegmentV1, HealthSessionV1, HealthSummaryV1, HealthValueStatus, } from "./health.js";
 export * from "./types.js";
 export { encodeCourse, buildCourseMesgs, type CoursePlan, type CourseRecordPoint, type CourseCuePoint, type FitMesg as CourseFitMesg, } from "./encoderCourse.js";
 import { FITDecoder } from "./decoder.js";

package/dist/FIT/types.d.ts

@@ -8,6 +8,11 @@ export interface FITFileType {
     userProfileMesgs?: UserProfileMesgType[];
     sessionMesgs?: SessionMesgType[];
     courseMesgs?: any[];
+    healthDocument?: import("./health.js").HealthDocumentV1;
+    fitDocumentMetadata?: {
+        detectedKinds: import("./health.js").FITPrimaryKind[];
+        messageCounts: Record<string, number>;
+    };
 }
 export type FITDecoderMesgs = {
     fileIdMesgs?: FileIdMesgType[];
@@ -243,7 +248,7 @@ export interface SessionMesgType {
     lapMesgs?: LapMesgType[];
 }
 export interface RecordMesgType {
-    timestamp: Date;
+    timestamp?: Date;
     positionLat?: number;
     positionLong?: number;
     altitude?: number;

package/dist/GPX/types.d.ts

@@ -69,7 +69,7 @@ export interface WptType {
     sym?: string;
     type?: string;
     fix?: FixType;
-    sat?: string;
+    sat?: number;
     hdop?: number;
     vdop?: number;
     pdop?: number;

package/dist/TCX/encoder.d.ts

@@ -18,6 +18,8 @@ export declare class TCXEncoder {
     private buildActivityLap;
     private buildTrack;
     private buildTrackpoint;
+    private buildGeoCoords;
+    private wrapGeoTag;
     private buildPosition;
     private buildCadence;
     private buildMultiActivitySession;
@@ -25,6 +27,9 @@ export declare class TCXEncoder {
     private buildNextActivity;
     private buildWorkouts;
     private buildCourses;
+    private buildCourseElement;
+    private buildCourseLap;
+    private buildCoursePoint;
     private buildAuthor;
     private buildExtensions;
     private buildExtensionContent;

package/dist/TCX/types.d.ts

@@ -97,7 +97,7 @@ export interface ActivityListType {
     MultiActivitySession?: MultiActivitySessionType[];
 }
 export interface ActivityType {
-    Activity?: "Other" | "Running" | "Biking";
+    Sport?: "Other" | "Running" | "Biking";
     Id: string;
     Lap: ActivityLapType[];
     Notes?: string;
@@ -121,6 +121,7 @@ export interface PlanType {
     IntervalWorkout: boolean;
 }
 export interface ActivityLapType {
+    StartTime?: string;
     TotalTimeSeconds?: number;
     DistanceMeters?: number;
     MaximumSpeed?: number;

package/dist/TrackSwap.d.ts

@@ -1,53 +1,16 @@
-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";
+import type { CourseEncodeOptions, DecodeOptions, EncodeOptions, TrackDocument, TrackFormat, TrackInput, TrackSwapOptions, TranscodeOptions } from "./document.js";
+import type { 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>;
+    private readonly registry;
+    private disposed;
+    constructor(options?: TrackSwapOptions);
+    detect(input: TrackInput): TrackFormat;
+    decode<TNative = unknown>(input: TrackInput, options?: DecodeOptions): Promise<TrackDocument<TNative>>;
+    decodeActivity(input: TrackInput, options?: DecodeOptions): Promise<FileType>;
+    encodeActivity(activity: FileType, options: EncodeOptions): Promise<Buffer>;
+    transcode(input: TrackInput, options: TranscodeOptions): Promise<Buffer>;
+    encodeCourse(source: TrackInput | FileType, options?: CourseEncodeOptions): Promise<Buffer>;
+    dispose(): Promise<void>;
+    private assertActive;
 }
 export default TrackSwap;

package/dist/activity/converters.d.ts

@@ -12,6 +12,8 @@ export declare class GPXToActivityConverter extends BaseActivityConverter {
     protected convertPoint(point: WptType, idx?: number, lapIdx?: number): ActivityRecordType;
     private convertTrk2Activity;
     private convertTrackSeg2Lap;
+    private convertRoute2Lap;
+    private convertPoints2Lap;
     private convertWpts2Points;
     private convertGPXExtensions;
     private autoNumber;
@@ -30,6 +32,8 @@ export declare class TCXToActivityConverter extends BaseActivityConverter {
     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

@@ -7,6 +7,8 @@ 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;
@@ -16,6 +18,7 @@ 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;
@@ -28,5 +31,6 @@ export declare class ActivityToTCXEncoder extends BaseActivityEncoder {
     private convertLap2TCXLap;
     private convertRecords2TCXTrack;
     private convertPoint2TCXTrackpoint;
-    private convertRoute2TCXCourse;
+    private validTimestamp;
+    private convertRouteToTCXCourse;
 }

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/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;