@robelest/convex-auth 0.0.4-preview.25 → 0.0.4-preview.28

package/dist/browser/index.d.ts

@@ -0,0 +1,30 @@
+import { AuthApiRefs, BrowserAuthClient, ClientOptions } from "../client/core/types.js";
+import "../client/index.js";
+
+//#region src/browser/index.d.ts
+/**
+ * Create a browser-configured auth client.
+ *
+ * This is the recommended entrypoint for web apps. It applies browser runtime
+ * defaults on top of the framework-agnostic `client(...)`
+ * helper, including `ConvexHttpClient` transport discovery and passkey support.
+ *
+ * @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.
+ *
+ * @example
+ * ```ts
+ * import { ConvexReactClient } from "convex/react";
+ * import { client } from "@robelest/convex-auth/browser";
+ * import { api } from "../convex/_generated/api";
+ *
+ * const convex = new ConvexReactClient(import.meta.env.VITE_CONVEX_URL);
+ * const auth = client({ convex, api: api.auth });
+ * ```
+ */
+declare function client<Api extends AuthApiRefs<boolean, boolean, boolean> = AuthApiRefs>(options: ClientOptions<Api>): BrowserAuthClient<Api>;
+//#endregion
+export { type AuthApiRefs, type BrowserAuthClient as AuthClient, type ClientOptions, client };
+//# sourceMappingURL=index.d.ts.map

package/dist/browser/index.js

@@ -0,0 +1,93 @@
+import { ClientAdapterFactoriesLive, ClientAdaptersLive } from "../client/services/adapters.js";
+import { ClientHttpLive } from "../client/services/http.js";
+import { resolveClientServices } from "../client/services/resolve.js";
+import { ClientRuntimeLive } from "../client/services/runtime.js";
+import { client as client$1 } from "../client/index.js";
+import { createBrowserRuntime } from "./runtime.js";
+import { createPasskeyClient } from "./passkey.js";
+import { ConvexHttpClient } from "convex/browser";
+
+//#region src/browser/index.ts
+/**
+* Browser-first auth client for `@robelest/convex-auth/browser`.
+*
+* This entrypoint wraps the framework-agnostic `client(...)`
+* helper with browser defaults such as `ConvexHttpClient`, local storage, URL
+* replacement, and passkey adapters.
+*
+* @module
+*/
+/**
+* Create a browser-configured auth client.
+*
+* This is the recommended entrypoint for web apps. It applies browser runtime
+* defaults on top of the framework-agnostic `client(...)`
+* helper, including `ConvexHttpClient` transport discovery and passkey support.
+*
+* @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.
+*
+* @example
+* ```ts
+* import { ConvexReactClient } from "convex/react";
+* import { client } from "@robelest/convex-auth/browser";
+* import { api } from "../convex/_generated/api";
+*
+* const convex = new ConvexReactClient(import.meta.env.VITE_CONVEX_URL);
+* const auth = client({ convex, api: api.auth });
+* ```
+*/
+function client(options) {
+	const url = options.proxyPath === void 0 ? options.url ?? inferConvexUrl(options.convex) : void 0;
+	const services = resolveClientServices({
+		runtime: ClientRuntimeLive(mergeBrowserRuntime(options.runtime)),
+		adapters: ClientAdaptersLive(options.adapters ?? {}),
+		adapterFactories: ClientAdapterFactoriesLive({
+			...options.adapterFactories,
+			passkey: options.adapterFactories?.passkey ?? ((deps) => createPasskeyClient(deps))
+		}),
+		http: ClientHttpLive(options.proxyPath !== void 0 ? null : options.httpClient ?? (url ? new ConvexHttpClient(url) : null))
+	});
+	return client$1({
+		...options,
+		storage: options.storage === void 0 && options.proxyPath !== void 0 ? null : options.storage,
+		runtime: services.runtime,
+		adapters: services.adapters,
+		adapterFactories: services.adapterFactories,
+		httpClient: services.httpClient
+	});
+}
+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,
+		sync: runtime?.sync ?? defaults.sync,
+		mutex: runtime?.mutex ?? defaults.mutex
+	};
+}
+function inferConvexUrl(convex) {
+	if (!convex || typeof convex !== "object") return;
+	const candidate = convex;
+	try {
+		if (typeof candidate.url === "string") return candidate.url;
+	} catch {
+		return;
+	}
+	try {
+		const client = typeof candidate.client === "object" && candidate.client !== null ? candidate.client : void 0;
+		return typeof client?.url === "string" ? client.url : void 0;
+	} catch {
+		return;
+	}
+}
+
+//#endregion
+export { client };
+//# sourceMappingURL=index.js.map

package/dist/browser/locks.js

