@pinta365/strava 0.0.1

package/esm/deps/jsr.io/@cross/runtime/1.2.1/mod.js

@@ -0,0 +1,480 @@
+// deno-lint-ignore-file no-process-global
+/* Private functions */
+import * as dntShim from "../../../../../_dnt.shims.js";
+function getChromeVersion(userAgent) {
+    const match = userAgent.match(/Chrom(e|ium)\/([0-9]+)\./);
+    return match ? match[2] : "Unknown";
+}
+function getFirefoxVersion(userAgent) {
+    const match = userAgent.match(/Firefox\/([0-9]+)\./);
+    return match ? match[1] : "Unknown";
+}
+function getEdgeVersion(userAgent) {
+    const match = userAgent.match(/Edg\/([0-9]+)\./);
+    return match ? match[1] : "Unknown";
+}
+function getSafariVersion(userAgent) {
+    const match = userAgent.match(/Version\/([0-9]+)\.([0-9]+)(\.[0-9]+)?/);
+    if (match)
+        return `${match[1]}.${match[2]}`;
+    return "Unknown";
+}
+function getOperaVersion(userAgent) {
+    // Look for either 'Opera/' or 'OPR/' followed by the version
+    const match = userAgent.match(/(Opera|OPR)\/([0-9]+)\./);
+    return match ? match[2] : "Unknown";
+}
+function getBraveVersion(userAgent) {
+    const match = userAgent.match(/Chrom(e|ium)\/([0-9]+)\./);
+    return match ? match[2] : "Unknown";
+}
+/**
+ * Enum of supported Runtimes.
+ * @enum {string}
+ */
+export var Runtime;
+(function (Runtime) {
+    Runtime["Deno"] = "deno";
+    Runtime["Bun"] = "bun";
+    Runtime["Node"] = "node";
+    Runtime["Browser"] = "browser";
+    Runtime["Tauri"] = "tauri";
+    Runtime["Workerd"] = "workerd";
+    Runtime["Netlify"] = "netlify";
+    Runtime["EdgeLight"] = "edgelight";
+    Runtime["Fastly"] = "fastly";
+    Runtime["Unsupported"] = "unsupported";
+})(Runtime || (Runtime = {}));
+/**
+ * Enum of supported Operating Systems.
+ * @enum {string}
+ */
+export var OperatingSystem;
+(function (OperatingSystem) {
+    OperatingSystem["Windows"] = "windows";
+    OperatingSystem["macOS"] = "macos";
+    OperatingSystem["Linux"] = "linux";
+    OperatingSystem["Android"] = "android";
+    OperatingSystem["Unix"] = "unix";
+    OperatingSystem["iOS"] = "ios";
+    OperatingSystem["Unsupported"] = "unsupported";
+})(OperatingSystem || (OperatingSystem = {}));
+/**
+ * Enum of supported Products.
+ * @enum {string}
+ */
+export var Product;
+(function (Product) {
+    // All runtimes
+    Product["Deno"] = "deno";
+    Product["Bun"] = "bun";
+    Product["Node"] = "node";
+    Product["Tauri"] = "tauri";
+    Product["Workerd"] = "workerd";
+    Product["Netlify"] = "netlify";
+    Product["EdgeLight"] = "edgelight";
+    Product["Fastly"] = "fastly";
+    // All browsers
+    Product["Firefox"] = "firefox";
+    Product["Safari"] = "safari";
+    Product["Chrome"] = "chrome";
+    Product["Edge"] = "edge";
+    Product["Opera"] = "opera";
+    Product["Brave"] = "brave";
+    // And unsupported
+    Product["Unsupported"] = "unsupported";
+})(Product || (Product = {}));
+/**
+ * Enum of common CPU architectures.
+ * @enum {string}
+ */
+export var Architecture;
+(function (Architecture) {
+    Architecture["x86"] = "x86";
+    Architecture["x64"] = "x86_64";
+    Architecture["arm"] = "arm";
+    Architecture["arm64"] = "arm64";
+    Architecture["Unsupported"] = "unsupported";
+})(Architecture || (Architecture = {}));
+///**
+// * Interface for Tauri-specific information.
+// */
+//export interface TauriInfo {
+//  /** The application version, as defined in `tauri.conf.json`. */
+//  version?: string;
+//  /** The application name, as defined in `tauri.conf.json`. */
+//  name?: string;
+//  /** The application's bundle identifier, as defined in `tauri.conf.json`. */
+//  identifier?: string;
+//  /** The version of the underlying Tauri runtime. */
+//  tauriVersion?: string;
+//}
+/**
+ * Verifies if a property exists in the global namespace and optionally checks its type.
+ *
+ * @param {string} name - The name of the property to verify.
+ * @param {string} [typeString] - The expected type of the property (optional).
+ * @returns {boolean} True if the property exists and matches the type (if provided), False otherwise.
+ */
+function verifyGlobal(name, typeString) {
+    return name in dntShim.dntGlobalThis && (!typeString || typeof dntShim.dntGlobalThis[name] === typeString);
+}
+// Disable getTauriInfo() while I figure some things out.
+///**
+// * Gets Tauri-specific information asynchronously.
+// * Only works when running in a Tauri application.
+// * @returns {Promise<TauriInfo>} Tauri-specific data
+// */
+//export async function getTauriInfo(): Promise<TauriInfo> {
+//  if (getCurrentRuntime() !== Runtime.Tauri) {
+//    return {};
+//  }
+//
+//  try {
+//    const { getVersion, getName, getIdentifier, getTauriVersion } = await import("@tauri-apps/api/app");
+//
+//    const [version, name, identifier, tauriVersion] = await Promise.all([
+//      getVersion().catch(() => undefined),
+//      getName().catch(() => undefined),
+//      getIdentifier().catch(() => undefined),
+//      getTauriVersion().catch(() => undefined),
+//    ]);
+//
+//    return { version, name, identifier, tauriVersion };
+//  } catch (_e) {
+//    return {};
+//  }
+//}
+/**
+ * Dynamically determines the current runtime environment.
+ */
+export function getCurrentRuntime() {
+    if (verifyGlobal("Deno", "object"))
+        return Runtime.Deno;
+    if (verifyGlobal("Bun", "object"))
+        return Runtime.Bun;
+    if (verifyGlobal("Netlify", "object"))
+        return Runtime.Netlify;
+    if (verifyGlobal("EdgeRuntime", "string"))
+        return Runtime.EdgeLight;
+    if (globalThis.navigator?.userAgent === "Cloudflare-Workers")
+        return Runtime.Workerd;
+    if (verifyGlobal("fastly", "object"))
+        return Runtime.Fastly;
+    if (verifyGlobal("process", "object") &&
+        //@ts-ignore Runtime detection
+        typeof process.versions !== "undefined" &&
+        //@ts-ignore Runtime detection
+        typeof process.versions.node !== "undefined") {
+        return Runtime.Node;
+    }
+    if (verifyGlobal("window", "object")) { // Check for Browser or Tauri
+        // Check for Tauri first (Tauri runs in a webview, so it has window)
+        if (verifyGlobal("__TAURI__", "object"))
+            return Runtime.Tauri;
+        return Runtime.Browser;
+    }
+    return Runtime.Unsupported;
+}
+/**
+ * Dynamically determines the current operating system.
+ */
+export function getCurrentOS() {
+    const runtime = getCurrentRuntime();
+    switch (runtime) {
+        case Runtime.Deno:
+            switch (Deno.build.os) {
+                case "darwin":
+                    return OperatingSystem.macOS;
+                case "windows":
+                    return OperatingSystem.Windows;
+                case "linux":
+                    return OperatingSystem.Linux;
+                case "android":
+                    return OperatingSystem.Android;
+                case "aix":
+                case "freebsd":
+                case "illumos":
+                case "netbsd":
+                case "solaris":
+                    return OperatingSystem.Unix;
+            }
+            return OperatingSystem.Unsupported;
+        case Runtime.Node:
+            // @ts-ignore Cross Runtime
+            switch (process.platform) {
+                case "darwin":
+                    return OperatingSystem.macOS;
+                case "win32":
+                    return OperatingSystem.Windows;
+                case "linux":
+                    return OperatingSystem.Linux;
+                case "android":
+                    return OperatingSystem.Android;
+                case "aix":
+                case "freebsd":
+                case "openbsd":
+                case "sunos":
+                    return OperatingSystem.Unix;
+            }
+            return OperatingSystem.Unsupported;
+        case Runtime.Bun:
+            // @ts-ignore Cross Runtime
+            switch (process.platform) {
+                case "darwin":
+                    return OperatingSystem.macOS;
+                case "win32":
+                    return OperatingSystem.Windows;
+                case "linux":
+                    return OperatingSystem.Linux;
+                case "android":
+                    return OperatingSystem.Android;
+                case "aix":
+                case "freebsd":
+                case "openbsd":
+                case "sunos":
+                    return OperatingSystem.Unix;
+            }
+            return OperatingSystem.Unsupported;
+        case Runtime.Tauri:
+        case Runtime.Browser: {
+            if ("userAgent" in navigator) {
+                const userAgent = navigator.userAgent;
+                return getOSFromUserAgent(userAgent);
+            }
+        }
+    }
+    return OperatingSystem.Unsupported;
+}
+/**
+ * Determine operating system from user agent string, if possible
+ */
+export function getOSFromUserAgent(userAgent) {
+    if (userAgent.indexOf("Win") !== -1)
+        return OperatingSystem.Windows;
+    if (userAgent.indexOf("like Mac") !== -1)
+        return OperatingSystem.iOS;
+    if (userAgent.indexOf("Mac") !== -1)
+        return OperatingSystem.macOS;
+    if (userAgent.indexOf("Android") !== -1)
+        return OperatingSystem.Android;
+    if (userAgent.indexOf("X11") !== -1 || userAgent.indexOf("Linux") !== -1)
+        return OperatingSystem.Linux;
+    return OperatingSystem.Unsupported;
+}
+/**
+ * Dynamically determines the current browser and its version (if applicable).
+ */
+export function getCurrentProduct() {
+    const runtime = getCurrentRuntime();
+    switch (runtime) {
+        case Runtime.Deno:
+            return Product.Deno;
+        case Runtime.Node:
+            return Product.Node;
+        case Runtime.Bun:
+            return Product.Bun;
+        case Runtime.Tauri:
+            return Product.Tauri;
+        case Runtime.Workerd:
+            return Product.Workerd;
+        case Runtime.Netlify:
+            return Product.Netlify;
+        case Runtime.EdgeLight:
+            return Product.EdgeLight;
+        case Runtime.Fastly:
+            return Product.Fastly;
+        case Runtime.Browser: {
+            // Brave can not be detected from user agent string, handle separately
+            if (verifyGlobal("brave") && "brave" in navigator)
+                return Product.Brave;
+            // For browser, get the specific browser
+            const userAgent = navigator.userAgent;
+            return getProductFromUserAgent(userAgent);
+        }
+        default:
+            return Product.Unsupported;
+    }
+}
+/**
+ * Determines the product from a user agent string, if possible
+ */
+export function getProductFromUserAgent(userAgent) {
+    if (userAgent.indexOf("Opera") !== -1 || userAgent.indexOf("OPR") !== -1)
+        return Product.Opera;
+    if (userAgent.indexOf("Safari") !== -1 && userAgent.indexOf("Chrome") === -1)
+        return Product.Safari;
+    if (userAgent.indexOf("Edg") !== -1)
+        return Product.Edge;
+    if (userAgent.indexOf("Chrome") !== -1)
+        return Product.Chrome;
+    if (userAgent.indexOf("Firefox") !== -1)
+        return Product.Firefox;
+    return Product.Unsupported;
+}
+/**
+ * Dynamically determines the version of the current product/runtime
+ * @returns {string} A string containing the detected version, or undefined if the product is not supported.
+ */
+export function getCurrentVersion() {
+    const product = getCurrentProduct();
+    switch (product) {
+        case Product.Deno:
+            // @ts-ignore Runtime detection
+            return Deno.version.deno;
+        case Product.Node:
+            // @ts-ignore Runtime detection
+            return process.versions.node;
+        case Product.Bun:
+            // @ts-ignore Runtime detection
+            return process.versions.bun;
+        case Product.Tauri: //Fallthrough to default handling.
+        default: {
+            const userAgent = globalThis.navigator?.userAgent;
+            return getVersionFromUserAgent(userAgent);
+        }
+    }
+}
+/**
+ * Determines the product version from a user agent string, if possible
+ */
+export function getVersionFromUserAgent(userAgent) {
+    const product = getProductFromUserAgent(userAgent);
+    switch (product) {
+        case Product.Chrome:
+            return getChromeVersion(userAgent);
+        case Product.Firefox:
+            return getFirefoxVersion(userAgent);
+        case Product.Edge:
+            return getEdgeVersion(userAgent);
+        case Product.Safari:
+            return getSafariVersion(userAgent);
+        case Product.Opera:
+            return getOperaVersion(userAgent);
+        case Product.Brave:
+            return getBraveVersion(userAgent);
+        default:
+            return undefined;
+    }
+}
+/**
+ * Attempts to determine the current CPU architecture of the runtime's environment.
+ */
+export function getCurrentArchitecture() {
+    const runtime = getCurrentRuntime();
+    switch (runtime) {
+        case Runtime.Deno:
+            if (Deno.build.arch === "x86_64")
+                return Architecture.x64;
+            if (Deno.build.arch === "aarch64")
+                return Architecture.arm64;
+            if (Deno.build.os === "darwin")
+                return Architecture.x64;
+            return Architecture.x86;
+        case Runtime.Bun:
+        case Runtime.Node:
+            // @ts-ignore Cross Runtime
+            switch (process.arch) {
+                case "arm":
+                    return Architecture.arm;
+                case "arm64":
+                    return Architecture.arm64;
+                case "ia32":
+                    return Architecture.x86;
+                case "x64":
+                    return Architecture.x64;
+                case "loong64":
+                case "mips":
+                case "mipsel":
+                case "ppc":
+                case "ppc64":
+                case "riscv64":
+                case "s390":
+                case "s390x":
+                    return Architecture.Unsupported;
+            }
+            return Architecture.Unsupported;
+        case Runtime.Tauri:
+        case Runtime.Browser: {
+            const userAgent = navigator.userAgent;
+            // @ts-ignore Cross Runtime
+            const platform = navigator.platform;
+            if (platform.indexOf("Win64") !== -1 || platform.indexOf("x64") !== -1 || platform.indexOf("x86_64") !== -1)
+                return Architecture.x64;
+            if (platform.indexOf("Win32") !== -1 || (platform.indexOf("x86") !== -1 && platform.indexOf("x86_64") === -1))
+                return Architecture.x86;
+            if (userAgent.indexOf("Win64") !== -1 || userAgent.indexOf("x64") !== -1 || userAgent.indexOf("x86_64") !== -1)
+                return Architecture.x64;
+            if (userAgent.indexOf("Win32") !== -1 || (userAgent.indexOf("x86") !== -1 && userAgent.indexOf("x86_64") === -1))
+                return Architecture.x86;
+            if (userAgent.indexOf("arm64") !== -1)
+                return Architecture.arm64;
+            if (userAgent.indexOf("arm") !== -1) {
+                return Architecture.arm;
+            }
+            // @ts-ignore Cross Runtime
+            if (platform.indexOf("iPhone") || platform.indexOf("iPad") || (userAgent.indexOf("Mac") !== -1 && "ontouchend" in document)) {
+                // Likely aarch64 on newer iOS devices and Apple Silicon Macs
+                return Architecture.arm64;
+            }
+            return Architecture.Unsupported;
+        }
+    }
+    return Architecture.Unsupported;
+}
+/**
+ * Retrieves the current system information.
+ * @returns {SystemInfo} An object containing the system information.
+ */
+function getSystemInfoInternal() {
+    const systemInfo = {
+        runtime: CurrentRuntime,
+        product: CurrentProduct,
+        version: CurrentVersion,
+        os: CurrentOS,
+        architecture: CurrentArchitecture,
+    };
+    return systemInfo;
+}
+/**
+ * Logs current system information to the console.
+ *
+ * @param {boolean} [useTable=false] - If true, formats the output as a table.
+ */
+export function dumpSystemInfo(useTable = false) {
+    const systemInfo = getSystemInfoInternal();
+    if (useTable) {
+        console.table(systemInfo);
+    }
+    else {
+        console.log(JSON.stringify(systemInfo, null, 2));
+    }
+}
+/**
+ * Gets the current system information as a formatted JSON string.
+ * @returns {string}
+ */
+export function getSystemInfo() {
+    const systemInfo = getSystemInfoInternal();
+    return JSON.stringify(systemInfo);
+}
+/**
+ * Static variable containing the current runtime.
+ */
+export const CurrentRuntime = getCurrentRuntime();
+/**
+ * Static variable containing the current product.
+ */
+export const CurrentProduct = getCurrentProduct();
+/**
+ * Static variable containing the current product/runtime version.
+ */
+export const CurrentVersion = getCurrentVersion();
+/**
+ * Static variable containing the current operating system.
+ */
+export const CurrentOS = getCurrentOS();
+/**
+ * Static variable containing the current operating system.
+ */
+export const CurrentArchitecture = getCurrentArchitecture();

