trackswap 0.2.2 → 0.2.4

package/dist/GPX/base.d.ts

@@ -1,16 +1,40 @@
 import { IPlugin, IConverterPlugin, IMiddlewarePlugin, BaseConverter, BaseMiddleware } from "../core/base.js";
 import { DecoderContext, GPX11Type } from "./types.js";
+/**
+ * GPX plugin interface (inherits generic plugin interface)
+ */
 export interface IGPXPlugin extends IPlugin<DecoderContext> {
 }
+/**
+ * GPX converter plugin interface (inherits generic converter interface)
+ */
 export interface IGPXConverterPlugin extends IConverterPlugin<DecoderContext> {
 }
+/**
+ * GPX middleware plugin interface (inherits generic middleware interface)
+ */
 export interface IGPXMiddlewarePlugin extends IMiddlewarePlugin<DecoderContext, GPX11Type> {
 }
+/**
+ * GPX base converter abstract class (inherits generic base converter)
+ */
 export declare abstract class BaseGPXConverter extends BaseConverter<DecoderContext> implements IGPXConverterPlugin {
+    /**
+     * Parse GPX coordinate values (latitude/longitude)
+     */
     protected parseCoordinate(value: string | number | undefined): number | undefined;
+    /**
+     * Parse GPX time format
+     */
     protected parseGPXTime(value: string | undefined): Date | undefined;
+    /**
+     * Extract numeric attributes (common GPX processing approach)
+     */
     protected extractNumericAttributes<U extends Record<string, any>>(ast: any, target: U, mapping: Record<string, keyof U>): void;
 }
+/**
+ * GPX base middleware abstract class (inherits generic base middleware)
+ */
 export declare abstract class BaseGPXMiddleware extends BaseMiddleware<DecoderContext, GPX11Type> implements IGPXMiddlewarePlugin {
     onError(error: Error, context: DecoderContext): Promise<void>;
 }

package/dist/GPX/converters.d.ts

@@ -1,62 +1,106 @@
 import { BaseGPXConverter } from "./base.js";
 import { TokenAST, ExtensionsType } from "../types.js";
 import { BoundsType, CopyrightType, EmailType, LinkType, MetadataType, PersonType, RteType, TrksegType, TrkType, WptType, DecoderContext } from "./types.js";
+/**
+ * WPT converter
+ */
 export declare class WptConverter extends BaseGPXConverter {
     name: string;
     supportedTags: string[];
     version: string;
     convert(ast: TokenAST, context: DecoderContext): WptType | undefined;
+    /**
+     * Maps extension fields from the extensions object to the point object.
+     * This is necessary because the extensions converter flattens the extensions
+     * into a single object, but the point object expects them as separate fields.
+     */
     private mapExtensionsToPoint;
 }
+/**
+ * Route converter
+ */
 export declare class RteConverter extends BaseGPXConverter {
     name: string;
     supportedTags: string[];
     convert(ast: TokenAST, context: DecoderContext): RteType | undefined;
 }
+/**
+ * Track converter
+ */
 export declare class TrkConverter extends BaseGPXConverter {
     name: string;
     supportedTags: string[];
     convert(ast: TokenAST, context: DecoderContext): TrkType | undefined;
 }
+/**
+ * Track Segment converter
+ */
 export declare class TrksegConverter extends BaseGPXConverter {
     name: string;
     supportedTags: string[];
     convert(ast: TokenAST, context: DecoderContext): TrksegType | undefined;
 }
+/**
+ * Link converter
+ */
 export declare class LinkConverter extends BaseGPXConverter {
     name: string;
     supportedTags: string[];
     convert(ast: TokenAST, context: DecoderContext): LinkType | undefined;
 }
+/**
+ * Metadata converter
+ */
 export declare class MetadataConverter extends BaseGPXConverter {
     name: string;
     supportedTags: string[];
     convert(ast: TokenAST, context: DecoderContext): MetadataType | undefined;
 }
