@estifanos-sh/convex-auth 0.0.1-preview.0

package/dist/browser/index.d.ts

@@ -0,0 +1,22 @@
+import { AuthApiRefs, ClientOptions, PlatformAuthClient } from "../client/core/types.js";
+import "../client/index.js";
+
+//#region src/browser/index.d.ts
+/**
+ * Create a browser-configured auth client.
+ *
+ * Applies browser runtime defaults (`ConvexHttpClient` transport, local
+ * storage, URL cleanup, OAuth launch, WebAuthn support) on top of the
+ * framework-agnostic `client(...)` helper, then returns it directly — the core
+ * owns OAuth launch/completion and initialization, driven by the injected
+ * browser runtime.
+ *
+ * @param options - Browser client configuration. See {@link ClientOptions}.
+ * @typeParam Api - Auth API references that control which factor helpers are
+ *   available on the returned client.
+ * @returns A browser auth client with the configured auth helpers.
+ */
+declare function client<Api extends AuthApiRefs<boolean, boolean, boolean> = AuthApiRefs>(options: ClientOptions<Api>): PlatformAuthClient<Api>;
+//#endregion
+export { type AuthApiRefs, type PlatformAuthClient as AuthClient, type ClientOptions, client };
+//# sourceMappingURL=index.d.ts.map

package/dist/browser/index.js

@@ -0,0 +1,61 @@
+import { client as client$1, resolveUrl } from "../client/index.js";
+import { createBrowserRuntime } from "./runtime.js";
+import { createWebAuthnClient } from "./webauthn.js";
+import { ConvexHttpClient } from "convex/browser";
+
+//#region src/browser/index.ts
+/**
+* Browser-first auth client for `@estifanos-sh/convex-auth/browser`.
+*
+* This entrypoint wraps the framework-agnostic `client(...)`
+* helper with browser defaults such as `ConvexHttpClient`, local storage, URL
+* replacement, OAuth launching, and WebAuthn adapters.
+*
+* @module
+*/
+/**
+* Create a browser-configured auth client.
+*
+* Applies browser runtime defaults (`ConvexHttpClient` transport, local
+* storage, URL cleanup, OAuth launch, WebAuthn support) on top of the
+* framework-agnostic `client(...)` helper, then returns it directly — the core
+* owns OAuth launch/completion and initialization, driven by the injected
+* browser runtime.
+*
+* @param options - Browser client configuration. See {@link ClientOptions}.
+* @typeParam Api - Auth API references that control which factor helpers are
+*   available on the returned client.
+* @returns A browser auth client with the configured auth helpers.
+*/
+function client(options) {
+	const proxyMode = options.proxyPath !== void 0;
+	const url = proxyMode ? void 0 : options.url ?? resolveUrl(options.convex);
+	return client$1({
+		...options,
+		storage: options.storage === void 0 && proxyMode ? null : options.storage,
+		runtime: mergeBrowserRuntime(options.runtime),
+		adapterFactories: {
+			...options.adapterFactories,
+			webauthn: options.adapterFactories?.webauthn ?? ((deps) => createWebAuthnClient(deps))
+		},
+		httpClient: proxyMode ? null : options.httpClient ?? (url ? new ConvexHttpClient(url) : null)
+	});
+}
+function mergeBrowserRuntime(runtime) {
+	const defaults = createBrowserRuntime();
+	return {
+		...defaults,
+		...runtime,
+		environment: runtime?.environment ?? defaults.environment,
+		proxy: runtime?.proxy ?? defaults.proxy,
+		storage: runtime?.storage === void 0 ? defaults.storage : runtime.storage,
+		location: runtime?.location ?? defaults.location,
+		oauth: runtime?.oauth ?? defaults.oauth,
+		sync: runtime?.sync ?? defaults.sync,
+		mutex: runtime?.mutex ?? defaults.mutex
+	};
+}
+
+//#endregion
+export { client };
+//# sourceMappingURL=index.js.map

package/dist/browser/locks.js

