@aurabase/aurabase-js 0.5.3 → 0.6.0

package/dist/nextjs.d.ts

@@ -0,0 +1,126 @@
+import { A as AuraClient } from './AuraClient-5jDiXjrO.js';
+import { User, Session } from '@aurabase/core';
+import '@aurabase/ai';
+import '@aurabase/auth';
+import '@aurabase/db';
+import '@aurabase/functions';
+import '@aurabase/notifications';
+import '@aurabase/realtime';
+import '@aurabase/storage';
+
+interface NextCookieItem {
+    name: string;
+    value: string;
+    options?: Record<string, unknown>;
+}
+interface NextRequestCookies {
+    getAll(): NextCookieItem[];
+    set(name: string, value: string): void;
+}
+interface NextUrlLike {
+    pathname: string;
+}
+interface NextRequestLike {
+    cookies: NextRequestCookies;
+    nextUrl: NextUrlLike;
+    url: string;
+}
+interface NextResponseCookies {
+    set(name: string, value: string, options?: Record<string, unknown>): void;
+}
+interface NextResponseLike {
+    cookies: NextResponseCookies;
+    headers?: unknown;
+}
+interface NextServerModule {
+    NextResponse: {
+        next(init?: {
+            request?: unknown;
+        }): NextResponseLike;
+        redirect(url: string | URL): NextResponseLike;
+    };
+}
+interface ReadonlyRequestCookiesLike {
+    getAll(): NextCookieItem[];
+    set?(name: string, value: string, options?: Record<string, unknown>): void;
+}
+interface NextHeadersModule {
+    cookies(): Promise<ReadonlyRequestCookiesLike> | ReadonlyRequestCookiesLike;
+}
+interface AuthContextParam {
+    user: User | null;
+    session: Session | null;
+    request: NextRequestLike;
+}
+interface AuthMiddlewareOptions {
+    /** Project URL (defaults to process.env.NEXT_PUBLIC_AURABASE_URL or process.env.AURABASE_URL). */
+    projectUrl?: string;
+    /** Anon API Key (defaults to process.env.NEXT_PUBLIC_AURABASE_ANON_KEY or process.env.AURABASE_ANON_KEY). */
+    anonKey?: string;
+    /** List of route patterns that do not require authentication (e.g. ['/', '/login', '/signup', '/auth/*']). */
+    publicRoutes?: string[];
+    /** URL to redirect unauthenticated users to (default: '/login'). */
+    loginUrl?: string;
+    /** Custom handler executed after session evaluation. */
+    onAuthenticated?: (authContext: AuthContextParam) => Promise<NextResponseLike | undefined | null | void> | NextResponseLike | undefined | null | void;
+}
+/**
+ * Creates a standard Next.js middleware that validates sessions and protects private routes.
+ *
+ * @example
+ * ```ts
+ * // middleware.ts
+ * import { createAuthMiddleware } from '@aurabase/aurabase-js/nextjs'
+ *
+ * export default createAuthMiddleware({
+ *   publicRoutes: ['/', '/login', '/signup', '/api/public'],
+ *   loginUrl: '/login',
+ * })
+ *
+ * export const config = {
+ *   matcher: ['/((?!_next/static|_next/image|favicon.ico).*)'],
+ * }
+ * ```
+ */
+declare function createAuthMiddleware(options?: AuthMiddlewareOptions): (request: NextRequestLike) => Promise<NextResponseLike>;
+/**
+ * Creates an Aurabase client optimized for React Server Components (RSC).
+ * Safe in read-only RSC context: prevents Next.js errors when evaluating tokens.
+ */
+declare function createClientForServerComponent(cookieStore: ReadonlyRequestCookiesLike, projectUrl?: string, apiKey?: string): AuraClient<any, any>;
+/**
+ * Creates an Aurabase client for Server Actions and Route Handlers.
+ * Full read-write cookie access for transparent session management.
+ */
+declare function createClientForServerAction(cookieStore: ReadonlyRequestCookiesLike, projectUrl?: string, apiKey?: string): AuraClient<any, any>;
+/**
+ * Server Component helper (Clerk-like API) to get the current authentication state.
+ *
+ * @example
+ * ```tsx
+ * import { auth } from '@aurabase/aurabase-js/nextjs'
+ *
+ * export default async function Page() {
+ *   const { userId, user } = await auth()
+ *   if (!userId) return <div>Non connecté</div>
+ *   return <div>Connecté en tant que {user?.email}</div>
+ * }
+ * ```
+ */
+declare function auth(options?: {
+    projectUrl?: string;
+    apiKey?: string;
+}): Promise<{
+    userId: string | null;
+    user: User | null;
+    session: Session | null;
+}>;
+/**
+ * Server Component helper to get the currently logged-in user profile.
+ */
+declare function currentUser(options?: {
+    projectUrl?: string;
+    apiKey?: string;
+}): Promise<User | null>;
+
+export { type AuthContextParam, type AuthMiddlewareOptions, type NextCookieItem, type NextHeadersModule, type NextRequestCookies, type NextRequestLike, type NextResponseCookies, type NextResponseLike, type NextServerModule, type NextUrlLike, type ReadonlyRequestCookiesLike, auth, createAuthMiddleware, createClientForServerAction, createClientForServerComponent, currentUser };

