@symbiote-native/auth-session 0.0.0-stage → 0.1.0

package/build/core/token-request.js

@@ -0,0 +1,328 @@
+import invariant from 'invariant';
+import * as Base64 from './base64.js';
+import { TokenError } from './errors.js';
+import { requestAsync } from './fetch.js';
+import { GrantType } from './token-request.types.js';
+export function getCurrentTimeInSeconds() {
+    return Math.floor(Date.now() / 1000);
+}
+function asTokenType(value) {
+    return value === 'bearer' || value === 'mac' ? value : undefined;
+}
+/** https://tools.ietf.org/html/rfc6749#section-5.1 */
+export class TokenResponse {
+    static isTokenFresh(token, 
+    /** -10 minutes in seconds. */
+    secondsMargin = 60 * 10 * -1) {
+        if (!token) {
+            return false;
+        }
+        if (token.expiresIn) {
+            const now = getCurrentTimeInSeconds();
+            return now < token.issuedAt + token.expiresIn + secondsMargin;
+        }
+        return true;
+    }
+    static fromQueryParams(params) {
+        return new TokenResponse({
+            accessToken: params.access_token ?? '',
+            refreshToken: params.refresh_token,
+            scope: params.scope,
+            state: params.state,
+            idToken: params.id_token,
+            tokenType: asTokenType(params.token_type),
+            expiresIn: params.expires_in ? Number(params.expires_in) : undefined,
+            issuedAt: params.issued_at ? Number(params.issued_at) : undefined,
+        });
+    }
+    accessToken;
+    tokenType;
+    expiresIn;
+    refreshToken;
+    scope;
+    state;
+    idToken;
+    issuedAt;
+    /** Unprocessed token response, for fields outside RFC 6749. */
+    rawResponse;
+    constructor(response, rawResponse) {
+        this.rawResponse = rawResponse;
+        this.accessToken = response.accessToken;
+        this.tokenType = response.tokenType ?? 'bearer';
+        this.expiresIn = response.expiresIn;
+        this.refreshToken = response.refreshToken;
+        this.scope = response.scope;
+        this.state = response.state;
+        this.idToken = response.idToken;
+        this.issuedAt = response.issuedAt ?? getCurrentTimeInSeconds();
+    }
+    applyResponseConfig(response) {
+        this.accessToken = response.accessToken ?? this.accessToken;
+        this.tokenType = response.tokenType ?? this.tokenType ?? 'bearer';
+        this.expiresIn = response.expiresIn ?? this.expiresIn;
+        this.refreshToken = response.refreshToken ?? this.refreshToken;
+        this.scope = response.scope ?? this.scope;
+        this.state = response.state ?? this.state;
+        this.idToken = response.idToken ?? this.idToken;
+        this.issuedAt =
+            response.issuedAt ?? this.issuedAt ?? getCurrentTimeInSeconds();
+    }
+    getRequestConfig() {
+        return {
+            accessToken: this.accessToken,
+            idToken: this.idToken,
+            refreshToken: this.refreshToken,
+            scope: this.scope,
+            state: this.state,
+            tokenType: this.tokenType,
+            issuedAt: this.issuedAt,
+            expiresIn: this.expiresIn,
+        };
+    }
+    async refreshAsync(config, discovery) {
+        const request = new RefreshTokenRequest({
+            ...config,
+            refreshToken: this.refreshToken,
+        });
+        const response = await request.performAsync(discovery);
+        response.refreshToken = response.refreshToken ?? this.refreshToken;
+        this.applyResponseConfig(response.getRequestConfig());
+        return this;
+    }
+    shouldRefresh() {
+        return !(TokenResponse.isTokenFresh(this) || !this.refreshToken);
+    }
+}
+function sanitizeExtraHeaders(extra, hasClientSecret) {
+    if (!extra) {
+        return undefined;
+    }
+    const extraHeaders = { ...extra };
+    delete extraHeaders['Content-Type'];
+    delete extraHeaders['content-type'];
+    if (hasClientSecret) {
+        delete extraHeaders.authorization;
+        delete extraHeaders.Authorization;
+    }
+    return extraHeaders;
+}
+function encodeBasicAuth(clientId, clientSecret) {
+    const credentials = `${encodeURIComponent(clientId)}:${encodeURIComponent(clientSecret)}`;
+    return Base64.encodeNoWrap(credentials);
+}
+class BaseRequest {
+    request;
+    constructor(request) {
+        this.request = request;
+    }
+}
+/** A generic token request. */
+export class TokenRequest extends BaseRequest {
+    grantType;
+    clientId;
+    clientSecret;
+    scopes;
+    extraParams;
+    extraHeaders;
+    constructor(request, grantType) {
+        super(request);
+        this.grantType = grantType;
+        this.clientId = request.clientId;
+        this.clientSecret = request.clientSecret;
+        this.extraParams = request.extraParams;
+        this.scopes = request.scopes;
+        this.extraHeaders = sanitizeExtraHeaders(request.extraHeaders, typeof request.clientSecret !== 'undefined');
+    }
+    getHeaders() {
+        const headers = {
+            ...this.extraHeaders,
+            'Content-Type': 'application/x-www-form-urlencoded',
+        };
+        if (typeof this.clientSecret !== 'undefined') {
+            headers.Authorization = `Basic ${encodeBasicAuth(this.clientId, this.clientSecret)}`;
+        }
+        return headers;
+    }
+    async performAsync(discovery) {
+        invariant(discovery.tokenEndpoint, 'Cannot invoke `performAsync()` without a valid tokenEndpoint');
+        const response = await requestAsync(discovery.tokenEndpoint, {
+            dataType: 'json',
+            method: 'POST',
+            headers: this.getHeaders(),
+            body: this.getQueryBody(),
+        });
+        if ('error' in response) {
+            throw new TokenError(response);
+        }
+        return new TokenResponse({
+            accessToken: response.access_token,
+            tokenType: response.token_type,
+            expiresIn: response.expires_in,
+            refreshToken: response.refresh_token,
+            scope: response.scope,
+            idToken: response.id_token,
+            issuedAt: response.issued_at,
+        }, response);
+    }
+    getRequestConfig() {
+        return this.request;
+    }
+    getQueryBody() {
+        const queryBody = { grant_type: this.grantType };
+        if (!this.clientSecret) {
+            queryBody.client_id = this.clientId;
+        }
+        if (this.scopes) {
+            queryBody.scope = this.scopes.join(' ');
+        }
+        for (const extra in this.extraParams) {
+            const param = this.extraParams[extra];
+            if (param != null && !(extra in queryBody)) {
+                queryBody[extra] = param;
+            }
+        }
+        return queryBody;
+    }
+}
+/** https://tools.ietf.org/html/rfc6749#section-4.1.3 */
+export class AccessTokenRequest extends TokenRequest {
+    code;
+    redirectUri;
+    constructor(options) {
+        invariant(options.redirectUri, '`AccessTokenRequest` requires a valid `redirectUri`.');
+        invariant(options.code, '`AccessTokenRequest` requires a valid authorization `code`.');
+        super(options, GrantType.AuthorizationCode);
+        this.code = options.code;
+        this.redirectUri = options.redirectUri;
+    }
+    getQueryBody() {
+        return {
+            ...super.getQueryBody(),
+            redirect_uri: this.redirectUri,
+            code: this.code,
+        };
+    }
+    getRequestConfig() {
+        return {
+            clientId: this.clientId,
+            clientSecret: this.clientSecret,
+            grantType: this.grantType,
+            code: this.code,
+            redirectUri: this.redirectUri,
+            extraParams: this.extraParams,
+            extraHeaders: this.extraHeaders,
+            scopes: this.scopes,
+        };
+    }
+}
+/** https://tools.ietf.org/html/rfc6749#section-6 */
+export class RefreshTokenRequest extends TokenRequest {
+    refreshToken;
+    constructor(options) {
+        invariant(options.refreshToken, '`RefreshTokenRequest` requires a valid `refreshToken`.');
+        super(options, GrantType.RefreshToken);
+        this.refreshToken = options.refreshToken;
+    }
+    getQueryBody() {
+        const queryBody = super.getQueryBody();
+        if (this.refreshToken) {
+            queryBody.refresh_token = this.refreshToken;
+        }
+        return queryBody;
+    }
+    getRequestConfig() {
+        return {
+            clientId: this.clientId,
+            clientSecret: this.clientSecret,
+            grantType: this.grantType,
+            refreshToken: this.refreshToken,
+            extraParams: this.extraParams,
+            extraHeaders: this.extraHeaders,
+            scopes: this.scopes,
+        };
+    }
+}
+/** https://tools.ietf.org/html/rfc7009#section-2.1 */
+export class RevokeTokenRequest extends BaseRequest {
+    clientId;
+    clientSecret;
+    token;
+    tokenTypeHint;
+    extraHeaders;
+    constructor(request) {
+        super(request);
+        invariant(request.token, '`RevokeTokenRequest` requires a valid `token` to revoke.');
+        this.clientId = request.clientId;
+        this.clientSecret = request.clientSecret;
+        this.token = request.token;
+        this.tokenTypeHint = request.tokenTypeHint;
+        this.extraHeaders = sanitizeExtraHeaders(request.extraHeaders, typeof request.clientSecret !== 'undefined');
+    }
+    getHeaders() {
+        const headers = {
+            ...this.extraHeaders,
+            'Content-Type': 'application/x-www-form-urlencoded',
+        };
+        if (typeof this.clientSecret !== 'undefined' && this.clientId) {
+            headers.Authorization = `Basic ${encodeBasicAuth(this.clientId, this.clientSecret)}`;
+        }
+        return headers;
+    }
+    async performAsync(discovery) {
+        invariant(discovery.revocationEndpoint, 'Cannot invoke `performAsync()` without a valid revocationEndpoint');
+        await requestAsync(discovery.revocationEndpoint, {
+            method: 'POST',
+            headers: this.getHeaders(),
+            body: this.getQueryBody(),
+        });
+        return true;
+    }
+    getRequestConfig() {
+        return {
+            clientId: this.clientId,
+            clientSecret: this.clientSecret,
+            token: this.token,
+            tokenTypeHint: this.tokenTypeHint,
+            extraHeaders: this.extraHeaders,
+        };
+    }
+    getQueryBody() {
+        const queryBody = { token: this.token };
+        if (this.tokenTypeHint) {
+            queryBody.token_type_hint = this.tokenTypeHint;
+        }
+        if (this.clientId) {
+            queryBody.client_id = this.clientId;
+        }
+        if (this.clientSecret) {
+            queryBody.client_secret = this.clientSecret;
+        }
+        return queryBody;
+    }
+}
+/** Exchange an authorization code for an access token. */
+export function exchangeCodeAsync(config, discovery) {
+    return new AccessTokenRequest(config).performAsync(discovery);
+}
+/** Refresh an access token. See `TokenResponse.isTokenFresh()`/`shouldRefresh()`. */
+export function refreshAsync(config, discovery) {
+    return new RefreshTokenRequest(config).performAsync(discovery);
+}
+/** Revoke a token, effectively requiring the user to sign in again. */
+export function revokeAsync(config, discovery) {
+    return new RevokeTokenRequest(config).performAsync(discovery);
+}
+/** Fetch generic user info from the provider's OpenID Connect `userInfoEndpoint`, if supported. */
+export function fetchUserInfoAsync(config, discovery) {
+    if (!discovery.userInfoEndpoint) {
+        throw new Error('User info endpoint is not defined in the service config discovery document');
+    }
+    return requestAsync(discovery.userInfoEndpoint, {
+        headers: {
+            'Content-Type': 'application/x-www-form-urlencoded',
+            Authorization: `Bearer ${config.accessToken}`,
+        },
+        dataType: 'json',
+        method: 'GET',
+    });
+}

