@pinta365/strava 0.0.1

package/script/src/resources/activities.d.ts

@@ -0,0 +1,149 @@
+/**
+ * Activities resource
+ */
+import type { StravaClient } from "../client.js";
+import type { ActivityZone, Comment, DetailedActivity, DetailedSegmentEffort, Lap, StreamSet, SummaryActivity, SummaryAthlete } from "../types/api.js";
+import type { StreamType } from "./streams.js";
+/**
+ * Options for listing activities
+ */
+export interface ListActivitiesOptions {
+    /** Unix timestamp for activities before this time */
+    before?: number;
+    /** Unix timestamp for activities after this time */
+    after?: number;
+    /** Page number (default: 1) */
+    page?: number;
+    /** Number of items per page (default: 30, max: 200) */
+    perPage?: number;
+}
+/**
+ * Data for creating a new activity
+ */
+export interface CreateActivityData {
+    /** Activity name */
+    name: string;
+    /** Activity type (e.g., "Run", "Ride") */
+    type: string;
+    /** Start date in ISO 8601 format */
+    startDateLocal: string;
+    /** Elapsed time in seconds */
+    elapsedTime: number;
+    /** Activity description */
+    description?: string;
+    /** Distance in meters */
+    distance?: number;
+    /** Whether activity was done on trainer */
+    trainer?: boolean;
+    /** Whether activity is a commute */
+    commute?: boolean;
+}
+/**
+ * Data for updating an existing activity
+ */
+export interface UpdateActivityData {
+    /** Activity name */
+    name?: string;
+    /** Activity type (e.g., "Run", "Ride") */
+    type?: string;
+    /** Sport type */
+    sportType?: string;
+    /** Start date in ISO 8601 format */
+    startDateLocal?: string;
+    /** Elapsed time in seconds */
+    elapsedTime?: number;
+    /** Activity description */
+    description?: string;
+    /** Distance in meters */
+    distance?: number;
+    /** Whether activity was done on trainer */
+    trainer?: boolean;
+    /** Whether activity is a commute */
+    commute?: boolean;
+    /** Gear ID */
+    gearId?: string;
+}
+/**
+ * Resource for interacting with Strava activities
+ */
+export declare class ActivitiesResource {
+    private client;
+    constructor(client: StravaClient);
+    /**
+     * Get activity by ID
+     */
+    getById(id: number): Promise<DetailedActivity>;
+    /**
+     * List athlete activities
+     */
+    list(options?: ListActivitiesOptions): Promise<SummaryActivity[]>;
+    /**
+     * List all activities (auto-pagination)
+     */
+    listAll(options?: Omit<ListActivitiesOptions, "page">): AsyncGenerator<SummaryActivity, void, unknown>;
+    /**
+     * Create activity
+     */
+    create(data: CreateActivityData): Promise<DetailedActivity>;
+    /**
+     * Update activity
+     */
+    update(id: number, data: UpdateActivityData): Promise<DetailedActivity>;
+    /**
+     * Delete activity
+     */
+    delete(id: number): Promise<void>;
+    /**
+     * Get activity with details (combines activity + laps + zones + comments + kudoers)
+     */
+    getWithDetails(id: number): Promise<DetailedActivity & {
+        laps: Lap[];
+        zones: ActivityZone[];
+        comments: Comment[];
+        kudoers: SummaryAthlete[];
+    }>;
+    /**
+     * Get activity laps
+     */
+    getLaps(id: number): Promise<Lap[]>;
+    /**
+     * Get activity zones
+     */
+    getZones(id: number): Promise<ActivityZone[]>;
+    /**
+     * Get activity comments
+     */
+    getComments(id: number, options?: {
+        page?: number;
+        perPage?: number;
+    }): Promise<Comment[]>;
+    /**
+     * Get activity kudoers
+     */
+    getKudoers(id: number, options?: {
+        page?: number;
+        perPage?: number;
+    }): Promise<SummaryAthlete[]>;
+    /**
+     * Analyze activity with comprehensive data
+     * Combines activity, zones, laps, best efforts (segments), and optionally streams
+     */
+    analyze(id: number, options?: {
+        includeStreams?: boolean;
+        streamTypes?: StreamType[];
+    }): Promise<DetailedActivity & {
+        zones: ActivityZone[];
+        laps: Lap[];
+        bestEfforts: DetailedSegmentEffort[];
+        streams?: StreamSet;
+        analysis: {
+            hasPowerData: boolean;
+            hasHeartRateData: boolean;
+            totalLaps: number;
+            bestEffortCount: number;
+            averageLapTime?: number;
+            averageLapDistance?: number;
+        };
+    }>;
+}
+//# sourceMappingURL=activities.d.ts.map

package/script/src/resources/activities.js

