@authara/react 0.0.1-trusted.3 → 0.2.0

package/dist/actions.js

@@ -0,0 +1,137 @@
+export async function runGoogleAction(client, selected, proof) {
+    await client.getCsrfToken();
+    const body = { code: proof.code, redirect_uri: proof.redirect_uri };
+    switch (selected.action) {
+        case "login":
+            return {
+                action: "login",
+                provider: "google",
+                session: await client.loginWithGoogle({
+                    audience: selected.audience,
+                    body,
+                }),
+            };
+        case "link":
+            await client.linkCurrentUserGoogle({ body });
+            return { action: "link", provider: "google" };
+        case "reauthenticate":
+            await client.reauthenticateWithGoogle({
+                body: {
+                    ...body,
+                    authentication_challenge_id: selected.authenticationChallengeId,
+                },
+            });
+            return { action: "reauthenticate", provider: "google" };
+        case "recover":
+            return {
+                action: "recover",
+                provider: "google",
+                session: await client.completeAccountRecoveryLinkWithGoogle({
+                    linkID: selected.recoveryLinkId,
+                    audience: selected.audience,
+                    body,
+                }),
+            };
+    }
+}
+export async function runAppleAction(client, selected, proof) {
+    await client.getCsrfToken();
+    switch (selected.action) {
+        case "login":
+            return {
+                action: "login",
+                provider: "apple",
+                session: await client.loginWithApple({
+                    audience: selected.audience,
+                    body: proof,
+                }),
+            };
+        case "link":
+            await client.linkCurrentUserApple({ body: proof });
+            return { action: "link", provider: "apple" };
+        case "reauthenticate":
+            await client.reauthenticateWithApple({
+                body: {
+                    ...proof,
+                    authentication_challenge_id: selected.authenticationChallengeId,
+                },
+            });
+            return { action: "reauthenticate", provider: "apple" };
+        case "recover":
+            return {
+                action: "recover",
+                provider: "apple",
+                session: await client.completeAccountRecoveryLinkWithApple({
+                    linkID: selected.recoveryLinkId,
+                    audience: selected.audience,
+                    body: proof,
+                }),
+            };
+    }
+}
+export async function runMicrosoftAction(client, selected, proof) {
+    await client.getCsrfToken();
+    switch (selected.action) {
+        case "login":
+            if (!client.loginWithMicrosoft)
+                throw microsoftClientUnavailable();
+            return {
+                action: "login",
+                provider: "microsoft",
+                session: await client.loginWithMicrosoft({
+                    audience: selected.audience,
+                    body: proof,
+                }),
+            };
+        case "link":
+            if (!client.linkCurrentUserMicrosoft)
+                throw microsoftClientUnavailable();
+            await client.linkCurrentUserMicrosoft({ body: proof });
+            return { action: "link", provider: "microsoft" };
+        case "reauthenticate":
+            if (!client.reauthenticateWithMicrosoft)
+                throw microsoftClientUnavailable();
+            await client.reauthenticateWithMicrosoft({
+                body: {
+                    ...proof,
+                    authentication_challenge_id: selected.authenticationChallengeId,
+                },
+            });
+            return { action: "reauthenticate", provider: "microsoft" };
+        case "recover":
+            if (!client.completeAccountRecoveryLinkWithMicrosoft)
+                throw microsoftClientUnavailable();
+            return {
+                action: "recover",
+                provider: "microsoft",
+                session: await client.completeAccountRecoveryLinkWithMicrosoft({
+                    linkID: selected.recoveryLinkId,
+                    audience: selected.audience,
+                    body: proof,
+                }),
+            };
+    }
+}
+function microsoftClientUnavailable() {
+    return {
+        status: 404,
+        message: "This @authara/browser client does not include Microsoft authentication.",
+    };
+}
+export function resolveAction(action, audience, authenticationChallengeId, recoveryLinkId) {
+    if (action === "link")
+        return { action };
+    if (action === "reauthenticate") {
+        if (!authenticationChallengeId) {
+            throw new Error("authenticationChallengeId is required for reauthentication.");
+        }
+        return { action, authenticationChallengeId };
+    }
+    if (action === "recover") {
+        if (!recoveryLinkId) {
+            throw new Error("recoveryLinkId is required for account recovery.");
+        }
+        return { action, audience: "app", recoveryLinkId };
+    }
+    return { action: "login", audience: audience ?? "app" };
+}

