ts-watches 0.1.0

package/LICENSE.md

@@ -0,0 +1,21 @@
+# MIT License
+
+Copyright (c) 2024 Open Web Foundation
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,358 @@
+<p align="center"><img src=".github/art/cover.jpg" alt="Social Card of this repo"></p>
+
+[![npm version](https://img.shields.io/npm/v/ts-watches?style=flat-square)](https://npmjs.com/package/ts-watches)
+[![GitHub Actions](https://img.shields.io/github/actions/workflow/status/stacksjs/ts-watches/ci.yml?style=flat-square&branch=main)](https://github.com/stacksjs/ts-watches/actions?query=workflow%3Aci)
+[![Commitizen friendly](https://img.shields.io/badge/commitizen-friendly-brightgreen.svg)](http://commitizen.github.io/cz-cli/)
+<!-- [![npm downloads][npm-downloads-src]][npm-downloads-href] -->
+<!-- [![Codecov][codecov-src]][codecov-href] -->
+
+# ts-watches
+
+A comprehensive TypeScript library for downloading, parsing, and analyzing data from smartwatches and fitness devices. Supports Garmin, Polar, Suunto, Coros, Wahoo, and Apple Watch with full FIT file parsing, cloud integrations, training analysis, and real-time data streaming.
+
+## Features
+
+### Device Support
+
+- **Garmin** - Full FIT file parsing for activities, monitoring, sleep, stress, HRV
+- **Polar** - HRM and JSON file format support
+- **Suunto** - SML (XML) format parsing
+- **Coros** - FIT file support with device detection
+- **Wahoo** - FIT file support for ELEMNT devices
+- **Apple Watch** - Health XML export parsing
+
+### Data Parsing
+
+- **FIT Protocol** - Complete binary parser for Garmin's FIT format
+- **Activity Data** - Runs, rides, swims, hikes with full GPS and metrics
+- **Health Monitoring** - Heart rate, sleep, stress, SpO2, HRV, respiration
+- **Training Metrics** - TSS, IF, NP, training load calculations
+
+### Data Export
+
+- **GPX 1.1** - With Garmin TrackPoint extensions for heart rate, cadence, power
+- **TCX** - Training Center XML format for Strava and other platforms
+- **CSV** - Flexible export for activities and monitoring data
+- **GeoJSON** - For mapping applications with Douglas-Peucker simplification
+
+### Cloud Integrations
+
+- **Garmin Activity API** - Official OAuth 2.0 PKCE integration with webhook push notifications, backfill and deregistration
+- **Garmin Connect** - Download activities, daily summaries, sleep, stress, body battery (unofficial, password-based)
+- **Strava** - OAuth authentication, activity upload, stream data retrieval
+
+### Training Analysis
+
+- **Training Load** - TSS, ATL, CTL, TSB calculations with recommendations
+- **Personal Records** - Track PRs for various distances and metrics
+- **Heart Rate Zones** - Percentage, Karvonen (reserve), LTHR-based calculations
+- **Power Zones** - FTP-based zone calculations
+- **Race Predictor** - Riegel formula predictions, VO2max estimation, training paces
+- **Running Dynamics** - Form analysis, ground contact time, vertical oscillation
+
+### Workout Tools
+
+- **Workout Builder** - Fluent API for creating structured workouts
+- **Course Builder** - Create GPS courses with waypoints
+- **Training Plans** - Generate marathon and 5K training plans
+- **iCal Export** - Export training plans to calendar format
+
+### Real-time Data
+
+- **ANT+** - Heart rate, power, speed/cadence sensor protocols
+- **Bluetooth LE** - BLE GATT services for fitness devices
+- **Live Tracking** - Real-time position and metrics sharing
+
+### Developer Experience
+
+- **CLI Tool** - Download, parse, and analyze from command line
+- **TypeScript** - Fully typed APIs with comprehensive type exports
+- **Zero Dependencies** - Core FIT parser has no external dependencies
+
+## Install
+
+```bash
+bun install ts-watches
+```
+
+## Quick Start
+
+```typescript
+import { createGarminDriver } from 'ts-watches'
+
+const driver = createGarminDriver()
+
+// Detect connected devices
+const devices = await driver.detectDevices()
+console.log('Found devices:', devices)
+
+// Download data from a device
+if (devices.length > 0) {
+  const result = await driver.downloadData(devices[0], {
+    outputDir: './my-watch-data',
+    includeActivities: true,
+    includeMonitoring: true,
+  })
+
+  console.log(`Downloaded ${result.activities.length} activities`)
+  console.log(`Downloaded ${result.monitoring.size} days of monitoring data`)
+}
+```
+
+## Usage Examples
+
+### Parse FIT Files
+
+```typescript
+import { createGarminDriver } from 'ts-watches'
+
+const driver = createGarminDriver()
+const activity = await driver.parseActivityFile('/path/to/activity.fit')
+
+console.log(`${activity.sport}: ${(activity.totalDistance / 1000).toFixed(2)}km`)
+console.log(`Duration: ${Math.floor(activity.totalTime / 60)} minutes`)
+console.log(`Avg HR: ${activity.avgHeartRate} bpm`)
+```
+
+### Export to GPX
+
+```typescript
+import { activityToGpx, activityToTcx, activityToCsv } from 'ts-watches'
+
+// Export activity to GPX
+const gpx = activityToGpx(activity)
+await Bun.write('activity.gpx', gpx)
+
+// Export to TCX for Strava upload
+const tcx = activityToTcx(activity)
+await Bun.write('activity.tcx', tcx)
+
+// Export to CSV for analysis
+const csv = activityToCsv(activity)
+await Bun.write('activity.csv', csv)
+```
+
+### Training Analysis
+
+```typescript
+import { calculateTSS, ZoneCalculator, RacePredictor } from 'ts-watches'
+
+// Calculate Training Stress Score
+const tss = calculateTSS(activity, { ftp: 250 })
+
+// Analyze zones
+const zones = new ZoneCalculator({ maxHR: 185, restingHR: 50, ftp: 250 })
+const zoneAnalysis = zones.analyzeActivity(activity)
+
+// Predict race times
+const predictor = new RacePredictor()
+const predictions = predictor.predictFromPerformance(5000, 20 * 60) // 5K in 20min
+console.log(`Predicted marathon: ${predictions.marathon}`)
+```
+
+### Cloud Integration
+
+```typescript
+import { GarminActivityApiClient, GarminConnectClient, StravaClient } from 'ts-watches'
+
+// Garmin Activity API (official, OAuth 2.0 PKCE, push notifications).
+// The athlete approves on Garmin's own site and can revoke at any time.
+const garmin = new GarminActivityApiClient({
+  clientId: process.env.GARMIN_CLIENT_ID!,
+  clientSecret: process.env.GARMIN_CLIENT_SECRET!,
+  redirectUri: 'https://example.com/garmin/callback',
+})
+
+const { verifier, challenge } = createPkcePair()
+const url = garmin.buildAuthorizationUrl({ state, challenge }) // send the athlete here
+const tokens = await garmin.exchangeCode(code, verifier) // on the callback
+const userId = await garmin.getUserId(tokens.accessToken) // the key push notifications carry
+
+// Garmin Connect (unofficial; needs the athlete's password, breaks under 2FA)
+const legacy = new GarminConnectClient()
+await legacy.login('email@example.com', 'password')
+const activities = await legacy.getActivities(new Date('2024-01-01'))
+
+// Strava
+const strava = new StravaClient({
+  clientId: 'your-client-id',
+  clientSecret: 'your-client-secret',
+})
+const authUrl = strava.getAuthorizationUrl('http://localhost:3000/callback')
+```
+
+### Build Workouts
+
+```typescript
+import { WorkoutBuilder, workoutTemplates } from 'ts-watches'
+
+// Use a template
+const intervals = workoutTemplates.vo2maxIntervals({ ftp: 250 })
+
+// Or build custom workout
+const workout = new WorkoutBuilder('Custom Threshold')
+  .warmup({ duration: 600, targetPower: { min: 100, max: 150 } })
+  .interval({ duration: 1200, targetPower: { min: 240, max: 260 } })
+  .recovery({ duration: 300, targetPower: { min: 100, max: 130 } })
+  .repeat(4)
+  .cooldown({ duration: 600, targetPower: { min: 100, max: 130 } })
+  .build()
+```
+
+### Real-time Data
+
+```typescript
+import { createLiveTracking, createBleScanner } from 'ts-watches'
+
+// Live tracking
+const tracker = createLiveTracking({
+  updateInterval: 5000,
+  onUpdate: (session) => console.log(`Distance: ${session.totalDistance}m`),
+})
+
+tracker.start('Morning Run')
+tracker.updatePosition({ lat: 37.7749, lng: -122.4194, altitude: 10 })
+
+// BLE sensors
+const ble = createBleScanner()
+await ble.startScanning()
+ble.on('data', (device, data) => {
+  if (data.type === 'heart_rate') {
+    console.log(`HR: ${data.data.heartRate} bpm`)
+  }
+})
+```
+
+## CLI
+
+```bash
+# Detect connected watches
+watch detect
+
+# Download all data from connected watch
+watch download
+
+# Download to specific directory
+watch download --output ./my-data
+
+# Download only activities from the last week
+watch download --activities --since 2024-01-01
+
+# Parse a single FIT file
+watch parse /path/to/activity.fit
+
+# Parse and output as JSON
+watch parse /path/to/activity.fit --format json
+
+# Watch for device connection and auto-download
+watch watch
+```
+
+## Supported Data Types
+
+### Activities
+
+- Running (treadmill, trail, track)
+- Cycling (road, mountain, gravel, indoor)
+- Swimming (pool, open water)
+- Hiking, Walking
+- Strength training, Cardio, HIIT
+- Multisport (triathlon)
+- And 50+ more sport types
+
+### Health Metrics
+
+| Metric | Description |
+|--------|-------------|
+| Heart Rate | Continuous monitoring, resting HR, zones |
+| Sleep | Duration, stages (light, deep, REM), score |
+| Stress | Stress levels throughout the day |
+| Body Battery | Energy levels based on HRV |
+| SpO2 | Blood oxygen saturation |
+| Respiration | Breathing rate |
+| HRV | Heart rate variability (RMSSD, SDRR) |
+| Steps | Daily count, goals, intensity minutes |
+
+### Training Metrics
+
+| Metric | Description |
+|--------|-------------|
+| TSS | Training Stress Score |
+| IF | Intensity Factor |
+| NP | Normalized Power |
+| ATL | Acute Training Load |
+| CTL | Chronic Training Load (Fitness) |
+| TSB | Training Stress Balance (Form) |
+| TRIMP | Training Impulse |
+
+## Device Setup
+
+### Garmin
+
+1. Connect your watch via USB
+2. On the watch: **Settings > System > USB Mode > Mass Storage**
+3. Close Garmin Express (it locks the device)
+4. The watch appears as `/Volumes/GARMIN` on macOS
+
+### Polar
+
+1. Export data from Polar Flow web interface
+2. Or use Polar's data export feature on the device
+
+### Apple Watch
+
+1. Open Health app on iPhone
+2. Tap profile > Export All Health Data
+3. Extract the ZIP file
+
+## API Reference
+
+See the [full API documentation](./docs/api.md) for detailed type definitions and method signatures.
+
+## Testing
+
+```bash
+bun test
+```
+
+## Changelog
+
+Please see our [releases](https://github.com/stacksjs/ts-watches/releases) page for more information on what has changed recently.
+
+## Contributing
+
+Please see [CONTRIBUTING](.github/CONTRIBUTING.md) for details.
+
+## Community
+
+For help, discussion about best practices, or any other conversation that would benefit from being searchable:
+
+[Discussions on GitHub](https://github.com/stacksjs/ts-watches/discussions)
+
+For casual chit-chat with others using this package:
+
+[Join the Stacks Discord Server](https://stacksjs.com/discord)
+
+## Postcardware
+
+"Software that is free, but hopes for a postcard." We love receiving postcards from around the world showing where Stacks is being used! We showcase them on our website too.
+
+Our address: Stacks.js, 12665 Village Ln #2306, Playa Vista, CA 90094, United States
+
+## Sponsors
+
+We would like to extend our thanks to the following sponsors for funding Stacks development. If you are interested in becoming a sponsor, please reach out to us.
+
+- [JetBrains](https://www.jetbrains.com/)
+- [The Solana Foundation](https://solana.com/)
+
+## License
+
+The MIT License (MIT). Please see [LICENSE](LICENSE.md) for more information.
+
+Made with 💙
+
+<!-- Badges -->
+
+<!-- [codecov-src]: https://img.shields.io/codecov/c/gh/stacksjs/ts-watches/main?style=flat-square
+[codecov-href]: https://codecov.io/gh/stacksjs/ts-watches -->

package/dist/analysis/index.d.ts

@@ -0,0 +1,5 @@
+export * from './training-load';
+export * from './personal-records';
+export * from './zones';
+export * from './race-predictor';
+export * from './running-dynamics';

package/dist/analysis/personal-records.d.ts

@@ -0,0 +1,58 @@
+import type { Activity, ActivityRecord } from '../types';
+export declare function createPersonalRecordsTracker(existingRecords?: PersonalRecord[]): PersonalRecordsTracker;
+export declare interface PersonalRecord {
+  type: RecordType
+  value: number
+  unit: string
+  activityId: string
+  activityName?: string
+  date: Date
+  sport: string
+  previousRecord?: {
+    value: number
+    date: Date
+  }
+}
+export declare interface RecordDefinition {
+  type: RecordType
+  label: string
+  unit: string
+  sports: string[]
+  extractor: (activity: Activity, records?: ActivityRecord[]) => number | null
+  comparator: 'higher' | 'lower'
+  distanceMeters?: number
+}
+export type RecordType = | 'longest_distance'
+  | 'longest_duration'
+  | 'fastest_1k'
+  | 'fastest_5k'
+  | 'fastest_10k'
+  | 'fastest_half_marathon'
+  | 'fastest_marathon'
+  | 'fastest_100m'
+  | 'fastest_400m'
+  | 'fastest_1_mile'
+  | 'highest_avg_power'
+  | 'highest_max_power'
+  | 'highest_normalized_power'
+  | 'highest_elevation_gain'
+  | 'most_calories'
+  | 'fastest_avg_pace'
+  | 'highest_avg_hr'
+  | 'highest_max_hr'
+  | 'longest_moving_time'
+  | 'best_20min_power'
+  | 'best_1hr_power'
+  | 'best_5min_power'
+  | 'max_speed';
+export declare class PersonalRecordsTracker {
+  constructor(existingRecords?: PersonalRecord[]);
+  processActivity(activity: Activity): PersonalRecord[];
+  processActivities(activities: Activity[]): PersonalRecord[];
+  getAllRecords(): PersonalRecord[];
+  getRecordsForSport(sport: string): PersonalRecord[];
+  getRecord(sport: string, type: RecordType): PersonalRecord | undefined;
+  formatRecordValue(record: PersonalRecord): string;
+  toJSON(): PersonalRecord[];
+  static fromJSON(data: PersonalRecord[]): PersonalRecordsTracker;
+}

package/dist/analysis/race-predictor.d.ts

@@ -0,0 +1,53 @@
+import type { Activity } from '../types';
+export declare function createRacePredictor(): RacePredictor;
+// Standard race distances in meters
+export declare const RACE_DISTANCES: {
+  '1K': 1000;
+  '1 Mile': 1609.34;
+  '5K': 5000;
+  '10K': 10000;
+  '15K': 15000;
+  'Half Marathon': 21097.5;
+  'Marathon': 42195;
+  '50K': 50000;
+  '100K': 100000
+};
+export declare interface RacePrediction {
+  distance: number
+  distanceName: string
+  predictedTime: number
+  predictedPace: number
+  confidence: 'high' | 'medium' | 'low'
+}
+export declare interface PredictorInput {
+  recentActivities: Activity[]
+  personalRecords?: Map<number, number>
+  vo2max?: number
+  age?: number
+  gender?: 'male' | 'female'
+}
+export declare interface FitnessEstimate {
+  vo2max: number
+  vdot: number
+  equivalentMarathon: number
+  fitnessAge: number
+}
+export declare class RacePredictor {
+  predictFromPerformance(distance: number): RacePrediction[];
+  predictFromActivities(activities: Activity[], targetDistances?: number[]): RacePrediction[];
+  estimateVO2max(distance: number, time: number): number;
+  estimateVDOT(distance: number, time: number): number;
+  estimateFitness(activities: Activity[], age?: number): FitnessEstimate;
+  getTrainingPaces(vdot: number): {
+    easy: {
+      min: number
+      max: number
+    }
+    marathon: number
+    threshold: number
+    interval: number
+    repetition: number
+  };
+  formatTime(seconds: number): string;
+  formatPace(secondsPerKm: number): string;
+}

package/dist/analysis/running-dynamics.d.ts

@@ -0,0 +1,66 @@
+import type { Activity, ActivityRecord } from '../types';
+export declare function createRunningDynamicsAnalyzer(): RunningDynamicsAnalyzer;
+export declare interface RunningDynamicsMetrics {
+  groundContactTime?: {
+    avg: number
+    min: number
+    max: number
+  }
+  groundContactBalance?: {
+    avg: number
+    left: number
+    right: number
+  }
+  strideLength?: {
+    avg: number
+    min: number
+    max: number
+  }
+  verticalOscillation?: {
+    avg: number
+    min: number
+    max: number
+  }
+  verticalRatio?: {
+    avg: number
+    min: number
+    max: number
+  }
+  cadence?: {
+    avg: number
+    min: number
+    max: number
+  }
+  stanceTimeBalance?: number
+  runningPowerEstimate?: number
+}
+export declare interface RunningFormAnalysis {
+  metrics: RunningDynamicsMetrics
+  formScore: number
+  insights: FormInsight[]
+  recommendations: string[]
+}
+export declare interface FormInsight {
+  metric: string
+  status: 'good' | 'warning' | 'needs_attention'
+  message: string
+  value: number
+  optimalRange: {
+    min: number
+    max: number
+  }
+}
+export declare interface ExtendedActivityRecord extends ActivityRecord {
+  groundContactTime?: number
+  groundContactBalance?: number
+  strideLength?: number
+  verticalOscillation?: number
+  verticalRatio?: number
+  stanceTimePercent?: number
+  stanceTime?: number
+}
+export declare class RunningDynamicsAnalyzer {
+  calculateMetrics(records: ExtendedActivityRecord[]): RunningDynamicsMetrics;
+  analyzeForm(activity: Activity, athleteLevel?: 'elite' | 'recreational'): RunningFormAnalysis;
+  calculateEfficiency(activity: Activity): number | null;
+}

package/dist/analysis/training-load.d.ts

@@ -0,0 +1,40 @@
+import type { Activity } from '../types';
+export declare function createTrainingLoadCalculator(config?: TrainingLoadConfig): TrainingLoadCalculator;
+export declare interface TrainingLoadMetrics {
+  tss: number
+  atl: number
+  ctl: number
+  tsb: number
+  ifactor: number
+  rampRate: number
+}
+export declare interface DailyTrainingLoad {
+  date: Date
+  tss: number
+  atl: number
+  ctl: number
+  tsb: number
+}
+export declare interface TrainingLoadConfig {
+  ftp?: number
+  lthr?: number
+  maxHr?: number
+  restingHr?: number
+  atlDecay?: number
+  ctlDecay?: number
+}
+export declare class TrainingLoadCalculator {
+  constructor(config?: TrainingLoadConfig);
+  calculateTSS(activity: Activity): number;
+  calculateIntensityFactor(activity: Activity): number;
+  calculateTrainingLoad(activities: Activity[], startDate?: Date, endDate?: Date): DailyTrainingLoad[];
+  getCurrentMetrics(activities: Activity[]): TrainingLoadMetrics;
+  getTrainingRecommendation(metrics: TrainingLoadMetrics): {
+    status: 'fresh' | 'optimal' | 'tired' | 'overtrained'
+    recommendation: string
+    suggestedTSS: {
+      min: number
+      max: number
+    }
+  };
+}

package/dist/analysis/zones.d.ts

@@ -0,0 +1,69 @@
+import type { Activity } from '../types';
+export declare function createZoneCalculator(config: ZoneConfig): ZoneCalculator;
+/**
+ * Estimate max heart rate by age
+ */
+export declare function estimateMaxHrByAge(age: number): number;
+/**
+ * Estimate LTHR from max HR
+ */
+export declare function estimateLthrFromMaxHr(maxHr: number): number;
+/**
+ * Calculate heart rate reserve
+ */
+export declare function calculateHrReserve(maxHr: number, restingHr: number): number;
+/**
+ * Calculate target HR using Karvonen formula
+ */
+export declare function calculateTargetHr(maxHr: number, restingHr: number, intensity: number): number;
+export declare interface Zone {
+  name: string
+  min: number
+  max: number
+  color?: string
+}
+export declare interface ZoneConfig {
+  heartRate?: {
+    maxHr: number
+    restingHr?: number
+    method: 'percentage' | 'reserve' | 'lthr'
+    lthr?: number
+    zones?: Zone[]
+  }
+  power?: {
+    ftp: number
+    zones?: Zone[]
+  }
+  pace?: {
+    thresholdPace: number
+    zones?: Zone[]
+  }
+}
+export declare interface ZoneDistribution {
+  zone: Zone
+  seconds: number
+  percentage: number
+}
+export declare interface ZoneAnalysis {
+  heartRate?: ZoneDistribution[]
+  power?: ZoneDistribution[]
+  pace?: ZoneDistribution[]
+  summary: {
+    timeInZ1: number
+    timeInZ2: number
+    timeInZ3: number
+    timeInZ4: number
+    timeInZ5: number
+    polarizedIndex?: number
+    intensityDistribution: 'polarized' | 'pyramidal' | 'threshold' | 'unknown'
+  }
+}
+export declare class ZoneCalculator {
+  constructor(config: ZoneConfig);
+  getHeartRateZones(): Zone[];
+  getPowerZones(): Zone[];
+  getPaceZones(): Zone[];
+  analyzeActivity(activity: Activity): ZoneAnalysis;
+  getZoneForValue(value: number, type: 'heartRate' | 'power' | 'pace'): Zone | null;
+  formatTime(seconds: number): string;
+}