package/esm/mod.d.ts

@@ -0,0 +1,27 @@
+/**
+ * @pinta365/strava - TypeScript client for Strava API v3
+ *
+ * A cross-runtime (Deno, Node.js, Bun, Browser) library for interacting with the Strava API.
+ */
+export { StravaClient } from "./src/client.js";
+export type { AuthCredentials, ClientOptions } from "./src/client.js";
+export { StravaAuthError, StravaError, StravaNotFoundError, StravaRateLimitError, StravaServerError, StravaValidationError } from "./src/errors.js";
+export { exchangeCode, getAuthorizationUrl, OAuthManager, refreshAccessToken } from "./src/auth/oauth.js";
+export { formatScopes, hasAllScopes, hasScope, parseScopes, StravaScope, validateScopes } from "./src/auth/scopes.js";
+export type { TokenData, TokenStore } from "./src/auth/token-store.js";
+export { FileSystemTokenStore, getDefaultTokenStore, LocalStorageTokenStore, MemoryTokenStore } from "./src/auth/token-store.js";
+export type { PaginationOptions, RateLimitInfo, RateLimitStrategy, RequestConfig, RetryConfig } from "./src/types/common.js";
+export type { Activity, ActivityStats, ActivityTotal, ActivityType, ActivityZone, Athlete, Club, Comment, DetailedActivity, DetailedAthlete, DetailedClub, DetailedGear, DetailedSegment, DetailedSegmentEffort, ExplorerResponse, ExplorerSegment, Gear, Lap, LatLng, PhotosSummary, PolylineMap, Route, Segment, SegmentEffort, Split, SportType, StreamSet, SummaryActivity, SummaryAthlete, SummaryClub, SummaryGear, SummaryPRSegmentEffort, SummarySegment, SummarySegmentEffort, UpdatableActivity, Upload, Waypoint, Zones, } from "./src/types/api.js";
+export { AthletesResource } from "./src/resources/athletes.js";
+export { ActivitiesResource } from "./src/resources/activities.js";
+export { SegmentsResource } from "./src/resources/segments.js";
+export { SegmentEffortsResource } from "./src/resources/segment-efforts.js";
+export { ClubsResource } from "./src/resources/clubs.js";
+export { GearsResource } from "./src/resources/gears.js";
+export { RoutesResource } from "./src/resources/routes.js";
+export { UploadsResource } from "./src/resources/uploads.js";
+export { StreamsResource } from "./src/resources/streams.js";
+export { buildPaginationQuery, listAll, PaginatedIterator } from "./src/utils/pagination.js";
+export { addComputedFields, applyTransformations, flattenResponses, transformDates } from "./src/utils/transformers.js";
+export { validateDate, validateNonEmptyString, validateNonNegativeInteger, validatePagination, validatePositiveInteger, validateRange, } from "./src/utils/validators.js";
+//# sourceMappingURL=mod.d.ts.map