package/build/core/token-request.types.d.ts

@@ -0,0 +1,52 @@
+/** https://tools.ietf.org/html/rfc6749#section-7.1 */
+export type ITokenType = 'bearer' | 'mac';
+/** A hint about the type of the token submitted for revocation. */
+export declare enum TokenTypeHint {
+    AccessToken = "access_token",
+    RefreshToken = "refresh_token"
+}
+export type ITokenRequestConfig = {
+    clientId: string;
+    clientSecret?: string;
+    extraParams?: Record<string, string>;
+    extraHeaders?: Record<string, string>;
+    scopes?: string[];
+};
+export type IAccessTokenRequestConfig = ITokenRequestConfig & {
+    code: string;
+    /** Must match the `redirectUri` used in the `AuthRequest`. */
+    redirectUri: string;
+};
+export type IRefreshTokenRequestConfig = ITokenRequestConfig & {
+    refreshToken?: string;
+};
+export type IRevokeTokenRequestConfig = Partial<ITokenRequestConfig> & {
+    token: string;
+    tokenTypeHint?: TokenTypeHint;
+};
+/** https://tools.ietf.org/html/rfc6749#appendix-A.10 */
+export declare enum GrantType {
+    AuthorizationCode = "authorization_code",
+    Implicit = "implicit",
+    RefreshToken = "refresh_token",
+    ClientCredentials = "client_credentials"
+}
+export type IServerTokenResponseConfig = {
+    access_token: string;
+    token_type?: ITokenType;
+    expires_in?: number;
+    refresh_token?: string;
+    scope?: string;
+    id_token?: string;
+    issued_at?: number;
+};
+export type ITokenResponseConfig = {
+    accessToken: string;
+    tokenType?: ITokenType;
+    expiresIn?: number;
+    refreshToken?: string;
+    scope?: string;
+    state?: string;
+    idToken?: string;
+    issuedAt?: number;
+};

