antarctic 0.2.0

package/dist/providers/bungie.d.ts

@@ -0,0 +1,17 @@
+import type { OAuth2Tokens } from "../oauth2.js";
+import type { OAuthCallbackQuery, OAuthUser, ProviderOptions } from "../auth.js";
+export interface BungieOptions extends ProviderOptions {
+    apiKey?: string;
+}
+export declare class Bungie {
+    private client;
+    private apiKey;
+    private auth;
+    constructor(options: BungieOptions);
+    constructor(clientId: string, clientSecret: string | null, redirectURI: string);
+    createAuthorizationURL(state: string, scopes: string[]): URL;
+    validateAuthorizationCode(code: string): Promise<OAuth2Tokens>;
+    refreshAccessToken(refreshToken: string): Promise<OAuth2Tokens>;
+    getAuthorizationURL(scopes?: string[]): Promise<URL>;
+    getUser(query: OAuthCallbackQuery): Promise<OAuthUser>;
+}

package/dist/providers/bungie.js

@@ -0,0 +1,72 @@
+import { OAuth2Client } from "../client.js";
+import { consumeOAuthState, fetchUserProfile, generateOAuthState, OAuthConfigurationError, OAuthProviderError, parseCallbackQuery, profileId, profileString, requireAuthConfig, resolveAuthConfig, resolveProviderOption, resolveScopes, saveOAuthState } from "../auth.js";
+const authorizationEndpoint = "https://www.bungie.net/en/oauth/authorize";
+const tokenEndpoint = "https://www.bungie.net/platform/app/oauth/token";
+const userEndpoint = "https://www.bungie.net/platform/User/GetCurrentBungieNetUser/";
+const envPrefix = "BUNGIE";
+// Bungie access is configured on the app, not requested via scopes.
+const defaultScopes = [];
+export class Bungie {
+    client;
+    apiKey = null;
+    auth = null;
+    constructor(clientIdOrOptions, clientSecret, redirectURI) {
+        if (typeof clientIdOrOptions === "object") {
+            this.auth = resolveAuthConfig(envPrefix, clientIdOrOptions, { redirectURI: true });
+            this.apiKey = resolveProviderOption(clientIdOrOptions.apiKey, envPrefix, "API_KEY");
+            this.client = new OAuth2Client(this.auth.clientId, this.auth.clientSecret, this.auth.redirectURI);
+        }
+        else {
+            this.client = new OAuth2Client(clientIdOrOptions, clientSecret ?? null, redirectURI ?? null);
+        }
+    }
+    createAuthorizationURL(state, scopes) {
+        const url = this.client.createAuthorizationURL(authorizationEndpoint, state, scopes);
+        return url;
+    }
+    async validateAuthorizationCode(code) {
+        const tokens = await this.client.validateAuthorizationCode(tokenEndpoint, code, null);
+        return tokens;
+    }
+    async refreshAccessToken(refreshToken) {
+        const tokens = await this.client.refreshAccessToken(tokenEndpoint, refreshToken, []);
+        return tokens;
+    }
+    async getAuthorizationURL(scopes) {
+        const auth = requireAuthConfig(this.auth);
+        const state = generateOAuthState();
+        const url = this.createAuthorizationURL(state, resolveScopes(scopes, auth, defaultScopes));
+        await saveOAuthState(auth.store, state, {});
+        return url;
+    }
+    async getUser(query) {
+        const auth = requireAuthConfig(this.auth);
+        if (this.apiKey === null) {
+            throw new OAuthConfigurationError("Missing 'apiKey': pass it in the constructor options or set BUNGIE_API_KEY");
+        }
+        const { code, state } = parseCallbackQuery(query);
+        await consumeOAuthState(auth.store, state);
+        const tokens = await this.validateAuthorizationCode(code);
+        const body = await fetchUserProfile(userEndpoint, tokens.accessToken(), {
+            "X-API-Key": this.apiKey
+        });
+        const profile = body.Response;
+        if (typeof profile !== "object" || profile === null) {
+            throw new OAuthProviderError("Unexpected user profile response body");
+        }
+        const user = profile;
+        const picturePath = profileString(user.profilePicturePath);
+        let image = null;
+        if (picturePath !== null) {
+            image = picturePath.startsWith("http")
+                ? picturePath
+                : `https://www.bungie.net${picturePath.startsWith("/") ? "" : "/"}${picturePath}`;
+        }
+        return {
+            id: profileId(user.membershipId),
+            name: profileString(user.cachedBungieGlobalDisplayName) ?? profileString(user.displayName),
+            email: null,
+            image
+        };
+    }
+}