package/esm/mod.js

@@ -0,0 +1,27 @@
+/**
+ * @pinta365/strava - TypeScript client for Strava API v3
+ *
+ * A cross-runtime (Deno, Node.js, Bun, Browser) library for interacting with the Strava API.
+ */
+// Main client
+export { StravaClient } from "./src/client.js";
+// Error classes
+export { StravaAuthError, StravaError, StravaNotFoundError, StravaRateLimitError, StravaServerError, StravaValidationError } from "./src/errors.js";
+// Auth
+export { exchangeCode, getAuthorizationUrl, OAuthManager, refreshAccessToken } from "./src/auth/oauth.js";
+export { formatScopes, hasAllScopes, hasScope, parseScopes, StravaScope, validateScopes } from "./src/auth/scopes.js";
+export { FileSystemTokenStore, getDefaultTokenStore, LocalStorageTokenStore, MemoryTokenStore } from "./src/auth/token-store.js";
+// Resources (for advanced usage)
+export { AthletesResource } from "./src/resources/athletes.js";
+export { ActivitiesResource } from "./src/resources/activities.js";
+export { SegmentsResource } from "./src/resources/segments.js";
+export { SegmentEffortsResource } from "./src/resources/segment-efforts.js";
+export { ClubsResource } from "./src/resources/clubs.js";
+export { GearsResource } from "./src/resources/gears.js";
+export { RoutesResource } from "./src/resources/routes.js";
+export { UploadsResource } from "./src/resources/uploads.js";
+export { StreamsResource } from "./src/resources/streams.js";
+// Utilities
+export { buildPaginationQuery, listAll, PaginatedIterator } from "./src/utils/pagination.js";
+export { addComputedFields, applyTransformations, flattenResponses, transformDates } from "./src/utils/transformers.js";
+export { validateDate, validateNonEmptyString, validateNonNegativeInteger, validatePagination, validatePositiveInteger, validateRange, } from "./src/utils/validators.js";

