@pinta365/strava 0.0.1

package/esm/src/resources/activities.js

@@ -0,0 +1,189 @@
+/**
+ * Activities resource
+ */
+import { buildPaginationQuery } from "../utils/pagination.js";
+import { validatePositiveInteger } from "../utils/validators.js";
+import { listAll } from "../utils/pagination.js";
+/**
+ * Resource for interacting with Strava activities
+ */
+export class ActivitiesResource {
+    constructor(client) {
+        Object.defineProperty(this, "client", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: client
+        });
+    }
+    /**
+     * Get activity by ID
+     */
+    async getById(id) {
+        validatePositiveInteger(id, "id");
+        return await this.client.request({
+            method: "GET",
+            path: `/activities/${id}`,
+        });
+    }
+    /**
+     * List athlete activities
+     */
+    async list(options) {
+        const query = {
+            ...buildPaginationQuery(options),
+        };
+        if (options?.before) {
+            query.before = options.before;
+        }
+        if (options?.after) {
+            query.after = options.after;
+        }
+        return await this.client.request({
+            method: "GET",
+            path: "/athlete/activities",
+            query,
+        });
+    }
+    /**
+     * List all activities (auto-pagination)
+     */
+    async *listAll(options) {
+        yield* listAll((page, perPage) => {
+            return this.list({ ...options, page, perPage });
+        }, options?.perPage || 30);
+    }
+    /**
+     * Create activity
+     */
+    async create(data) {
+        return await this.client.request({
+            method: "POST",
+            path: "/activities",
+            body: data,
+        });
+    }
+    /**
+     * Update activity
+     */
+    async update(id, data) {
+        validatePositiveInteger(id, "id");
+        return await this.client.request({
+            method: "PUT",
+            path: `/activities/${id}`,
+            body: data,
+        });
+    }
+    /**
+     * Delete activity
+     */
+    async delete(id) {
+        validatePositiveInteger(id, "id");
+        await this.client.request({
+            method: "DELETE",
+            path: `/activities/${id}`,
+        });
+    }
+    /**
+     * Get activity with details (combines activity + laps + zones + comments + kudoers)
+     */
+    async getWithDetails(id) {
+        validatePositiveInteger(id, "id");
+        const [activity, laps, zones, comments, kudoers] = await Promise.all([
+            this.getById(id),
+            this.getLaps(id),
+            this.getZones(id),
+            this.getComments(id),
+            this.getKudoers(id),
+        ]);
+        return {
+            ...activity,
+            laps,
+            zones,
+            comments,
+            kudoers,
+        };
+    }
+    /**
+     * Get activity laps
+     */
+    async getLaps(id) {
+        validatePositiveInteger(id, "id");
+        return await this.client.request({
+            method: "GET",
+            path: `/activities/${id}/laps`,
+        });
+    }
+    /**
+     * Get activity zones
+     */
+    async getZones(id) {
+        validatePositiveInteger(id, "id");
+        return await this.client.request({
+            method: "GET",
+            path: `/activities/${id}/zones`,
+        });
+    }
+    /**
+     * Get activity comments
+     */
+    async getComments(id, options) {
+        validatePositiveInteger(id, "id");
+        return await this.client.request({
+            method: "GET",
+            path: `/activities/${id}/comments`,
+            query: buildPaginationQuery(options),
+        });
+    }
+    /**
+     * Get activity kudoers
+     */
+    async getKudoers(id, options) {
+        validatePositiveInteger(id, "id");
+        return await this.client.request({
+            method: "GET",
+            path: `/activities/${id}/kudoers`,
+            query: buildPaginationQuery(options),
+        });
+    }
+    /**
+     * Analyze activity with comprehensive data
+     * Combines activity, zones, laps, best efforts (segments), and optionally streams
+     */
+    async analyze(id, options) {
+        validatePositiveInteger(id, "id");
+        const [activity, zones, laps] = await Promise.all([
+            this.getById(id),
+            this.getZones(id).catch(() => []),
+            this.getLaps(id).catch(() => []),
+        ]);
+        const bestEfforts = activity.bestEfforts || [];
+        const analysis = {
+            hasPowerData: zones.some((z) => z.type === "power"),
+            hasHeartRateData: zones.some((z) => z.type === "heartrate"),
+            totalLaps: laps.length,
+            bestEffortCount: bestEfforts.length,
+            averageLapTime: laps.length > 0 ? laps.reduce((sum, lap) => sum + (lap.movingTime || 0), 0) / laps.length : undefined,
+            averageLapDistance: laps.length > 0 ? laps.reduce((sum, lap) => sum + (lap.distance || 0), 0) / laps.length : undefined,
+        };
+        const result = {
+            ...activity,
+            zones,
+            laps,
+            bestEfforts,
+            analysis,
+        };
+        if (options?.includeStreams) {
+            try {
+                const streams = await this.client.streams.getForActivity(id, {
+                    types: options.streamTypes,
+                });
+                result.streams = streams;
+            }
+            catch {
+                // Streams may not be available for all activities
+            }
+        }
+        return result;
+    }
+}