package/build/core/token-request.types.js

@@ -0,0 +1,14 @@
+/** A hint about the type of the token submitted for revocation. */
+export var TokenTypeHint;
+(function (TokenTypeHint) {
+    TokenTypeHint["AccessToken"] = "access_token";
+    TokenTypeHint["RefreshToken"] = "refresh_token";
+})(TokenTypeHint || (TokenTypeHint = {}));
+/** https://tools.ietf.org/html/rfc6749#appendix-A.10 */
+export var GrantType;
+(function (GrantType) {
+    GrantType["AuthorizationCode"] = "authorization_code";
+    GrantType["Implicit"] = "implicit";
+    GrantType["RefreshToken"] = "refresh_token";
+    GrantType["ClientCredentials"] = "client_credentials";
+})(GrantType || (GrantType = {}));

package/build/react/index.d.ts

@@ -0,0 +1,3 @@
+export * from '../core';
+export { useAuthRequest, useAuthRequestResult, useAutoDiscovery, useFacebookAuthRequest, useGoogleAuthRequest, useGoogleIdTokenAuthRequest, useLoadedAuthRequest, } from './use-auth-request';
+export type { IUseAuthRequestResult } from './use-auth-request';

package/build/react/index.js

@@ -0,0 +1,2 @@
+export * from '../core/index.js';
+export { useAuthRequest, useAuthRequestResult, useAutoDiscovery, useFacebookAuthRequest, useGoogleAuthRequest, useGoogleIdTokenAuthRequest, useLoadedAuthRequest, } from './use-auth-request.js';