+/**
+ * Person converter
+ */
 export declare class PersonConverter extends BaseGPXConverter {
     name: string;
     supportedTags: string[];
     convert(ast: TokenAST, context: DecoderContext): PersonType | undefined;
 }
+/**
+ * Email converter
+ */
 export declare class EmailConverter extends BaseGPXConverter {
     name: string;
     supportedTags: string[];
     convert(ast: TokenAST, context: DecoderContext): EmailType | undefined;
 }
+/**
+ * Copyright converter
+ */
 export declare class CopyrightConverter extends BaseGPXConverter {
     name: string;
     supportedTags: string[];
     convert(ast: TokenAST, context: DecoderContext): CopyrightType | undefined;
 }
+/**
+ * Bounds converter
+ */
 export declare class BoundsConverter extends BaseGPXConverter {
     name: string;
     supportedTags: string[];
     convert(ast: TokenAST, context: DecoderContext): BoundsType | undefined;
 }
+/**
+ * Extensions converter
+ */
 export declare class ExtensionsConverter extends BaseGPXConverter {
     name: string;
     supportedTags: string[];
     convert(ast: TokenAST, context: DecoderContext): ExtensionsType | undefined;
+    /**
+     * Flatten extension element, extracting all leaf nodes
+     */
     private flattenExtensionElement;
+    /**
+     * Parse extension value, trying to convert to appropriate type
+     */
     private parseExtensionValue;
 }

package/dist/GPX/decoder.d.ts

@@ -1,6 +1,9 @@
 import { ExtensionsType, TokenAST } from "../types.js";
 import { IGPXConverterPlugin, IGPXMiddlewarePlugin } from "./base.js";
 import { GPX11Type } from "./types.js";
