@nuxtjs/better-auth 0.0.0 → 0.1.4

package/dist/runtime/app/components/BetterAuthState.d.vue.ts

@@ -0,0 +1,20 @@
+declare var __VLS_1: {
+    loggedIn: boolean;
+    user: import("../../types.js").AuthUser | null;
+    session: import("../../types.js").AuthSession | null;
+    signOut: (options?: import("../composables/useUserSession.js").SignOutOptions) => Promise<void>;
+}, __VLS_3: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_1) => any;
+} & {
+    placeholder?: (props: typeof __VLS_3) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/runtime/app/components/BetterAuthState.vue

@@ -0,0 +1,9 @@
+<script setup>
+import { useUserSession } from "../composables/useUserSession";
+const { loggedIn, user, session, signOut, ready } = useUserSession();
+</script>
+
+<template>
+  <slot v-if="ready" v-bind="{ loggedIn, user, session, signOut }" />
+  <slot v-else name="placeholder" />
+</template>

package/dist/runtime/app/components/BetterAuthState.vue.d.ts

@@ -0,0 +1,20 @@
+declare var __VLS_1: {
+    loggedIn: boolean;
+    user: import("../../types.js").AuthUser | null;
+    session: import("../../types.js").AuthSession | null;
+    signOut: (options?: import("../composables/useUserSession.js").SignOutOptions) => Promise<void>;
+}, __VLS_3: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_1) => any;
+} & {
+    placeholder?: (props: typeof __VLS_3) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/runtime/app/composables/runWithSessionRefresh.d.ts

@@ -0,0 +1 @@
+export declare function runWithSessionRefresh<TResult>(runner: () => Promise<TResult>): Promise<TResult>;

package/dist/runtime/app/composables/runWithSessionRefresh.js

@@ -0,0 +1,12 @@
+import { isAuthActionErrorResult } from "../internal/auth-action-handles.js";
+import { refreshSessionAfterAuthAction } from "../internal/wrap-auth-method.js";
+import { useUserSession } from "./useUserSession.js";
+export async function runWithSessionRefresh(runner) {
+  if (typeof runner !== "function")
+    throw new TypeError("runWithSessionRefresh(runner) requires an async function");
+  const auth = useUserSession();
+  const result = await runner();
+  if (!isAuthActionErrorResult(result))
+    await refreshSessionAfterAuthAction(auth.fetchSession, auth.loggedIn, auth.waitForSession);
+  return result;
+}

package/dist/runtime/app/composables/useAction.d.ts

@@ -0,0 +1,2 @@
+import type { UserAuthActionHandle } from '../internal/auth-action-handles.js';
+export declare function useAction<TArgs extends unknown[], TResult>(runner: (...args: TArgs) => Promise<TResult>): UserAuthActionHandle<TArgs, TResult>;

package/dist/runtime/app/composables/useAction.js

@@ -0,0 +1,6 @@
+import { createActionHandle } from "../internal/auth-action-handles.js";
+export function useAction(runner) {
+  if (typeof runner !== "function")
+    throw new TypeError("useAction(runner) requires an async function");
+  return createActionHandle(() => runner);
+}

package/dist/runtime/app/composables/useAuthAsyncData.d.ts

@@ -0,0 +1,6 @@
+import type { AsyncDataOptions } from '#app';
+import { useAuthRequestFetch } from './useAuthRequestFetch.js';
+export interface UseAuthAsyncDataOptions<T> extends Omit<AsyncDataOptions<T | null>, 'default'> {
+    requireAuth?: boolean;
+}
+export declare function useAuthAsyncData<T>(key: string, fetcher: (requestFetch: ReturnType<typeof useAuthRequestFetch>) => Promise<T>, options?: UseAuthAsyncDataOptions<T>): any;

package/dist/runtime/app/composables/useAuthAsyncData.js

@@ -0,0 +1,16 @@
+import { useAsyncData } from "#imports";
+import { useAuthRequestFetch } from "./useAuthRequestFetch.js";
+import { useUserSession } from "./useUserSession.js";
+export function useAuthAsyncData(key, fetcher, options = {}) {
+  const requestFetch = useAuthRequestFetch();
+  const { loggedIn } = useUserSession();
+  const { requireAuth = true, ...asyncDataOptions } = options;
+  return useAsyncData(key, async () => {
+    if (requireAuth && !loggedIn.value)
+      return null;
+    return await fetcher(requestFetch);
+  }, {
+    default: () => null,
+    ...asyncDataOptions
+  });
+}

package/dist/runtime/app/composables/useAuthClient.d.ts

@@ -0,0 +1,9 @@
+import type { AppAuthClient } from '#nuxt-better-auth';
+interface RuntimeFlags {
+    client: boolean;
+    server: boolean;
+}
+export declare function getAuthRuntimeFlags(): RuntimeFlags;
+export declare function useRawAuthClient(): AppAuthClient | null;
+export declare function useAuthClient(): AppAuthClient | null;
+export {};

package/dist/runtime/app/composables/useAuthClient.js

@@ -0,0 +1,35 @@
+import createAppAuthClient from "#auth/client";
+import { useRequestURL, useRuntimeConfig } from "#imports";
+import { createVueSafeAuthProxy } from "../internal/vue-safe-auth-proxy.js";
+let _client = null;
+let _clientFacade = null;
+export function getAuthRuntimeFlags() {
+  const globalFlags = globalThis.__NUXT_BETTER_AUTH_TEST_FLAGS__;
+  if (globalFlags)
+    return globalFlags;
+  return { client: Boolean(import.meta.client), server: Boolean(import.meta.server) };
+}
+function getClient(baseURL) {
+  if (!_client)
+    _client = createAppAuthClient(baseURL);
+  return _client;
+}
+function getClientFacade(client) {
+  if (!_clientFacade)
+    _clientFacade = createVueSafeAuthProxy(client);
+  return _clientFacade;
+}
+export function useRawAuthClient() {
+  const runtimeFlags = getAuthRuntimeFlags();
+  if (!runtimeFlags.client)
+    return null;
+  const runtimeConfig = useRuntimeConfig();
+  const requestURL = useRequestURL();
+  const configuredSiteUrl = runtimeConfig.public.siteUrl;
+  const siteUrl = typeof configuredSiteUrl === "string" && configuredSiteUrl ? configuredSiteUrl : requestURL.origin;
+  return getClient(siteUrl);
+}
+export function useAuthClient() {
+  const rawClient = useRawAuthClient();
+  return rawClient ? getClientFacade(rawClient) : null;
+}

package/dist/runtime/app/composables/useAuthClientAction.d.ts

@@ -0,0 +1,3 @@
+import type { AppAuthClient } from '#nuxt-better-auth';
+import type { UserAuthActionHandle } from '../internal/auth-action-handles.js';
+export declare function useAuthClientAction<TArgs extends unknown[], TResult>(select: (client: AppAuthClient) => (...args: TArgs) => Promise<TResult>): UserAuthActionHandle<TArgs, TResult>;

package/dist/runtime/app/composables/useAuthClientAction.js

@@ -0,0 +1,15 @@
+import { useAction } from "./useAction.js";
+import { useAuthClient } from "./useAuthClient.js";
+export function useAuthClientAction(select) {
+  if (typeof select !== "function")
+    throw new TypeError("useAuthClientAction(select) requires a selector function");
+  return useAction(async (...args) => {
+    const client = useAuthClient();
+    if (!client)
+      throw new Error("Auth client is unavailable. This action can only run on client-side.");
+    const method = select(client);
+    if (typeof method !== "function")
+      throw new TypeError("useAuthClientAction(select) must resolve to a function");
+    return method(...args);
+  });
+}

package/dist/runtime/app/composables/useAuthRequestFetch.d.ts

@@ -0,0 +1,11 @@
+import type { AuthApiEndpointMethod, AuthApiEndpointPath, AuthApiEndpointResponse } from '#nuxt-better-auth';
+import { useRequestFetch } from '#imports';
+type RequestFetchOptions = NonNullable<Parameters<ReturnType<typeof useRequestFetch>>[1]>;
+type AuthRequestFetchExtractedMethod<Options> = Options extends undefined ? 'get' : Lowercase<Extract<Exclude<Options extends {
+    method?: infer Method;
+} ? Method : never, undefined>, string>> extends infer NormalizedMethod extends string ? NormalizedMethod : 'get';
+type AuthRequestFetchMethodFromOptions<Options> = RequestFetchOptions extends Options ? 'get' : AuthRequestFetchExtractedMethod<Options>;
+type AuthRequestFetchResolvedMethod<Path extends AuthApiEndpointPath, Options> = Extract<AuthRequestFetchMethodFromOptions<Options>, AuthApiEndpointMethod<Path>> extends infer Method extends string ? Method : never;
+type AuthRequestFetch = <Path extends AuthApiEndpointPath, Options extends RequestFetchOptions = RequestFetchOptions>(request: Path, opts?: Options) => Promise<AuthApiEndpointResponse<Path, Extract<AuthRequestFetchResolvedMethod<Path, Options>, AuthApiEndpointMethod<Path>>>>;
+export declare function useAuthRequestFetch(): AuthRequestFetch & ReturnType<typeof useRequestFetch>;
+export {};

package/dist/runtime/app/composables/useAuthRequestFetch.js

@@ -0,0 +1,4 @@
+import { useRequestFetch } from "#imports";
+export function useAuthRequestFetch() {
+  return useRequestFetch();
+}

package/dist/runtime/app/composables/useSignIn.d.ts

@@ -0,0 +1,16 @@
+import type { AppAuthClient, AuthSocialProviderRegistry } from '#nuxt-better-auth';
+import type { ActionHandleFor } from '../internal/auth-action-handles.js';
+type SignIn = NonNullable<AppAuthClient>['signIn'];
+type AuthSocialProviderId = AuthSocialProviderRegistry extends {
+    ids: infer T;
+} ? Extract<T, string> : never;
+type TypedSocialMethod<Method> = Method extends (data: infer Data, ...rest: infer Rest) => Promise<infer Result> ? (data: Omit<Extract<Data, Record<string, unknown>>, 'provider'> & {
+    provider: AuthSocialProviderId;
+}, ...rest: Rest) => Promise<Result> : Method;
+type SignInWithTypedSocial = Omit<SignIn, 'social'> & (SignIn extends {
+    social: infer SocialMethod;
+} ? {
+    social: TypedSocialMethod<SocialMethod>;
+} : unknown);
+export declare function useSignIn<MethodKey extends keyof SignInWithTypedSocial>(method: MethodKey): ActionHandleFor<SignInWithTypedSocial[MethodKey]>;
+export {};

package/dist/runtime/app/composables/useSignIn.js

@@ -0,0 +1,8 @@
+import { createActionHandles } from "../internal/auth-action-handles.js";
+import { useAuthActionNamespaces } from "./useUserSession.js";
+export function useSignIn(method) {
+  if (method === void 0 || method === null)
+    throw new TypeError("useSignIn(method) requires a sign-in method key");
+  const handles = createActionHandles(() => useAuthActionNamespaces().signIn, "signIn");
+  return handles[method];
+}

package/dist/runtime/app/composables/useSignUp.d.ts

@@ -0,0 +1,5 @@
+import type { AppAuthClient } from '#nuxt-better-auth';
+import type { ActionHandleFor } from '../internal/auth-action-handles.js';
+type SignUp = NonNullable<AppAuthClient>['signUp'];
+export declare function useSignUp<MethodKey extends keyof SignUp>(method: MethodKey): ActionHandleFor<SignUp[MethodKey]>;
+export {};

package/dist/runtime/app/composables/useSignUp.js

@@ -0,0 +1,8 @@
+import { createActionHandles } from "../internal/auth-action-handles.js";
+import { useAuthActionNamespaces } from "./useUserSession.js";
+export function useSignUp(method) {
+  if (method === void 0 || method === null)
+    throw new TypeError("useSignUp(method) requires a sign-up method key");
+  const handles = createActionHandles(() => useAuthActionNamespaces().signUp, "signUp");
+  return handles[method];
+}

package/dist/runtime/app/composables/useUserSession.d.ts

@@ -0,0 +1,23 @@
+import type { ComputedRef, Ref } from 'vue';
+import type { AuthSession, AuthUser } from '#nuxt-better-auth';
+export interface SignOutOptions {
+    onSuccess?: () => void | Promise<void>;
+}
+export interface UseUserSessionReturn {
+    session: Ref<AuthSession | null>;
+    user: Ref<AuthUser | null>;
+    loggedIn: ComputedRef<boolean>;
+    ready: ComputedRef<boolean>;
+    signOut: (options?: SignOutOptions) => Promise<void>;
+    waitForSession: () => Promise<void>;
+    fetchSession: (options?: {
+        headers?: HeadersInit;
+        force?: boolean;
+    }) => Promise<void>;
+    updateUser: (updates: Partial<AuthUser>) => Promise<void>;
+}
+export declare function useUserSession(): UseUserSessionReturn;
+export declare function useAuthActionNamespaces(): {
+    signIn: any;
+    signUp: any;
+};

package/dist/runtime/app/composables/useUserSession.js

@@ -0,0 +1,247 @@
+import { computed, navigateTo, nextTick, useNuxtApp, useRequestURL, useRuntimeConfig, useState, watch } from "#imports";
+import { normalizeAuthActionError } from "../internal/auth-action-error.js";
+import { resolvePostAuthSuccessRedirect, withFallbackSocialCallbackURL } from "../internal/redirect-helpers.js";
+import { fetchSessionClient, fetchSessionServer, stripToken } from "../internal/session-fetch.js";
+import { isRecord } from "../internal/utils.js";
+import { createVueSafeAuthFacade, isAuthProxyProbeKey } from "../internal/vue-safe-auth-proxy.js";
+import { wrapAuthMethod } from "../internal/wrap-auth-method.js";
+import { getAuthRuntimeFlags, useRawAuthClient } from "./useAuthClient.js";
+let _sessionSignalListenerBound = false;
+let _signOutPromise = null;
+function createServerOnlyActionNamespace(path) {
+  return new Proxy({}, {
+    get(_target, prop) {
+      if (isAuthProxyProbeKey(prop))
+        return void 0;
+      const key = prop;
+      return async () => {
+        throw new Error(`${path}.${key}() can only be called on client-side`);
+      };
+    }
+  });
+}
+const _signInServerOnly = createServerOnlyActionNamespace("signIn");
+const _signUpServerOnly = createServerOnlyActionNamespace("signUp");
+function ensureSessionSignalListener(client, onSignal) {
+  if (_sessionSignalListenerBound)
+    return;
+  const store = client.$store;
+  if (!isRecord(store))
+    return;
+  const listen = store.listen;
+  if (typeof listen !== "function")
+    return;
+  _sessionSignalListenerBound = true;
+  const listenFn = listen;
+  listenFn("$sessionSignal", async () => {
+    try {
+      await onSignal();
+    } catch {
+    }
+  });
+}
+export function useUserSession() {
+  const runtimeFlags = getAuthRuntimeFlags();
+  const runtimeConfig = useRuntimeConfig();
+  const nuxtApp = useNuxtApp();
+  const rawClient = useRawAuthClient();
+  const session = useState("auth:session", () => null);
+  const user = useState("auth:user", () => null);
+  const authReady = useState("auth:ready", () => false);
+  const prerenderReadyResetQueued = useState("auth:prerender-ready-reset-queued", () => false);
+  const hydrationReconcileQueued = useState("auth:hydration-reconcile-queued", () => false);
+  const ready = computed(() => authReady.value);
+  const loggedIn = computed(() => Boolean(session.value && user.value));
+  const isPrerenderedPayload = computed(() => Boolean(nuxtApp.payload.prerenderedAt || nuxtApp.payload.isCached));
+  const isPrerenderHydrationEmptySnapshot = computed(() => {
+    if (!runtimeFlags.client)
+      return false;
+    if (!nuxtApp.isHydrating || !nuxtApp.payload.serverRendered || !isPrerenderedPayload.value)
+      return false;
+    return !session.value && !user.value;
+  });
+  const skipHydratedSsrGetSession = computed(() => {
+    const authConfig = runtimeConfig.public.auth;
+    return Boolean(authConfig?.session?.skipHydratedSsrGetSession);
+  });
+  const shouldSkipInitialClientSessionFetch = computed(() => {
+    if (!skipHydratedSsrGetSession.value)
+      return false;
+    if (!runtimeFlags.client)
+      return false;
+    if (!nuxtApp.payload.serverRendered)
+      return false;
+    if (isPrerenderedPayload.value)
+      return false;
+    return Boolean(session.value && user.value);
+  });
+  if (isPrerenderHydrationEmptySnapshot.value && authReady.value && !prerenderReadyResetQueued.value) {
+    prerenderReadyResetQueued.value = true;
+    nuxtApp.hook("app:suspense:resolve", () => {
+      try {
+        if (!session.value && !user.value && authReady.value)
+          authReady.value = false;
+      } finally {
+        prerenderReadyResetQueued.value = false;
+      }
+    });
+  }
+  if (shouldSkipInitialClientSessionFetch.value && !authReady.value)
+    authReady.value = true;
+  function clearSession() {
+    session.value = null;
+    user.value = null;
+  }
+  async function fetchSession(options = {}) {
+    if (runtimeFlags.server)
+      return fetchSessionServer(session, user, authReady, options);
+    if (rawClient)
+      return fetchSessionClient(rawClient, session, user, authReady, options);
+  }
+  async function updateUser(updates) {
+    if (!user.value)
+      return;
+    const previousUser = user.value;
+    user.value = { ...user.value, ...updates };
+    if (!rawClient)
+      return;
+    try {
+      const clientWithUpdateUser = rawClient;
+      const result = await clientWithUpdateUser.updateUser(updates);
+      if (result?.error) {
+        if (result.error instanceof Error)
+          throw result.error;
+        const normalizedError = normalizeAuthActionError(result.error);
+        throw new Error(normalizedError.message);
+      }
+    } catch (error) {
+      user.value = previousUser;
+      if (!(error instanceof Error)) {
+        const normalizedError = normalizeAuthActionError(error);
+        throw new Error(normalizedError.message);
+      }
+      throw error;
+    }
+  }
+  if (runtimeFlags.client && rawClient && !shouldSkipInitialClientSessionFetch.value) {
+    const clientSession = rawClient.useSession();
+    watch(
+      () => clientSession.value,
+      (newSession) => {
+        const shouldWaitForPrerenderResolution = isPrerenderHydrationEmptySnapshot.value && !newSession?.data?.session && !newSession?.data?.user;
+        if (shouldWaitForPrerenderResolution)
+          return;
+        if (newSession?.data?.session && newSession?.data?.user) {
+          session.value = stripToken(newSession.data.session);
+          user.value = newSession.data.user;
+        } else if (!newSession?.isPending && !newSession?.isRefetching) {
+          const isHydrationEmptySnapshot = nuxtApp.isHydrating && nuxtApp.payload.serverRendered && Boolean(session.value && user.value) && !newSession?.data?.session && !newSession?.data?.user;
+          if (isHydrationEmptySnapshot) {
+            if (!hydrationReconcileQueued.value) {
+              hydrationReconcileQueued.value = true;
+              nuxtApp.hook("app:mounted", async () => {
+                await fetchSession({ force: true });
+                hydrationReconcileQueued.value = false;
+              });
+            }
+            return;
+          }
+          clearSession();
+        }
+        if (!authReady.value && !newSession?.isPending && !newSession?.isRefetching)
+          authReady.value = true;
+      },
+      { immediate: true, deep: true }
+    );
+  }
+  function waitForSession() {
+    return new Promise((resolve) => {
+      if (loggedIn.value) {
+        resolve();
+        return;
+      }
+      const unwatch = watch(loggedIn, (isLoggedIn) => {
+        if (isLoggedIn) {
+          unwatch();
+          resolve();
+        }
+      });
+      setTimeout(() => {
+        unwatch();
+        resolve();
+      }, 5e3);
+    });
+  }
+  if (runtimeFlags.client && rawClient && shouldSkipInitialClientSessionFetch.value) {
+    ensureSessionSignalListener(rawClient, () => fetchSession({ force: true }));
+  }
+  async function signOut(options) {
+    if (!rawClient)
+      throw new Error("signOut can only be called on client-side");
+    if (_signOutPromise) {
+      await _signOutPromise;
+      return;
+    }
+    _signOutPromise = (async () => {
+      await rawClient.signOut();
+      clearSession();
+      if (options?.onSuccess) {
+        await options.onSuccess();
+        return;
+      }
+      const authConfig = runtimeConfig.public.auth;
+      const logoutRedirect = authConfig?.redirects?.logout;
+      if (logoutRedirect) {
+        await nextTick();
+        await navigateTo(logoutRedirect);
+      }
+    })().finally(() => {
+      _signOutPromise = null;
+    });
+    await _signOutPromise;
+  }
+  return {
+    session,
+    user,
+    loggedIn,
+    ready,
+    signOut,
+    waitForSession,
+    fetchSession,
+    updateUser
+  };
+}
+export function useAuthActionNamespaces() {
+  const rawClient = useRawAuthClient();
+  const auth = useUserSession();
+  const requestURL = useRequestURL();
+  const wrapDeps = {
+    fetchSession: auth.fetchSession,
+    loggedIn: auth.loggedIn,
+    waitForSession: auth.waitForSession,
+    resolvePostAuthSuccessRedirect: () => resolvePostAuthSuccessRedirect(requestURL)
+  };
+  const signIn = rawClient?.signIn ? createVueSafeAuthFacade((prop) => {
+    const targetRecord = rawClient.signIn;
+    const method = targetRecord[prop];
+    if (typeof method !== "function")
+      return method;
+    const isRedirectOAuthSignIn = prop === "social" || prop === "oauth2";
+    return wrapAuthMethod(
+      (...args) => targetRecord[prop](...args),
+      wrapDeps,
+      isRedirectOAuthSignIn ? {
+        shouldSkipSessionSync: (data) => !isRecord(data) || data.disableRedirect !== true,
+        transformData: (data) => withFallbackSocialCallbackURL(data, requestURL)
+      } : {}
+    );
+  }) : _signInServerOnly;
+  const signUp = rawClient?.signUp ? createVueSafeAuthFacade((prop) => {
+    const targetRecord = rawClient.signUp;
+    const method = targetRecord[prop];
+    if (typeof method !== "function")
+      return method;
+    return wrapAuthMethod((...args) => targetRecord[prop](...args), wrapDeps);
+  }) : _signUpServerOnly;
+  return { signIn, signUp };
+}

package/dist/runtime/app/composables/useUserSessionState.d.ts

@@ -0,0 +1,3 @@
+import type { UseUserSessionReturn } from './useUserSession.js';
+export type UseUserSessionStateReturn = UseUserSessionReturn;
+export declare function useUserSessionState(): UseUserSessionStateReturn;

package/dist/runtime/app/composables/useUserSessionState.js

@@ -0,0 +1,4 @@
+import { useUserSession } from "./useUserSession.js";
+export function useUserSessionState() {
+  return useUserSession();
+}

package/dist/runtime/app/internal/auth-action-error.d.ts

@@ -0,0 +1,3 @@
+import type { AuthActionError } from '../../types.js';
+export declare const DEFAULT_AUTH_ACTION_ERROR_MESSAGE = "Request failed. Please try again.";
+export declare function normalizeAuthActionError(error: unknown): AuthActionError;

package/dist/runtime/app/internal/auth-action-error.js

@@ -0,0 +1,33 @@
+import { isRecord } from "./utils.js";
+export const DEFAULT_AUTH_ACTION_ERROR_MESSAGE = "Request failed. Please try again.";
+function getMessage(value) {
+  if (value instanceof Error)
+    return value.message;
+  if (typeof value === "string")
+    return value;
+  if (isRecord(value) && typeof value.message === "string")
+    return value.message;
+  return DEFAULT_AUTH_ACTION_ERROR_MESSAGE;
+}
+function getCode(value) {
+  if (!isRecord(value))
+    return void 0;
+  return typeof value.code === "string" ? value.code : void 0;
+}
+function getStatus(value) {
+  if (!isRecord(value))
+    return void 0;
+  if (typeof value.status === "number")
+    return value.status;
+  if (typeof value.statusCode === "number")
+    return value.statusCode;
+  return void 0;
+}
+export function normalizeAuthActionError(error) {
+  return {
+    message: getMessage(error),
+    code: getCode(error),
+    status: getStatus(error),
+    raw: error
+  };
+}

package/dist/runtime/app/internal/auth-action-handles.d.ts

@@ -0,0 +1,21 @@
+import type { Ref } from 'vue';
+import type { AuthActionError } from '../../types.js';
+export type UserAuthActionStatus = 'idle' | 'pending' | 'success' | 'error';
+export interface UserAuthActionHandle<TArgs extends unknown[], TResult> {
+    execute: (...args: TArgs) => Promise<void>;
+    status: Ref<UserAuthActionStatus>;
+    data: Ref<TResult | null>;
+    error: Ref<AuthActionError | null>;
+}
+export interface CreateActionHandleOptions {
+    keepPendingOnRedirect?: boolean;
+}
+export type ActionHandleFor<T> = T extends (...args: infer A) => Promise<infer R> ? UserAuthActionHandle<A, R> : never;
+export type ActionHandleMap<T> = {
+    [K in keyof T]: ActionHandleFor<T[K]>;
+};
+export declare function isAuthActionErrorResult(value: unknown): value is {
+    error: unknown;
+};
+export declare function createActionHandle<TArgs extends unknown[], TResult>(getMethod: () => (...args: TArgs) => Promise<TResult>, options?: CreateActionHandleOptions): UserAuthActionHandle<TArgs, TResult>;
+export declare function createActionHandles<T extends object>(getTarget: () => T, targetName: string): ActionHandleMap<T>;