@@ -0,0 +1,20 @@
+import { localMutex } from "../client/runtime/mutex.js";
+
+//#region src/browser/locks.ts
+const BrowserLocksLive = { withKey: async (key, callback) => {
+	const lockManager = typeof navigator === "undefined" ? void 0 : navigator.locks;
+	if (lockManager === void 0) return await localMutex(key, callback);
+	try {
+		return await lockManager.request(key, callback);
+	} catch (err) {
+		console.warn("[auth] navigator.locks.request failed; falling back to localMutex", {
+			key,
+			err
+		});
+		return await localMutex(key, callback);
+	}
+} };
+
+//#endregion
+export { BrowserLocksLive };
+//# sourceMappingURL=locks.js.map

package/dist/browser/navigation.js

@@ -0,0 +1,14 @@
+//#region src/browser/navigation.ts
+const BrowserNavigationLive = {
+	get: () => typeof window === "undefined" ? null : new URL(window.location.href),
+	replace: (url) => {
+		if (typeof window !== "undefined") window.history.replaceState({}, "", url);
+	},
+	open: (url) => {
+		if (typeof window !== "undefined") window.location.href = url.toString();
+	}
+};
+
+//#endregion
+export { BrowserNavigationLive };
+//# sourceMappingURL=navigation.js.map

package/dist/browser/runtime.js

@@ -0,0 +1,90 @@
+import { BrowserLocksLive } from "./locks.js";
+import { BrowserNavigationLive } from "./navigation.js";
+
+//#region src/browser/runtime.ts
+const browserStorage = {
+	getItem(key) {
+		try {
+			return localStorage.getItem(key);
+		} catch {
+			return null;
+		}
+	},
+	setItem(key, value) {
+		localStorage.setItem(key, value);
+	},
+	removeItem(key) {
+		localStorage.removeItem(key);
+	}
+};
+/** @internal */
+function base64urlEncode(buffer) {
+	const bytes = new Uint8Array(buffer);
+	let binary = "";
+	for (let i = 0; i < bytes.byteLength; i++) binary += String.fromCharCode(bytes[i]);
+	return btoa(binary).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+}
+/** @internal */
+function base64urlDecode(str) {
+	const normalized = str.replace(/-/g, "+").replace(/_/g, "/");
+	const padded = normalized + "=".repeat((4 - normalized.length % 4) % 4);
+	const binary = atob(padded);
+	const bytes = new Uint8Array(binary.length);
+	for (let i = 0; i < binary.length; i++) bytes[i] = binary.charCodeAt(i);
+	return bytes;
+}
+/** @internal */
+function getStorageListenerRegistry() {
+	const globals = globalThis;
+	if (globals.__convexAuthStorageListeners === void 0) globals.__convexAuthStorageListeners = {};
+	return globals.__convexAuthStorageListeners;
+}
+/** @internal */
+function createBrowserRuntime() {
+	return {
+		environment: typeof window === "undefined" ? "server" : "client",
+		storage: typeof window === "undefined" ? null : browserStorage,
+		location: {
+			get: () => BrowserNavigationLive.get(),
+			replace: (url) => {
+				BrowserNavigationLive.replace(url);
+				return Promise.resolve();
+			}
+		},
+		oauth: { open: (url) => {
+			BrowserNavigationLive.open(url);
+			return Promise.resolve();
+		} },
+		mutex: { withKey: (key, callback) => BrowserLocksLive.withKey(key, callback) },
+		proxy: { fetch: async (body, proxyPath) => {
+			if (typeof window === "undefined" || window.location?.origin === void 0) throw new Error("Browser proxy fetch is unavailable outside the browser runtime.");
+			return fetch(new URL(proxyPath, window.location.origin), {
+				method: "POST",
+				headers: { "Content-Type": "application/json" },
+				credentials: "include",
+				body: JSON.stringify(body)
+			});
+		} },
+		sync: { subscribe: (key, callback) => {
+			if (typeof window === "undefined") return null;
+			const registry = getStorageListenerRegistry();
+			if (registry[key] === void 0) registry[key] = /* @__PURE__ */ new Set();
+			const controller = new AbortController();
+			window.addEventListener("storage", (event) => {
+				if (event.key !== key) return;
+				callback(event.newValue ?? null);
+			}, { signal: controller.signal });
+			const unsubscribe = () => {
+				registry[key]?.delete(unsubscribe);
+				if (registry[key]?.size === 0) delete registry[key];
+				controller.abort();
+			};
+			registry[key].add(unsubscribe);
+			return unsubscribe;
+		} }
+	};
+}
+
+//#endregion
+export { base64urlDecode, base64urlEncode, createBrowserRuntime };
+//# sourceMappingURL=runtime.js.map