package/esm/src/resources/athletes.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Athletes resource
+ */
+import type { StravaClient } from "../client.js";
+import type { ActivityStats, DetailedAthlete, DetailedGear, SummaryActivity } from "../types/api.js";
+/**
+ * Resource for interacting with Strava athletes
+ */
+export declare class AthletesResource {
+    private client;
+    constructor(client: StravaClient);
+    /**
+     * Get authenticated athlete
+     */
+    get(): Promise<DetailedAthlete>;
+    /**
+     * Get athlete stats
+     */
+    getStats(id: number): Promise<ActivityStats>;
+    /**
+     * Update authenticated athlete
+     */
+    update(weight: number): Promise<DetailedAthlete>;
+    /**
+     * Get athlete stats with recent activities and gear
+     * Combines stats, recent activities, and gear information
+     */
+    getStatsWithActivities(id: number, options?: {
+        recentActivitiesLimit?: number;
+        includeGear?: boolean;
+    }): Promise<DetailedAthlete & {
+        stats: ActivityStats;
+        recentActivities: SummaryActivity[];
+        gear?: DetailedGear[];
+    }>;
+}
+//# sourceMappingURL=athletes.d.ts.map

package/esm/src/resources/athletes.js

@@ -0,0 +1,85 @@
+/**
+ * Athletes resource
+ */
+import { validatePositiveInteger } from "../utils/validators.js";
+/**
+ * Resource for interacting with Strava athletes
+ */
+export class AthletesResource {
+    constructor(client) {
+        Object.defineProperty(this, "client", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: client
+        });
+    }
+    /**
+     * Get authenticated athlete
+     */
+    async get() {
+        return await this.client.request({
+            method: "GET",
+            path: "/athlete",
+        });
+    }
+    /**
+     * Get athlete stats
+     */
+    async getStats(id) {
+        validatePositiveInteger(id, "id");
+        return await this.client.request({
+            method: "GET",
+            path: `/athletes/${id}/stats`,
+        });
+    }
+    /**
+     * Update authenticated athlete
+     */
+    async update(weight) {
+        return await this.client.request({
+            method: "PUT",
+            path: "/athlete",
+            query: { weight },
+        });
+    }
+    /**
+     * Get athlete stats with recent activities and gear
+     * Combines stats, recent activities, and gear information
+     */
+    async getStatsWithActivities(id, options) {
+        validatePositiveInteger(id, "id");
+        const [athlete, stats, recentActivities] = await Promise.all([
+            this.get(),
+            this.getStats(id),
+            this.client.activities.list({
+                perPage: options?.recentActivitiesLimit || 10,
+            }),
+        ]);
+        const result = {
+            ...athlete,
+            stats,
+            recentActivities,
+        };
+        if (options?.includeGear !== false) {
+            const gearIds = [];
+            if (athlete.bikes) {
+                gearIds.push(...athlete.bikes.map((bike) => bike.id).filter((id) => id !== undefined));
+            }
+            if (athlete.shoes) {
+                gearIds.push(...athlete.shoes.map((shoe) => shoe.id).filter((id) => id !== undefined));
+            }
+            if (gearIds.length > 0) {
+                try {
+                    const gearPromises = gearIds.map((id) => this.client.gears.getById(id).catch(() => null));
+                    const gearResults = await Promise.all(gearPromises);
+                    result.gear = gearResults.filter((g) => g !== null);
+                }
+                catch {
+                    // Gear may not be accessible
+                }
+            }
+        }
+        return result;
+    }
+}