package/dist/color-mode.d.ts

@@ -0,0 +1,3 @@
+export type AutharaColorMode = "dark" | "light" | "system";
+export type ResolvedAutharaColorMode = Exclude<AutharaColorMode, "system">;
+export declare function useResolvedAutharaColorMode(mode: AutharaColorMode): ResolvedAutharaColorMode;

package/dist/color-mode.js

@@ -0,0 +1,20 @@
+import { useSyncExternalStore } from "react";
+const darkModeQuery = "(prefers-color-scheme: dark)";
+function systemColorMode() {
+    if (typeof window === "undefined" || !window.matchMedia)
+        return "light";
+    return window.matchMedia(darkModeQuery).matches ? "dark" : "light";
+}
+function subscribeSystemColorMode(update) {
+    if (typeof window === "undefined" || !window.matchMedia)
+        return () => { };
+    const query = window.matchMedia(darkModeQuery);
+    query.addEventListener("change", update);
+    return () => query.removeEventListener("change", update);
+}
+const noSubscription = () => () => { };
+const serverColorMode = () => "light";
+export function useResolvedAutharaColorMode(mode) {
+    const systemMode = useSyncExternalStore(mode === "system" ? subscribeSystemColorMode : noSubscription, systemColorMode, serverColorMode);
+    return mode === "system" ? systemMode : mode;
+}

package/dist/context.d.ts

@@ -1,16 +1,17 @@
 import { type PropsWithChildren } from "react";
 import type { AutharaReactClient } from "./contract.js";
-import { AppleService, GoogleService } from "./services.js";
+import { AppleService, GoogleService, MicrosoftService } from "./services.js";
 type AutharaReactContextValue = {
     apple: AppleService;
+    client: AutharaReactClient;
     google: GoogleService;
+    microsoft: MicrosoftService;
 };
 export type AutharaProviderProps = PropsWithChildren<{
     client: AutharaReactClient;
 }>;
 /**
- * Owns the page-wide Google and Apple SDK configuration. Use one provider per
- * document so Google Identity Services is initialized only once.
+ * Owns the page-wide external-provider SDK configuration.
  */
 export declare function AutharaProvider({ client, children, }: AutharaProviderProps): React.JSX.Element;
 export declare function useAutharaServices(): AutharaReactContextValue;

package/dist/context.js

@@ -1,15 +1,16 @@
 import { jsx as _jsx } from "react/jsx-runtime";
 import { createContext, useContext, useMemo, } from "react";
-import { AppleService, GoogleService } from "./services.js";
+import { AppleService, GoogleService, MicrosoftService } from "./services.js";
 const AutharaContext = createContext(null);
 /**
- * Owns the page-wide Google and Apple SDK configuration. Use one provider per
- * document so Google Identity Services is initialized only once.
+ * Owns the page-wide external-provider SDK configuration.
  */
 export function AutharaProvider({ client, children, }) {
     const value = useMemo(() => ({
         apple: new AppleService(client),
+        client,
         google: new GoogleService(client),
+        microsoft: new MicrosoftService(client),
     }), [client]);
     return (_jsx(AutharaContext.Provider, { value: value, children: children }));
 }

package/dist/contract.d.ts