package/dist/providers/coinbase.d.ts

@@ -0,0 +1,18 @@
+import type { OAuth2Tokens } from "../oauth2.js";
+import type { OAuthCallbackQuery, OAuthUser, ProviderOptions } from "../auth.js";
+export interface CoinbaseOptions extends ProviderOptions {
+}
+export declare class Coinbase {
+    private clientId;
+    private clientSecret;
+    private redirectURI;
+    private auth;
+    constructor(options: CoinbaseOptions);
+    constructor(clientId: string, clientSecret: string, redirectURI: string);
+    createAuthorizationURL(state: string, scopes: string[]): URL;
+    validateAuthorizationCode(code: string): Promise<OAuth2Tokens>;
+    refreshAccessToken(refreshToken: string): Promise<OAuth2Tokens>;
+    revokeToken(token: string): Promise<void>;
+    getAuthorizationURL(scopes?: string[]): Promise<URL>;
+    getUser(query: OAuthCallbackQuery): Promise<OAuthUser>;
+}

package/dist/providers/coinbase.js

@@ -0,0 +1,95 @@
+import { createOAuth2Request, sendTokenRequest, sendTokenRevocationRequest } from "../request.js";
+import { consumeOAuthState, fetchUserProfile, generateOAuthState, OAuthProviderError, parseCallbackQuery, profileId, profileString, requireAuthConfig, resolveAuthConfig, resolveScopes, saveOAuthState } from "../auth.js";
+const authorizationEndpoint = "https://www.coinbase.com/oauth/authorize";
+const tokenEndpoint = "https://www.coinbase.com/oauth/token";
+const tokenRevocationEndpoint = "https://api.coinbase.com/oauth/revoke";
+const userEndpoint = "https://api.coinbase.com/v2/user";
+const envPrefix = "COINBASE";
+const defaultScopes = ["wallet:user:read", "wallet:user:email"];
+export class Coinbase {
+    clientId;
+    clientSecret;
+    redirectURI;
+    auth = null;
+    constructor(clientIdOrOptions, clientSecret, redirectURI) {
+        if (typeof clientIdOrOptions === "object") {
+            this.auth = resolveAuthConfig(envPrefix, clientIdOrOptions, {
+                clientSecret: true,
+                redirectURI: true
+            });
+            this.clientId = this.auth.clientId;
+            this.clientSecret = this.auth.clientSecret ?? "";
+            this.redirectURI = this.auth.redirectURI ?? "";
+        }
+        else {
+            this.clientId = clientIdOrOptions;
+            this.clientSecret = clientSecret ?? "";
+            this.redirectURI = redirectURI ?? "";
+        }
+    }
+    createAuthorizationURL(state, scopes) {
+        const url = new URL(authorizationEndpoint);
+        url.searchParams.set("response_type", "code");
+        url.searchParams.set("client_id", this.clientId);
+        url.searchParams.set("state", state);
+        if (scopes.length > 0) {
+            url.searchParams.set("scope", scopes.join(" "));
+        }
+        url.searchParams.set("redirect_uri", this.redirectURI);
+        return url;
+    }
+    async validateAuthorizationCode(code) {
+        const body = new URLSearchParams();
+        body.set("grant_type", "authorization_code");
+        body.set("code", code);
+        body.set("redirect_uri", this.redirectURI);
+        body.set("client_id", this.clientId);
+        body.set("client_secret", this.clientSecret);
+        const request = createOAuth2Request(tokenEndpoint, body);
+        const tokens = await sendTokenRequest(request);
+        return tokens;
+    }
+    async refreshAccessToken(refreshToken) {
+        const body = new URLSearchParams();
+        body.set("grant_type", "refresh_token");
+        body.set("refresh_token", refreshToken);
+        body.set("client_id", this.clientId);
+        body.set("client_secret", this.clientSecret);
+        const request = createOAuth2Request(tokenEndpoint, body);
+        const tokens = await sendTokenRequest(request);
+        return tokens;
+    }
+    async revokeToken(token) {
+        const body = new URLSearchParams();
+        body.set("token", token);
+        body.set("client_id", this.clientId);
+        body.set("client_secret", this.clientSecret);
+        const request = createOAuth2Request(tokenRevocationEndpoint, body);
+        await sendTokenRevocationRequest(request);
+    }
+    async getAuthorizationURL(scopes) {
+        const auth = requireAuthConfig(this.auth);
+        const state = generateOAuthState();
+        const url = this.createAuthorizationURL(state, resolveScopes(scopes, auth, defaultScopes));
+        await saveOAuthState(auth.store, state, {});
+        return url;
+    }
+    async getUser(query) {
+        const auth = requireAuthConfig(this.auth);
+        const { code, state } = parseCallbackQuery(query);
+        await consumeOAuthState(auth.store, state);
+        const tokens = await this.validateAuthorizationCode(code);
+        const body = await fetchUserProfile(userEndpoint, tokens.accessToken());
+        const profile = body.data;
+        if (typeof profile !== "object" || profile === null) {
+            throw new OAuthProviderError("Unexpected user profile response body");
+        }
+        const user = profile;
+        return {
+            id: profileId(user.id),
+            name: profileString(user.name) ?? profileString(user.username),
+            email: profileString(user.email),
+            image: profileString(user.avatar_url)
+        };
+    }
+}