package/esm/src/resources/clubs.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Clubs resource
+ */
+import type { StravaClient } from "../client.js";
+import type { ClubActivity, DetailedClub, SummaryAthlete, SummaryClub } from "../types/api.js";
+/**
+ * Resource for interacting with Strava clubs
+ */
+export declare class ClubsResource {
+    private client;
+    constructor(client: StravaClient);
+    /**
+     * Get club by ID
+     */
+    getById(id: number): Promise<DetailedClub>;
+    /**
+     * List athlete clubs
+     */
+    list(options?: {
+        page?: number;
+        perPage?: number;
+    }): Promise<SummaryClub[]>;
+    /**
+     * Get club members
+     */
+    getMembers(id: number, options?: {
+        page?: number;
+        perPage?: number;
+    }): Promise<SummaryAthlete[]>;
+    /**
+     * Get club activities
+     */
+    getActivities(id: number, options?: {
+        page?: number;
+        perPage?: number;
+    }): Promise<ClubActivity[]>;
+    /**
+     * Get club admins
+     */
+    getAdmins(id: number, options?: {
+        page?: number;
+        perPage?: number;
+    }): Promise<SummaryAthlete[]>;
+}
+//# sourceMappingURL=clubs.d.ts.map

package/esm/src/resources/clubs.js

@@ -0,0 +1,71 @@
+/**
+ * Clubs resource
+ */
+import { validatePositiveInteger } from "../utils/validators.js";
+import { buildPaginationQuery } from "../utils/pagination.js";
+/**
+ * Resource for interacting with Strava clubs
+ */
+export class ClubsResource {
+    constructor(client) {
+        Object.defineProperty(this, "client", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: client
+        });
+    }
+    /**
+     * Get club by ID
+     */
+    async getById(id) {
+        validatePositiveInteger(id, "id");
+        return await this.client.request({
+            method: "GET",
+            path: `/clubs/${id}`,
+        });
+    }
+    /**
+     * List athlete clubs
+     */
+    async list(options) {
+        return await this.client.request({
+            method: "GET",
+            path: "/athlete/clubs",
+            query: buildPaginationQuery(options),
+        });
+    }
+    /**
+     * Get club members
+     */
+    async getMembers(id, options) {
+        validatePositiveInteger(id, "id");
+        return await this.client.request({
+            method: "GET",
+            path: `/clubs/${id}/members`,
+            query: buildPaginationQuery(options),
+        });
+    }
+    /**
+     * Get club activities
+     */
+    async getActivities(id, options) {
+        validatePositiveInteger(id, "id");
+        return await this.client.request({
+            method: "GET",
+            path: `/clubs/${id}/activities`,
+            query: buildPaginationQuery(options),
+        });
+    }
+    /**
+     * Get club admins
+     */
+    async getAdmins(id, options) {
+        validatePositiveInteger(id, "id");
+        return await this.client.request({
+            method: "GET",
+            path: `/clubs/${id}/admins`,
+            query: buildPaginationQuery(options),
+        });
+    }
+}

package/esm/src/resources/gears.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Gears resource
+ */
+import type { StravaClient } from "../client.js";
+import type { DetailedGear } from "../types/api.js";
+/**
+ * Resource for interacting with Strava gear
+ */
+export declare class GearsResource {
+    private client;
+    constructor(client: StravaClient);
+    /**
+     * Get gear by ID
+     */
+    getById(id: string): Promise<DetailedGear>;
+}
+//# sourceMappingURL=gears.d.ts.map

package/esm/src/resources/gears.js

@@ -0,0 +1,27 @@
+/**
+ * Gears resource
+ */
+import { validateNonEmptyString } from "../utils/validators.js";
+/**
+ * Resource for interacting with Strava gear
+ */
+export class GearsResource {
+    constructor(client) {
+        Object.defineProperty(this, "client", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: client
+        });
+    }
+    /**
+     * Get gear by ID
+     */
+    async getById(id) {
+        validateNonEmptyString(id, "id");
+        return await this.client.request({
+            method: "GET",
+            path: `/gear/${id}`,
+        });
+    }
+}

package/esm/src/resources/routes.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Routes resource
+ */
+import type { StravaClient } from "../client.js";
+import type { Route } from "../types/api.js";
+/**
+ * Resource for interacting with Strava routes
+ */
+export declare class RoutesResource {
+    private client;
+    constructor(client: StravaClient);
+    /**
+     * Get route by ID
+     */
+    getById(id: number): Promise<Route>;
+    /**
+     * List athlete routes
+     */
+    list(options?: {
+        page?: number;
+        perPage?: number;
+    }): Promise<Route[]>;
+    /**
+     * Download route as GPX
+     */
+    downloadAsGPX(id: number): Promise<string>;
+    /**
+     * Download route as TCX
+     */
+    downloadAsTCX(id: number): Promise<string>;
+    private getAccessToken;
+}
+//# sourceMappingURL=routes.d.ts.map

package/esm/src/resources/routes.js