package/build/react/use-auth-request.d.ts

@@ -0,0 +1,20 @@
+import { AuthRequest, FacebookAuthRequest, GoogleAuthRequest } from '../core';
+import type { IAuthRequestClass, IAuthRequestConfig, IAuthRequestPromptOptions, IAuthSessionRedirectUriOptions, IAuthSessionResult, IDiscoveryDocument, IFacebookAuthRequestConfig, IGoogleAuthRequestConfig, IIssuerOrDiscovery, IPromptMethod } from '../core';
+type IDiscoveryValue = IDiscoveryDocument | null;
+type IResultValue = IAuthSessionResult | null;
+export type IUseAuthRequestResult<TRequest extends AuthRequest = AuthRequest> = readonly [TRequest | null, IResultValue, IPromptMethod];
+/** React twin of `useAutoDiscovery`, `null` until the discovery document has loaded */
+export declare function useAutoDiscovery(issuerOrDiscovery: IIssuerOrDiscovery): IDiscoveryValue;
+/** React twin of `useLoadedAuthRequest`, `null` until the request url has loaded */
+export declare function useLoadedAuthRequest(config: IAuthRequestConfig, discovery: IDiscoveryValue, RequestClass: IAuthRequestClass<AuthRequest>): AuthRequest | null;
+/** React twin of `useAuthRequestResult`, the result and the prompt method */
+export declare function useAuthRequestResult(request: AuthRequest | null, discovery: IDiscoveryValue, customOptions?: IAuthRequestPromptOptions): readonly [IResultValue, IPromptMethod];
+/** React twin of `useAuthRequest`: the loaded request, the result and the prompt method */
+export declare function useAuthRequest(config: IAuthRequestConfig, discovery: IDiscoveryValue): IUseAuthRequestResult;
+/** React twin of Google's `useAuthRequest`, exchanges the code for a token by default */
+export declare function useGoogleAuthRequest(config?: Partial<IGoogleAuthRequestConfig>, redirectUriOptions?: Partial<IAuthSessionRedirectUriOptions>): IUseAuthRequestResult<GoogleAuthRequest>;
+/** React twin of Google's `useIdTokenAuthRequest`, the id token is in `params.id_token` */
+export declare function useGoogleIdTokenAuthRequest(config: Partial<IGoogleAuthRequestConfig>, redirectUriOptions?: Partial<IAuthSessionRedirectUriOptions>): IUseAuthRequestResult<GoogleAuthRequest>;
+/** React twin of Facebook's `useAuthRequest` */
+export declare function useFacebookAuthRequest(config?: Partial<IFacebookAuthRequestConfig>, redirectUriOptions?: Partial<IAuthSessionRedirectUriOptions>): IUseAuthRequestResult<FacebookAuthRequest>;
+export {};

package/build/react/use-auth-request.js

@@ -0,0 +1,52 @@
+// React twins of `expo-auth-session`'s auth request hooks. The load, prompt and code-exchange
+// logic is the shared controllers in `core/`, React only supplies the lifecycle
+import { createEventValueHook, createResourceHook, } from '@symbiote-native/react';
+import { AUTH_CELL_CHANGE, AuthRequest, FacebookAuthRequest, GoogleAuthRequest, createAutoDiscoveryController, createGoogleExchangeController, createLoadedRequestController, createRequestResultController, facebookDiscovery, googleDiscovery, resolveFacebookRequestSetup, resolveGoogleRequestSetup, toGoogleIdTokenConfig, } from '../core/index.js';
+function readAuthCell(cell) {
+    return cell.getSnapshot();
+}
+const useDiscoveryCell = createResourceHook(createAutoDiscoveryController);
+const useLoadedCell = createResourceHook(() => createLoadedRequestController());
+const useResultHolder = createResourceHook(createRequestResultController);
+const useExchangeCell = createResourceHook(createGoogleExchangeController);
+const useDiscoveryValue = createEventValueHook(AUTH_CELL_CHANGE, readAuthCell);
+const useRequestValue = createEventValueHook(AUTH_CELL_CHANGE, readAuthCell);
+const useResultValue = createEventValueHook(AUTH_CELL_CHANGE, readAuthCell);
+/** React twin of `useAutoDiscovery`, `null` until the discovery document has loaded */
+export function useAutoDiscovery(issuerOrDiscovery) {
+    return useDiscoveryValue(useDiscoveryCell(issuerOrDiscovery));
+}
+/** React twin of `useLoadedAuthRequest`, `null` until the request url has loaded */
+export function useLoadedAuthRequest(config, discovery, RequestClass) {
+    return useRequestValue(useLoadedCell(config, discovery, RequestClass));
+}
+/** React twin of `useAuthRequestResult`, the result and the prompt method */
+export function useAuthRequestResult(request, discovery, customOptions = {}) {
+    const holder = useResultHolder(request, discovery, customOptions);
+    return [useResultValue(holder.result), holder.promptAsync];
+}
+/** React twin of `useAuthRequest`: the loaded request, the result and the prompt method */
+export function useAuthRequest(config, discovery) {
+    const request = useLoadedAuthRequest(config, discovery, AuthRequest);
+    const [result, promptAsync] = useAuthRequestResult(request, discovery);
+    return [request, result, promptAsync];
+}
+/** React twin of Google's `useAuthRequest`, exchanges the code for a token by default */
+export function useGoogleAuthRequest(config = {}, redirectUriOptions = {}) {
+    const { requestConfig, exchange } = resolveGoogleRequestSetup(config, redirectUriOptions);
+    const request = useLoadedAuthRequest(requestConfig, googleDiscovery, GoogleAuthRequest);
+    const [result, promptAsync] = useAuthRequestResult(request, googleDiscovery);
+    const fullResult = useResultValue(useExchangeCell(result, request, exchange));
+    return [request, fullResult, promptAsync];
+}
+/** React twin of Google's `useIdTokenAuthRequest`, the id token is in `params.id_token` */
+export function useGoogleIdTokenAuthRequest(config, redirectUriOptions = {}) {
+    return useGoogleAuthRequest(toGoogleIdTokenConfig(config), redirectUriOptions);
+}
+/** React twin of Facebook's `useAuthRequest` */
+export function useFacebookAuthRequest(config = {}, redirectUriOptions = {}) {
+    const requestConfig = resolveFacebookRequestSetup(config, redirectUriOptions);
+    const request = useLoadedAuthRequest(requestConfig, facebookDiscovery, FacebookAuthRequest);
+    const [result, promptAsync] = useAuthRequestResult(request, facebookDiscovery);
+    return [request, result, promptAsync];
+}