package/dist/browser/webauthn.js

@@ -0,0 +1,99 @@
+import { createWebAuthnClientCore } from "../client/factors/webauthn.js";
+import { base64urlDecode, base64urlEncode } from "./runtime.js";
+
+//#region src/browser/webauthn.ts
+const browserWebAuthnCeremony = {
+	isSupported: () => typeof window !== "undefined" && typeof window.PublicKeyCredential !== "undefined",
+	isAutofillSupported: async () => {
+		if (typeof window === "undefined") return false;
+		if (typeof window.PublicKeyCredential === "undefined") return false;
+		const credential = window.PublicKeyCredential;
+		if (typeof credential.isConditionalMediationAvailable !== "function") return false;
+		return credential.isConditionalMediationAvailable();
+	},
+	register: async (rawOptions, opts) => {
+		const options = rawOptions;
+		const createOptions = { publicKey: {
+			rp: options.rp,
+			user: {
+				id: base64urlDecode(options.user.id).buffer,
+				name: options.user.name,
+				displayName: options.user.displayName
+			},
+			challenge: base64urlDecode(options.challenge).buffer,
+			pubKeyCredParams: options.pubKeyCredParams,
+			timeout: options.timeout,
+			hints: options.hints,
+			attestation: options.attestation,
+			authenticatorSelection: options.authenticatorSelection,
+			excludeCredentials: (options.excludeCredentials ?? []).map((cred) => ({
+				type: cred.type ?? "public-key",
+				id: base64urlDecode(cred.id).buffer,
+				transports: cred.transports
+			}))
+		} };
+		const createAbort = new AbortController();
+		createOptions.signal = createAbort.signal;
+		const createAbortTimer = setTimeout(() => createAbort.abort(new DOMException("Passkey registration timed out", "TimeoutError")), options.timeout ?? 12e4);
+		let credential;
+		try {
+			credential = await navigator.credentials.create(createOptions);
+		} finally {
+			clearTimeout(createAbortTimer);
+		}
+		if (!credential) throw new Error("Passkey registration was cancelled");
+		const response = credential.response;
+		const transports = typeof response.getTransports === "function" ? response.getTransports() : void 0;
+		return {
+			flow: "verify",
+			clientDataJSON: base64urlEncode(response.clientDataJSON),
+			attestationObject: base64urlEncode(response.attestationObject),
+			transports,
+			passkeyName: opts?.name
+		};
+	},
+	signIn: async (rawOptions, opts) => {
+		const options = rawOptions;
+		const getOptions = {
+			publicKey: {
+				challenge: base64urlDecode(options.challenge).buffer,
+				timeout: options.timeout,
+				rpId: options.rpId,
+				hints: options.hints,
+				userVerification: options.userVerification,
+				allowCredentials: (options.allowCredentials ?? []).map((cred) => ({
+					type: cred.type ?? "public-key",
+					id: base64urlDecode(cred.id).buffer,
+					transports: cred.transports
+				}))
+			},
+			...opts?.autofill ? { mediation: "conditional" } : {}
+		};
+		const getAbort = new AbortController();
+		getOptions.signal = getAbort.signal;
+		const getAbortTimer = opts?.autofill ? void 0 : setTimeout(() => getAbort.abort(new DOMException("Passkey authentication timed out", "TimeoutError")), options.timeout ?? 12e4);
+		let credential;
+		try {
+			credential = await navigator.credentials.get(getOptions);
+		} finally {
+			if (getAbortTimer !== void 0) clearTimeout(getAbortTimer);
+		}
+		if (!credential) throw new Error("Passkey authentication was cancelled");
+		const response = credential.response;
+		return {
+			flow: "verify",
+			credentialId: base64urlEncode(credential.rawId),
+			clientDataJSON: base64urlEncode(response.clientDataJSON),
+			authenticatorData: base64urlEncode(response.authenticatorData),
+			signature: base64urlEncode(response.signature)
+		};
+	}
+};
+/** @internal */
+function createWebAuthnClient(deps) {
+	return createWebAuthnClientCore(deps, browserWebAuthnCeremony);
+}
+
+//#endregion
+export { createWebAuthnClient };
+//# sourceMappingURL=webauthn.js.map