@@ -1,3 +1,12 @@
+import type { AccountRecoveryLink as BrowserAccountRecoveryLink, AuthSession } from "@authara/browser";
+import type { AutharaButtonError, AutharaLinkErrorCode, AutharaLoginErrorCode, AutharaRecoveryErrorCode, AutharaReauthenticationErrorCode } from "./errors.js";
+export type AutharaAudience = "app" | "admin" | "operator";
+export type AutharaAction = "login" | "link" | "reauthenticate" | "recover";
+export type AutharaProviderName = "apple" | "google" | "microsoft";
+export type AutharaAccountRecoveryLink = Omit<BrowserAccountRecoveryLink, "provider" | "proof_methods"> & {
+    provider: AutharaProviderName;
+    proof_methods: Array<"password" | AutharaProviderName>;
+};
 export interface GoogleLoginOptions {
     client_id: string;
     nonce: string;
@@ -8,13 +17,131 @@ export interface AppleLoginOptions {
     state: string;
     nonce: string;
 }
+export interface MicrosoftLoginOptions {
+    client_id: string;
+    authority: string;
+    nonce: string;
+}
+export type GoogleProof = {
+    code: string;
+    redirect_uri: string;
+};
+export type AppleProof = {
+    code: string;
+    state: string;
+};
+export type MicrosoftProof = {
+    credential: string;
+    nonce: string;
+};
 /**
  * The generated @authara/browser contract slice used by the React components.
- * AutharaBrowserClient satisfies this interface once both providers are
- * available in the released Core contract.
+ * AutharaBrowserClient satisfies the required provider methods from the
+ * released Core contract. Microsoft remains optional during SDK rollout.
  */
 export interface AutharaReactClient {
+    getCsrfToken(): Promise<unknown>;
     getGoogleLoginOptions(): Promise<GoogleLoginOptions>;
     getAppleLoginOptions(): Promise<AppleLoginOptions>;
+    loginWithGoogle(options: {
+        audience?: AutharaAudience;
+        body: GoogleProof;
+    }): Promise<AuthSession>;
+    loginWithApple(options: {
+        audience?: AutharaAudience;
+        body: AppleProof;
+    }): Promise<AuthSession>;
+    linkCurrentUserGoogle(options: {
+        body: GoogleProof;
+    }): Promise<void>;
+    linkCurrentUserApple(options: {
+        body: AppleProof;
+    }): Promise<void>;
+    reauthenticateWithGoogle(options: {
+        body: GoogleProof & {
+            authentication_challenge_id: string;
+        };
+    }): Promise<void>;
+    reauthenticateWithApple(options: {
+        body: AppleProof & {
+            authentication_challenge_id: string;
+        };
+    }): Promise<void>;
+    completeAccountRecoveryLinkWithGoogle(options: {
+        linkID: AutharaAccountRecoveryLink["link_id"];
+        audience?: "app";
+        body: GoogleProof;
+    }): Promise<AuthSession>;
+    completeAccountRecoveryLinkWithApple(options: {
+        linkID: AutharaAccountRecoveryLink["link_id"];
+        audience?: "app";
+        body: AppleProof;
+    }): Promise<AuthSession>;
+    getMicrosoftLoginOptions?(): Promise<MicrosoftLoginOptions>;
+    loginWithMicrosoft?(options: {
+        audience?: AutharaAudience;
+        body: MicrosoftProof;
+    }): Promise<AuthSession>;
+    linkCurrentUserMicrosoft?(options: {
+        body: MicrosoftProof;
+    }): Promise<void>;
+    reauthenticateWithMicrosoft?(options: {
+        body: MicrosoftProof & {
+            authentication_challenge_id: string;
+        };
+    }): Promise<void>;
+    completeAccountRecoveryLinkWithMicrosoft?(options: {
+        linkID: AutharaAccountRecoveryLink["link_id"];
+        audience?: "app";
+        body: MicrosoftProof;
+    }): Promise<AuthSession>;
 }
+export type AutharaLoginSuccess<P extends AutharaProviderName> = {
+    action: "login";
+    provider: P;
+    session: AuthSession;
+};
+export type AutharaLinkSuccess<P extends AutharaProviderName> = {
+    action: "link";
+    provider: P;
+};
+export type AutharaReauthenticationSuccess<P extends AutharaProviderName> = {
+    action: "reauthenticate";
+    provider: P;
+};
+export type AutharaRecoverySuccess<P extends AutharaProviderName> = {
+    action: "recover";
+    provider: P;
+    session: AuthSession;
+};
+export type AutharaActionSuccess<P extends AutharaProviderName> = AutharaLoginSuccess<P> | AutharaLinkSuccess<P> | AutharaReauthenticationSuccess<P> | AutharaRecoverySuccess<P>;
+export type AutharaActionProps<P extends AutharaProviderName> = {
+    action?: "login";
+    audience?: AutharaAudience;
+    authenticationChallengeId?: never;
+    recoveryLinkId?: never;
+    onSuccess?: (result: AutharaLoginSuccess<P>) => MaybePromise<void>;
+    onError?: (error: AutharaButtonError<AutharaLoginErrorCode>) => void;
+} | {
+    action: "link";
+    audience?: never;
+    authenticationChallengeId?: never;
+    recoveryLinkId?: never;
+    onSuccess?: (result: AutharaLinkSuccess<P>) => MaybePromise<void>;
+    onError?: (error: AutharaButtonError<AutharaLinkErrorCode>) => void;
+} | {
+    action: "reauthenticate";
+    audience?: never;
+    authenticationChallengeId: string;
+    recoveryLinkId?: never;
+    onSuccess?: (result: AutharaReauthenticationSuccess<P>) => MaybePromise<void>;
+    onError?: (error: AutharaButtonError<AutharaReauthenticationErrorCode>) => void;
+} | {
+    action: "recover";
+    audience?: "app";
+    authenticationChallengeId?: never;
+    recoveryLinkId: AutharaAccountRecoveryLink["link_id"];
+    onSuccess?: (result: AutharaRecoverySuccess<P>) => MaybePromise<void>;
+    onError?: (error: AutharaButtonError<AutharaRecoveryErrorCode>) => void;
+};
 export type MaybePromise<T> = T | Promise<T>;

package/dist/errors.d.ts

@@ -1,3 +1,37 @@
+import type { AutharaAccountRecoveryLink } from "./contract.js";
+import { type AutharaContractErrorCode } from "./generated-error-codes.js";
 export declare function isProviderUnavailable(error: unknown): boolean;
 export declare function toError(error: unknown, fallback: string): Error;
+export type AutharaButtonErrorSource = "authara" | "provider" | "configuration" | "consumer";
+export type AutharaLocalErrorCode = "csrf_token_missing" | "unknown_authara_error";
+export type AutharaLoginErrorCode = AutharaContractErrorCode<"login"> | AutharaLocalErrorCode;
+export type AutharaLinkErrorCode = AutharaContractErrorCode<"link"> | AutharaLocalErrorCode;
+export type AutharaReauthenticationErrorCode = AutharaContractErrorCode<"reauthenticate"> | AutharaLocalErrorCode;
+export type AutharaRecoveryErrorCode = AutharaContractErrorCode<"recover"> | AutharaLocalErrorCode;
+export type AutharaButtonErrorCode = AutharaLoginErrorCode | AutharaLinkErrorCode | AutharaReauthenticationErrorCode | AutharaRecoveryErrorCode;
+export type AutharaAuthenticationChallenge = {
+    id: string;
+    expires_at: string;
+};
+export declare class AutharaButtonError<Code extends string = AutharaButtonErrorCode> extends Error {
+    readonly source: AutharaButtonErrorSource;
+    readonly code?: Code;
+    readonly serverCode?: string;
+    readonly status?: number;
+    readonly authenticationChallenge?: AutharaAuthenticationChallenge;
+    readonly reauthenticateUrl?: string;
+    readonly recovery?: AutharaAccountRecoveryLink;
+    readonly originalError: unknown;
+    constructor(message: string, source: AutharaButtonErrorSource, originalError: unknown, metadata?: {
+        code?: Code;
+        serverCode?: string;
+        status?: number;
+        authenticationChallenge?: AutharaAuthenticationChallenge;
+        reauthenticateUrl?: string;
+        recovery?: AutharaAccountRecoveryLink;
+    });
+}
+export declare function toAutharaButtonError(error: unknown, fallback: string, defaultSource: AutharaButtonErrorSource): AutharaButtonError;
+export declare function isAutharaButtonError(error: unknown): error is AutharaButtonError;
 export declare function isAppleCancellation(error: unknown): boolean;
+export declare function isMicrosoftCancellation(error: unknown): boolean;

package/dist/errors.js

@@ -1,3 +1,4 @@
+import { autharaActionErrorCodes, } from "./generated-error-codes.js";
 export function isProviderUnavailable(error) {
     return (typeof error === "object" &&
         error !== null &&
@@ -16,6 +17,101 @@ export function toError(error, fallback) {
     }
     return new Error(fallback);
 }
+const knownAutharaErrorCodes = new Set([
+    ...autharaActionErrorCodes.login,
+    ...autharaActionErrorCodes.link,
+    ...autharaActionErrorCodes.reauthenticate,
+    ...autharaActionErrorCodes.recover,
+    "csrf_token_missing",
+]);
+export class AutharaButtonError extends Error {
+    constructor(message, source, originalError, metadata = {}) {
+        super(message);
+        this.name = "AutharaButtonError";
+        this.source = source;
+        this.originalError = originalError;
+        this.code = metadata.code;
+        this.serverCode = metadata.serverCode;
+        this.status = metadata.status;
+        this.authenticationChallenge = metadata.authenticationChallenge;
+        this.reauthenticateUrl = metadata.reauthenticateUrl;
+        this.recovery = metadata.recovery;
+    }
+}
+function record(value) {
+    return typeof value === "object" && value !== null
+        ? value
+        : undefined;
+}
+function challengeFrom(error) {
+    const details = record(error?.details);
+    const candidate = record(error?.authenticationChallenge) ??
+        record(details?.authentication_challenge);
+    if (typeof candidate?.id !== "string" ||
+        typeof candidate.expires_at !== "string") {
+        return undefined;
+    }
+    return { id: candidate.id, expires_at: candidate.expires_at };
+}
+function recoveryFrom(error) {
+    const details = record(error?.details);
+    const candidate = record(error?.recovery) ?? record(details?.recovery);
+    if (typeof candidate?.link_id !== "string" ||
+        !candidate.link_id ||
+        typeof candidate.provider !== "string" ||
+        !candidate.provider ||
+        !Array.isArray(candidate.proof_methods) ||
+        !candidate.proof_methods.every((method) => typeof method === "string")) {
+        return undefined;
+    }
+    return {
+        link_id: candidate.link_id,
+        provider: candidate.provider,
+        proof_methods: candidate.proof_methods,
+    };
+}
+export function toAutharaButtonError(error, fallback, defaultSource) {
+    if (error instanceof AutharaButtonError)
+        return error;
+    const value = record(error);
+    const details = record(value?.details);
+    const nestedError = record(details?.error);
+    const status = typeof value?.status === "number" ? value.status : undefined;
+    const rawCode = typeof value?.code === "string"
+        ? value.code
+        : typeof nestedError?.code === "string"
+            ? nestedError.code
+            : value?.name === "AutharaCSRFError"
+                ? "csrf_token_missing"
+                : undefined;
+    const autharaFailure = status !== undefined ||
+        details !== undefined ||
+        value?.name === "AutharaApiError" ||
+        value?.name === "AutharaCSRFError";
+    const source = autharaFailure ? "authara" : defaultSource;
+    const normalized = toError(error, fallback);
+    const reauthenticateUrl = typeof value?.reauthenticateUrl === "string"
+        ? value.reauthenticateUrl
+        : typeof details?.reauthenticate_url === "string"
+            ? details.reauthenticate_url
+            : undefined;
+    const knownCode = rawCode !== undefined && knownAutharaErrorCodes.has(rawCode);
+    return new AutharaButtonError(normalized.message, source, error, {
+        code: source === "authara"
+            ? (knownCode
+                ? rawCode
+                : "unknown_authara_error")
+            : undefined,
+        serverCode: source === "authara" && !knownCode ? rawCode : undefined,
+        status,
+        authenticationChallenge: challengeFrom(value),
+        reauthenticateUrl,
+        recovery: recoveryFrom(value),
+    });
+}
+export function isAutharaButtonError(error) {
+    return error instanceof AutharaButtonError;
+}
 export function isAppleCancellation(error) {
     if (typeof error !== "object" || error === null || !("error" in error)) {
         return false;
@@ -23,3 +119,11 @@ export function isAppleCancellation(error) {
     return (error.error === "user_cancelled_authorize" ||
         error.error === "popup_closed_by_user");
 }
+export function isMicrosoftCancellation(error) {
+    if (typeof error !== "object" || error === null || !("errorCode" in error)) {
+        return false;
+    }
+    return (error.errorCode === "user_cancelled" ||
+        error.errorCode === "popup_window_error" ||
+        error.errorCode === "empty_window_error");
+}

package/dist/generated-error-codes.d.ts

@@ -0,0 +1,8 @@
+export declare const autharaActionErrorCodes: {
+    readonly login: readonly ["account_link_required", "forbidden", "internal_error", "invalid_request", "not_found", "unauthorized"];
+    readonly link: readonly ["auth_method_already_linked", "forbidden", "internal_error", "invalid_request", "not_found", "recent_authentication_required", "unauthorized"];
+    readonly reauthenticate: readonly ["internal_error", "invalid_authentication_challenge", "invalid_request", "not_found", "unauthorized"];
+    readonly recover: readonly ["auth_method_already_linked", "forbidden", "internal_error", "invalid_request", "invitation_already_accepted", "invitation_email_mismatch", "invitation_expired", "invitation_not_found", "invitation_revoked", "not_found", "organization_membership_conflict", "provider_link_expired", "unauthorized"];
+};
+export type AutharaContractAction = keyof typeof autharaActionErrorCodes;
+export type AutharaContractErrorCode<Action extends AutharaContractAction> = (typeof autharaActionErrorCodes)[Action][number];

package/dist/generated-error-codes.js

@@ -0,0 +1,42 @@
+// Code generated from authara-core/contract/openapi.yaml; DO NOT EDIT.
+export const autharaActionErrorCodes = {
+    login: [
+        "account_link_required",
+        "forbidden",
+        "internal_error",
+        "invalid_request",
+        "not_found",
+        "unauthorized",
+    ],
+    link: [
+        "auth_method_already_linked",
+        "forbidden",
+        "internal_error",
+        "invalid_request",
+        "not_found",
+        "recent_authentication_required",
+        "unauthorized",
+    ],
+    reauthenticate: [
+        "internal_error",
+        "invalid_authentication_challenge",
+        "invalid_request",
+        "not_found",
+        "unauthorized",
+    ],
+    recover: [
+        "auth_method_already_linked",
+        "forbidden",
+        "internal_error",
+        "invalid_request",
+        "invitation_already_accepted",
+        "invitation_email_mismatch",
+        "invitation_expired",
+        "invitation_not_found",
+        "invitation_revoked",
+        "not_found",
+        "organization_membership_conflict",
+        "provider_link_expired",
+        "unauthorized",
+    ],
+};

package/dist/index.d.ts

@@ -1,6 +1,9 @@
-export { AppleButton, type AppleButtonProps } from "./AppleButton.js";
-export { GoogleButton, type GoogleButtonProps } from "./GoogleButton.js";
+export { AppleButton, AppleCredentialButton, type AppleButtonLabel, type AppleButtonProps, type AppleButtonVariant, type AppleCredentialButtonProps, } from "./AppleButton.js";
+export { GoogleButton, GoogleCredentialButton, type GoogleButtonLabel, type GoogleButtonProps, type GoogleButtonVariant, type GoogleCredentialButtonProps, } from "./GoogleButton.js";
+export { MicrosoftButton, MicrosoftCredentialButton, type MicrosoftButtonLabel, type MicrosoftButtonProps, type MicrosoftButtonVariant, type MicrosoftCredentialButtonProps, } from "./MicrosoftButton.js";
 export { AutharaProvider, type AutharaProviderProps } from "./context.js";
-export type { AppleLoginOptions, AutharaReactClient, GoogleLoginOptions, MaybePromise, } from "./contract.js";
-export { isAppleCancellation, isProviderUnavailable } from "./errors.js";
-export type { AppleAuthorization, GoogleCredential } from "./services.js";
+export type { AutharaColorMode, ResolvedAutharaColorMode, } from "./color-mode.js";
+export { autharaActionErrorCodes, type AutharaContractAction, type AutharaContractErrorCode, } from "./generated-error-codes.js";
+export type { AppleLoginOptions, AppleProof, AutharaAction, AutharaAccountRecoveryLink, AutharaActionProps, AutharaActionSuccess, AutharaAudience, AutharaLinkSuccess, AutharaLoginSuccess, AutharaProviderName, AutharaRecoverySuccess, AutharaReauthenticationSuccess, AutharaReactClient, GoogleProof, GoogleLoginOptions, MicrosoftLoginOptions, MicrosoftProof, MaybePromise, } from "./contract.js";
+export { AutharaButtonError, isAppleCancellation, isMicrosoftCancellation, isAutharaButtonError, isProviderUnavailable, type AutharaAuthenticationChallenge, type AutharaButtonErrorCode, type AutharaButtonErrorSource, type AutharaLocalErrorCode, type AutharaLinkErrorCode, type AutharaLoginErrorCode, type AutharaRecoveryErrorCode, type AutharaReauthenticationErrorCode, } from "./errors.js";
+export type { AppleAuthorization, GoogleCredential, MicrosoftCredential, } from "./services.js";

package/dist/index.js

@@ -1,4 +1,6 @@
-export { AppleButton } from "./AppleButton.js";
-export { GoogleButton } from "./GoogleButton.js";
+export { AppleButton, AppleCredentialButton, } from "./AppleButton.js";
+export { GoogleButton, GoogleCredentialButton, } from "./GoogleButton.js";
+export { MicrosoftButton, MicrosoftCredentialButton, } from "./MicrosoftButton.js";
 export { AutharaProvider } from "./context.js";
-export { isAppleCancellation, isProviderUnavailable } from "./errors.js";
+export { autharaActionErrorCodes, } from "./generated-error-codes.js";
+export { AutharaButtonError, isAppleCancellation, isMicrosoftCancellation, isAutharaButtonError, isProviderUnavailable, } from "./errors.js";

package/dist/provider-sdks.d.ts

@@ -1,29 +1,34 @@
-export type GoogleCredentialResponse = {
-    credential?: string;
-    select_by?: string;
-    state?: string;
+export type GoogleCodeResponse = {
+    code?: string;
+    error?: string;
+    error_description?: string;
+};
+export type GoogleCodeClient = {
+    requestCode(): void;
+};
+export type GoogleCodeClientConfiguration = {
+    client_id: string;
+    scope: string;
+    ux_mode: "popup";
+    select_account: boolean;
+    callback: (response: GoogleCodeResponse) => void;
+    error_callback: (error: {
+        type?: string;
+    }) => void;
 };
 export type GoogleButtonConfiguration = {
     type?: "standard" | "icon";
-    theme?: "outline" | "filled_blue" | "filled_black";
+    theme?: "light" | "dark" | "neutral";
     size?: "large" | "medium" | "small";
     text?: "signin_with" | "signup_with" | "continue_with" | "signin";
     shape?: "rectangular" | "pill" | "circle" | "square";
     logo_alignment?: "left" | "center";
     width?: number;
-    locale?: string;
-    state?: string;
-    click_listener?: () => void;
 };
 export type GoogleIdentity = {
     accounts: {
-        id: {
-            initialize(options: {
-                client_id: string;
-                nonce: string;
-                callback: (response: GoogleCredentialResponse) => void;
-            }): void;
-            renderButton(parent: HTMLElement, options: GoogleButtonConfiguration): void;
+        oauth2: {
+            initCodeClient(options: GoogleCodeClientConfiguration): GoogleCodeClient;
         };
     };
 };

package/dist/provider-sdks.js

@@ -8,14 +8,17 @@ function appendScript(url, resolveGlobal, failureMessage) {
     return new Promise((resolve, reject) => {
         const existing = document.querySelector(`script[src="${url}"]`);
         const script = existing ?? document.createElement("script");
+        const failed = () => {
+            script.remove();
+            reject(new Error(failureMessage));
+        };
         const loaded = () => {
             const value = resolveGlobal();
             if (value)
                 resolve(value);
             else
-                reject(new Error(failureMessage));
+                failed();
         };
-        const failed = () => reject(new Error(failureMessage));
         script.addEventListener("load", loaded, { once: true });
         script.addEventListener("error", failed, { once: true });
         if (!existing) {
@@ -26,7 +29,7 @@ function appendScript(url, resolveGlobal, failureMessage) {
     });
 }
 export function loadGoogleIdentity(locale) {
-    if (window.google?.accounts?.id)
+    if (window.google?.accounts?.oauth2)
         return Promise.resolve(window.google);
     if (googlePromise) {
         if (locale !== googleLocale) {