ts-garmin 0.1.1 → 0.1.3

package/README.md

@@ -172,6 +172,7 @@ const userId = await garmin.getUserId(tokens.accessToken) // the key push notifi
 const legacy = new GarminConnectClient()
 await legacy.login('email@example.com', 'password')
 const activities = await legacy.getActivities(new Date('2024-01-01'))
+const { bytes, filename } = await legacy.downloadOriginalActivity(activityId) // "Export Original" zip, in memory
 
 // Strava
 const strava = new StravaClient({

package/dist/garmin/GarminConnect.d.ts

@@ -1,5 +1,5 @@
 import { HttpClient } from '../common/HttpClient';
-import type { ActivitySubType, ActivityType, ExportFileTypeValue, GCActivityId, GCGearId, GarminDomain, IActivity, ICountActivities, IGarminTokens, IOauth1Token, IOauth2Token, ISocialProfile, IUserSettings, IWorkout, IWorkoutDetail, ListCoursesResponse, UploadFileTypeValue } from './types/index';
+import type { ActivitySubType, ActivityType, ExportFileTypeValue, GCActivityId, GCGearId, GarminDomain, IActivity, IActivityDetails, ICountActivities, IGarminTokens, IOauth1Token, IOauth2Token, ISocialProfile, IUserSettings, IWorkout, IWorkoutDetail, ListCoursesResponse, UploadFileTypeValue } from './types/index';
 import type { CoursePoint, GeoPoint, GpxActivityType, ImportedGpxResponse } from './types/gpx';
 import type { GearData } from './types/gear';
 import type { HeartRate } from './types/heartrate';
@@ -29,8 +29,10 @@ export default class GarminConnect {
   getUserProfile(): Promise<ISocialProfile>;
   getActivities(start?: number, limit?: number, activityType?: ActivityType, subActivityType?: ActivitySubType): Promise<IActivity[]>;
   getActivity(activity: { activityId: GCActivityId }): Promise<IActivity>;
+  getActivityDetails(activity: { activityId: GCActivityId }, maxChartSize?: number): Promise<IActivityDetails>;
   countActivities(): Promise<ICountActivities>;
-  downloadOriginalActivityData(activity: { activityId: GCActivityId }, dir: string, type?: ExportFileTypeValue): Promise<void>;
+  getOriginalActivityData(activity: { activityId: GCActivityId }, type?: ExportFileTypeValue): Promise<{ bytes: Uint8Array, filename: string }>;
+  downloadOriginalActivityData(activity: { activityId: GCActivityId }, dir: string, type?: ExportFileTypeValue): Promise<string>;
   uploadActivity(file: string, format?: UploadFileTypeValue): Promise<unknown>;
   deleteActivity(activity: { activityId: GCActivityId }): Promise<void>;
   getWorkouts(start: number, limit: number): Promise<IWorkout[]>;

package/dist/garmin/types/activity.d.ts

@@ -377,6 +377,24 @@ export declare interface IActivityDetails {
     maxDistance: number
   }[] | null
 }
+/** One series in an activity's details, e.g. directHeartRate or sumDuration. */
+export declare interface IActivityDetailMetricDescriptor {
+  metricsIndex: number
+  key: string
+  unit?: { id?: number, key?: string, factor?: number }
+}
+/**
+ * An activity's recorded time series from activity-service's details
+ * endpoint: `activityDetailMetrics[i].metrics[metricsIndex]` is sample i of
+ * the series the descriptor names. Garmin downsamples to `maxChartSize`.
+ */
+export declare interface IActivityDetails {
+  activityId: number
+  measurementCount?: number
+  metricsCount?: number
+  metricDescriptors: IActivityDetailMetricDescriptor[]
+  activityDetailMetrics: Array<{ metrics: Array<number | null> }>
+}
 export type GCActivityId = number;
 export declare enum ActivityType {
   Cycling = 'cycling',

package/dist/index.js

@@ -143,13 +143,13 @@ class HttpClient {
       const text = await response.text();
       throw new Error(`HTTP Error: ${response.status} ${response.statusText} - ${text}`);
     }
+    if (responseType === "arraybuffer") {
+      return response.arrayBuffer();
+    }
     const contentType = response.headers.get("content-type");
     if (contentType?.includes("application/json")) {
       return response.json();
     }
-    if (responseType === "arraybuffer") {
-      return response.arrayBuffer();
-    }
     return response.text();
   }
   async get(url, config) {
@@ -538,54 +538,54 @@ class UrlClass {
 
 // src/garmin/types/activity.ts
 var ActivityType;
-((ActivityType2) => {
-  ActivityType2["Cycling"] = "cycling";
-  ActivityType2["FitnessEquipment"] = "fitness_equipment";
-  ActivityType2["Walking"] = "walking";
-  ActivityType2["Hiking"] = "hiking";
-  ActivityType2["Other"] = "other";
-  ActivityType2["WaterSport"] = "water_sports";
-  ActivityType2["Running"] = "street_running";
+((ActivityType) => {
+  ActivityType["Cycling"] = "cycling";
+  ActivityType["FitnessEquipment"] = "fitness_equipment";
+  ActivityType["Walking"] = "walking";
+  ActivityType["Hiking"] = "hiking";
+  ActivityType["Other"] = "other";
+  ActivityType["WaterSport"] = "water_sports";
+  ActivityType["Running"] = "street_running";
 })(ActivityType ||= {});
 var ActivitySubType;
-((ActivitySubType2) => {
-  ActivitySubType2["IndoorCardio"] = "indoor_cardio";
-  ActivitySubType2["StrengthTraining"] = "strength_training";
-  ActivitySubType2["HIIT"] = "hiit";
-  ActivitySubType2["Yoga"] = "yoga";
-  ActivitySubType2["IndoorCycling"] = "indoor_cycling";
-  ActivitySubType2["Breathwork"] = "breathwork";
-  ActivitySubType2["Surfing"] = "surfing";
-  ActivitySubType2["StreetRunning"] = "street_running";
-  ActivitySubType2["TrailRunning"] = "trail_running";
-  ActivitySubType2["IndoorRunning"] = "indoor_running";
+((ActivitySubType) => {
+  ActivitySubType["IndoorCardio"] = "indoor_cardio";
+  ActivitySubType["StrengthTraining"] = "strength_training";
+  ActivitySubType["HIIT"] = "hiit";
+  ActivitySubType["Yoga"] = "yoga";
+  ActivitySubType["IndoorCycling"] = "indoor_cycling";
+  ActivitySubType["Breathwork"] = "breathwork";
+  ActivitySubType["Surfing"] = "surfing";
+  ActivitySubType["StreetRunning"] = "street_running";
+  ActivitySubType["TrailRunning"] = "trail_running";
+  ActivitySubType["IndoorRunning"] = "indoor_running";
 })(ActivitySubType ||= {});
 // src/garmin/types/gpx.ts
 var GpxActivityType;
-((GpxActivityType2) => {
-  GpxActivityType2[GpxActivityType2["Running"] = 1] = "Running";
-  GpxActivityType2[GpxActivityType2["Running_Road"] = 1] = "Running_Road";
-  GpxActivityType2[GpxActivityType2["Running_Trail"] = 1] = "Running_Trail";
-  GpxActivityType2[GpxActivityType2["Cycling"] = 10] = "Cycling";
-  GpxActivityType2[GpxActivityType2["Cycling_Road"] = 10] = "Cycling_Road";
-  GpxActivityType2[GpxActivityType2["Cycling_Gravel"] = 143] = "Cycling_Gravel";
-  GpxActivityType2[GpxActivityType2["Hiking"] = 3] = "Hiking";
-  GpxActivityType2[GpxActivityType2["Other"] = 4] = "Other";
+((GpxActivityType) => {
+  GpxActivityType[GpxActivityType["Running"] = 1] = "Running";
+  GpxActivityType[GpxActivityType["Running_Road"] = 1] = "Running_Road";
+  GpxActivityType[GpxActivityType["Running_Trail"] = 1] = "Running_Trail";
+  GpxActivityType[GpxActivityType["Cycling"] = 10] = "Cycling";
+  GpxActivityType[GpxActivityType["Cycling_Road"] = 10] = "Cycling_Road";
+  GpxActivityType[GpxActivityType["Cycling_Gravel"] = 143] = "Cycling_Gravel";
+  GpxActivityType[GpxActivityType["Hiking"] = 3] = "Hiking";
+  GpxActivityType[GpxActivityType["Other"] = 4] = "Other";
 })(GpxActivityType ||= {});
 
 // src/garmin/types/index.ts
 var ExportFileType;
-((ExportFileType2) => {
-  ExportFileType2["tcx"] = "tcx";
-  ExportFileType2["gpx"] = "gpx";
-  ExportFileType2["kml"] = "kml";
-  ExportFileType2["zip"] = "zip";
+((ExportFileType) => {
+  ExportFileType["tcx"] = "tcx";
+  ExportFileType["gpx"] = "gpx";
+  ExportFileType["kml"] = "kml";
+  ExportFileType["zip"] = "zip";
 })(ExportFileType ||= {});
 var UploadFileType;
-((UploadFileType2) => {
-  UploadFileType2["tcx"] = "tcx";
-  UploadFileType2["gpx"] = "gpx";
-  UploadFileType2["fit"] = "fit";
+((UploadFileType) => {
+  UploadFileType["tcx"] = "tcx";
+  UploadFileType["gpx"] = "gpx";
+  UploadFileType["fit"] = "fit";
 })(UploadFileType ||= {});
 
 // src/garmin/common/DateUtils.ts
@@ -720,10 +720,17 @@ class GarminConnect {
       params: { start, limit, activityType, subActivityType }
     });
   }
-  async getActivity(activity2) {
-    if (!activity2.activityId)
+  async getActivity(activity) {
+    if (!activity.activityId)
+      throw new Error("Missing activityId");
+    return this.client.get(`${this.url.ACTIVITY}${activity.activityId}`);
+  }
+  async getActivityDetails(activity, maxChartSize = 2000) {
+    if (!activity.activityId)
       throw new Error("Missing activityId");
-    return this.client.get(`${this.url.ACTIVITY}${activity2.activityId}`);
+    return this.client.get(`${this.url.ACTIVITY_BY_ID(activity.activityId)}/details`, {
+      params: { maxChartSize, maxPolylineSize: 0, maxHeatMapSize: 0 }
+    });
   }
   async countActivities() {
     const now = new Date;
@@ -737,27 +744,32 @@ class GarminConnect {
       }
     });
   }
-  async downloadOriginalActivityData(activity2, dir, type = "zip") {
-    if (!activity2.activityId)
+  async getOriginalActivityData(activity, type = "zip") {
+    if (!activity.activityId)
       throw new Error("Missing activityId");
-    if (!checkIsDirectory(dir)) {
-      createDirectory(dir);
-    }
-    let fileBuffer;
     let url;
     if (type === "tcx") {
-      url = `${this.url.DOWNLOAD_TCX}${activity2.activityId}`;
+      url = `${this.url.DOWNLOAD_TCX}${activity.activityId}`;
     } else if (type === "gpx") {
-      url = `${this.url.DOWNLOAD_GPX}${activity2.activityId}`;
+      url = `${this.url.DOWNLOAD_GPX}${activity.activityId}`;
     } else if (type === "kml") {
-      url = `${this.url.DOWNLOAD_KML}${activity2.activityId}`;
+      url = `${this.url.DOWNLOAD_KML}${activity.activityId}`;
     } else if (type === "zip") {
-      url = `${this.url.DOWNLOAD_ZIP}${activity2.activityId}`;
+      url = `${this.url.DOWNLOAD_ZIP}${activity.activityId}`;
     } else {
-      throw new Error(`downloadOriginalActivityData - Invalid type: ${type}`);
+      throw new Error(`getOriginalActivityData - Invalid type: ${type}`);
+    }
+    const body = await this.client.get(url, { responseType: "arraybuffer" });
+    return { bytes: new Uint8Array(body), filename: `${activity.activityId}.${type}` };
+  }
+  async downloadOriginalActivityData(activity, dir, type = "zip") {
+    const { bytes, filename } = await this.getOriginalActivityData(activity, type);
+    if (!checkIsDirectory(dir)) {
+      createDirectory(dir);
     }
-    fileBuffer = await this.client.get(url, { responseType: "arraybuffer" });
-    writeToFile(path.join(dir, `${activity2.activityId}.${type}`), Buffer.from(fileBuffer));
+    const file = path.join(dir, filename);
+    writeToFile(file, bytes);
+    return file;
   }
   async uploadActivity(file, format = "fit") {
     const detectedFormat = (format || path.extname(file))?.toLowerCase();
@@ -776,31 +788,31 @@ class GarminConnect {
     });
     return response.json();
   }
-  async deleteActivity(activity2) {
-    if (!activity2.activityId)
+  async deleteActivity(activity) {
+    if (!activity.activityId)
       throw new Error("Missing activityId");
-    await this.client.delete(`${this.url.ACTIVITY}${activity2.activityId}`);
+    await this.client.delete(`${this.url.ACTIVITY}${activity.activityId}`);
   }
   async getWorkouts(start, limit) {
     return this.client.get(this.url.WORKOUTS, {
       params: { start, limit }
     });
   }
-  async getWorkoutDetail(workout2) {
-    if (!workout2.workoutId)
+  async getWorkoutDetail(workout) {
+    if (!workout.workoutId)
       throw new Error("Missing workoutId");
-    return this.client.get(this.url.WORKOUT(workout2.workoutId));
+    return this.client.get(this.url.WORKOUT(workout.workoutId));
   }
-  async createWorkout(workout2) {
-    return this.client.post(this.url.WORKOUT(), workout2);
+  async createWorkout(workout) {
+    return this.client.post(this.url.WORKOUT(), workout);
   }
-  async deleteWorkout(workout2) {
-    if (!workout2.workoutId)
+  async deleteWorkout(workout) {
+    if (!workout.workoutId)
       throw new Error("Missing workout");
-    return this.client.delete(this.url.WORKOUT(workout2.workoutId));
+    return this.client.delete(this.url.WORKOUT(workout.workoutId));
   }
-  async scheduleWorkout(workout2, scheduleDate) {
-    return this.client.post(this.url.SCHEDULE_WORKOUT(Number.parseInt(workout2.workoutId)), { date: scheduleDate });
+  async scheduleWorkout(workout, scheduleDate) {
+    return this.client.post(this.url.SCHEDULE_WORKOUT(Number.parseInt(workout.workoutId)), { date: scheduleDate });
   }
   async getSteps(date = new Date) {
     const dateString = toDateString(date);
@@ -1482,30 +1494,30 @@ class WorkoutType {
   static Cardio = new WorkoutType("cardio_training", 6);
 }
 export {
-  courseRequestTemplate,
-  WorkoutType,
-  WorkoutBuilder,
-  UploadFileType,
-  TimeDuration,
-  Target,
-  StepType,
-  Step,
-  PowerZoneTarget,
-  PowerZone,
-  PaceTarget,
-  NoTarget,
-  NoDuration,
-  LapPressDuration,
-  HrmZoneTarget,
-  HrmTarget,
-  HeartRateDuration,
-  GpxActivityType,
-  GarminConnect,
-  ExportFileType,
-  Duration,
-  DistanceDuration,
-  CaloriesDuration,
-  CadenceTarget,
+  ActivitySubType,
   ActivityType,
-  ActivitySubType
+  CadenceTarget,
+  CaloriesDuration,
+  DistanceDuration,
+  Duration,
+  ExportFileType,
+  GarminConnect,
+  GpxActivityType,
+  HeartRateDuration,
+  HrmTarget,
+  HrmZoneTarget,
+  LapPressDuration,
+  NoDuration,
+  NoTarget,
+  PaceTarget,
+  PowerZone,
+  PowerZoneTarget,
+  Step,
+  StepType,
+  Target,
+  TimeDuration,
+  UploadFileType,
+  WorkoutBuilder,
+  WorkoutType,
+  courseRequestTemplate
 };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "ts-garmin",
   "type": "module",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "description": "TypeScript library for interfacing with Garmin Connect API",
   "author": "Chris Breuer <chris@stacksjs.org>",
   "license": "MIT",