package/dist/providers/discord.d.ts

@@ -0,0 +1,16 @@
+import type { OAuth2Tokens } from "../oauth2.js";
+import type { OAuthCallbackQuery, OAuthUser, ProviderOptions } from "../auth.js";
+export interface DiscordOptions extends ProviderOptions {
+}
+export declare class Discord {
+    private client;
+    private auth;
+    constructor(options: DiscordOptions);
+    constructor(clientId: string, clientSecret: string | null, redirectURI: string);
+    createAuthorizationURL(state: string, codeVerifier: string | null, scopes: string[]): URL;
+    validateAuthorizationCode(code: string, codeVerifier: string | null): Promise<OAuth2Tokens>;
+    refreshAccessToken(refreshToken: string): Promise<OAuth2Tokens>;
+    revokeToken(token: string): Promise<void>;
+    getAuthorizationURL(scopes?: string[]): Promise<URL>;
+    getUser(query: OAuthCallbackQuery): Promise<OAuthUser>;
+}

package/dist/providers/discord.js

@@ -0,0 +1,68 @@
+import { CodeChallengeMethod, OAuth2Client } from "../client.js";
+import { consumeOAuthState, fetchUserProfile, generateOAuthCodeVerifier, generateOAuthState, InvalidOAuthCallbackError, parseCallbackQuery, profileId, profileString, requireAuthConfig, resolveAuthConfig, resolveScopes, saveOAuthState } from "../auth.js";
+const authorizationEndpoint = "https://discord.com/oauth2/authorize";
+const tokenEndpoint = "https://discord.com/api/oauth2/token";
+const tokenRevocationEndpoint = "https://discord.com/api/oauth2/token/revoke";
+const userEndpoint = "https://discord.com/api/users/@me";
+const envPrefix = "DISCORD";
+const defaultScopes = ["identify", "email"];
+export class Discord {
+    client;
+    auth = null;
+    constructor(clientIdOrOptions, clientSecret, redirectURI) {
+        if (typeof clientIdOrOptions === "object") {
+            this.auth = resolveAuthConfig(envPrefix, clientIdOrOptions, { redirectURI: true });
+            this.client = new OAuth2Client(this.auth.clientId, this.auth.clientSecret, this.auth.redirectURI);
+        }
+        else {
+            this.client = new OAuth2Client(clientIdOrOptions, clientSecret ?? null, redirectURI ?? null);
+        }
+    }
+    createAuthorizationURL(state, codeVerifier, scopes) {
+        let url;
+        if (codeVerifier !== null) {
+            url = this.client.createAuthorizationURLWithPKCE(authorizationEndpoint, state, CodeChallengeMethod.S256, codeVerifier, scopes);
+        }
+        else {
+            url = this.client.createAuthorizationURL(authorizationEndpoint, state, scopes);
+        }
+        return url;
+    }
+    async validateAuthorizationCode(code, codeVerifier) {
+        const tokens = await this.client.validateAuthorizationCode(tokenEndpoint, code, codeVerifier);
+        return tokens;
+    }
+    async refreshAccessToken(refreshToken) {
+        const tokens = await this.client.refreshAccessToken(tokenEndpoint, refreshToken, []);
+        return tokens;
+    }
+    async revokeToken(token) {
+        await this.client.revokeToken(tokenRevocationEndpoint, token);
+    }
+    async getAuthorizationURL(scopes) {
+        const auth = requireAuthConfig(this.auth);
+        const state = generateOAuthState();
+        const codeVerifier = generateOAuthCodeVerifier();
+        const url = this.createAuthorizationURL(state, codeVerifier, resolveScopes(scopes, auth, defaultScopes));
+        await saveOAuthState(auth.store, state, { codeVerifier });
+        return url;
+    }
+    async getUser(query) {
+        const auth = requireAuthConfig(this.auth);
+        const { code, state } = parseCallbackQuery(query);
+        const stored = await consumeOAuthState(auth.store, state);
+        if (typeof stored.codeVerifier !== "string") {
+            throw new InvalidOAuthCallbackError("Missing PKCE code verifier for OAuth state");
+        }
+        const tokens = await this.validateAuthorizationCode(code, stored.codeVerifier);
+        const profile = await fetchUserProfile(userEndpoint, tokens.accessToken());
+        const id = profileId(profile.id);
+        const avatar = profileString(profile.avatar);
+        return {
+            id,
+            name: profileString(profile.global_name) ?? profileString(profile.username),
+            email: profileString(profile.email),
+            image: avatar === null ? null : `https://cdn.discordapp.com/avatars/${id}/${avatar}.png`
+        };
+    }
+}