package/dist/nextjs.js

@@ -0,0 +1,383 @@
+import { clientScope, LocalAuthStore, DEFAULT_MAX_RETRIES, BaseAuthStore } from '@aurabase/core';
+import { AiService } from '@aurabase/ai';
+import { AuthService, AuthAdminService } from '@aurabase/auth';
+import { DatabaseService } from '@aurabase/db';
+import { FunctionsService } from '@aurabase/functions';
+import { NotificationsService } from '@aurabase/notifications';
+import { RealtimeService } from '@aurabase/realtime';
+import { StorageService } from '@aurabase/storage';
+
+// src/ssr.ts
+function isBrowserContext() {
+  if (typeof window !== "undefined") return true;
+  const g = globalThis;
+  if (typeof g.DedicatedWorkerGlobalScope !== "undefined") return true;
+  if (typeof g.SharedWorkerGlobalScope !== "undefined") return true;
+  return false;
+}
+var SERVICE_ROLE_KEY_PREFIX = "aura_sk_";
+var AuraClient = class {
+  /** URL du projet (`https://<slug>.aurabase.cloud`), sans barre finale. */
+  baseUrl;
+  apiKey;
+  fetchFn;
+  authStore;
+  retryConfig;
+  /** Timeout par défaut (ms) des requêtes JSON sans signal. `undefined` → défaut core (30s). */
+  requestTimeoutMs;
+  /** Hook d'observabilité (LOT 3) — voir `AuraClientOptions.onEvent`. */
+  onEvent;
+  /** Journalise chaque `AuraObservabilityEvent` via `console.debug` — voir `AuraClientOptions.debug`. */
+  debug;
+  // Lazy-initialised service instances
+  _auth = null;
+  _db = null;
+  _storage = null;
+  _realtime = null;
+  _functions = null;
+  _ai = null;
+  _notifications = null;
+  _authAdmin = null;
+  _disposed = false;
+  _persistSession;
+  _autoRefresh;
+  _detectSessionInUrl;
+  /**
+   * @param baseUrl URL du projet (`https://<slug>.aurabase.cloud`).
+   * @param apiKey  Clé API du projet (`aura_anon_…`, `aura_auth_…`, `aura_sk_…`).
+   */
+  constructor(baseUrl, apiKey, options) {
+    this.baseUrl = baseUrl.replace(/\/+$/, "");
+    const resolvedOptions = options;
+    this.apiKey = apiKey || null;
+    this.fetchFn = resolvedOptions?.fetch ?? globalThis.fetch.bind(globalThis);
+    const r = resolvedOptions?.retry;
+    this.retryConfig = r === false ? { enabled: false, maxRetries: 0 } : r === void 0 || r === true ? { enabled: true, maxRetries: DEFAULT_MAX_RETRIES } : { enabled: r.enabled ?? true, maxRetries: r.maxRetries ?? DEFAULT_MAX_RETRIES };
+    this.requestTimeoutMs = resolvedOptions?.requestTimeoutMs;
+    this.onEvent = resolvedOptions?.onEvent;
+    this.debug = resolvedOptions?.debug;
+    if (!this.apiKey && typeof console !== "undefined") {
+      console.warn(
+        "[aurabase] No API key provided. Most operations require an API key (apikey header). Only public auth routes (register, login, refresh) will work without one."
+      );
+    }
+    if (typeof console !== "undefined" && /^https?:\/\/(localhost|127\.0\.0\.1)(:\d+)?\/?$/.test(this.baseUrl)) {
+      console.warn(
+        "[aurabase] Attention : en local, l'URL du projet doit inclure le sous-domaine (ex: http://<slug>.localhost:8080) pour permettre la r\xE9solution automatique du projet par la passerelle."
+      );
+    }
+    if (this.apiKey?.startsWith(SERVICE_ROLE_KEY_PREFIX) && isBrowserContext()) {
+      const refuse = resolvedOptions?.refuseServiceRoleInBrowser ?? true;
+      const message = "[aurabase] S\xC9CURIT\xC9 : une cl\xE9 service_role (aura_sk_\u2026) est fournie \xE0 createClient() dans un contexte navigateur. Cette cl\xE9 \xE0 privil\xE8ges \xE9lev\xE9s NE DOIT JAMAIS \xEAtre expos\xE9e c\xF4t\xE9 client (elle fuiterait dans le bundle). Utilisez une cl\xE9 anon (aura_anon_\u2026) c\xF4t\xE9 client, et createAdminClient() c\xF4t\xE9 serveur pour les op\xE9rations d'administration.";
+      if (refuse) {
+        throw new Error(message);
+      } else if (typeof console !== "undefined") {
+        console.warn(message);
+      }
+    }
+    if (resolvedOptions?.auth?.storage) {
+      this.authStore = resolvedOptions.auth.storage;
+    } else if (resolvedOptions?.auth?.persistSession === false) {
+      this.authStore = new BaseAuthStore();
+    } else if (isBrowserContext() && typeof window.localStorage !== "undefined" || typeof globalThis !== "undefined" && (() => {
+      const g = globalThis;
+      const proc = g?.process;
+      const isTest = !!(proc?.env?.VITEST || proc?.env?.NODE_ENV === "test" || proc?.env?.JEST_WORKER_ID);
+      return isTest && !!g?.localStorage && typeof g.localStorage.getItem === "function";
+    })()) {
+      this.authStore = new LocalAuthStore(`aura-${clientScope(this.baseUrl)}-auth`);
+    } else {
+      this.authStore = new BaseAuthStore();
+    }
+    this.authStore.setObservabilityHook(this.onEvent, this.debug);
+    this._persistSession = resolvedOptions?.auth?.persistSession !== false;
+    this._autoRefresh = resolvedOptions?.auth?.autoRefresh ?? true;
+    this._detectSessionInUrl = resolvedOptions?.auth?.detectSessionInUrl;
+    if (this._autoRefresh && this._persistSession && typeof window !== "undefined") {
+      void this.auth;
+    }
+  }
+  /**
+   * Démonte le client : arrête le refresh proactif (ticker + visibilité + BroadcastChannel),
+   * déconnecte le realtime, vide les listeners d'auth. Idempotent. À appeler en teardown
+   * (React Strict Mode / HMR / tests).
+   */
+  dispose() {
+    if (this._disposed) return;
+    this._disposed = true;
+    this._auth?.dispose();
+    this._realtime?.disconnect();
+  }
+  // -- Lazy service getters ---------------------------------------------------
+  get auth() {
+    if (!this._auth) {
+      this._auth = new AuthService(this, {
+        autoRefresh: this._autoRefresh,
+        persistSession: this._persistSession,
+        detectSessionInUrl: this._detectSessionInUrl
+      });
+      this._auth.onAuthStateChange(({ event, accessToken }) => {
+        if (this._realtime) {
+          if (accessToken) {
+            this._realtime.setAuth(accessToken);
+          } else if (event === "SIGNED_OUT") {
+            this._realtime.setAuth("");
+          }
+        }
+      });
+    }
+    return this._auth;
+  }
+  get authAdmin() {
+    if (isBrowserContext()) {
+      throw new Error(
+        "[aurabase] S\xC9CURIT\xC9 : authAdmin est inaccessible dans un contexte navigateur. L'API admin requiert une cl\xE9 service_role qui ne doit JAMAIS \xEAtre expos\xE9e c\xF4t\xE9 client (elle fuiterait dans le bundle). Utilisez createAdminClient() c\xF4t\xE9 serveur uniquement."
+      );
+    }
+    if (!this._authAdmin) this._authAdmin = new AuthAdminService(this);
+    return this._authAdmin;
+  }
+  get db() {
+    if (!this._db) this._db = new DatabaseService(this);
+    return this._db;
+  }
+  get storage() {
+    if (!this._storage) this._storage = new StorageService(this);
+    return this._storage;
+  }
+  get realtime() {
+    if (!this._realtime) this._realtime = new RealtimeService(this);
+    return this._realtime;
+  }
+  get functions() {
+    if (!this._functions) this._functions = new FunctionsService(this);
+    return this._functions;
+  }
+  get ai() {
+    if (!this._ai) this._ai = new AiService(this);
+    return this._ai;
+  }
+  get notifications() {
+    if (!this._notifications) this._notifications = new NotificationsService(this);
+    return this._notifications;
+  }
+  from(table) {
+    return this.db.from(table);
+  }
+  /**
+   * Shortcut: call a stored procedure / PostgreSQL function via RPC (Supabase-compatible API).
+   * Equivalent to `aura.db.rpc(fn, args, options)`.
+   *
+   * @example
+   * ```ts
+   * const { data, error } = await aura.rpc('echo_test', { message: 'hello' })
+   * ```
+   */
+  rpc(fn, args, options) {
+    return this.db.rpc(fn, args, options);
+  }
+  /**
+   * Shortcut: create a realtime channel with Supabase-compatible API.
+   * Equivalent to `aura.realtime.channel(name)`.
+   *
+   * @example
+   * ```ts
+   * const channel = aura.channel('room-1')
+   *   .on('postgres_changes', { event: 'INSERT', schema: 'public', table: 'messages' }, cb)
+   *   .subscribe()
+   * ```
+   */
+  channel(name, options) {
+    return this.realtime.channel(name, options);
+  }
+  /**
+   * Shortcut: remove a realtime channel by name or AuraChannel instance.
+   * Equivalent to `aura.realtime.removeChannel(channel)`.
+   */
+  removeChannel(channel) {
+    return this.realtime.removeChannel(channel);
+  }
+  /**
+   * Shortcut: remove all realtime channels and unsubscribe.
+   * Equivalent to `aura.realtime.removeAllChannels()`.
+   */
+  removeAllChannels() {
+    return this.realtime.removeAllChannels();
+  }
+  /**
+   * Shortcut: list all active realtime channels.
+   * Equivalent to `aura.realtime.getChannels()`.
+   */
+  getChannels() {
+    return this.realtime.getChannels();
+  }
+};
+var MAX_CHUNK_SIZE = 3600;
+function createServerClient(baseUrl, apiKey, options) {
+  const cookieName = `aura-${clientScope(baseUrl)}-auth`;
+  const store = new LocalAuthStore(cookieName);
+  const idxRe = new RegExp(`^${cookieName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\\.(\\d+)$`);
+  const incoming = options.cookies.getAll();
+  const numbered = incoming.filter((c) => idxRe.test(c.name)).sort((a, b) => Number(a.name.match(idxRe)[1]) - Number(b.name.match(idxRe)[1]));
+  const base = incoming.find((c) => c.name === cookieName);
+  const decodedValue = numbered.length > 0 ? numbered.map((c) => c.value).join("") : base?.value;
+  if (decodedValue) {
+    store.loadFromCookie(`${cookieName}=${encodeURIComponent(decodedValue)}`);
+  }
+  const initialNames = incoming.filter((c) => c.name === cookieName || idxRe.test(c.name)).map((c) => c.name);
+  const defaultCookieOpts = {
+    path: "/",
+    secure: baseUrl.startsWith("https://"),
+    sameSite: "Lax",
+    httpOnly: true,
+    maxAge: 60 * 60 * 24 * 30,
+    // 30 days
+    ...options.cookieOptions
+  };
+  store.onChange(() => {
+    const toSet = [];
+    const used = /* @__PURE__ */ new Set();
+    if (store.token) {
+      const cookieStr = store.exportToCookie();
+      const eqIdx = cookieStr.indexOf("=");
+      const rawEncoded = eqIdx >= 0 ? cookieStr.slice(eqIdx + 1).split(";")[0] : "";
+      const decoded = rawEncoded ? decodeURIComponent(rawEncoded) : "";
+      if (decoded.length <= MAX_CHUNK_SIZE) {
+        toSet.push({ name: cookieName, value: decoded, options: defaultCookieOpts });
+        used.add(cookieName);
+      } else {
+        let idx = 0;
+        for (let i = 0; i < decoded.length; i += MAX_CHUNK_SIZE, idx++) {
+          const name = `${cookieName}.${idx}`;
+          toSet.push({
+            name,
+            value: decoded.slice(i, i + MAX_CHUNK_SIZE),
+            options: defaultCookieOpts
+          });
+          used.add(name);
+        }
+      }
+    }
+    const expireOpts = { ...defaultCookieOpts, maxAge: 0 };
+    for (const name of initialNames) {
+      if (!used.has(name)) toSet.push({ name, value: "", options: expireOpts });
+    }
+    if (toSet.length > 0) options.cookies.setAll(toSet);
+  });
+  return new AuraClient(baseUrl, apiKey, {
+    auth: { persistSession: false, storage: store }
+  });
+}
+
+// src/nextjs.ts
+async function loadNextModule(specifier) {
+  try {
+    const mod = await import(
+      /* @vite-ignore */
+      specifier
+    );
+    return mod;
+  } catch {
+    return null;
+  }
+}
+function createAuthMiddleware(options = {}) {
+  return async function middleware(request) {
+    const nextServer = await loadNextModule("next/server");
+    if (!nextServer?.NextResponse) {
+      throw new Error(
+        "[@aurabase/nextjs] Next.js n'est pas install\xE9. createAuthMiddleware n\xE9cessite next/server."
+      );
+    }
+    const { NextResponse } = nextServer;
+    const projectUrl = options.projectUrl ?? process.env.NEXT_PUBLIC_AURABASE_URL ?? process.env.AURABASE_URL ?? "";
+    const anonKey = options.anonKey ?? process.env.NEXT_PUBLIC_AURABASE_ANON_KEY ?? process.env.AURABASE_ANON_KEY ?? "";
+    if (!projectUrl || !anonKey) {
+      console.warn(
+        "[@aurabase/nextjs] Variables d'environnement manquantes : NEXT_PUBLIC_AURABASE_URL ou NEXT_PUBLIC_AURABASE_ANON_KEY non d\xE9finies."
+      );
+      return NextResponse.next({ request });
+    }
+    const response = NextResponse.next({ request });
+    const cookieHandler = {
+      getAll: () => request.cookies.getAll(),
+      setAll: (cookiesToSet) => {
+        cookiesToSet.forEach(({ name, value, options: cookieOpts }) => {
+          request.cookies.set(name, value);
+          response.cookies.set(name, value, cookieOpts);
+        });
+      }
+    };
+    const client = createServerClient(projectUrl, anonKey, {
+      cookies: cookieHandler
+    });
+    const { data: sessionData } = await client.auth.getSession();
+    const session = sessionData?.session ?? null;
+    const user = session?.user ?? null;
+    const pathname = request.nextUrl.pathname;
+    const publicPatterns = options.publicRoutes ?? ["/", "/login", "/signup", "/auth/callback"];
+    const isPublic = publicPatterns.some((pattern) => {
+      if (pattern.endsWith("*")) {
+        return pathname.startsWith(pattern.slice(0, -1));
+      }
+      return pathname === pattern;
+    });
+    if (!isPublic && !user) {
+      const loginUrl = new URL(options.loginUrl ?? "/login", request.url);
+      loginUrl.searchParams.set("redirectTo", pathname);
+      return NextResponse.redirect(loginUrl);
+    }
+    if (options.onAuthenticated) {
+      const customResponse = await options.onAuthenticated({ user, session, request });
+      if (customResponse) return customResponse;
+    }
+    return response;
+  };
+}
+function createClientForServerComponent(cookieStore, projectUrl, apiKey) {
+  const url = projectUrl ?? process.env.NEXT_PUBLIC_AURABASE_URL ?? process.env.AURABASE_URL ?? "";
+  const key = apiKey ?? process.env.NEXT_PUBLIC_AURABASE_ANON_KEY ?? process.env.AURABASE_ANON_KEY ?? "";
+  return createServerClient(url, key, {
+    cookies: {
+      getAll: () => cookieStore.getAll(),
+      setAll: () => {
+      }
+    }
+  });
+}
+function createClientForServerAction(cookieStore, projectUrl, apiKey) {
+  const url = projectUrl ?? process.env.NEXT_PUBLIC_AURABASE_URL ?? process.env.AURABASE_URL ?? "";
+  const key = apiKey ?? process.env.NEXT_PUBLIC_AURABASE_ANON_KEY ?? process.env.AURABASE_ANON_KEY ?? "";
+  return createServerClient(url, key, {
+    cookies: {
+      getAll: () => cookieStore.getAll(),
+      setAll: (cookiesToSet) => {
+        cookiesToSet.forEach(({ name, value, options }) => {
+          cookieStore.set?.(name, value, options);
+        });
+      }
+    }
+  });
+}
+async function auth(options) {
+  const nextHeaders = await loadNextModule("next/headers");
+  if (!nextHeaders?.cookies) {
+    throw new Error("[@aurabase/nextjs] auth() ne peut \xEAtre appel\xE9 que dans un environnement Next.js App Router.");
+  }
+  const cookieStore = await nextHeaders.cookies();
+  const client = createClientForServerComponent(cookieStore, options?.projectUrl, options?.apiKey);
+  const { data } = await client.auth.getSession();
+  const session = data?.session ?? null;
+  const user = session?.user ?? null;
+  return {
+    userId: user?.id ?? null,
+    user,
+    session
+  };
+}
+async function currentUser(options) {
+  const { user } = await auth(options);
+  return user;
+}
+
+export { auth, createAuthMiddleware, createClientForServerAction, createClientForServerComponent, currentUser };