@@ -0,0 +1,11 @@
+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;
+	return lockManager !== void 0 ? await lockManager.request(key, callback) : 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);
+	},
+	redirect: (url) => {
+		if (typeof window !== "undefined") window.location.href = url.toString();
+	}
+};
+
+//#endregion
+export { BrowserNavigationLive };
+//# sourceMappingURL=navigation.js.map

package/dist/{factors → browser}/passkey.js

@@ -1,38 +1,28 @@
-import { base64urlDecode, base64urlEncode } from "../runtime/browser.js";
-import { Fx } from "@robelest/fx";
+import { base64urlDecode, base64urlEncode } from "./runtime.js";
 
-//#region src/client/factors/passkey.ts
+//#region src/browser/passkey.ts
 /** @internal */
 function createPasskeyClient(deps) {
 	const { proxy, convex, requireApiRefs, proxyFetch, setTokenAndMaybeWait } = deps;
 	const handleSignedInResult = async (result, flow) => {
-		return Fx.run(Fx.match(result, result.kind, {
-			signedIn: (signedInResult) => Fx.promise(async () => {
-				return await setTokenAndMaybeWait(proxy ? {
-					shouldStore: false,
-					tokens: signedInResult.tokens === null ? null : { token: signedInResult.tokens.token },
-					waitForHandshake: true,
-					context: {
-						provider: "passkey",
-						flow
-					}
-				} : {
-					shouldStore: true,
-					tokens: signedInResult.tokens,
-					waitForHandshake: true,
-					context: {
-						provider: "passkey",
-						flow
-					}
-				}) ? { kind: "signedIn" } : { kind: "started" };
-			}),
-			redirect: () => Fx.succeed({ kind: "started" }),
-			started: () => Fx.succeed({ kind: "started" }),
-			passkeyOptions: () => Fx.succeed({ kind: "started" }),
-			totpRequired: () => Fx.succeed({ kind: "started" }),
-			totpSetup: () => Fx.succeed({ kind: "started" }),
-			deviceCode: () => Fx.succeed({ kind: "started" })
-		}));
+		if (result.kind !== "signedIn") return { kind: "started" };
+		return await setTokenAndMaybeWait(proxy ? {
+			shouldStore: false,
+			tokens: result.tokens === null ? null : { token: result.tokens.token },
+			waitForHandshake: true,
+			context: {
+				provider: "passkey",
+				flow
+			}
+		} : {
+			shouldStore: true,
+			tokens: result.tokens,
+			waitForHandshake: true,
+			context: {
+				provider: "passkey",
+				flow
+			}
+		}) ? { kind: "signedIn" } : { kind: "started" };
 	};
 	return {
 		isSupported: () => {
@@ -41,8 +31,9 @@ function createPasskeyClient(deps) {
 		isAutofillSupported: async () => {
 			if (typeof window === "undefined") return false;
 			if (typeof window.PublicKeyCredential === "undefined") return false;
-			if (typeof window.PublicKeyCredential.isConditionalMediationAvailable !== "function") return false;
-			return window.PublicKeyCredential.isConditionalMediationAvailable();
+			const credential = window.PublicKeyCredential;
+			if (typeof credential.isConditionalMediationAvailable !== "function") return false;
+			return credential.isConditionalMediationAvailable();
 		},
 		register: async (opts) => {
 			const phase1Params = {

package/dist/browser/runtime.js

@@ -0,0 +1,92 @@
+import { BrowserLocksLive } from "./locks.js";
+import { BrowserNavigationLive } from "./navigation.js";
+
+//#region src/browser/runtime.ts
+const browserStorage = {
+	async getItem(key) {
+		try {
+			return localStorage.getItem(key);
+		} catch {
+			return null;
+		}
+	},
+	async setItem(key, value) {
+		try {
+			localStorage.setItem(key, value);
+		} catch {}
+	},
+	async removeItem(key) {
+		try {
+			localStorage.removeItem(key);
+		} catch {}
+	}
+};
+/** @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 padded = str.replace(/-/g, "+").replace(/_/g, "/");
+	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();
+			},
+			redirect: (url) => {
+				BrowserNavigationLive.redirect(url);
+				return Promise.resolve();
+			}
+		},
+		mutex: { withKey: (key, callback) => BrowserLocksLive.withKey(key, callback) },
+		proxy: { fetch: async (body, proxyPath) => {
+			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();
+			const existingSubscription = registry[key];
+			if (existingSubscription !== void 0) existingSubscription();
+			const controller = new AbortController();
+			window.addEventListener("storage", (event) => {
+				if (event.key !== key) return;
+				callback(event.newValue ?? null);
+			}, { signal: controller.signal });
+			const unsubscribe = () => {
+				if (registry[key] === unsubscribe) delete registry[key];
+				controller.abort();
+			};
+			registry[key] = unsubscribe;
+			return unsubscribe;
+		} }
+	};
+}
+
+//#endregion
+export { base64urlDecode, base64urlEncode, createBrowserRuntime };
+//# sourceMappingURL=runtime.js.map