ts-watches 0.1.0

package/dist/fit/parser.d.ts

@@ -0,0 +1,21 @@
+import type { FitFileHeader } from '../types';
+// Utility functions for converting FIT values
+export declare function fitTimestampToDate(timestamp: number): Date;
+export declare function semicirclesToDegrees(semicircles: number): number;
+export declare function degreesToSemicircles(degrees: number): number;
+export declare interface FitMessage {
+  globalMsgNum: number
+  fields: Record<number, unknown>
+}
+export declare interface FitParseResult {
+  header: FitFileHeader
+  messages: FitMessage[]
+}
+export declare class FitParseError extends Error {
+  public offset?: number;
+  constructor(message: string, offset?: number);
+}
+export declare class FitParser {
+  constructor(data: Buffer | ArrayBuffer | Uint8Array);
+  parse(): FitParseResult;
+}

package/dist/index.d.ts

@@ -0,0 +1,40 @@
+// Re-export commonly used types for convenience
+export type {
+  Activity,
+  ActivityLap,
+  ActivityRecord,
+  MonitoringData,
+  WatchDevice,
+  GarminDevice,
+  DownloadResult,
+  DownloadOptions,
+  WatchDriver,
+  SleepData,
+  StressData,
+  HRVData,
+  SpO2Data,
+  DailyHeartRate,
+  BodyBattery,
+  DailySteps,
+  WeightData,
+  GeoPosition,
+  SportType,
+  SubSportType,
+} from './types';
+// Core exports
+export * from './config';
+export * from './types';
+// FIT file parsing
+export * from './fit/index';
+// Device drivers
+export * from './drivers/index';
+// Data export
+export * from './export/index';
+// Cloud integrations
+export * from './cloud/index';
+// Analysis tools
+export * from './analysis/index';
+// Workout tools
+export * from './workouts/index';
+// Real-time data
+export * from './realtime/index';

package/dist/realtime/ant-plus.d.ts