package/dist/react.cjs

@@ -0,0 +1,150 @@
+'use strict';
+
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// src/react.ts
+function getReact() {
+  const g = globalThis;
+  if (g.React) {
+    return g.React;
+  }
+  if (typeof __require === "function") {
+    try {
+      return __require("react");
+    } catch {
+      return null;
+    }
+  }
+  return null;
+}
+var defaultAuthContextValue = {
+  client: null,
+  user: null,
+  session: null,
+  accessToken: null,
+  isLoading: true,
+  isAuthenticated: false,
+  signOut: async () => {
+  }
+};
+var authContextInstance = null;
+function getAuthContext() {
+  if (!authContextInstance) {
+    const React = getReact();
+    if (React?.createContext) {
+      authContextInstance = React.createContext(defaultAuthContextValue);
+    }
+  }
+  return authContextInstance;
+}
+function AuthProvider({ client, children, initialSession = null }) {
+  const React = getReact();
+  if (!React) {
+    throw new Error("[@aurabase/react] React est requis pour utiliser <AuthProvider>.");
+  }
+  const [session, setSession] = React.useState(initialSession);
+  const [user, setUser] = React.useState(initialSession?.user ?? null);
+  const [isLoading, setIsLoading] = React.useState(!initialSession);
+  React.useEffect(() => {
+    let isMounted = true;
+    void client.auth.getSession().then(({ data }) => {
+      if (!isMounted) return;
+      const s = data?.session ?? null;
+      setSession(s);
+      setUser(s?.user ?? null);
+      setIsLoading(false);
+    }).catch(() => {
+      if (!isMounted) return;
+      setIsLoading(false);
+    });
+    const subscription = client.auth.onAuthStateChange(({ event, user: nextUser }) => {
+      if (!isMounted) return;
+      if (event === "SIGNED_OUT") {
+        setSession(null);
+        setUser(null);
+      } else if (event === "SIGNED_IN" || event === "TOKEN_REFRESHED" || event === "USER_UPDATED") {
+        void client.auth.getSession().then(({ data }) => {
+          if (!isMounted) return;
+          const s = data?.session ?? null;
+          setSession(s);
+          setUser(nextUser ?? s?.user ?? null);
+        }).catch(() => {
+        });
+      }
+    });
+    return () => {
+      isMounted = false;
+      subscription.unsubscribe();
+    };
+  }, [client]);
+  const value = React.useMemo(
+    () => ({
+      client,
+      user,
+      session,
+      accessToken: session?.access_token ?? null,
+      isLoading,
+      isAuthenticated: !!user,
+      signOut: async () => {
+        await client.auth.signOut();
+        setSession(null);
+        setUser(null);
+      }
+    }),
+    [client, user, session, isLoading]
+  );
+  const Context = getAuthContext();
+  if (!Context) {
+    return children;
+  }
+  return React.createElement(Context.Provider, { value }, children);
+}
+function useAuth() {
+  const React = getReact();
+  const Context = getAuthContext();
+  if (!React || !Context) {
+    return {
+      client: null,
+      user: null,
+      session: null,
+      accessToken: null,
+      isLoading: false,
+      isAuthenticated: false,
+      signOut: async () => {
+      }
+    };
+  }
+  return React.useContext(Context);
+}
+function useUser() {
+  const { user } = useAuth();
+  return user;
+}
+function useSession() {
+  const { session } = useAuth();
+  return session;
+}
+function SignedIn({ children }) {
+  const React = getReact();
+  const { isAuthenticated, isLoading } = useAuth();
+  if (isLoading || !isAuthenticated || !React) return null;
+  return React.createElement(React.Fragment, null, children);
+}
+function SignedOut({ children }) {
+  const React = getReact();
+  const { isAuthenticated, isLoading } = useAuth();
+  if (isLoading || isAuthenticated || !React) return null;
+  return React.createElement(React.Fragment, null, children);
+}
+
+exports.AuthProvider = AuthProvider;
+exports.SignedIn = SignedIn;
+exports.SignedOut = SignedOut;
+exports.useAuth = useAuth;
+exports.useSession = useSession;
+exports.useUser = useUser;