@@ -0,0 +1,71 @@
+/**
+ * Routes resource
+ */
+import { validatePositiveInteger } from "../utils/validators.js";
+import { buildPaginationQuery } from "../utils/pagination.js";
+/**
+ * Resource for interacting with Strava routes
+ */
+export class RoutesResource {
+    constructor(client) {
+        Object.defineProperty(this, "client", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: client
+        });
+    }
+    /**
+     * Get route by ID
+     */
+    async getById(id) {
+        validatePositiveInteger(id, "id");
+        return await this.client.request({
+            method: "GET",
+            path: `/routes/${id}`,
+        });
+    }
+    /**
+     * List athlete routes
+     */
+    async list(options) {
+        return await this.client.request({
+            method: "GET",
+            path: "/athlete/routes",
+            query: buildPaginationQuery(options),
+        });
+    }
+    /**
+     * Download route as GPX
+     */
+    async downloadAsGPX(id) {
+        validatePositiveInteger(id, "id");
+        const response = await fetch(`https://www.strava.com/api/v3/routes/${id}/export_gpx`, {
+            headers: {
+                "Authorization": `Bearer ${await this.getAccessToken()}`,
+            },
+        });
+        if (!response.ok) {
+            throw new Error(`Failed to download GPX: ${response.statusText}`);
+        }
+        return response.text();
+    }
+    /**
+     * Download route as TCX
+     */
+    async downloadAsTCX(id) {
+        validatePositiveInteger(id, "id");
+        const response = await fetch(`https://www.strava.com/api/v3/routes/${id}/export_tcx`, {
+            headers: {
+                "Authorization": `Bearer ${await this.getAccessToken()}`,
+            },
+        });
+        if (!response.ok) {
+            throw new Error(`Failed to download TCX: ${response.statusText}`);
+        }
+        return response.text();
+    }
+    async getAccessToken() {
+        return await this.client.getAccessToken();
+    }
+}

package/esm/src/resources/segment-efforts.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Segment efforts resource
+ */
+import type { StravaClient } from "../client.js";
+import type { DetailedSegmentEffort, SummarySegmentEffort } from "../types/api.js";
+/**
+ * Options for listing segment efforts
+ */
+export interface ListSegmentEffortsOptions {
+    /** Filter by segment ID */
+    segmentId?: number;
+    /** Filter by athlete ID */
+    athleteId?: number;
+    /** Start date in ISO 8601 format */
+    startDateLocal?: string;
+    /** End date in ISO 8601 format */
+    endDateLocal?: string;
+    /** Page number (default: 1) */
+    page?: number;
+    /** Number of items per page (default: 30, max: 200) */
+    perPage?: number;
+}
+/**
+ * Resource for interacting with Strava segment efforts
+ */
+export declare class SegmentEffortsResource {
+    private client;
+    constructor(client: StravaClient);
+    /**
+     * Get segment effort by ID
+     */
+    getById(id: number): Promise<DetailedSegmentEffort>;
+    /**
+     * List segment efforts
+     */
+    list(options?: ListSegmentEffortsOptions): Promise<SummarySegmentEffort[]>;
+}
+//# sourceMappingURL=segment-efforts.d.ts.map

package/esm/src/resources/segment-efforts.js

@@ -0,0 +1,53 @@
+/**
+ * Segment efforts resource
+ */
+import { validatePositiveInteger } from "../utils/validators.js";
+import { buildPaginationQuery } from "../utils/pagination.js";
+/**
+ * Resource for interacting with Strava segment efforts
+ */
+export class SegmentEffortsResource {
+    constructor(client) {
+        Object.defineProperty(this, "client", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: client
+        });
+    }
+    /**
+     * Get segment effort by ID
+     */
+    async getById(id) {
+        validatePositiveInteger(id, "id");
+        return await this.client.request({
+            method: "GET",
+            path: `/segment_efforts/${id}`,
+        });
+    }
+    /**
+     * List segment efforts
+     */
+    async list(options) {
+        const query = {
+            ...buildPaginationQuery(options),
+        };
+        if (options?.segmentId) {
+            query.segment_id = options.segmentId;
+        }
+        if (options?.athleteId) {
+            query.athlete_id = options.athleteId;
+        }
+        if (options?.startDateLocal) {
+            query.start_date_local = options.startDateLocal;
+        }
+        if (options?.endDateLocal) {
+            query.end_date_local = options.endDateLocal;
+        }
+        return await this.client.request({
+            method: "GET",
+            path: "/segment_efforts",
+            query,
+        });
+    }
+}