package/build/solid/index.d.ts

@@ -0,0 +1,2 @@
+export * from '../core';
+export { useAuthRequest, useAuthRequestResult, useAutoDiscovery, useFacebookAuthRequest, useGoogleAuthRequest, useGoogleIdTokenAuthRequest, useLoadedAuthRequest, } from './use-auth-request';

package/build/solid/index.js

@@ -0,0 +1,2 @@
+export * from '../core/index.js';
+export { useAuthRequest, useAuthRequestResult, useAutoDiscovery, useFacebookAuthRequest, useGoogleAuthRequest, useGoogleIdTokenAuthRequest, useLoadedAuthRequest, } from './use-auth-request.js';

package/build/solid/use-auth-request.d.ts

@@ -0,0 +1,6 @@
+export declare const useAuthRequest: (config: () => import(".").IAuthRequestConfig, discovery: () => import(".").IDiscoveryDocument | null) => readonly [() => import(".").AuthRequest | null, () => import(".").IAuthSessionResult | null, import(".").IPromptMethod], useAuthRequestResult: (request: () => import(".").AuthRequest | null, discovery: () => import(".").IDiscoveryDocument | null, customOptions?: (() => import("@symbiote-native/web-browser").IWebBrowserOpenOptions & {
+    preferEphemeralSession?: boolean;
+    preferUniversalLinks?: boolean;
+} & {
+    url?: string;
+}) | undefined) => readonly [() => import(".").IAuthSessionResult | null, import(".").IPromptMethod], useAutoDiscovery: (issuerOrDiscovery: () => import(".").IIssuerOrDiscovery) => () => import(".").IDiscoveryDocument | null, useFacebookAuthRequest: (config?: (() => Partial<import(".").IFacebookAuthRequestConfig>) | undefined, redirectUriOptions?: (() => Partial<import(".").IAuthSessionRedirectUriOptions>) | undefined) => readonly [() => import(".").FacebookAuthRequest | null, () => import(".").IAuthSessionResult | null, import(".").IPromptMethod], useGoogleAuthRequest: (config?: (() => Partial<import(".").IGoogleAuthRequestConfig>) | undefined, redirectUriOptions?: (() => Partial<import(".").IAuthSessionRedirectUriOptions>) | undefined) => readonly [() => import(".").GoogleAuthRequest | null, () => import(".").IAuthSessionResult | null, import(".").IPromptMethod], useGoogleIdTokenAuthRequest: (config: () => Partial<import(".").IGoogleAuthRequestConfig>, redirectUriOptions?: (() => Partial<import(".").IAuthSessionRedirectUriOptions>) | undefined) => readonly [() => import(".").GoogleAuthRequest | null, () => import(".").IAuthSessionResult | null, import(".").IPromptMethod], useLoadedAuthRequest: (config: () => import(".").IAuthRequestConfig, discovery: () => import(".").IDiscoveryDocument | null, RequestClass: import(".").IAuthRequestClass<import(".").AuthRequest>) => () => import(".").AuthRequest | null;

package/build/solid/use-auth-request.js

@@ -0,0 +1,10 @@
+// Solid twins of `expo-auth-session`'s auth request hooks: accessor arguments, accessor results
+import { createEventValueHook, createResourceHook, } from '@symbiote-native/solid';
+import { GETTER_ARGS, createAuthRequestHooks } from '../core/index.js';
+export const { useAuthRequest, useAuthRequestResult, useAutoDiscovery, useFacebookAuthRequest, useGoogleAuthRequest, useGoogleIdTokenAuthRequest, useLoadedAuthRequest, } = createAuthRequestHooks({
+    createResourceHook,
+    createEventValueHook,
+    readResource: box => box(),
+    readValue: box => box(),
+    ...GETTER_ARGS,
+});