+/**
+ * GPX decoder main class
+ */
 export declare class GPXDecoder {
     private converterPlugins;
     private registeredPlugins;
@@ -9,32 +12,95 @@ export declare class GPXDecoder {
     private initialized;
     private defaultConvertersRegistered;
     constructor();
+    /**
+     * Initialize pipeline - register fixed core processors
+     */
     private initializePipeline;
+    /**
+     * Auto-register default converters - handle standard GPX tags
+     */
     private registerDefaultConverters;
+    /**
+     * Add converter for specified tag, sorted by priority
+     */
     private addConverterForTag;
+    /**
+     * Register converter plugin
+     */
     registerConverter(plugin: IGPXConverterPlugin): Promise<void>;
+    /**
+     * Register middleware plugin - the real extension point
+     */
     registerMiddleware(plugin: IGPXMiddlewarePlugin): Promise<void>;
+    /**
+     * Get converter (returns highest priority one)
+     */
     getConverter(tag: string): IGPXConverterPlugin | undefined;
+    /**
+     * Get all converters for specified tag (sorted by priority)
+     */
     getAllConverters(tag: string): IGPXConverterPlugin[];
+    /**
+     * Remove converter
+     */
     unregisterConverter(pluginName: string): void;
+    /**
+     * Remove middleware
+     */
     unregisterMiddleware(name: string): void;
+    /**
+     * List all registered converter tags
+     */
     listConverters(): string[];
+    /**
+     * List all registered converter plugins
+     */
     listConverterPlugins(): string[];
+    /**
+     * List all registered middleware
+     */
     listMiddlewares(): string[];
+    /**
+     * List core processors (read-only)
+     */
     listProcessors(): string[];
+    /**
+     * Get converter details for tag (including priority information)
+     */
     getConverterDetails(tag?: string): Record<string, Array<{
         name: string;
         priority: number;
     }>>;
+    /**
+     * Get middleware details (including supported hooks)
+     */
     getMiddlewareDetails(): Array<{
         name: string;
         hooks: string[];
     }>;
+    /**
+     * Initialize decoder
+     */
     initialize(): Promise<void>;
+    /**
+     * Destroy decoder
+     */
     destroy(): Promise<void>;
+    /**
+     * Create decode context
+     */
     private createContext;
+    /**
+     * Execute middleware hook
+     */
     private executeMiddlewareHook;
+    /**
+     * Main parse method - fixed pipeline + flexible middleware
+     */
     parserByBuffer(buffer: Buffer): Promise<GPX11Type | undefined>;
+    /**
+     * Convert Extensions (backward compatibility)
+     */
     convertExtensions(extensionsAST: TokenAST): ExtensionsType;
 }
 declare const _default: {

package/dist/GPX/encoder.d.ts

@@ -1,42 +1,151 @@
 import { GPX11Type } from "./types.js";
+/**
+ * GPX encoder - encodes GPX11Type data to GPX XML format
+ */
 export declare class GPXEncoder {
     private compact;
+    /**
+     * Constructor
+     * @param options Encoder options
+     */
     constructor(options?: {
         compact?: boolean;
     });
+    /**
+     * Encode GPX data to Buffer
+     */
     encode(gpxData: GPX11Type): Promise<Buffer>;
+    /**
+     * Encode GPX data to XML string
+     */
     encodeToString(gpxData: GPX11Type): string;
+    /**
+     * Build complete GPX XML
+     */
     private buildGPXXML;
+    /**
+     * Compress XML string, remove redundant newlines and spaces
+     */
     private compressXML;
+    /**
+     * Build XML header
+     */
     private buildXMLHeader;
+    /**
+     * Build GPX content
+     */
     private buildGPXContent;
+    /**
+     * Build metadata element
+     */
     private buildMetadata;
+    /**
+     * Build author element
+     */
     private buildAuthor;
+    /**
+     * Build copyright element
+     */
     private buildCopyright;
+    /**
+     * Build bounds element
+     */
     private buildBounds;
+    /**
+     * Build waypoint element
+     */
     private buildWaypoint;
+    /**
+     * Add standard waypoint elements
+     */
     private addStandardWaypointElements;
+    /**
+     * Build rte element
+     */
     private buildRoute;
+    /**
+     * Build track element
+     */
     private buildTrack;
+    /**
+     * Build track segment element
+     */
     private buildTrackSegment;
+    /**
+     * Add common elements for route and track
+     */
     private addRouteTrackCommonElements;
+    /**
+     * Process point extension attributes
+     */
     private processPointExtensions;
+    /**
+     * Build TrackPoint extension
+     */
     private buildTrackPointExtension;
+    /**
+     * Build Power extension
+     */
     private buildPowerExtension;
+    /**
+     * Build GPX extensions
+     */
     private buildGpxExtensions;
+    /**
+     * Build extensions element
+     */
     private buildExtensions;
+    /**
+     * Recursively build extension content
+     */
     private buildExtensionContent;
+    /**
+     * Build link element
+     */
     private buildLink;
+    /**
+     * Add multiple link elements
+     */
     private addLinks;
+    /**
+     * Build time element
+     */
     private buildTimeElement;
+    /**
+     * Add optional element
+     */
     private addOptionalElement;
+    /**
+     * Validate coordinate validity
+     */
     private isValidCoordinate;
+    /**
+     * Format coordinate
+     */
     private formatCoordinate;
+    /**
+     * Format elevation
+     */
     private formatElevation;
+    /**
+     * Round number
+     */
     private roundTo;
+    /**
+     * XML escape
+     */
     private escapeXML;
+    /**
+     * XML attribute value escape (specifically for safe escaping of attribute values)
+     */
     private escapeXMLAttribute;
+    /**
+     * Deep clone
+     */
     private deepClone;
+    /**
+     * @deprecated Use encode() instead
+     */
     encoder(node: GPX11Type): Promise<Buffer>;
 }
 declare const _default: {

package/dist/GPX/middleware.d.ts

@@ -1,6 +1,9 @@
 import { Token, TokenAST } from "../types";
 import { BaseGPXMiddleware } from "./base";
 import { DecoderContext } from "./types";
+/**
+ * Performance monitoring middleware
+ */
 export declare class PerformanceMiddleware extends BaseGPXMiddleware {
     name: string;
     description: string;
@@ -9,10 +12,16 @@ export declare class PerformanceMiddleware extends BaseGPXMiddleware {
     onComplete(result: any, context: DecoderContext): Promise<any>;
     private countNodes;
 }
+/**
+ * Validation middleware
+ */
 export declare class ValidationMiddleware extends BaseGPXMiddleware {
     name: string;
     description: string;
     onComplete(result: any, context: DecoderContext): Promise<any>;
     private validateGPX;
 }
+/**
+ * Register all default middleware
+ */
 export declare function registerDefaultMiddlewares(decoder: any): Promise<void>;

package/dist/GPX/processor.d.ts

@@ -1,22 +1,37 @@
 import { DecoderContext } from "./types.js";
+/**
+ * Pipeline stages
+ */
 export declare enum PipelineStage {
     TOKENIZE = "tokenize",
     AST_GENERATE = "ast_generate",
     CONVERT = "convert",
     COMPLETE = "complete"
 }
+/**
+ * Pipeline processor
+ */
 export interface IPipelineProcessor {
     stage: PipelineStage;
     process(context: DecoderContext): Promise<DecoderContext>;
 }
+/**
+ * Tokenize processor, converts xml to tokens
+ */
 export declare class TokenizeProcessor implements IPipelineProcessor {
     stage: PipelineStage;
     process(context: DecoderContext): Promise<DecoderContext>;
 }
+/**
+ * AST generation processor
+ */
 export declare class AstGenerateProcessor implements IPipelineProcessor {
     stage: PipelineStage;
     process(context: DecoderContext): Promise<DecoderContext>;
 }
+/**
+ * Conversion processor
+ */
 export declare class ConvertProcessor implements IPipelineProcessor {
     private getConverter;
     stage: PipelineStage;
@@ -24,6 +39,9 @@ export declare class ConvertProcessor implements IPipelineProcessor {
     process(context: DecoderContext): Promise<DecoderContext>;
     private assignResult;
 }
+/**
+ * Complete processor
+ */
 export declare class CompleteProcessor implements IPipelineProcessor {
     stage: PipelineStage;
     process(context: DecoderContext): Promise<DecoderContext>;

package/dist/GPX/types.d.ts

@@ -1,5 +1,8 @@
 import { DegreesType, ExtensionsType, LatitudeType, LongitudeType, Token, TokenAST } from "../types.js";
 import { IProcessingContext } from "../core/base.js";
+/**
+ * Two lat/lon pairs defining the extent of an element.
+ */
 export interface BoundsType {
     minlat?: LatitudeType;
     minlon?: LongitudeType;
@@ -20,14 +23,35 @@ export interface EmailType {
     id?: string;
     domain?: string;
 }
+/**
+ * Type of GPS fix. none means GPS had no fix. To signify "the fix info is unknown, leave out fixType entirely. pps = military signal used
+ */
 type FixType = "none" | "2d" | "3d" | "dgps" | "pps" | string;
 export type LinkType = {
+    /**
+     * URL of hyperlink.
+     */
     href?: string;
+    /**
+     * Text of hyperlink.
+     */
     text?: string;
+    /**
+     * Mime type of content (image/jpeg)
+     */
     type?: string;
 };
+/**
+ * GPX 1.1 version type
+ */
 export interface GPX11Type {
+    /**
+     * gpx version 1.1
+     */
     version?: string;
+    /**
+     * You must include the name or URL of the software that created your GPX document. This allows others to inform the creator of a GPX instance document that fails to validate.
+     */
     creator?: string;
     xmlns?: string;
     "xmlns:gte"?: string;
@@ -40,54 +64,168 @@ export interface GPX11Type {
     extensions?: any;
     [key: string]: any | undefined;
 }
+/**
+ * Metadata about the file.
+ */
 export interface MetadataType {
+    /**
+     * The name of the GPX file.
+     */
     name?: string;
+    /**
+     * A description of the contents of the GPX file.
+     */
     desc?: string;
+    /**
+     * The person or organization who created the GPX file.
+     */
     author?: PersonType;
+    /**
+     * Copyright and license information governing use of the file.
+     */
     copyright?: CopyrightType;
+    /**
+     * URLs associated with the location described in the file.
+     */
     link?: LinkType[];
+    /**
+     * The creation date of the file.
+     */
     time?: Date;
+    /**
+     * Keywords associated with the file. Search engines or databases can use this information to classify the data.
+     */
     keywords?: string;
+    /**
+     * Minimum and maximum coordinates which describe the extent of the coordinates in the file.
+     */
     bounds?: BoundsType;
     extensions?: ExtensionsType;
     [key: string]: any;
 }
+/**
+ * A list of waypoints.
+ */
 export interface WptType {
     lat?: LatitudeType;
     lon?: LongitudeType;
+    /**
+     * Elevation (in meters) of the point.
+     */
     ele?: number;
+    /**
+     * Creation/modification timestamp for element. Date and time in are in Univeral Coordinated Time (UTC), not local time! Conforms to ISO 8601 specification for date/time representation. Fractional seconds are allowed for millisecond timing in tracklogs.
+     */
     time?: Date;
+    /**
+     * Instantaneous speed at the point (meters per second)
+     */
     speed?: number;
+    /**
+     * Instantaneous course at the point (degrees, true north)
+     */
     course?: number;
+    /**
+     * Magnetic variation (in degrees) at the point
+     */
     magvar?: DegreesType;
+    /**
+     * Height (in meters) of geoid (mean sea level) above WGS84 earth ellipsoid. As defined in NMEA GGA message.
+     */
     geoidheight?: number;
+    /**
+     * The GPS name of the waypoint. This field will be transferred to and from the GPS. GPX does not place restrictions on the length of this field or the characters contained in it. It is up to the receiving application to validate the field before sending it to the GPS.
+     */
     name?: string;
+    /**
+     * GPS waypoint comment. Sent to GPS as comment.
+     */
     cmt?: string;
+    /**
+     * A text description of the element. Holds additional information about the element intended for the user, not the GPS.
+     */
     desc?: string;
+    /**
+     * Source of data. Included to give user some idea of reliability and accuracy of data. "Garmin eTrex", "USGS quad Boston North", e.g.
+     */
     src?: string;
+    /**
+     * Link to additional information about the waypoint.
+     */
     link?: LinkType[];
+    /**
+     * Text of GPS symbol name. For interchange with other programs, use the exact spelling of the symbol as displayed on the GPS. If the GPS abbreviates words, spell them out.
+     */
     sym?: string;
+    /**
+     * Type (classification) of the waypoint.
+     */
     type?: string;
     fix?: FixType;
+    /**
+     * Number of satellites used to calculate the GPX fix.
+     */
     sat?: number;
+    /**
+     * Horizontal dilution of precision.
+     */
     hdop?: number;
+    /**
+     * Vertical dilution of precision.
+     */
     vdop?: number;
+    /**
+     * Position dilution of precision.
+     */
     pdop?: number;
+    /**
+     * Number of seconds since last DGPS update.
+     */
     ageofdgpsdata?: number;
+    /**
+     * ID of DGPS station used in differential correction.
+     */
     dgpsid?: DegreesType;
+    /**
+     * You can add extend GPX by adding your own elements from another schema here.
+     */
     extensions?: ExtensionsType;
     power?: number;
     heartRate?: number;
     cadence?: number;
 }
+/**
+ * A list of route points.
+ */
 type RteptType = WptType;
 export interface RteType {
+    /**
+     * GPS name of route.
+     */
     name?: string;
+    /**
+     * GPS comment for route.
+     */
     cmt?: string;
+    /**
+     * Text description of route for user. Not sent to GPS.
+     */
     desc?: string;
+    /**
+     * Source of data. Included to give user some idea of reliability and accuracy of data.
+     */
     src?: string;
+    /**
+     * Links to external information about the route.
+     */
     link?: LinkType[];
+    /**
+     * GPS route number.
+     */
     number?: number;
+    /**
+     * Type (classification) of route.
+     */
     type?: string;
     extensions?: ExtensionsType;
     rtept?: RteptType[];