@rttnd/gau 1.4.3 → 1.4.4

package/dist/src/client/solid2/index.jsx

@@ -0,0 +1,708 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/client/token.ts
+import { BROWSER } from "esm-env";
+function storeSessionToken(token) {
+  if (!BROWSER)
+    return;
+  try {
+    localStorage.setItem(SESSION_TOKEN_KEY, token);
+  } catch {
+  }
+}
+function getSessionToken() {
+  if (!BROWSER)
+    return null;
+  try {
+    return localStorage.getItem(SESSION_TOKEN_KEY);
+  } catch {
+    return null;
+  }
+}
+function clearSessionToken() {
+  if (!BROWSER)
+    return;
+  try {
+    localStorage.removeItem(SESSION_TOKEN_KEY);
+  } catch {
+  }
+}
+function handleRefreshedToken(response) {
+  if (!BROWSER)
+    return;
+  const refreshed = response.headers.get(REFRESHED_TOKEN_HEADER);
+  if (refreshed)
+    storeSessionToken(refreshed);
+}
+async function generatePKCE() {
+  if (!BROWSER || !window.crypto || !window.crypto.subtle)
+    throw new Error("PKCE relies on window.crypto, which is not available in this environment.");
+  function base64UrlEncode(array) {
+    return btoa(String.fromCharCode(...array)).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+  }
+  const verifierLength = 43;
+  const randomValues = new Uint8Array(verifierLength);
+  window.crypto.getRandomValues(randomValues);
+  const codeVerifier = base64UrlEncode(randomValues);
+  const encoder = new TextEncoder();
+  const data = encoder.encode(codeVerifier);
+  const hash = await window.crypto.subtle.digest("SHA-256", data);
+  const codeChallenge = base64UrlEncode(new Uint8Array(hash));
+  return { codeVerifier, codeChallenge };
+}
+var SESSION_TOKEN_KEY, REFRESHED_TOKEN_HEADER;
+var init_token = __esm({
+  "src/client/token.ts"() {
+    "use strict";
+    SESSION_TOKEN_KEY = "__gau-session-token";
+    REFRESHED_TOKEN_HEADER = "X-Refreshed-Token";
+  }
+});
+
+// src/runtimes/tauri/index.ts
+var tauri_exports = {};
+__export(tauri_exports, {
+  handleTauriDeepLink: () => handleTauriDeepLink,
+  isTauri: () => isTauri,
+  linkAccountWithTauri: () => linkAccountWithTauri,
+  setupTauriListener: () => setupTauriListener,
+  signInWithTauri: () => signInWithTauri,
+  startAuthBridge: () => startAuthBridge
+});
+import { BROWSER as BROWSER2 } from "esm-env";
+function isTauri() {
+  return BROWSER2 && "__TAURI_INTERNALS__" in globalThis;
+}
+function resolveOrigin(baseUrl) {
+  try {
+    return new URL(baseUrl).origin;
+  } catch {
+    if (BROWSER2 && typeof window !== "undefined") {
+      try {
+        return new URL(baseUrl, window.location.origin).origin;
+      } catch {
+        return null;
+      }
+    }
+    return null;
+  }
+}
+function resolveAbsoluteBase(baseUrl) {
+  try {
+    return new URL(baseUrl).toString().replace(/\/$/, "");
+  } catch {
+    if (BROWSER2 && typeof window !== "undefined") {
+      try {
+        return new URL(baseUrl, window.location.origin).toString().replace(/\/$/, "");
+      } catch {
+        return baseUrl;
+      }
+    }
+    return baseUrl;
+  }
+}
+function resolveTauriRedirect(redirectOverride, scheme) {
+  return redirectOverride ?? `${scheme}://oauth/callback`;
+}
+async function signInWithTauri(provider, baseUrl, scheme = "gau", redirectOverride, profile) {
+  if (!isTauri())
+    return;
+  const { openUrl } = await import("@tauri-apps/plugin-opener");
+  const redirectTo = resolveTauriRedirect(redirectOverride, scheme);
+  const { codeVerifier, codeChallenge } = await generatePKCE();
+  localStorage.setItem("gau-pkce-verifier", codeVerifier);
+  const params = new URLSearchParams();
+  params.set("redirectTo", redirectTo);
+  if (profile)
+    params.set("profile", String(profile));
+  params.set("code_challenge", codeChallenge);
+  const authUrl = `${resolveAbsoluteBase(baseUrl)}/${provider}?${params.toString()}`;
+  await openUrl(authUrl);
+}
+async function setupTauriListener(handler) {
+  if (!isTauri())
+    return;
+  const { listen } = await import("@tauri-apps/api/event");
+  try {
+    const unlisten = await listen("deep-link", async (event) => {
+      await handler(event.payload);
+    });
+    return unlisten;
+  } catch (err) {
+    console.error(err);
+  }
+}
+async function handleTauriDeepLink(url, baseUrl, scheme, onToken) {
+  const parsed = new URL(url);
+  const baseOrigin = resolveOrigin(baseUrl);
+  if (parsed.protocol !== `${scheme}:` && (!baseOrigin || parsed.origin !== baseOrigin))
+    return;
+  const queryParams = new URLSearchParams(parsed.search);
+  const code = queryParams.get("code");
+  if (code) {
+    const verifier = localStorage.getItem("gau-pkce-verifier");
+    if (!verifier) {
+      console.error("No PKCE verifier found");
+      return;
+    }
+    localStorage.removeItem("gau-pkce-verifier");
+    try {
+      const res = await fetch(`${baseUrl}/token`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ code, codeVerifier: verifier })
+      });
+      if (res.ok) {
+        const data = await res.json();
+        if (data.token)
+          onToken(data.token);
+      } else {
+        console.error("Failed to exchange code for token");
+      }
+    } catch (e) {
+      console.error("Error exchanging code for token:", e);
+    }
+  }
+}
+async function linkAccountWithTauri(provider, baseUrl, scheme = "gau", redirectOverride, profile) {
+  if (!isTauri())
+    return;
+  const { openUrl } = await import("@tauri-apps/plugin-opener");
+  const redirectTo = resolveTauriRedirect(redirectOverride, scheme);
+  const token = getSessionToken();
+  if (!token) {
+    console.error("No session token found, cannot link account.");
+    return;
+  }
+  const params = new URLSearchParams();
+  params.set("redirectTo", redirectTo);
+  params.set("token", token);
+  if (profile)
+    params.set("profile", String(profile));
+  const linkUrl = `${resolveAbsoluteBase(baseUrl)}/link/${provider}?${params.toString()}`;
+  await openUrl(linkUrl);
+}
+async function startAuthBridge(baseUrl, scheme, onToken) {
+  if (!isTauri())
+    return;
+  const unlisten = await setupTauriListener(async (url) => {
+    handleTauriDeepLink(url, baseUrl, scheme, onToken);
+  });
+  return unlisten;
+}
+var init_tauri = __esm({
+  "src/runtimes/tauri/index.ts"() {
+    "use strict";
+    init_token();
+  }
+});
+
+// src/client/solid2/index.tsx
+init_tauri();
+import { isServer as isServer2 } from "@solidjs/web";
+import { createContext, createMemo, onSettled as onSettled2, untrack, useContext } from "solid-js";
+import { createStore } from "solid-js/store";
+
+// src/client/shared/clientAuth.ts
+init_tauri();
+var EMPTY_CLIENT_SESSION = {
+  user: null,
+  session: null,
+  accounts: null
+};
+function createEmptyClientSession() {
+  return { ...EMPTY_CLIENT_SESSION, providers: [] };
+}
+function isBrowser() {
+  return typeof window !== "undefined";
+}
+function createBrowserEnvironment(env = {}) {
+  return {
+    isBrowser,
+    isTauri: () => isBrowser() && isTauri(),
+    origin: () => window.location.origin,
+    href: () => window.location.href,
+    navigate: (url) => {
+      window.location.href = url;
+    },
+    ...env
+  };
+}
+function createClientAuth({
+  client,
+  redirectTo: defaultRedirectTo,
+  setSession,
+  onReady,
+  onRefreshing,
+  replaceUrl,
+  logger = console,
+  env
+}) {
+  const browser = createBrowserEnvironment(env);
+  function resolveRedirectTo(type, redirectTo) {
+    let next = redirectTo ?? defaultRedirectTo;
+    if (!next && browser.isBrowser())
+      next = type === "signIn" ? browser.origin() : browser.href();
+    return next;
+  }
+  function navigateTo(url) {
+    if (browser.isBrowser() && !browser.isTauri())
+      browser.navigate(url);
+  }
+  async function refresh() {
+    onRefreshing?.(true);
+    try {
+      setSession(browser.isBrowser() ? await client.refreshSession() : createEmptyClientSession());
+    } finally {
+      onRefreshing?.(false);
+    }
+  }
+  async function signIn(provider, options = {}) {
+    const profile = options.profile;
+    const url = await client.signIn(provider, { redirectTo: resolveRedirectTo("signIn", options.redirectTo), profile });
+    navigateTo(url);
+  }
+  async function linkAccount(provider, options = {}) {
+    const profile = options.profile;
+    const url = await client.linkAccount(provider, { redirectTo: resolveRedirectTo("linkAccount", options.redirectTo), profile });
+    navigateTo(url);
+  }
+  async function unlinkAccount(provider) {
+    const ok = await client.unlinkAccount(provider);
+    if (!ok)
+      logger.error("Failed to unlink account");
+  }
+  function mount() {
+    if (!browser.isBrowser())
+      return () => {
+      };
+    const unsubscribe = client.onSessionChange(setSession);
+    let disposed = false;
+    let cleanup;
+    void (async () => {
+      try {
+        const handled = await client.handleRedirectCallback(replaceUrl);
+        if (!handled)
+          await refresh();
+      } finally {
+        if (!disposed)
+          onReady?.();
+      }
+    })();
+    if (browser.isTauri()) {
+      void (async () => {
+        const unlisten = await client.startTauriBridge();
+        if (disposed)
+          unlisten?.();
+        else
+          cleanup = unlisten ?? void 0;
+      })();
+    }
+    return () => {
+      disposed = true;
+      cleanup?.();
+      cleanup = void 0;
+      unsubscribe();
+    };
+  }
+  return {
+    mount,
+    controls: {
+      signIn,
+      linkAccount,
+      unlinkAccount,
+      signOut: client.signOut,
+      refresh,
+      fetch: client.fetch
+    }
+  };
+}
+
+// src/client/solid/solidStartFetchBridge.ts
+init_token();
+import { BROWSER as BROWSER3 } from "esm-env";
+function installSolidStartFetchBridge(options = {}) {
+  if (!BROWSER3 || typeof window === "undefined")
+    return;
+  if (window.__GAU_SOLIDSTART_FETCH_BRIDGE_INSTALLED__)
+    return;
+  window.__GAU_SOLIDSTART_FETCH_BRIDGE_INSTALLED__ = true;
+  const originalFetch = globalThis.fetch.bind(globalThis);
+  const serverFunctionTarget = resolveServerFunctionTarget(options.serverBaseUrl);
+  const wrappedFetch = async (input, init = {}) => {
+    const requestUrl = resolveRequestUrl(input);
+    if (!requestUrl || !isSolidStartServerFunctionRequest(requestUrl, serverFunctionTarget))
+      return originalFetch(input, init);
+    const headers = mergeHeaders(input, init);
+    if (!headers.has("Authorization")) {
+      const token = getSessionToken();
+      if (token)
+        headers.set("Authorization", `Bearer ${token}`);
+    }
+    const response = await originalFetch(input, {
+      ...init,
+      headers
+    });
+    handleRefreshedToken(response);
+    return response;
+  };
+  const wrappedFetchWithBunCompat = wrappedFetch;
+  wrappedFetchWithBunCompat.preconnect = originalFetch.preconnect?.bind(originalFetch);
+  globalThis.fetch = wrappedFetchWithBunCompat;
+  window.fetch = wrappedFetchWithBunCompat;
+}
+function resolveServerFunctionTarget(serverBaseUrl) {
+  const envBase = serverBaseUrl ?? (import.meta?.env?.SERVER_BASE_URL ?? "");
+  const trimmed = envBase.trim();
+  if (!trimmed || trimmed === "/") {
+    return {
+      origin: window.location.origin,
+      path: "/_server"
+    };
+  }
+  try {
+    const baseUrl = new URL(trimmed, window.location.origin);
+    const basePath = normalizePath(baseUrl.pathname);
+    const serverPath = basePath === "/" ? "/_server" : `${basePath}/_server`;
+    return {
+      origin: baseUrl.origin,
+      path: normalizePath(serverPath)
+    };
+  } catch {
+    return {
+      origin: window.location.origin,
+      path: "/_server"
+    };
+  }
+}
+function resolveRequestUrl(input) {
+  try {
+    if (input instanceof URL)
+      return input;
+    if (typeof input === "string")
+      return new URL(input, window.location.href);
+    return new URL(input.url, window.location.href);
+  } catch {
+    return null;
+  }
+}
+function mergeHeaders(input, init) {
+  const headers = new Headers();
+  if (input instanceof Request) {
+    input.headers.forEach((value, key) => {
+      headers.set(key, value);
+    });
+  }
+  if (init.headers) {
+    new Headers(init.headers).forEach((value, key) => {
+      headers.set(key, value);
+    });
+  }
+  return headers;
+}
+function isSolidStartServerFunctionRequest(requestUrl, target) {
+  if (requestUrl.origin !== target.origin)
+    return false;
+  return normalizePath(requestUrl.pathname) === target.path;
+}
+function normalizePath(pathname) {
+  if (!pathname)
+    return "/";
+  const normalized = pathname.replace(/\/{2,}/g, "/").replace(/\/+$/, "");
+  return normalized || "/";
+}
+
+// src/client/vanilla/index.ts
+init_tauri();
+init_token();
+init_token();
+function buildQuery(params) {
+  const q = new URLSearchParams();
+  for (const [k, v] of Object.entries(params)) {
+    if (v != null && v !== "")
+      q.set(k, String(v));
+  }
+  const s = q.toString();
+  return s ? `?${s}` : "";
+}
+function createAuthClient({ baseUrl, scheme = "gau" }) {
+  let currentSession = { user: null, session: null, accounts: null, providers: [] };
+  const listeners = /* @__PURE__ */ new Set();
+  const notify = () => {
+    for (const l of listeners)
+      l(currentSession);
+  };
+  async function fetchSession() {
+    const token = getSessionToken();
+    const headers = token ? { Authorization: `Bearer ${token}` } : void 0;
+    const res = await fetch(`${baseUrl}/session`, token ? { headers } : { credentials: "include" });
+    const contentType = res.headers.get("content-type");
+    if (contentType?.includes("application/json"))
+      return await res.json();
+    return { user: null, session: null, accounts: null, providers: [] };
+  }
+  async function refreshSession() {
+    const next = await fetchSession();
+    currentSession = next;
+    notify();
+    return next;
+  }
+  async function applySessionToken(token) {
+    try {
+      storeSessionToken(token);
+    } finally {
+      await refreshSession();
+    }
+  }
+  function onSessionChange(listener) {
+    listeners.add(listener);
+    return () => listeners.delete(listener);
+  }
+  async function handleRedirectCallback(replaceUrl) {
+    if (typeof window === "undefined")
+      return false;
+    if (window.location.hash === "#_=_") {
+      const cleanUrl2 = window.location.pathname + window.location.search;
+      if (replaceUrl)
+        replaceUrl(cleanUrl2);
+      else
+        window.history.replaceState(null, "", cleanUrl2);
+      return false;
+    }
+    const hash = window.location.hash?.substring(1) ?? "";
+    if (!hash)
+      return false;
+    const params = new URLSearchParams(hash);
+    const token = params.get("token");
+    if (!token)
+      return false;
+    await applySessionToken(token);
+    const cleanUrl = window.location.pathname + window.location.search;
+    if (replaceUrl)
+      replaceUrl(cleanUrl);
+    else
+      window.history.replaceState(null, "", cleanUrl);
+    return true;
+  }
+  function makeProviderUrl(provider, params) {
+    const q = buildQuery({
+      redirectTo: params?.redirectTo,
+      profile: params?.profile != null ? String(params.profile) : void 0
+    });
+    return `${baseUrl}/${provider}${q}`;
+  }
+  function makeLinkUrl(provider, params) {
+    const q = buildQuery({
+      redirectTo: params.redirectTo,
+      profile: params.profile != null ? String(params.profile) : void 0,
+      redirect: params.redirect
+    });
+    return `${baseUrl}/link/${provider}${q}`;
+  }
+  async function signIn(provider, options) {
+    const url = makeProviderUrl(provider, options);
+    if (isTauri()) {
+      const { signInWithTauri: signInWithTauri2 } = await Promise.resolve().then(() => (init_tauri(), tauri_exports));
+      await signInWithTauri2(provider, baseUrl, scheme, options?.redirectTo, options?.profile);
+    }
+    return url;
+  }
+  async function linkAccount(provider, options) {
+    if (isTauri()) {
+      const { linkAccountWithTauri: linkAccountWithTauri2 } = await Promise.resolve().then(() => (init_tauri(), tauri_exports));
+      await linkAccountWithTauri2(provider, baseUrl, scheme, options?.redirectTo, options?.profile);
+      return makeLinkUrl(provider, { redirectTo: options?.redirectTo, profile: options?.profile, redirect: "false" });
+    }
+    const linkUrl = makeLinkUrl(provider, { redirectTo: options?.redirectTo, profile: options?.profile, redirect: "false" });
+    const token = getSessionToken();
+    const fetchOptions = token ? { headers: { Authorization: `Bearer ${token}` } } : { credentials: "include" };
+    const res = await fetch(linkUrl, fetchOptions);
+    if (res.redirected)
+      return res.url;
+    try {
+      const data = await res.json();
+      if (data?.url)
+        return data.url;
+    } catch {
+    }
+    return linkUrl;
+  }
+  async function unlinkAccount(provider) {
+    const token = getSessionToken();
+    const fetchOptions = token ? { headers: { Authorization: `Bearer ${token}` } } : { credentials: "include" };
+    const res = await fetch(`${baseUrl}/unlink/${provider}`, { method: "POST", ...fetchOptions });
+    if (res.ok) {
+      await refreshSession();
+      return true;
+    }
+    return false;
+  }
+  async function signOut() {
+    const token = getSessionToken();
+    clearSessionToken();
+    const headers = token ? { Authorization: `Bearer ${token}` } : void 0;
+    await fetch(`${baseUrl}/signout`, token ? { method: "POST", headers } : { method: "POST", credentials: "include" });
+    await refreshSession();
+  }
+  async function startTauriBridge() {
+    if (!isTauri())
+      return;
+    const { startAuthBridge: startAuthBridge2 } = await Promise.resolve().then(() => (init_tauri(), tauri_exports));
+    const cleanup = await startAuthBridge2(baseUrl, scheme, async (token) => {
+      await applySessionToken(token);
+    });
+    return cleanup;
+  }
+  async function authFetch(input, init = {}) {
+    const token = getSessionToken();
+    const headers = new Headers(init.headers);
+    if (token)
+      headers.set("Authorization", `Bearer ${token}`);
+    const res = await globalThis.fetch(input, {
+      ...init,
+      headers,
+      ...!token && { credentials: "include" }
+    });
+    handleRefreshedToken(res);
+    return res;
+  }
+  return {
+    get session() {
+      return currentSession;
+    },
+    fetch: authFetch,
+    fetchSession,
+    refreshSession,
+    applySessionToken,
+    handleRedirectCallback,
+    onSessionChange,
+    signIn,
+    linkAccount,
+    unlinkAccount,
+    signOut,
+    startTauriBridge
+  };
+}
+
+// src/client/solid2/Protected.tsx
+import { useNavigate } from "@solidjs/router";
+import { isServer } from "@solidjs/web";
+import { onSettled, Show } from "solid-js";
+function onClientReady(fn) {
+  if (isServer)
+    return;
+  onSettled(fn);
+}
+function Protected(page, fallbackOrRedirect) {
+  return () => {
+    const auth = useAuth();
+    const navigate = useNavigate();
+    const isRedirectMode = typeof fallbackOrRedirect === "string" || fallbackOrRedirect === void 0;
+    const redirectTo = isRedirectMode ? fallbackOrRedirect ?? "/" : void 0;
+    const Fallback = !isRedirectMode ? fallbackOrRedirect : void 0;
+    const Redirect = () => {
+      onClientReady(() => {
+        if (!isServer && redirectTo)
+          navigate(redirectTo, { replace: true });
+      });
+      return null;
+    };
+    return <Show when={!auth.isLoading()} fallback={null}>
+        <Show
+      when={auth.session().user}
+      fallback={isRedirectMode ? <Redirect /> : Fallback ? <Fallback /> : null}
+    >
+          {page(auth.session)}
+        </Show>
+      </Show>;
+  };
+}
+
+// src/client/solid2/index.tsx
+var AuthContext = createContext();
+function onClientReady2(fn) {
+  if (isServer2)
+    return;
+  onSettled2(fn);
+}
+function AuthProvider(props) {
+  const scheme = untrack(() => props.scheme ?? "gau");
+  const baseUrl = untrack(() => props.baseUrl ?? "/api/auth");
+  if (!isServer2 && isTauri())
+    installSolidStartFetchBridge();
+  const client = createAuthClient({
+    baseUrl,
+    scheme
+  });
+  const hasExternalSession = () => props.session !== void 0;
+  const getExternalSession = () => {
+    const external = props.session;
+    return typeof external === "function" ? external() : external;
+  };
+  const [state, setState] = createStore({
+    mounted: false,
+    isRefreshing: false,
+    isReady: false,
+    clientOverride: null,
+    clientSession: null
+  });
+  const setResolvedSession = (next) => {
+    setState(hasExternalSession() ? { clientOverride: next } : { clientSession: next });
+  };
+  const session = createMemo(() => {
+    const override = state.clientOverride;
+    if (override !== null)
+      return override;
+    if (hasExternalSession()) {
+      const ext = getExternalSession();
+      return ext;
+    }
+    return state.clientSession ?? createEmptyClientSession();
+  });
+  const isLoading = createMemo(() => {
+    if (hasExternalSession())
+      return false;
+    return !state.mounted || !state.isReady || state.clientSession === null && state.isRefreshing;
+  });
+  const auth = createClientAuth({
+    client,
+    redirectTo: untrack(() => props.redirectTo),
+    setSession: setResolvedSession,
+    onReady: () => {
+      setState({ isReady: true });
+    },
+    onRefreshing: (refreshing) => {
+      setState({ isRefreshing: refreshing });
+    }
+  });
+  const contextValue = {
+    session,
+    isLoading,
+    ...auth.controls
+  };
+  const provider = <AuthContext value={contextValue}>
+      {props.children}
+    </AuthContext>;
+  onClientReady2(() => {
+    if (!untrack(hasExternalSession))
+      setState({ mounted: true });
+    return auth.mount();
+  });
+  return provider;
+}
+function useAuth() {
+  return useContext(AuthContext);
+}
+export {
+  AuthProvider,
+  Protected,
+  useAuth
+};