package/build/svelte/index.d.ts

@@ -0,0 +1,2 @@
+export * from '../core';
+export { useAuthRequest, useAuthRequestResult, useAutoDiscovery, useFacebookAuthRequest, useGoogleAuthRequest, useGoogleIdTokenAuthRequest, useLoadedAuthRequest, } from './use-auth-request.svelte';

package/build/svelte/index.js

@@ -0,0 +1,2 @@
+export * from '../core/index.js';
+export { useAuthRequest, useAuthRequestResult, useAutoDiscovery, useFacebookAuthRequest, useGoogleAuthRequest, useGoogleIdTokenAuthRequest, useLoadedAuthRequest, } from './use-auth-request.svelte';

package/build/svelte/use-auth-request.svelte.d.ts

@@ -0,0 +1,28 @@
+export declare const useAuthRequest: (config: () => import(".").IAuthRequestConfig, discovery: () => import(".").IDiscoveryDocument | null) => readonly [{
+    readonly current: import(".").AuthRequest | null;
+}, {
+    readonly current: import(".").IAuthSessionResult | null;
+}, import(".").IPromptMethod], useAuthRequestResult: (request: () => import(".").AuthRequest | null, discovery: () => import(".").IDiscoveryDocument | null, customOptions?: (() => import("@symbiote-native/web-browser").IWebBrowserOpenOptions & {
+    preferEphemeralSession?: boolean;
+    preferUniversalLinks?: boolean;
+} & {
+    url?: string;
+}) | undefined) => readonly [{
+    readonly current: import(".").IAuthSessionResult | null;
+}, import(".").IPromptMethod], useAutoDiscovery: (issuerOrDiscovery: () => import(".").IIssuerOrDiscovery) => {
+    readonly current: import(".").IDiscoveryDocument | null;
+}, useFacebookAuthRequest: (config?: (() => Partial<import(".").IFacebookAuthRequestConfig>) | undefined, redirectUriOptions?: (() => Partial<import(".").IAuthSessionRedirectUriOptions>) | undefined) => readonly [{
+    readonly current: import(".").FacebookAuthRequest | null;
+}, {
+    readonly current: import(".").IAuthSessionResult | null;
+}, import(".").IPromptMethod], useGoogleAuthRequest: (config?: (() => Partial<import(".").IGoogleAuthRequestConfig>) | undefined, redirectUriOptions?: (() => Partial<import(".").IAuthSessionRedirectUriOptions>) | undefined) => readonly [{
+    readonly current: import(".").GoogleAuthRequest | null;
+}, {
+    readonly current: import(".").IAuthSessionResult | null;
+}, import(".").IPromptMethod], useGoogleIdTokenAuthRequest: (config: () => Partial<import(".").IGoogleAuthRequestConfig>, redirectUriOptions?: (() => Partial<import(".").IAuthSessionRedirectUriOptions>) | undefined) => readonly [{
+    readonly current: import(".").GoogleAuthRequest | null;
+}, {
+    readonly current: import(".").IAuthSessionResult | null;
+}, import(".").IPromptMethod], useLoadedAuthRequest: (config: () => import(".").IAuthRequestConfig, discovery: () => import(".").IDiscoveryDocument | null, RequestClass: import(".").IAuthRequestClass<import(".").AuthRequest>) => {
+    readonly current: import(".").AuthRequest | null;
+};

package/build/svelte/use-auth-request.svelte.js

@@ -0,0 +1,11 @@
+// Svelte twins of `expo-auth-session`'s auth request hooks: getter arguments, boxed getter results
+import { createEventValueHook } from '@symbiote-native/svelte/runes/create-event-value-hook';
+import { createResourceHook } from '@symbiote-native/svelte/runes/create-resource-hook';
+import { GETTER_ARGS, createAuthRequestHooks } from '../core/index.js';
+export const { useAuthRequest, useAuthRequestResult, useAutoDiscovery, useFacebookAuthRequest, useGoogleAuthRequest, useGoogleIdTokenAuthRequest, useLoadedAuthRequest, } = createAuthRequestHooks({
+    createResourceHook,
+    createEventValueHook,
+    readResource: box => box.current,
+    readValue: box => box.current,
+    ...GETTER_ARGS,
+});

package/build/vue/index.d.ts

@@ -0,0 +1,2 @@
+export * from '../core';
+export { useAuthRequest, useAuthRequestResult, useAutoDiscovery, useFacebookAuthRequest, useGoogleAuthRequest, useGoogleIdTokenAuthRequest, useLoadedAuthRequest, } from './use-auth-request';

package/build/vue/index.js

@@ -0,0 +1,2 @@
+export * from '../core/index.js';
+export { useAuthRequest, useAuthRequestResult, useAutoDiscovery, useFacebookAuthRequest, useGoogleAuthRequest, useGoogleIdTokenAuthRequest, useLoadedAuthRequest, } from './use-auth-request.js';