@@ -0,0 +1,201 @@
+/**
+ * Create an ANT+ scanner
+ * Returns a mock scanner - integrate with ant-plus package for real hardware
+ */
+export declare function createAntPlusScanner(): AntPlusScanner;
+/**
+ * Calculate wheel speed from ANT+ speed sensor data
+ */
+export declare function calculateWheelSpeed(currentRevolutions: number, currentEventTime: number, previousRevolutions: number, previousEventTime: number): number;
+/**
+ * Calculate cadence from ANT+ cadence sensor data
+ */
+export declare function calculateCadence(currentRevolutions: number, currentEventTime: number, previousRevolutions: number, previousEventTime: number): number;
+// ANT+ Device Profile Constants
+export declare const ANT_PLUS_PROFILES: {
+  HEART_RATE: {
+  deviceType: 120;
+  frequency: 57;
+  period: 8070;
+  searchTimeout: 30
+};
+  SPEED_CADENCE: {
+  deviceType: 121;
+  frequency: 57;
+  period: 8086;
+  searchTimeout: 30
+};
+  BIKE_SPEED: {
+  deviceType: 123;
+  frequency: 57;
+  period: 8118;
+  searchTimeout: 30
+};
+  BIKE_CADENCE: {
+  deviceType: 122;
+  frequency: 57;
+  period: 8102;
+  searchTimeout: 30
+};
+  POWER: {
+  deviceType: 11;
+  frequency: 57;
+  period: 8182;
+  searchTimeout: 30
+};
+  RUNNING_DYNAMICS: {
+  deviceType: 26;
+  frequency: 57;
+  period: 8134;
+  searchTimeout: 30
+};
+  FITNESS_EQUIPMENT: {
+  deviceType: 17;
+  frequency: 57;
+  period: 8192;
+  searchTimeout: 30
+};
+  ENVIRONMENT: {
+  deviceType: 25;
+  frequency: 57;
+  period: 8070;
+  searchTimeout: 30
+}
+};
+export declare interface AntPlusDevice {
+  deviceId: number
+  deviceType: AntPlusDeviceType
+  transmissionType: number
+  name?: string
+  batteryStatus?: 'new' | 'good' | 'ok' | 'low' | 'critical'
+}
+export declare interface HeartRateData {
+  heartRate: number
+  beatCount: number
+  beatTime: number
+  rrIntervals?: number[]
+  operatingTime?: number
+}
+export declare interface SpeedCadenceData {
+  speed?: number
+  cadence?: number
+  wheelRevolutions?: number
+  crankRevolutions?: number
+  wheelEventTime?: number
+  crankEventTime?: number
+}
+export declare interface PowerData {
+  instantPower: number
+  cadence?: number
+  accumulatedPower?: number
+  pedalPowerBalance?: number
+  torqueEffectiveness?: {
+    left: number
+    right: number
+  }
+  pedalSmoothness?: {
+    left: number
+    right: number
+  }
+}
+export declare interface RunningDynamicsData {
+  cadence: number
+  groundContactTime?: number
+  groundContactBalance?: number
+  strideLength?: number
+  verticalOscillation?: number
+  verticalRatio?: number
+  stanceTime?: number
+}
+export declare interface FitnessEquipmentData {
+  elapsedTime: number
+  distance: number
+  speed: number
+  heartRate?: number
+  cadence?: number
+  power?: number
+  resistance?: number
+  incline?: number
+  state: 'ready' | 'in_use' | 'finished' | 'paused'
+}
+/**
+ * ANT+ Channel configuration
+ */
+export declare interface AntPlusChannelConfig {
+  deviceType: AntPlusDeviceType
+  deviceId?: number
+  transmissionType?: number
+  frequency?: number
+  period?: number
+}
+/**
+ * ANT+ Scanner interface
+ *
+ * Provides an interface for scanning and connecting to ANT+ devices.
+ * Actual implementation requires native USB access via ant-plus package or similar.
+ */
+export declare interface AntPlusScanner {
+  startScanning(deviceTypes?: AntPlusDeviceType[]): Promise<void>
+  stopScanning(): Promise<void>
+  getDevices(): AntPlusDevice[]
+  connect(deviceId: number): Promise<void>
+  disconnect(deviceId: number): Promise<void>
+  on(event: 'data', handler: AntPlusEventHandler): void
+  on(event: 'device_found', handler: (_device: AntPlusDevice) => void): void
+  on(event: 'device_lost', handler: (_device: AntPlusDevice) => void): void
+  on(event: 'error', handler: (error: Error) => void): void
+  off(event: string, handler: (...args: any[]) => void): void
+  isAvailable(): boolean
+  close(): Promise<void>
+}
+/**
+ * ANT+ Protocol Implementation
+ *
+ * ANT+ is a wireless protocol used by fitness devices for real-time data transmission.
+ * This module provides interfaces and utilities for ANT+ communication.
+ *
+ * Note: Actual ANT+ communication requires native USB access to an ANT+ stick.
+ * This module provides the protocol layer - integration with ant-plus npm package
+ * or native bindings is required for full functionality.
+ */
+export type AntPlusDeviceType = | 'heart_rate'
+  | 'speed_cadence'
+  | 'power_meter'
+  | 'fitness_equipment'
+  | 'running_dynamics'
+  | 'environment';
+export type AntPlusData = | {
+    type: 'heart_rate'
+    data: HeartRateData
+  }
+  | {
+    type: 'speed_cadence'
+    data: SpeedCadenceData
+  }
+  | {
+    type: 'power_meter'
+    data: PowerData
+  }
+  | {
+    type: 'running_dynamics'
+    data: RunningDynamicsData
+  }
+  | {
+    type: 'fitness_equipment'
+    data: FitnessEquipmentData
+  }
+export type AntPlusEventHandler = (_device: AntPlusDevice, _data: AntPlusData) => void;
+/**
+ * Mock ANT+ Scanner for testing
+ */
+export declare class MockAntPlusScanner implements AntPlusScanner {
+  startScanning(_deviceTypes?: AntPlusDeviceType[]): Promise<void>;
+  stopScanning(): Promise<void>;
+  getDevices(): AntPlusDevice[];
+  connect(_deviceId: number): Promise<void>;
+  disconnect(_deviceId: number): Promise<void>;
+  on(event: string, handler: (...args: any[]) => void): void;
+  off(event: string, handler: (...args: any[]) => void): void;
+  isAvailable(): boolean;
+  close(): Promise<void>;
+}

package/dist/realtime/bluetooth.d.ts