package/esm/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "module"
+}

package/esm/src/auth/oauth.d.ts

@@ -0,0 +1,68 @@
+/**
+ * OAuth 2.0 authentication flow for Strava API
+ */
+import type { TokenData, TokenStore } from "./token-store.js";
+import { type StravaScope } from "./scopes.js";
+interface AuthorizationUrlOptions {
+    clientId: string;
+    redirectUri: string;
+    scope: StravaScope[];
+    state?: string;
+    approvalPrompt?: "force" | "auto";
+}
+/**
+ * Generate authorization URL
+ */
+export declare function getAuthorizationUrl(options: AuthorizationUrlOptions): string;
+/**
+ * Exchange authorization code for tokens
+ * @param code - Authorization code from OAuth callback
+ * @param clientId - Strava client ID
+ * @param clientSecret - Strava client secret
+ * @param redirectUri - Redirect URI used in authorization (optional)
+ * @returns Token data
+ */
+export declare function exchangeCode(code: string, clientId: string, clientSecret: string, redirectUri?: string): Promise<TokenData>;
+/**
+ * Refresh access token using refresh token
+ */
+export declare function refreshAccessToken(refreshToken: string, clientId: string, clientSecret: string): Promise<TokenData>;
+/**
+ * Check if token is expired or about to expire
+ */
+export declare function isTokenExpired(token: TokenData, bufferSeconds?: number): boolean;
+/**
+ * OAuth manager for handling authentication and token refresh
+ */
+export declare class OAuthManager {
+    private tokenStore;
+    private clientId;
+    private clientSecret;
+    constructor(clientId: string, clientSecret: string, tokenStore: TokenStore);
+    /**
+     * Get authorization URL
+     */
+    getAuthorizationUrl(options: Omit<AuthorizationUrlOptions, "clientId">): string;
+    /**
+     * Exchange code and store tokens
+     */
+    authenticate(code: string, redirectUri?: string): Promise<TokenData>;
+    /**
+     * Get current token, refreshing if needed
+     */
+    getToken(): Promise<TokenData | null>;
+    /**
+     * Manually refresh token
+     */
+    refreshToken(): Promise<TokenData>;
+    /**
+     * Get current scopes
+     */
+    getScopes(): Promise<StravaScope[]>;
+    /**
+     * Clear stored tokens
+     */
+    clearTokens(): Promise<void>;
+}
+export {};
+//# sourceMappingURL=oauth.d.ts.map