package/dist/providers/donation-alerts.d.ts

@@ -0,0 +1,17 @@
+import type { OAuth2Tokens } from "../oauth2.js";
+import type { OAuthCallbackQuery, OAuthUser, ProviderOptions } from "../auth.js";
+export interface DonationAlertsOptions extends ProviderOptions {
+}
+export declare class DonationAlerts {
+    private clientId;
+    private clientSecret;
+    private redirectURI;
+    private auth;
+    constructor(options: DonationAlertsOptions);
+    constructor(clientId: string, clientSecret: string, redirectURI: string);
+    createAuthorizationURL(scopes: string[]): URL;
+    validateAuthorizationCode(code: string): Promise<OAuth2Tokens>;
+    refreshAccessToken(refreshToken: string, scopes: string[]): Promise<OAuth2Tokens>;
+    getAuthorizationURL(scopes?: string[]): Promise<URL>;
+    getUser(query: OAuthCallbackQuery): Promise<OAuthUser>;
+}

package/dist/providers/donation-alerts.js

@@ -0,0 +1,86 @@
+import { createOAuth2Request, sendTokenRequest } from "../request.js";
+import { consumeOAuthState, fetchUserProfile, generateOAuthState, OAuthProviderError, parseCallbackQuery, profileId, profileString, requireAuthConfig, resolveAuthConfig, resolveScopes, saveOAuthState } from "../auth.js";
+const authorizationEndpoint = "https://www.donationalerts.com/oauth/authorize";
+const tokenEndpoint = "https://www.donationalerts.com/oauth/token";
+const userEndpoint = "https://www.donationalerts.com/api/v1/user/oauth";
+const envPrefix = "DONATION_ALERTS";
+const defaultScopes = ["oauth-user-show"];
+export class DonationAlerts {
+    clientId;
+    clientSecret;
+    redirectURI;
+    auth = null;
+    constructor(clientIdOrOptions, clientSecret, redirectURI) {
+        if (typeof clientIdOrOptions === "object") {
+            this.auth = resolveAuthConfig(envPrefix, clientIdOrOptions, {
+                clientSecret: true,
+                redirectURI: true
+            });
+            this.clientId = this.auth.clientId;
+            this.clientSecret = this.auth.clientSecret ?? "";
+            this.redirectURI = this.auth.redirectURI ?? "";
+        }
+        else {
+            this.clientId = clientIdOrOptions;
+            this.clientSecret = clientSecret ?? "";
+            this.redirectURI = redirectURI ?? "";
+        }
+    }
+    createAuthorizationURL(scopes) {
+        const url = new URL(authorizationEndpoint);
+        url.searchParams.set("response_type", "code");
+        url.searchParams.set("client_id", this.clientId);
+        url.searchParams.set("scope", scopes.join(" "));
+        url.searchParams.set("redirect_uri", this.redirectURI);
+        return url;
+    }
+    async validateAuthorizationCode(code) {
+        const body = new URLSearchParams();
+        body.set("grant_type", "authorization_code");
+        body.set("code", code);
+        body.set("redirect_uri", this.redirectURI);
+        body.set("client_id", this.clientId);
+        body.set("client_secret", this.clientSecret);
+        const request = createOAuth2Request(tokenEndpoint, body);
+        const tokens = await sendTokenRequest(request);
+        return tokens;
+    }
+    async refreshAccessToken(refreshToken, scopes) {
+        const body = new URLSearchParams();
+        body.set("grant_type", "refresh_token");
+        body.set("refresh_token", refreshToken);
+        body.set("client_id", this.clientId);
+        body.set("client_secret", this.clientSecret);
+        body.set("scope", scopes.join(" "));
+        const request = createOAuth2Request(tokenEndpoint, body);
+        const tokens = await sendTokenRequest(request);
+        return tokens;
+    }
+    async getAuthorizationURL(scopes) {
+        const auth = requireAuthConfig(this.auth);
+        const state = generateOAuthState();
+        const url = this.createAuthorizationURL(resolveScopes(scopes, auth, defaultScopes));
+        // The legacy URL builder does not take a state parameter.
+        url.searchParams.set("state", state);
+        await saveOAuthState(auth.store, state, {});
+        return url;
+    }
+    async getUser(query) {
+        const auth = requireAuthConfig(this.auth);
+        const { code, state } = parseCallbackQuery(query);
+        await consumeOAuthState(auth.store, state);
+        const tokens = await this.validateAuthorizationCode(code);
+        const body = await fetchUserProfile(userEndpoint, tokens.accessToken());
+        const profile = body.data;
+        if (typeof profile !== "object" || profile === null) {
+            throw new OAuthProviderError("Unexpected user profile response body");
+        }
+        const user = profile;
+        return {
+            id: profileId(user.id),
+            name: profileString(user.name) ?? profileString(user.code),
+            email: profileString(user.email),
+            image: profileString(user.avatar)
+        };
+    }
+}