@@ -0,0 +1,153 @@
+/**
+ * Parse heart rate measurement characteristic value
+ */
+export declare function parseHeartRateMeasurement(data: DataView): BleHeartRateData;
+/**
+ * Parse cycling speed and cadence measurement
+ */
+export declare function parseCscMeasurement(data: DataView, prevWheelRevs?: number, prevWheelTime?: number, prevCrankRevs?: number, prevCrankTime?: number): BleCyclingData;
+/**
+ * Parse cycling power measurement
+ */
+export declare function parsePowerMeasurement(data: DataView): BlePowerData;
+/**
+ * Create a BLE scanner
+ */
+export declare function createBleScanner(): BleScanner;
+// BLE GATT Service UUIDs
+export declare const BLE_SERVICES: {
+  HEART_RATE: '0000180d-0000-1000-8000-00805f9b34fb';
+  CYCLING_SPEED_CADENCE: '00001816-0000-1000-8000-00805f9b34fb';
+  CYCLING_POWER: '00001818-0000-1000-8000-00805f9b34fb';
+  RUNNING_SPEED_CADENCE: '00001814-0000-1000-8000-00805f9b34fb';
+  FITNESS_MACHINE: '00001826-0000-1000-8000-00805f9b34fb';
+  DEVICE_INFORMATION: '0000180a-0000-1000-8000-00805f9b34fb';
+  BATTERY: '0000180f-0000-1000-8000-00805f9b34fb'
+};
+// BLE GATT Characteristic UUIDs
+export declare const BLE_CHARACTERISTICS: {
+  HEART_RATE_MEASUREMENT: '00002a37-0000-1000-8000-00805f9b34fb';
+  BODY_SENSOR_LOCATION: '00002a38-0000-1000-8000-00805f9b34fb';
+  CSC_MEASUREMENT: '00002a5b-0000-1000-8000-00805f9b34fb';
+  CSC_FEATURE: '00002a5c-0000-1000-8000-00805f9b34fb';
+  CYCLING_POWER_MEASUREMENT: '00002a63-0000-1000-8000-00805f9b34fb';
+  CYCLING_POWER_FEATURE: '00002a65-0000-1000-8000-00805f9b34fb';
+  RSC_MEASUREMENT: '00002a53-0000-1000-8000-00805f9b34fb';
+  RSC_FEATURE: '00002a54-0000-1000-8000-00805f9b34fb';
+  FITNESS_MACHINE_FEATURE: '00002acc-0000-1000-8000-00805f9b34fb';
+  TREADMILL_DATA: '00002acd-0000-1000-8000-00805f9b34fb';
+  INDOOR_BIKE_DATA: '00002ad2-0000-1000-8000-00805f9b34fb';
+  BATTERY_LEVEL: '00002a19-0000-1000-8000-00805f9b34fb'
+};
+export declare interface BleDevice {
+  id: string
+  name: string
+  type: BleDeviceType
+  rssi?: number
+  connected: boolean
+}
+export declare interface BleHeartRateData {
+  heartRate: number
+  contactDetected?: boolean
+  energyExpended?: number
+  rrIntervals?: number[]
+}
+export declare interface BleCyclingData {
+  speed?: number
+  cadence?: number
+  wheelRevolutions?: number
+  crankRevolutions?: number
+}
+export declare interface BlePowerData {
+  instantPower: number
+  pedalPowerBalance?: number
+  accumulatedTorque?: number
+  wheelRevolutions?: number
+  crankRevolutions?: number
+  cadence?: number
+}
+export declare interface BleRunningData {
+  speed: number
+  cadence: number
+  strideLength?: number
+  totalDistance?: number
+}
+export declare interface BleFitnessMachineData {
+  speed?: number
+  cadence?: number
+  power?: number
+  heartRate?: number
+  distance?: number
+  elapsedTime?: number
+  resistance?: number
+  incline?: number
+  status: 'idle' | 'warmup' | 'workout' | 'cooldown' | 'paused'
+}
+/**
+ * BLE Scanner interface
+ */
+export declare interface BleScanner {
+  startScanning(services?: string[]): Promise<void>
+  stopScanning(): Promise<void>
+  getDevices(): BleDevice[]
+  connect(deviceId: string): Promise<void>
+  disconnect(deviceId: string): Promise<void>
+  subscribe(deviceId: string, characteristic: string): Promise<void>
+  on(event: 'data', handler: BleEventHandler): void
+  on(event: 'device_found', handler: (_device: BleDevice) => void): void
+  on(event: 'device_lost', handler: (_device: BleDevice) => void): void
+  on(event: 'connected', handler: (_device: BleDevice) => void): void
+  on(event: 'disconnected', handler: (_device: BleDevice) => void): void
+  on(event: 'error', handler: (error: Error) => void): void
+  off(event: string, handler: (...args: any[]) => void): void
+  isAvailable(): Promise<boolean>
+  close(): Promise<void>
+}
+/**
+ * Bluetooth Low Energy (BLE) Heart Rate and Fitness Device Support
+ *
+ * This module provides interfaces for connecting to BLE fitness devices.
+ * Uses Web Bluetooth API when available, or can be integrated with noble/bleno
+ * for Node.js native Bluetooth access.
+ */
+export type BleDeviceType = | 'heart_rate'
+  | 'cycling_speed_cadence'
+  | 'cycling_power'
+  | 'running_speed_cadence'
+  | 'fitness_machine';
+export type BleData = | {
+    type: 'heart_rate'
+    data: BleHeartRateData
+  }
+  | {
+    type: 'cycling'
+    data: BleCyclingData
+  }
+  | {
+    type: 'power'
+    data: BlePowerData
+  }
+  | {
+    type: 'running'
+    data: BleRunningData
+  }
+  | {
+    type: 'fitness_machine'
+    data: BleFitnessMachineData
+  }
+export type BleEventHandler = (_device: BleDevice, _data: BleData) => void;
+/**
+ * Mock BLE Scanner for testing
+ */
+export declare class MockBleScanner implements BleScanner {
+  startScanning(_services?: string[]): Promise<void>;
+  stopScanning(): Promise<void>;
+  getDevices(): BleDevice[];
+  connect(deviceId: string): Promise<void>;
+  disconnect(deviceId: string): Promise<void>;
+  subscribe(_deviceId: string, _characteristic: string): Promise<void>;
+  on(event: string, handler: (...args: any[]) => void): void;
+  off(event: string, handler: (...args: any[]) => void): void;
+  isAvailable(): Promise<boolean>;
+  close(): Promise<void>;
+}