package/build/vue/use-auth-request.d.ts

@@ -0,0 +1,7 @@
+import type { MaybeRefOrGetter, ShallowRef } from '@vue/runtime-core';
+export declare const useAuthRequest: (config: MaybeRefOrGetter<import(".").IAuthRequestConfig>, discovery: MaybeRefOrGetter<import(".").IDiscoveryDocument | null>) => readonly [ShallowRef<import(".").AuthRequest | null>, ShallowRef<import(".").IAuthSessionResult | null>, import(".").IPromptMethod], useAuthRequestResult: (request: MaybeRefOrGetter<import(".").AuthRequest | null>, discovery: MaybeRefOrGetter<import(".").IDiscoveryDocument | null>, customOptions?: MaybeRefOrGetter<import("@symbiote-native/web-browser").IWebBrowserOpenOptions & {
+    preferEphemeralSession?: boolean;
+    preferUniversalLinks?: boolean;
+} & {
+    url?: string;
+}> | undefined) => readonly [ShallowRef<import(".").IAuthSessionResult | null>, import(".").IPromptMethod], useAutoDiscovery: (issuerOrDiscovery: MaybeRefOrGetter<import(".").IIssuerOrDiscovery>) => ShallowRef<import(".").IDiscoveryDocument | null>, useFacebookAuthRequest: (config?: MaybeRefOrGetter<Partial<import(".").IFacebookAuthRequestConfig>> | undefined, redirectUriOptions?: MaybeRefOrGetter<Partial<import(".").IAuthSessionRedirectUriOptions>> | undefined) => readonly [ShallowRef<import(".").FacebookAuthRequest | null>, ShallowRef<import(".").IAuthSessionResult | null>, import(".").IPromptMethod], useGoogleAuthRequest: (config?: MaybeRefOrGetter<Partial<import(".").IGoogleAuthRequestConfig>> | undefined, redirectUriOptions?: MaybeRefOrGetter<Partial<import(".").IAuthSessionRedirectUriOptions>> | undefined) => readonly [ShallowRef<import(".").GoogleAuthRequest | null>, ShallowRef<import(".").IAuthSessionResult | null>, import(".").IPromptMethod], useGoogleIdTokenAuthRequest: (config: MaybeRefOrGetter<Partial<import(".").IGoogleAuthRequestConfig>>, redirectUriOptions?: MaybeRefOrGetter<Partial<import(".").IAuthSessionRedirectUriOptions>> | undefined) => readonly [ShallowRef<import(".").GoogleAuthRequest | null>, ShallowRef<import(".").IAuthSessionResult | null>, import(".").IPromptMethod], useLoadedAuthRequest: (config: MaybeRefOrGetter<import(".").IAuthRequestConfig>, discovery: MaybeRefOrGetter<import(".").IDiscoveryDocument | null>, RequestClass: import(".").IAuthRequestClass<import(".").AuthRequest>) => ShallowRef<import(".").AuthRequest | null>;

package/build/vue/use-auth-request.js

@@ -0,0 +1,12 @@
+// Vue twins of `expo-auth-session`'s auth request hooks: ref or getter arguments, ref results
+import { toValue } from '@vue/runtime-core';
+import { createEventValueHook, createResourceHook } from '@symbiote-native/vue';
+import { createAuthRequestHooks } from '../core/index.js';
+export const { useAuthRequest, useAuthRequestResult, useAutoDiscovery, useFacebookAuthRequest, useGoogleAuthRequest, useGoogleIdTokenAuthRequest, useLoadedAuthRequest, } = createAuthRequestHooks({
+    createResourceHook,
+    createEventValueHook,
+    readResource: box => box.value,
+    readValue: box => box.value,
+    toGetter: arg => () => toValue(arg),
+    constant: value => value,
+});

package/build-ngc/angular/index.d.ts

@@ -0,0 +1,2 @@
+export * from '../core';
+export { injectAuthRequest, injectAuthRequestResult, injectAutoDiscovery, injectFacebookAuthRequest, injectGoogleAuthRequest, injectGoogleIdTokenAuthRequest, injectLoadedAuthRequest, } from './use-auth-request';

package/build-ngc/angular/index.js

@@ -0,0 +1,4 @@
+// The hooks are the `inject*` twins below, the rest is the shared core with nothing to wrap
+export * from '../core';
+export { injectAuthRequest, injectAuthRequestResult, injectAutoDiscovery, injectFacebookAuthRequest, injectGoogleAuthRequest, injectGoogleIdTokenAuthRequest, injectLoadedAuthRequest, } from './use-auth-request';
+//# sourceMappingURL=index.js.map

package/build-ngc/angular/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/angular/index.ts"],"names":[],"mappings":"AAAA,4FAA4F;AAC5F,cAAc,SAAS,CAAC;AACxB,OAAO,EACL,iBAAiB,EACjB,uBAAuB,EACvB,mBAAmB,EACnB,yBAAyB,EACzB,uBAAuB,EACvB,8BAA8B,EAC9B,uBAAuB,GACxB,MAAM,oBAAoB,CAAC"}