package/dist/providers/dribbble.d.ts

@@ -0,0 +1,16 @@
+import type { OAuth2Tokens } from "../oauth2.js";
+import type { OAuthCallbackQuery, OAuthUser, ProviderOptions } from "../auth.js";
+export interface DribbbleOptions extends ProviderOptions {
+}
+export declare class Dribbble {
+    private clientId;
+    private clientSecret;
+    private redirectURI;
+    private auth;
+    constructor(options: DribbbleOptions);
+    constructor(clientId: string, clientSecret: string, redirectURI: string);
+    createAuthorizationURL(state: string, scopes: string[]): URL;
+    validateAuthorizationCode(code: string): Promise<OAuth2Tokens>;
+    getAuthorizationURL(scopes?: string[]): Promise<URL>;
+    getUser(query: OAuthCallbackQuery): Promise<OAuthUser>;
+}

package/dist/providers/dribbble.js

@@ -0,0 +1,73 @@
+import { createOAuth2Request, sendTokenRequest } from "../request.js";
+import { consumeOAuthState, fetchUserProfile, generateOAuthState, parseCallbackQuery, profileId, profileString, requireAuthConfig, resolveAuthConfig, resolveScopes, saveOAuthState } from "../auth.js";
+const authorizationEndpoint = "https://dribbble.com/oauth/authorize";
+const tokenEndpoint = "https://dribbble.com/oauth/token";
+const userEndpoint = "https://api.dribbble.com/v2/user";
+const envPrefix = "DRIBBBLE";
+// Dribbble grants the "public" scope by default.
+const defaultScopes = [];
+export class Dribbble {
+    clientId;
+    clientSecret;
+    redirectURI;
+    auth = null;
+    constructor(clientIdOrOptions, clientSecret, redirectURI) {
+        if (typeof clientIdOrOptions === "object") {
+            this.auth = resolveAuthConfig(envPrefix, clientIdOrOptions, {
+                clientSecret: true,
+                redirectURI: true
+            });
+            this.clientId = this.auth.clientId;
+            this.clientSecret = this.auth.clientSecret ?? "";
+            this.redirectURI = this.auth.redirectURI ?? "";
+        }
+        else {
+            this.clientId = clientIdOrOptions;
+            this.clientSecret = clientSecret ?? "";
+            this.redirectURI = redirectURI ?? "";
+        }
+    }
+    createAuthorizationURL(state, scopes) {
+        const url = new URL(authorizationEndpoint);
+        url.searchParams.set("response_type", "code");
+        url.searchParams.set("client_id", this.clientId);
+        url.searchParams.set("state", state);
+        if (scopes.length > 0) {
+            url.searchParams.set("scope", scopes.join(" "));
+        }
+        url.searchParams.set("redirect_uri", this.redirectURI);
+        return url;
+    }
+    async validateAuthorizationCode(code) {
+        const body = new URLSearchParams();
+        body.set("grant_type", "authorization_code");
+        body.set("code", code);
+        body.set("redirect_uri", this.redirectURI);
+        body.set("client_id", this.clientId);
+        body.set("client_secret", this.clientSecret);
+        const request = createOAuth2Request(tokenEndpoint, body);
+        const tokens = await sendTokenRequest(request);
+        return tokens;
+    }
+    async getAuthorizationURL(scopes) {
+        const auth = requireAuthConfig(this.auth);
+        const state = generateOAuthState();
+        const url = this.createAuthorizationURL(state, resolveScopes(scopes, auth, defaultScopes));
+        await saveOAuthState(auth.store, state, {});
+        return url;
+    }
+    async getUser(query) {
+        const auth = requireAuthConfig(this.auth);
+        const { code, state } = parseCallbackQuery(query);
+        await consumeOAuthState(auth.store, state);
+        const tokens = await this.validateAuthorizationCode(code);
+        const profile = await fetchUserProfile(userEndpoint, tokens.accessToken());
+        return {
+            id: profileId(profile.id),
+            name: profileString(profile.name) ?? profileString(profile.login),
+            // The v2 user endpoint does not expose an email address.
+            email: null,
+            image: profileString(profile.avatar_url)
+        };
+    }
+}

