@faire-auth/expo 1.0.0

package/README.md

@@ -0,0 +1,95 @@
+# Faire Auth Expo Plugin
+
+This plugin integrates Faire Auth with Expo, allowing you to easily add authentication to your Expo (React Native) applications. It supports both Expo native and web apps.
+
+## Installation
+
+To get started, install the necessary packages:
+
+```bash
+# Using npm
+npm install faire-auth @faire-auth/expo
+
+# Using yarn
+yarn add faire-auth @faire-auth/expo
+
+# Using pnpm
+pnpm add faire-auth @faire-auth/expo
+
+# Using bun
+bun add faire-auth @faire-auth/expo
+```
+
+You will also need to install `expo-secure-store` for secure session and cookie storage in your Expo app:
+
+```bash
+npm install expo-secure-store
+# or
+yarn add expo-secure-store
+# or
+pnpm add expo-secure-store
+# or
+bun add expo-secure-store
+```
+
+## Basic Usage
+
+### Configure the Faire Auth Backend
+
+Ensure you have a Faire Auth backend set up. You can follow the main [Installation Guide](https://www.faire-auth.com/docs/installation).
+
+Then, add the Expo plugin to your Faire Auth server configuration (e.g., in your `auth.ts` or `lib/auth.ts` file):
+
+```typescript
+// lib/auth.ts
+import { faireAuth } from "faire-auth";
+import { expo } from "@faire-auth/expo"; // Import the server plugin
+
+export const auth = faireAuth({
+    // ...your other Faire Auth options
+    baseURL: "http://localhost:8081", // The base URL of your application server where the routes are mounted.
+    plugins: [expo()], // Add the Expo server plugin
+    emailAndPassword: {
+        enabled: true,
+    },
+    // Add other configurations like trustedOrigins
+    trustedOrigins: ["myapp://"] // Replace "myapp" with your app's scheme
+});
+```
+
+### Initialize the Faire Auth Client in Expo
+
+In your Expo app, initialize the client (e.g., in `lib/auth-client.ts`):
+
+```typescript
+// lib/auth-client.ts
+import { createAuthClient } from "faire-auth/react";
+import { expoClient } from "@faire-auth/expo/client"; // Import the client plugin
+import * as SecureStore from "expo-secure-store";
+
+export const authClient = createAuthClient({
+    baseURL: "http://localhost:8081", // Your Faire Auth backend URL
+    plugins: [
+        expoClient({
+            scheme: "myapp", // Your app's scheme (defined in app.json)
+            storagePrefix: "myapp", // A prefix for storage keys
+            storage: SecureStore, // Pass SecureStore for token storage
+        })
+    ]
+});
+
+// You can also export specific methods if you prefer:
+// export const { signIn, signUp, useSession } = authClient;
+```
+Make sure your app's scheme (e.g., "myapp") is defined in your `app.json`.
+
+## Documentation
+
+For more detailed information and advanced configurations, please refer to the documentation:
+
+- **Main Faire Auth Installation:** [https://www.faire-auth.com/docs/installation](https://www.faire-auth.com/docs/installation)
+- **Expo Integration Guide:** [https://www.faire-auth.com/docs/integrations/expo](https://www.faire-auth.com/docs/integrations/expo)
+
+## License
+
+MIT

package/dist/client.cjs

@@ -0,0 +1,196 @@
+//#region rolldown:runtime
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+//#endregion
+let expo_linking = require("expo-linking");
+expo_linking = __toESM(expo_linking);
+let react_native = require("react-native");
+let expo_constants = require("expo-constants");
+expo_constants = __toESM(expo_constants);
+let faire_auth = require("faire-auth");
+
+//#region src/client.ts
+function parseSetCookieHeader(header) {
+	const cookieMap = /* @__PURE__ */ new Map();
+	splitSetCookieHeader(header).forEach((cookie) => {
+		const [nameValue, ...attributes] = cookie.split(";").map((p) => p.trim());
+		if (!nameValue) return;
+		const [name, ...valueParts] = nameValue.split("=");
+		if (!name) return;
+		const cookieObj = { value: valueParts.join("=") };
+		attributes.forEach((attr) => {
+			const [attrName, ...attrValueParts] = attr.split("=");
+			if (!attrName) return;
+			const attrValue = attrValueParts.join("=");
+			cookieObj[attrName.toLowerCase()] = attrValue;
+		});
+		cookieMap.set(name, cookieObj);
+	});
+	return cookieMap;
+}
+function splitSetCookieHeader(setCookie) {
+	const parts = [];
+	let buffer = "";
+	let i = 0;
+	while (i < setCookie.length) {
+		const char = setCookie[i];
+		if (char === ",") {
+			const recent = buffer.toLowerCase();
+			const hasExpires = recent.includes("expires=");
+			const hasGmt = /gmt/i.test(recent);
+			if (hasExpires && !hasGmt) {
+				buffer += char;
+				i += 1;
+				continue;
+			}
+			if (buffer.trim().length > 0) {
+				parts.push(buffer.trim());
+				buffer = "";
+			}
+			i += 1;
+			if (setCookie[i] === " ") i += 1;
+			continue;
+		}
+		buffer += char;
+		i += 1;
+	}
+	if (buffer.trim().length > 0) parts.push(buffer.trim());
+	return parts;
+}
+function getSetCookie(header, prevCookie) {
+	const parsed = parseSetCookieHeader(header);
+	let toSetCookie = {};
+	parsed.forEach((cookie, key) => {
+		const expiresAt = cookie["expires"];
+		const maxAge = cookie["max-age"];
+		const expires = maxAge ? new Date(Date.now() + Number(maxAge) * 1e3) : expiresAt ? new Date(String(expiresAt)) : null;
+		toSetCookie[key] = {
+			value: cookie["value"],
+			expires: expires ? expires.toISOString() : null
+		};
+	});
+	if (prevCookie) try {
+		toSetCookie = {
+			...JSON.parse(prevCookie),
+			...toSetCookie
+		};
+	} catch {}
+	return JSON.stringify(toSetCookie);
+}
+function getCookie(cookie) {
+	let parsed = {};
+	try {
+		parsed = JSON.parse(cookie);
+	} catch (e) {}
+	return Object.entries(parsed).reduce((acc, [key, value], idx) => {
+		if (value.expires && new Date(value.expires) < /* @__PURE__ */ new Date()) return acc;
+		return `${idx !== 0 ? `${acc}; ` : ""}${key}=${value.value}`;
+	}, "");
+}
+function getOrigin(scheme) {
+	return expo_linking.createURL("", { scheme });
+}
+const expoClient = ({ storage, disableCache, scheme: rawScheme = expo_constants.default.expoConfig?.scheme || expo_constants.default.platform?.scheme, storagePrefix = "faire-auth" }) => {
+	let store = null;
+	const cookieName = `${storagePrefix}_cookie`;
+	const localCacheName = `${storagePrefix}_session_data`;
+	const isWeb = react_native.Platform.OS === "web";
+	const scheme = Array.isArray(rawScheme) ? rawScheme[0] : rawScheme;
+	if (!scheme && !isWeb) throw new Error("Scheme not found in app.json. Please provide a scheme in the options.");
+	return {
+		id: "expo",
+		getActions(_, $store) {
+			store = $store;
+			return { getCookie: () => {
+				return getCookie(storage.getItem(cookieName) || "{}");
+			} };
+		},
+		fetchPlugins: [{
+			id: "expo",
+			name: "Expo",
+			hooks: { async onSuccess(context) {
+				if (isWeb) return;
+				const setCookie = context.response.headers.get("set-cookie");
+				if (setCookie) {
+					const prevCookie = await storage.getItem(cookieName);
+					const toSetCookie = getSetCookie(setCookie || "", prevCookie ?? void 0);
+					await storage.setItem(cookieName, toSetCookie);
+					store?.notify("$sessionSignal");
+				}
+				if (context.request.url.toString().includes("/get-session") && !disableCache && context.data?.data) storage.setItem(localCacheName, JSON.stringify(context.data.data));
+				if (context.data?.data.redirect && (context.request.url.toString().includes("/sign-in") || context.request.url.toString().includes("/link-social")) && !context.request?.body.includes("idToken")) {
+					const callbackURL = JSON.parse(context.request.body)?.callbackURL;
+					const to = callbackURL?.startsWith("/") ? expo_linking.createURL(callbackURL, { scheme }) : callbackURL;
+					const signInURL = context.data?.data.url;
+					let Browser = void 0;
+					try {
+						Browser = await import("expo-web-browser");
+					} catch (error) {
+						throw new Error("\"expo-web-browser\" is not installed as a dependency!", { cause: error });
+					}
+					const result = await Browser.openAuthSessionAsync(signInURL, to);
+					if (result.type !== "success") return;
+					const url = new URL(result.url);
+					const cookie = String(url.searchParams.get("cookie"));
+					if (!cookie) return;
+					storage.setItem(cookieName, getSetCookie(cookie));
+					store?.notify("$sessionSignal");
+				}
+			} },
+			async init(url, options) {
+				if (isWeb) return {
+					url,
+					options
+				};
+				options ||= {};
+				const cookie = getCookie(storage.getItem(cookieName) || "{}");
+				options.credentials = "omit";
+				options.headers = (0, faire_auth.mergeHeaders)(options.headers, {
+					cookie,
+					"expo-origin": getOrigin(scheme),
+					"x-skip-oauth-proxy": "true"
+				});
+				if (url.includes("/sign-out")) {
+					await storage.setItem(cookieName, "{}");
+					store?.atoms.session?.set({
+						...store.atoms.session.get(),
+						data: null,
+						error: null,
+						isPending: false
+					});
+					storage.setItem(localCacheName, "{}");
+				}
+				return {
+					url,
+					options
+				};
+			}
+		}]
+	};
+};
+
+//#endregion
+exports.__toESM = __toESM;
+exports.expoClient = expoClient;
+exports.getCookie = getCookie;
+exports.getSetCookie = getSetCookie;
+exports.parseSetCookieHeader = parseSetCookieHeader;

package/dist/client.d.cts

@@ -0,0 +1,119 @@
+import * as _better_fetch_fetch0 from "@better-fetch/fetch";
+import { BetterFetchOption } from "@better-fetch/fetch";
+import { Store } from "faire-auth/types";
+
+//#region src/client.d.ts
+interface CookieAttributes {
+  value: string;
+  expires?: Date;
+  "max-age"?: number;
+  domain?: string;
+  path?: string;
+  secure?: boolean;
+  httpOnly?: boolean;
+  sameSite?: "Strict" | "Lax" | "None";
+}
+declare function parseSetCookieHeader(header: string): Map<string, CookieAttributes>;
+interface ExpoClientOptions {
+  scheme?: string;
+  storage: {
+    setItem: (key: string, value: string) => any;
+    getItem: (key: string) => string | null;
+  };
+  storagePrefix?: string;
+  disableCache?: boolean;
+}
+declare function getSetCookie(header: string, prevCookie?: string): string;
+declare function getCookie(cookie: string): string;
+declare const expoClient: ({
+  storage,
+  disableCache,
+  scheme: rawScheme,
+  storagePrefix
+}: ExpoClientOptions) => {
+  id: "expo";
+  getActions(_: _better_fetch_fetch0.BetterFetch, $store: Store): {
+    /**
+     * Get the stored cookie.
+     *
+     * You can use this to get the cookie stored in the device and use it in your fetch
+     * requests.
+     *
+     * @example
+     * ```ts
+     * const cookie = client.getCookie();
+     * fetch("https://api.example.com", {
+     * 	headers: {
+     * 		cookie,
+     * 	},
+     * });
+     */
+    getCookie: () => string;
+  };
+  fetchPlugins: {
+    id: string;
+    name: string;
+    hooks: {
+      onSuccess(context: _better_fetch_fetch0.SuccessContext<any>): Promise<void>;
+    };
+    init(url: string, options: {
+      method?: string;
+      redirect?: RequestRedirect;
+      headers?: HeadersInit & (HeadersInit | {
+        accept: "application/json" | "text/plain" | "application/octet-stream";
+        "content-type": "application/json" | "text/plain" | "application/x-www-form-urlencoded" | "multipart/form-data" | "application/octet-stream";
+        authorization: "Bearer" | "Basic";
+      });
+      cache?: RequestCache;
+      credentials?: RequestCredentials;
+      integrity?: string;
+      keepalive?: boolean;
+      mode?: RequestMode;
+      priority?: RequestPriority;
+      referrer?: string;
+      referrerPolicy?: ReferrerPolicy;
+      signal?: AbortSignal | null;
+      window?: null;
+      onRequest?: <T extends Record<string, any>>(context: _better_fetch_fetch0.RequestContext<T>) => Promise<_better_fetch_fetch0.RequestContext | void> | _better_fetch_fetch0.RequestContext | void;
+      onResponse?: (context: _better_fetch_fetch0.ResponseContext) => Promise<Response | void | _better_fetch_fetch0.ResponseContext> | Response | _better_fetch_fetch0.ResponseContext | void;
+      onSuccess?: (context: _better_fetch_fetch0.SuccessContext<any>) => Promise<void> | void;
+      onError?: (context: _better_fetch_fetch0.ErrorContext) => Promise<void> | void;
+      onRetry?: (response: _better_fetch_fetch0.ResponseContext) => Promise<void> | void;
+      hookOptions?: {
+        cloneResponse?: boolean;
+      };
+      timeout?: number;
+      customFetchImpl?: _better_fetch_fetch0.FetchEsque;
+      plugins?: _better_fetch_fetch0.BetterFetchPlugin[];
+      baseURL?: string;
+      throw?: boolean;
+      auth?: {
+        type: "Bearer";
+        token: string | Promise<string | undefined> | (() => string | Promise<string | undefined> | undefined) | undefined;
+      } | {
+        type: "Basic";
+        username: string | (() => string | undefined) | undefined;
+        password: string | (() => string | undefined) | undefined;
+      } | {
+        type: "Custom";
+        prefix: string | (() => string | undefined) | undefined;
+        value: string | (() => string | undefined) | undefined;
+      };
+      body?: any;
+      query?: any;
+      params?: any;
+      duplex?: "full" | "half";
+      jsonParser?: (text: string) => Promise<any> | any;
+      retry?: _better_fetch_fetch0.RetryOptions;
+      retryAttempt?: number;
+      output?: _better_fetch_fetch0.StandardSchemaV1 | typeof Blob | typeof File;
+      errorSchema?: _better_fetch_fetch0.StandardSchemaV1;
+      disableValidation?: boolean;
+    } | undefined): Promise<{
+      url: string;
+      options: BetterFetchOption;
+    }>;
+  }[];
+};
+//#endregion
+export { expoClient, getCookie, getSetCookie, parseSetCookieHeader };

package/dist/client.d.mts

@@ -0,0 +1,119 @@
+import * as _better_fetch_fetch0 from "@better-fetch/fetch";
+import { BetterFetchOption } from "@better-fetch/fetch";
+import { Store } from "faire-auth/types";
+
+//#region src/client.d.ts
+interface CookieAttributes {
+  value: string;
+  expires?: Date;
+  "max-age"?: number;
+  domain?: string;
+  path?: string;
+  secure?: boolean;
+  httpOnly?: boolean;
+  sameSite?: "Strict" | "Lax" | "None";
+}
+declare function parseSetCookieHeader(header: string): Map<string, CookieAttributes>;
+interface ExpoClientOptions {
+  scheme?: string;
+  storage: {
+    setItem: (key: string, value: string) => any;
+    getItem: (key: string) => string | null;
+  };
+  storagePrefix?: string;
+  disableCache?: boolean;
+}
+declare function getSetCookie(header: string, prevCookie?: string): string;
+declare function getCookie(cookie: string): string;
+declare const expoClient: ({
+  storage,
+  disableCache,
+  scheme: rawScheme,
+  storagePrefix
+}: ExpoClientOptions) => {
+  id: "expo";
+  getActions(_: _better_fetch_fetch0.BetterFetch, $store: Store): {
+    /**
+     * Get the stored cookie.
+     *
+     * You can use this to get the cookie stored in the device and use it in your fetch
+     * requests.
+     *
+     * @example
+     * ```ts
+     * const cookie = client.getCookie();
+     * fetch("https://api.example.com", {
+     * 	headers: {
+     * 		cookie,
+     * 	},
+     * });
+     */
+    getCookie: () => string;
+  };
+  fetchPlugins: {
+    id: string;
+    name: string;
+    hooks: {
+      onSuccess(context: _better_fetch_fetch0.SuccessContext<any>): Promise<void>;
+    };
+    init(url: string, options: {
+      method?: string;
+      redirect?: RequestRedirect;
+      headers?: HeadersInit & (HeadersInit | {
+        accept: "application/json" | "text/plain" | "application/octet-stream";
+        "content-type": "application/json" | "text/plain" | "application/x-www-form-urlencoded" | "multipart/form-data" | "application/octet-stream";
+        authorization: "Bearer" | "Basic";
+      });
+      cache?: RequestCache;
+      credentials?: RequestCredentials;
+      integrity?: string;
+      keepalive?: boolean;
+      mode?: RequestMode;
+      priority?: RequestPriority;
+      referrer?: string;
+      referrerPolicy?: ReferrerPolicy;
+      signal?: AbortSignal | null;
+      window?: null;
+      onRequest?: <T extends Record<string, any>>(context: _better_fetch_fetch0.RequestContext<T>) => Promise<_better_fetch_fetch0.RequestContext | void> | _better_fetch_fetch0.RequestContext | void;
+      onResponse?: (context: _better_fetch_fetch0.ResponseContext) => Promise<Response | void | _better_fetch_fetch0.ResponseContext> | Response | _better_fetch_fetch0.ResponseContext | void;
+      onSuccess?: (context: _better_fetch_fetch0.SuccessContext<any>) => Promise<void> | void;
+      onError?: (context: _better_fetch_fetch0.ErrorContext) => Promise<void> | void;
+      onRetry?: (response: _better_fetch_fetch0.ResponseContext) => Promise<void> | void;
+      hookOptions?: {
+        cloneResponse?: boolean;
+      };
+      timeout?: number;
+      customFetchImpl?: _better_fetch_fetch0.FetchEsque;
+      plugins?: _better_fetch_fetch0.BetterFetchPlugin[];
+      baseURL?: string;
+      throw?: boolean;
+      auth?: {
+        type: "Bearer";
+        token: string | Promise<string | undefined> | (() => string | Promise<string | undefined> | undefined) | undefined;
+      } | {
+        type: "Basic";
+        username: string | (() => string | undefined) | undefined;
+        password: string | (() => string | undefined) | undefined;
+      } | {
+        type: "Custom";
+        prefix: string | (() => string | undefined) | undefined;
+        value: string | (() => string | undefined) | undefined;
+      };
+      body?: any;
+      query?: any;
+      params?: any;
+      duplex?: "full" | "half";
+      jsonParser?: (text: string) => Promise<any> | any;
+      retry?: _better_fetch_fetch0.RetryOptions;
+      retryAttempt?: number;
+      output?: _better_fetch_fetch0.StandardSchemaV1 | typeof Blob | typeof File;
+      errorSchema?: _better_fetch_fetch0.StandardSchemaV1;
+      disableValidation?: boolean;
+    } | undefined): Promise<{
+      url: string;
+      options: BetterFetchOption;
+    }>;
+  }[];
+};
+//#endregion
+export { expoClient, getCookie, getSetCookie, parseSetCookieHeader };

package/dist/client.mjs

@@ -0,0 +1,167 @@
+import * as Linking from "expo-linking";
+import { Platform } from "react-native";
+import Constants from "expo-constants";
+import { mergeHeaders } from "faire-auth";
+
+//#region src/client.ts
+function parseSetCookieHeader(header) {
+	const cookieMap = /* @__PURE__ */ new Map();
+	splitSetCookieHeader(header).forEach((cookie) => {
+		const [nameValue, ...attributes] = cookie.split(";").map((p) => p.trim());
+		if (!nameValue) return;
+		const [name, ...valueParts] = nameValue.split("=");
+		if (!name) return;
+		const cookieObj = { value: valueParts.join("=") };
+		attributes.forEach((attr) => {
+			const [attrName, ...attrValueParts] = attr.split("=");
+			if (!attrName) return;
+			const attrValue = attrValueParts.join("=");
+			cookieObj[attrName.toLowerCase()] = attrValue;
+		});
+		cookieMap.set(name, cookieObj);
+	});
+	return cookieMap;
+}
+function splitSetCookieHeader(setCookie) {
+	const parts = [];
+	let buffer = "";
+	let i = 0;
+	while (i < setCookie.length) {
+		const char = setCookie[i];
+		if (char === ",") {
+			const recent = buffer.toLowerCase();
+			const hasExpires = recent.includes("expires=");
+			const hasGmt = /gmt/i.test(recent);
+			if (hasExpires && !hasGmt) {
+				buffer += char;
+				i += 1;
+				continue;
+			}
+			if (buffer.trim().length > 0) {
+				parts.push(buffer.trim());
+				buffer = "";
+			}
+			i += 1;
+			if (setCookie[i] === " ") i += 1;
+			continue;
+		}
+		buffer += char;
+		i += 1;
+	}
+	if (buffer.trim().length > 0) parts.push(buffer.trim());
+	return parts;
+}
+function getSetCookie(header, prevCookie) {
+	const parsed = parseSetCookieHeader(header);
+	let toSetCookie = {};
+	parsed.forEach((cookie, key) => {
+		const expiresAt = cookie["expires"];
+		const maxAge = cookie["max-age"];
+		const expires = maxAge ? new Date(Date.now() + Number(maxAge) * 1e3) : expiresAt ? new Date(String(expiresAt)) : null;
+		toSetCookie[key] = {
+			value: cookie["value"],
+			expires: expires ? expires.toISOString() : null
+		};
+	});
+	if (prevCookie) try {
+		toSetCookie = {
+			...JSON.parse(prevCookie),
+			...toSetCookie
+		};
+	} catch {}
+	return JSON.stringify(toSetCookie);
+}
+function getCookie(cookie) {
+	let parsed = {};
+	try {
+		parsed = JSON.parse(cookie);
+	} catch (e) {}
+	return Object.entries(parsed).reduce((acc, [key, value], idx) => {
+		if (value.expires && new Date(value.expires) < /* @__PURE__ */ new Date()) return acc;
+		return `${idx !== 0 ? `${acc}; ` : ""}${key}=${value.value}`;
+	}, "");
+}
+function getOrigin(scheme) {
+	return Linking.createURL("", { scheme });
+}
+const expoClient = ({ storage, disableCache, scheme: rawScheme = Constants.expoConfig?.scheme || Constants.platform?.scheme, storagePrefix = "faire-auth" }) => {
+	let store = null;
+	const cookieName = `${storagePrefix}_cookie`;
+	const localCacheName = `${storagePrefix}_session_data`;
+	const isWeb = Platform.OS === "web";
+	const scheme = Array.isArray(rawScheme) ? rawScheme[0] : rawScheme;
+	if (!scheme && !isWeb) throw new Error("Scheme not found in app.json. Please provide a scheme in the options.");
+	return {
+		id: "expo",
+		getActions(_, $store) {
+			store = $store;
+			return { getCookie: () => {
+				return getCookie(storage.getItem(cookieName) || "{}");
+			} };
+		},
+		fetchPlugins: [{
+			id: "expo",
+			name: "Expo",
+			hooks: { async onSuccess(context) {
+				if (isWeb) return;
+				const setCookie = context.response.headers.get("set-cookie");
+				if (setCookie) {
+					const prevCookie = await storage.getItem(cookieName);
+					const toSetCookie = getSetCookie(setCookie || "", prevCookie ?? void 0);
+					await storage.setItem(cookieName, toSetCookie);
+					store?.notify("$sessionSignal");
+				}
+				if (context.request.url.toString().includes("/get-session") && !disableCache && context.data?.data) storage.setItem(localCacheName, JSON.stringify(context.data.data));
+				if (context.data?.data.redirect && (context.request.url.toString().includes("/sign-in") || context.request.url.toString().includes("/link-social")) && !context.request?.body.includes("idToken")) {
+					const callbackURL = JSON.parse(context.request.body)?.callbackURL;
+					const to = callbackURL?.startsWith("/") ? Linking.createURL(callbackURL, { scheme }) : callbackURL;
+					const signInURL = context.data?.data.url;
+					let Browser = void 0;
+					try {
+						Browser = await import("expo-web-browser");
+					} catch (error) {
+						throw new Error("\"expo-web-browser\" is not installed as a dependency!", { cause: error });
+					}
+					const result = await Browser.openAuthSessionAsync(signInURL, to);
+					if (result.type !== "success") return;
+					const url = new URL(result.url);
+					const cookie = String(url.searchParams.get("cookie"));
+					if (!cookie) return;
+					storage.setItem(cookieName, getSetCookie(cookie));
+					store?.notify("$sessionSignal");
+				}
+			} },
+			async init(url, options) {
+				if (isWeb) return {
+					url,
+					options
+				};
+				options ||= {};
+				const cookie = getCookie(storage.getItem(cookieName) || "{}");
+				options.credentials = "omit";
+				options.headers = mergeHeaders(options.headers, {
+					cookie,
+					"expo-origin": getOrigin(scheme),
+					"x-skip-oauth-proxy": "true"
+				});
+				if (url.includes("/sign-out")) {
+					await storage.setItem(cookieName, "{}");
+					store?.atoms.session?.set({
+						...store.atoms.session.get(),
+						data: null,
+						error: null,
+						isPending: false
+					});
+					storage.setItem(localCacheName, "{}");
+				}
+				return {
+					url,
+					options
+				};
+			}
+		}]
+	};
+};
+
+//#endregion
+export { expoClient, getCookie, getSetCookie, parseSetCookieHeader };