package/dist/realtime/index.d.ts

@@ -0,0 +1,3 @@
+export * from './ant-plus';
+export * from './bluetooth';
+export * from './live-tracking';

package/dist/realtime/live-tracking.d.ts

@@ -0,0 +1,70 @@
+import type { GeoPosition, ActivityRecord } from '../types';
+/**
+ * Create a live tracking manager
+ */
+export declare function createLiveTracking(config?: LiveTrackingConfig): LiveTrackingManager;
+/**
+ * Convert live tracking session to activity records
+ */
+export declare function sessionToRecords(session: LiveTrackingSession): ActivityRecord[];
+/**
+ * Format live tracking stats for display
+ */
+export declare function formatLiveStats(session: LiveTrackingSession): {
+  distance: string
+  duration: string
+  pace: string
+  speed: string
+  heartRate: string
+  power: string
+};
+export declare interface LiveTrackingSession {
+  id: string
+  name?: string
+  startTime: Date
+  lastUpdate: Date
+  currentPosition?: GeoPosition
+  totalDistance: number
+  elapsedTime: number
+  currentSpeed?: number
+  currentHeartRate?: number
+  currentCadence?: number
+  currentPower?: number
+  status: 'active' | 'paused' | 'stopped'
+  trackPoints: GeoPosition[]
+}
+export declare interface LiveTrackingConfig {
+  updateInterval?: number
+  shareUrl?: string
+  enableHeartRate?: boolean
+  enablePower?: boolean
+  onUpdate?: (session: LiveTrackingSession) => void
+  onError?: (error: Error) => void
+}
+export type LiveTrackingEventHandler = {
+  'position': (position: GeoPosition) => void
+  'update': (session: LiveTrackingSession) => void
+  'start': (session: LiveTrackingSession) => void
+  'stop': (session: LiveTrackingSession) => void
+  'pause': (session: LiveTrackingSession) => void
+  'resume': (session: LiveTrackingSession) => void
+  'error': (error: Error) => void
+}
+/**
+ * Live tracking manager for real-time activity sharing
+ */
+export declare class LiveTrackingManager {
+  constructor(config?: LiveTrackingConfig);
+  start(name?: string): LiveTrackingSession;
+  stop(): LiveTrackingSession | null;
+  pause(): void;
+  resume(): void;
+  updatePosition(position: GeoPosition): void;
+  updateHeartRate(heartRate: number): void;
+  updatePower(power: number): void;
+  updateCadence(cadence: number): void;
+  getSession(): LiveTrackingSession | null;
+  getShareUrl(): string | null;
+  on<K extends keyof LiveTrackingEventHandler>(event: K, handler: LiveTrackingEventHandler[K]): void;
+  off<K extends keyof LiveTrackingEventHandler>(event: K, handler: LiveTrackingEventHandler[K]): void;
+}