package/build-ngc/angular/use-auth-request.d.ts

@@ -0,0 +1,7 @@
+import type { Signal } from '@angular/core';
+export declare const injectAuthRequest: (config: () => import(".").IAuthRequestConfig, discovery: () => import(".").IDiscoveryDocument | null) => readonly [Signal<import(".").AuthRequest | null>, Signal<import(".").IAuthSessionResult | null>, import(".").IPromptMethod], injectAuthRequestResult: (request: () => import(".").AuthRequest | null, discovery: () => import(".").IDiscoveryDocument | null, customOptions?: (() => import("@symbiote-native/web-browser").IWebBrowserOpenOptions & {
+    preferEphemeralSession?: boolean;
+    preferUniversalLinks?: boolean;
+} & {
+    url?: string;
+}) | undefined) => readonly [Signal<import(".").IAuthSessionResult | null>, import(".").IPromptMethod], injectAutoDiscovery: (issuerOrDiscovery: () => import(".").IIssuerOrDiscovery) => Signal<import(".").IDiscoveryDocument | null>, injectFacebookAuthRequest: (config?: (() => Partial<import(".").IFacebookAuthRequestConfig>) | undefined, redirectUriOptions?: (() => Partial<import(".").IAuthSessionRedirectUriOptions>) | undefined) => readonly [Signal<import(".").FacebookAuthRequest | null>, Signal<import(".").IAuthSessionResult | null>, import(".").IPromptMethod], injectGoogleAuthRequest: (config?: (() => Partial<import(".").IGoogleAuthRequestConfig>) | undefined, redirectUriOptions?: (() => Partial<import(".").IAuthSessionRedirectUriOptions>) | undefined) => readonly [Signal<import(".").GoogleAuthRequest | null>, Signal<import(".").IAuthSessionResult | null>, import(".").IPromptMethod], injectGoogleIdTokenAuthRequest: (config: () => Partial<import(".").IGoogleAuthRequestConfig>, redirectUriOptions?: (() => Partial<import(".").IAuthSessionRedirectUriOptions>) | undefined) => readonly [Signal<import(".").GoogleAuthRequest | null>, Signal<import(".").IAuthSessionResult | null>, import(".").IPromptMethod], injectLoadedAuthRequest: (config: () => import(".").IAuthRequestConfig, discovery: () => import(".").IDiscoveryDocument | null, RequestClass: import(".").IAuthRequestClass<import(".").AuthRequest>) => Signal<import(".").AuthRequest | null>;

package/build-ngc/angular/use-auth-request.js

@@ -0,0 +1,12 @@
+// Angular twins of `expo-auth-session`'s auth request hooks, `injectX` shape, call them in an
+// injection context: getter or signal arguments, signal results
+import { createEventValueHook, createResourceHook, } from '@symbiote-native/angular';
+import { GETTER_ARGS, createAuthRequestHooks } from '../core';
+export const { useAuthRequest: injectAuthRequest, useAuthRequestResult: injectAuthRequestResult, useAutoDiscovery: injectAutoDiscovery, useFacebookAuthRequest: injectFacebookAuthRequest, useGoogleAuthRequest: injectGoogleAuthRequest, useGoogleIdTokenAuthRequest: injectGoogleIdTokenAuthRequest, useLoadedAuthRequest: injectLoadedAuthRequest, } = createAuthRequestHooks({
+    createResourceHook,
+    createEventValueHook,
+    readResource: box => box(),
+    readValue: box => box(),
+    ...GETTER_ARGS,
+});
+//# sourceMappingURL=use-auth-request.js.map

package/build-ngc/angular/use-auth-request.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-auth-request.js","sourceRoot":"","sources":["../../src/angular/use-auth-request.ts"],"names":[],"mappings":"AAAA,8FAA8F;AAC9F,gEAAgE;AAGhE,OAAO,EACL,oBAAoB,EACpB,kBAAkB,GACnB,MAAM,0BAA0B,CAAC;AAClC,OAAO,EAAE,WAAW,EAAE,sBAAsB,EAAE,MAAM,SAAS,CAAC;AAO9D,MAAM,CAAC,MAAM,EACX,cAAc,EAAE,iBAAiB,EACjC,oBAAoB,EAAE,uBAAuB,EAC7C,gBAAgB,EAAE,mBAAmB,EACrC,sBAAsB,EAAE,yBAAyB,EACjD,oBAAoB,EAAE,uBAAuB,EAC7C,2BAA2B,EAAE,8BAA8B,EAC3D,oBAAoB,EAAE,uBAAuB,GAC9C,GAAG,sBAAsB,CAAwC;IAChE,kBAAkB;IAClB,oBAAoB;IACpB,YAAY,EAAE,GAAG,CAAC,EAAE,CAAC,GAAG,EAAE;IAC1B,SAAS,EAAE,GAAG,CAAC,EAAE,CAAC,GAAG,EAAE;IACvB,GAAG,WAAW;CACf,CAAC,CAAC"}