@@ -0,0 +1,193 @@
+"use strict";
+/**
+ * Activities resource
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ActivitiesResource = void 0;
+const pagination_js_1 = require("../utils/pagination.js");
+const validators_js_1 = require("../utils/validators.js");
+const pagination_js_2 = require("../utils/pagination.js");
+/**
+ * Resource for interacting with Strava activities
+ */
+class ActivitiesResource {
+    constructor(client) {
+        Object.defineProperty(this, "client", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: client
+        });
+    }
+    /**
+     * Get activity by ID
+     */
+    async getById(id) {
+        (0, validators_js_1.validatePositiveInteger)(id, "id");
+        return await this.client.request({
+            method: "GET",
+            path: `/activities/${id}`,
+        });
+    }
+    /**
+     * List athlete activities
+     */
+    async list(options) {
+        const query = {
+            ...(0, pagination_js_1.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* (0, pagination_js_2.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) {
+        (0, validators_js_1.validatePositiveInteger)(id, "id");
+        return await this.client.request({
+            method: "PUT",
+            path: `/activities/${id}`,
+            body: data,
+        });
+    }
+    /**
+     * Delete activity
+     */
+    async delete(id) {
+        (0, validators_js_1.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) {
+        (0, validators_js_1.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) {
+        (0, validators_js_1.validatePositiveInteger)(id, "id");
+        return await this.client.request({
+            method: "GET",
+            path: `/activities/${id}/laps`,
+        });
+    }
+    /**
+     * Get activity zones
+     */
+    async getZones(id) {
+        (0, validators_js_1.validatePositiveInteger)(id, "id");
+        return await this.client.request({
+            method: "GET",
+            path: `/activities/${id}/zones`,
+        });
+    }
+    /**
+     * Get activity comments
+     */
+    async getComments(id, options) {
+        (0, validators_js_1.validatePositiveInteger)(id, "id");
+        return await this.client.request({
+            method: "GET",
+            path: `/activities/${id}/comments`,
+            query: (0, pagination_js_1.buildPaginationQuery)(options),
+        });
+    }
+    /**
+     * Get activity kudoers
+     */
+    async getKudoers(id, options) {
+        (0, validators_js_1.validatePositiveInteger)(id, "id");
+        return await this.client.request({
+            method: "GET",
+            path: `/activities/${id}/kudoers`,
+            query: (0, pagination_js_1.buildPaginationQuery)(options),
+        });
+    }
+    /**
+     * Analyze activity with comprehensive data
+     * Combines activity, zones, laps, best efforts (segments), and optionally streams
+     */
+    async analyze(id, options) {
+        (0, validators_js_1.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;
+    }
+}
+exports.ActivitiesResource = ActivitiesResource;

package/script/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/script/src/resources/athletes.js

@@ -0,0 +1,89 @@
+"use strict";
+/**
+ * Athletes resource
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AthletesResource = void 0;
+const validators_js_1 = require("../utils/validators.js");
+/**
+ * Resource for interacting with Strava athletes
+ */
+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) {
+        (0, validators_js_1.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) {
+        (0, validators_js_1.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;
+    }
+}
+exports.AthletesResource = AthletesResource;

package/script/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/script/src/resources/clubs.js

@@ -0,0 +1,75 @@
+"use strict";
+/**
+ * Clubs resource
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClubsResource = void 0;
+const validators_js_1 = require("../utils/validators.js");
+const pagination_js_1 = require("../utils/pagination.js");
+/**
+ * Resource for interacting with Strava clubs
+ */
+class ClubsResource {
+    constructor(client) {
+        Object.defineProperty(this, "client", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: client
+        });
+    }
+    /**
+     * Get club by ID
+     */
+    async getById(id) {
+        (0, validators_js_1.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: (0, pagination_js_1.buildPaginationQuery)(options),
+        });
+    }
+    /**
+     * Get club members
+     */
+    async getMembers(id, options) {
+        (0, validators_js_1.validatePositiveInteger)(id, "id");
+        return await this.client.request({
+            method: "GET",
+            path: `/clubs/${id}/members`,
+            query: (0, pagination_js_1.buildPaginationQuery)(options),
+        });
+    }
+    /**
+     * Get club activities
+     */
+    async getActivities(id, options) {
+        (0, validators_js_1.validatePositiveInteger)(id, "id");
+        return await this.client.request({
+            method: "GET",
+            path: `/clubs/${id}/activities`,
+            query: (0, pagination_js_1.buildPaginationQuery)(options),
+        });
+    }
+    /**
+     * Get club admins
+     */
+    async getAdmins(id, options) {
+        (0, validators_js_1.validatePositiveInteger)(id, "id");
+        return await this.client.request({
+            method: "GET",
+            path: `/clubs/${id}/admins`,
+            query: (0, pagination_js_1.buildPaginationQuery)(options),
+        });
+    }
+}
+exports.ClubsResource = ClubsResource;

package/script/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/script/src/resources/gears.js

@@ -0,0 +1,31 @@
+"use strict";
+/**
+ * Gears resource
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GearsResource = void 0;
+const validators_js_1 = require("../utils/validators.js");
+/**
+ * Resource for interacting with Strava gear
+ */
+class GearsResource {
+    constructor(client) {
+        Object.defineProperty(this, "client", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: client
+        });
+    }
+    /**
+     * Get gear by ID
+     */
+    async getById(id) {
+        (0, validators_js_1.validateNonEmptyString)(id, "id");
+        return await this.client.request({
+            method: "GET",
+            path: `/gear/${id}`,
+        });
+    }
+}
+exports.GearsResource = GearsResource;

package/script/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