package/dist/providers/dropbox.d.ts

@@ -0,0 +1,16 @@
+import type { OAuth2Tokens } from "../oauth2.js";
+import type { OAuthCallbackQuery, OAuthUser, ProviderOptions } from "../auth.js";
+export interface DropboxOptions extends ProviderOptions {
+}
+export declare class Dropbox {
+    private client;
+    private auth;
+    constructor(options: DropboxOptions);
+    constructor(clientId: string, clientSecret: string, redirectURI: string);
+    createAuthorizationURL(state: string, scopes: string[]): URL;
+    validateAuthorizationCode(code: string): Promise<OAuth2Tokens>;
+    refreshAccessToken(refreshToken: string): Promise<OAuth2Tokens>;
+    revokeToken(token: string): Promise<void>;
+    getAuthorizationURL(scopes?: string[]): Promise<URL>;
+    getUser(query: OAuthCallbackQuery): Promise<OAuthUser>;
+}

package/dist/providers/dropbox.js

@@ -0,0 +1,96 @@
+import { OAuth2Client } from "../client.js";
+import { consumeOAuthState, generateOAuthState, OAuthProviderError, parseCallbackQuery, profileId, profileString, requireAuthConfig, resolveAuthConfig, resolveScopes, saveOAuthState } from "../auth.js";
+const authorizationEndpoint = "https://www.dropbox.com/oauth2/authorize";
+const tokenEndpoint = "https://api.dropboxapi.com/oauth2/token";
+const tokenRevocationEndpoint = "https://api.dropboxapi.com/2/auth/token/revoke";
+const userEndpoint = "https://api.dropboxapi.com/2/users/get_current_account";
+const envPrefix = "DROPBOX";
+const defaultScopes = ["account_info.read"];
+export class Dropbox {
+    client;
+    auth = null;
+    constructor(clientIdOrOptions, clientSecret, redirectURI) {
+        if (typeof clientIdOrOptions === "object") {
+            this.auth = resolveAuthConfig(envPrefix, clientIdOrOptions, {
+                clientSecret: true,
+                redirectURI: true
+            });
+            this.client = new OAuth2Client(this.auth.clientId, this.auth.clientSecret, this.auth.redirectURI);
+        }
+        else {
+            this.client = new OAuth2Client(clientIdOrOptions, clientSecret ?? null, redirectURI ?? null);
+        }
+    }
+    createAuthorizationURL(state, scopes) {
+        const url = this.client.createAuthorizationURL(authorizationEndpoint, state, scopes);
+        return url;
+    }
+    async validateAuthorizationCode(code) {
+        const tokens = await this.client.validateAuthorizationCode(tokenEndpoint, code, null);
+        return tokens;
+    }
+    async refreshAccessToken(refreshToken) {
+        const tokens = await this.client.refreshAccessToken(tokenEndpoint, refreshToken, []);
+        return tokens;
+    }
+    async revokeToken(token) {
+        await this.client.revokeToken(tokenRevocationEndpoint, token);
+    }
+    async getAuthorizationURL(scopes) {
+        const auth = requireAuthConfig(this.auth);
+        const state = generateOAuthState();
+        const url = this.createAuthorizationURL(state, resolveScopes(scopes, auth, defaultScopes));
+        await saveOAuthState(auth.store, state, {});
+        return url;
+    }
+    async getUser(query) {
+        const auth = requireAuthConfig(this.auth);
+        const { code, state } = parseCallbackQuery(query);
+        await consumeOAuthState(auth.store, state);
+        const tokens = await this.validateAuthorizationCode(code);
+        const profile = await fetchCurrentAccount(tokens.accessToken());
+        let name = null;
+        if (typeof profile.name === "object" && profile.name !== null) {
+            name = profileString(profile.name.display_name);
+        }
+        return {
+            id: profileId(profile.account_id),
+            name,
+            email: profileString(profile.email),
+            image: profileString(profile.profile_photo_url)
+        };
+    }
+}
+// Dropbox requires a POST with no body for the current account endpoint.
+async function fetchCurrentAccount(accessToken) {
+    let response;
+    try {
+        response = await fetch(userEndpoint, {
+            method: "POST",
+            headers: {
+                Authorization: `Bearer ${accessToken}`,
+                "User-Agent": "arctic"
+            }
+        });
+    }
+    catch {
+        throw new OAuthProviderError("Failed to fetch user profile");
+    }
+    if (!response.ok) {
+        if (response.body !== null) {
+            await response.body.cancel();
+        }
+        throw new OAuthProviderError(`User profile request failed with status ${response.status}`);
+    }
+    let data;
+    try {
+        data = await response.json();
+    }
+    catch {
+        throw new OAuthProviderError("User profile response was not valid JSON");
+    }
+    if (typeof data !== "object" || data === null) {
+        throw new OAuthProviderError("Unexpected user profile response body");
+    }
+    return data;
+}

package/dist/providers/epicgames.d.ts

@@ -0,0 +1,16 @@
+import type { OAuth2Tokens } from "../oauth2.js";
+import type { OAuthCallbackQuery, OAuthUser, ProviderOptions } from "../auth.js";
+export interface EpicGamesOptions extends ProviderOptions {
+}
+export declare class EpicGames {
+    private client;
+    private auth;
+    constructor(options: EpicGamesOptions);
+    constructor(clientId: string, clientSecret: string, redirectURI: string);
+    createAuthorizationURL(state: string, scopes: string[]): URL;
+    validateAuthorizationCode(code: string): Promise<OAuth2Tokens>;
+    refreshAccessToken(refreshToken: string): Promise<OAuth2Tokens>;
+    revokeToken(token: string): Promise<void>;
+    getAuthorizationURL(scopes?: string[]): Promise<URL>;
+    getUser(query: OAuthCallbackQuery): Promise<OAuthUser>;
+}