faire-auth 1.0.0

package/dist/hono-BEq1NYVX.cjs

@@ -0,0 +1,526 @@
+const require_chunk = require('./chunk-oakRccI5.cjs');
+const require_url = require('./url-D2yvKaM7.cjs');
+const require_request = require('./request-CPNlp-DK.cjs');
+const require_defu = require('./defu-B0Svx_x4.cjs');
+const require_parser = require('./parser-CdncAl9i.cjs');
+let hono_utils_cookie = require("hono/utils/cookie");
+let __better_fetch_fetch = require("@better-fetch/fetch");
+let nanostores = require("nanostores");
+
+//#region src/client/fetch-plugins.ts
+const redirectPlugin = {
+	id: "redirect",
+	name: "Redirect",
+	hooks: { onSuccess(context) {
+		if (context.data?.url && context.data?.redirect) {
+			if (typeof window !== "undefined" && window.location) {
+				if (window.location) try {
+					window.location.href = context.data.url;
+				} catch {}
+			}
+		}
+	} }
+};
+
+//#endregion
+//#region src/client/plugins/lifecycle.ts
+const lifecycle = (options) => ({
+	id: "lifecycle-hooks",
+	name: "lifecycle-hooks",
+	hooks: {
+		...options?.fetchOptions?.onSuccess && { onSuccess: options?.fetchOptions?.onSuccess },
+		...options?.fetchOptions?.onError && { onError: options.fetchOptions.onError },
+		...options?.fetchOptions?.onRequest && { onRequest: options.fetchOptions.onRequest },
+		...options?.fetchOptions?.onResponse && { onResponse: options.fetchOptions.onResponse }
+	}
+});
+
+//#endregion
+//#region src/client/query.ts
+const isServer = typeof window === "undefined";
+const useAuthQuery = (initializedAtom, path, $fetch, options) => {
+	const value = (0, nanostores.atom)({
+		data: null,
+		error: null,
+		isPending: true,
+		isRefetching: false,
+		refetch: async () => fn()
+	});
+	const fn = async () => {
+		const opts = typeof options === "function" ? options({
+			data: value.get().data,
+			error: value.get().error,
+			isPending: value.get().isPending
+		}) : options;
+		return $fetch(path, {
+			...opts,
+			onSuccess: async (context) => {
+				value.set({
+					data: context.data,
+					error: null,
+					isPending: false,
+					isRefetching: false,
+					refetch: value.value.refetch
+				});
+				await opts?.onSuccess?.(context);
+			},
+			onError: async (context) => {
+				const { request } = context;
+				const retryAttempts = typeof request.retry === "number" ? request.retry : request.retry?.attempts;
+				const retryAttempt = request.retryAttempt ?? 0;
+				if (retryAttempts != null && retryAttempt < retryAttempts) return;
+				value.set({
+					error: context.error,
+					data: null,
+					isPending: false,
+					isRefetching: false,
+					refetch: value.value.refetch
+				});
+				await opts?.onError?.(context);
+			},
+			onRequest: async (context) => {
+				const currentValue = value.get();
+				value.set({
+					isPending: currentValue.data === null,
+					data: currentValue.data,
+					error: null,
+					isRefetching: true,
+					refetch: value.value.refetch
+				});
+				await opts?.onRequest?.(context);
+			}
+		});
+	};
+	initializedAtom = Array.isArray(initializedAtom) ? initializedAtom : [initializedAtom];
+	let isMounted = false;
+	for (const initAtom of initializedAtom) initAtom.subscribe(() => {
+		if (isServer) return;
+		if (isMounted) fn();
+		else (0, nanostores.onMount)(value, () => {
+			setTimeout(() => {
+				fn();
+			}, 0);
+			isMounted = true;
+			return () => {
+				value.off();
+				initAtom.off();
+			};
+		});
+	});
+	return value;
+};
+
+//#endregion
+//#region src/client/broadcast-channel.ts
+const now$1 = () => Math.floor(Date.now() / 1e3);
+function createBroadcastChannel(name = "faire-auth.message") {
+	return {
+		receive(onReceive) {
+			const handler = (event) => {
+				if (event.key !== name) return;
+				const message = JSON.parse(event.newValue ?? "{}");
+				if (message?.event !== "session" || !message?.data) return;
+				onReceive(message);
+			};
+			window.addEventListener("storage", handler);
+			return () => window.removeEventListener("storage", handler);
+		},
+		post(message) {
+			if (typeof window === "undefined") return;
+			try {
+				localStorage.setItem(name, JSON.stringify({
+					...message,
+					timestamp: now$1()
+				}));
+			} catch {}
+		}
+	};
+}
+
+//#endregion
+//#region src/client/session-refresh.ts
+const now = () => Math.floor(Date.now() / 1e3);
+function createSessionRefreshManager(opts) {
+	const { sessionAtom, sessionSignal, options = {} } = opts;
+	const { refetchInterval = 0, refetchOnWindowFocus = true, refetchWhenOffline = false } = options?.sessionOptions || {};
+	const state = {
+		lastSync: 0,
+		cachedSession: void 0
+	};
+	let isOnline = typeof navigator !== "undefined" ? navigator.onLine : true;
+	const broadcast = createBroadcastChannel();
+	const shouldRefetch = () => {
+		if (typeof window === "undefined") return false;
+		return refetchWhenOffline || isOnline;
+	};
+	const triggerRefetch = (event) => {
+		if (!shouldRefetch()) return;
+		if (event?.event === "storage") {
+			state.lastSync = now();
+			sessionSignal.set(!sessionSignal.get());
+			return;
+		}
+		const currentSession = sessionAtom.get();
+		if (currentSession?.data === null || currentSession?.data === void 0 || event?.event === "poll" || event?.event === "visibilitychange") {
+			state.lastSync = now();
+			sessionSignal.set(!sessionSignal.get());
+		}
+	};
+	const broadcastSessionUpdate = (trigger) => {
+		broadcast.post({
+			event: "session",
+			data: { trigger },
+			clientId: Math.random().toString(36).substring(7)
+		});
+	};
+	const setupPolling = () => {
+		if (refetchInterval && refetchInterval > 0) state.pollInterval = setInterval(() => {
+			if (sessionAtom.get()?.data) triggerRefetch({ event: "poll" });
+		}, refetchInterval * 1e3);
+	};
+	const setupBroadcast = () => {
+		state.unsubscribeBroadcast = broadcast.receive(() => {
+			triggerRefetch({ event: "storage" });
+		});
+	};
+	const setupVisibilityChange = () => {
+		if (!refetchOnWindowFocus) return;
+		if (typeof document === "undefined") return;
+		const visibilityHandler = () => {
+			if (document.visibilityState === "visible") triggerRefetch({ event: "visibilitychange" });
+		};
+		document.addEventListener("visibilitychange", visibilityHandler, false);
+		state.unsubscribeVisibility = () => {
+			document.removeEventListener("visibilitychange", visibilityHandler, false);
+		};
+	};
+	const setupOnlineDetection = () => {
+		if (typeof window === "undefined") return;
+		const setOnline = () => {
+			isOnline = true;
+			triggerRefetch({ event: "visibilitychange" });
+		};
+		const setOffline = () => {
+			isOnline = false;
+		};
+		window.addEventListener("online", setOnline);
+		window.addEventListener("offline", setOffline);
+		state.unsubscribeOnline = () => window.removeEventListener("online", setOnline);
+		state.unsubscribeOffline = () => window.removeEventListener("offline", setOffline);
+	};
+	const init = () => {
+		if (typeof window === "undefined") return;
+		setupPolling();
+		setupBroadcast();
+		setupVisibilityChange();
+		setupOnlineDetection();
+	};
+	const cleanup = () => {
+		if (state.pollInterval) {
+			clearInterval(state.pollInterval);
+			state.pollInterval = void 0;
+		}
+		if (state.unsubscribeBroadcast) {
+			state.unsubscribeBroadcast();
+			state.unsubscribeBroadcast = void 0;
+		}
+		if (state.unsubscribeVisibility) {
+			state.unsubscribeVisibility();
+			state.unsubscribeVisibility = void 0;
+		}
+		if (state.unsubscribeOnline) {
+			state.unsubscribeOnline();
+			state.unsubscribeOnline = void 0;
+		}
+		if (state.unsubscribeOffline) {
+			state.unsubscribeOffline();
+			state.unsubscribeOffline = void 0;
+		}
+		state.lastSync = 0;
+		state.cachedSession = void 0;
+	};
+	return {
+		init,
+		cleanup,
+		triggerRefetch,
+		broadcastSessionUpdate
+	};
+}
+
+//#endregion
+//#region src/client/session-atom.ts
+const getSessionAtom = ($fetch, options) => {
+	const $signal = (0, nanostores.atom)(false);
+	const session = useAuthQuery($signal, "/get-session", $fetch, { method: "GET" });
+	if (typeof window !== "undefined") (0, nanostores.onMount)(session, () => {
+		const refreshManager = createSessionRefreshManager({
+			sessionAtom: session,
+			sessionSignal: $signal,
+			$fetch,
+			options
+		});
+		refreshManager.init();
+		return () => {
+			refreshManager.cleanup();
+		};
+	});
+	return {
+		session,
+		$sessionSignal: $signal
+	};
+};
+
+//#endregion
+//#region src/client/config.ts
+const getClientConfig = (options) => {
+	const baseURL = () => require_url.getBaseURL(options?.baseURL, options?.basePath) ?? "/api/auth";
+	const plugins = options?.plugins ?? [];
+	const pluginsFetchPlugins = plugins.flatMap((plugin) => plugin.fetchPlugins).filter((pl) => pl !== void 0);
+	const { onSuccess: _, onError: __, onRequest: ___, onResponse: ____,...restOfFetchOptions } = options?.fetchOptions ?? {};
+	const $fetch = (0, __better_fetch_fetch.createFetch)({
+		get baseURL() {
+			return baseURL();
+		},
+		..."credentials" in Request.prototype && { credentials: "include" },
+		method: "GET",
+		jsonParser(text) {
+			if (!text) return null;
+			return require_parser.parseJSON(text, { strict: false });
+		},
+		customFetchImpl: fetch,
+		...restOfFetchOptions,
+		plugins: [
+			lifecycle(options),
+			...restOfFetchOptions.plugins ?? [],
+			...options?.disableDefaultFetchPlugins ? [] : [redirectPlugin],
+			...pluginsFetchPlugins
+		]
+	});
+	const sessionAtom = getSessionAtom($fetch);
+	const pluginsActions = {};
+	const pluginsAtoms = sessionAtom;
+	const pluginPathMethods = {
+		"/sign-out": "POST",
+		"/revoke-sessions": "POST",
+		"/revoke-other-sessions": "POST",
+		"/delete-user": "POST"
+	};
+	const atomListeners = [{
+		signal: "$sessionSignal",
+		matcher(path) {
+			return path === "/sign-out" || path === "/update-user" || path.startsWith("/sign-in") || path.startsWith("/sign-up") || path === "/delete-user" || path === "/verify-email";
+		}
+	}];
+	for (const plugin of plugins) {
+		if (plugin.getAtoms) Object.assign(pluginsAtoms, plugin.getAtoms?.($fetch));
+		if (plugin.pathMethods) Object.assign(pluginPathMethods, plugin.pathMethods);
+		if (plugin.atomListeners) atomListeners.push(...plugin.atomListeners);
+	}
+	const $store = {
+		notify: (signal) => {
+			if (signal) pluginsAtoms[signal].set(!pluginsAtoms[signal].get());
+		},
+		listen: (signal, listener) => {
+			pluginsAtoms[signal].subscribe(listener);
+		},
+		atoms: pluginsAtoms
+	};
+	for (const plugin of plugins) if (plugin.getActions) Object.assign(pluginsActions, plugin.getActions?.($fetch, $store, options));
+	return {
+		get baseURL() {
+			return baseURL();
+		},
+		pluginsActions,
+		pluginsAtoms,
+		pluginPathMethods,
+		atomListeners,
+		$fetch,
+		$store
+	};
+};
+
+//#endregion
+//#region src/client/hono.ts
+const isPromise = (value) => value != null && typeof value.then === "function";
+const isHonoRequestLike = (value) => value != null && typeof value === "object" && "raw" in value && value.raw instanceof Request && "header" in value && typeof value.header === "function" && "query" in value && typeof value.query === "function" && "param" in value && typeof value.param === "function" && "json" in value && typeof value.json === "function" && "path" in value && typeof value.path === "string";
+const isInputOpts = (value) => value == null || typeof value === "object" && Object.keys(value).every((k) => k !== "fetchOptions" && k !== "fetch" && k !== "websocket" && k !== "init" && k !== "headers");
+const returnFromRoutesIfFn = (fullPath, routes) => {
+	let current = routes;
+	for (const segment of fullPath) if (current && typeof current === "object" && segment in current) current = current[segment];
+	else {
+		current = void 0;
+		break;
+	}
+	if (typeof current === "function" || fullPath[0] === "$fetch" || fullPath[0] === "$store") return current;
+};
+const createProxy = (callback, path, routes) => {
+	return new Proxy(() => {}, {
+		get(_obj, key) {
+			if (typeof key !== "string" || key === "then" || key === "catch" || key === "finally") return void 0;
+			const fullPath = [...path, key];
+			const maybeFn = returnFromRoutesIfFn(fullPath, routes);
+			if (maybeFn) return maybeFn;
+			return createProxy(callback, fullPath, routes);
+		},
+		apply(_1, _2, args) {
+			return callback({
+				path,
+				args
+			});
+		}
+	});
+};
+var ClientRequestImpl = class {
+	url;
+	path;
+	method;
+	queryParams = void 0;
+	pathParams = {};
+	rBody;
+	cType = void 0;
+	$fetch;
+	atoms;
+	atomListeners;
+	constructor(url, path, method, $fetch, atoms, atomListeners) {
+		this.url = url;
+		this.path = path;
+		this.method = method;
+		this.$fetch = $fetch;
+		if (atoms) this.atoms = atoms;
+		if (atomListeners) this.atomListeners = atomListeners;
+	}
+	fetch = async (args, opt) => {
+		if (isHonoRequestLike(opt.fetch)) return this.$fetch(opt.fetch.url, opt.fetch.raw);
+		if (args) {
+			if (args.query) this.queryParams = require_request.buildSearchParams(args.query);
+			if (args.form) {
+				const form = new FormData();
+				for (const [k, v] of Object.entries(args.form)) if (Array.isArray(v)) for (const v2 of v) form.append(k, v2);
+				else form.append(k, v);
+				this.rBody = form;
+			}
+			if (args.json) {
+				this.rBody = JSON.stringify(args.json);
+				this.cType = "application/json";
+			}
+			if (args.param) this.pathParams = args.param;
+		}
+		let methodUpperCase = this.method.toUpperCase();
+		let headers = require_request.normaliseHeaders(opt.headers);
+		if (isPromise(headers)) headers = await headers;
+		if (args?.header) Object.entries(args.header).forEach(([k, v]) => headers.set(k, v));
+		if (args?.cookie) {
+			const cookies = [];
+			for (const [key, value] of Object.entries(args.cookie)) cookies.push((0, hono_utils_cookie.serialize)(key, value, { path: "/" }));
+			headers.set("Cookie", cookies.join(","));
+		}
+		if (this.cType) headers.set("Content-Type", this.cType);
+		let url = this.url;
+		url = require_request.removeIndexString(url);
+		url = require_request.replaceUrlParam(url, this.pathParams);
+		if (this.queryParams && this.queryParams.size > 0) url = url + "?" + this.queryParams.toString();
+		methodUpperCase = this.method.toUpperCase();
+		const setBody = !(methodUpperCase === "GET" || methodUpperCase === "HEAD");
+		return this.$fetch(url, {
+			customFetchImpl: opt.fetch,
+			...opt.fetchOptions,
+			...setBody === true && { body: this.rBody },
+			method: methodUpperCase,
+			headers,
+			...opt.init,
+			onSuccess: async (context) => {
+				if (opt.fetchOptions?.onSuccess) await opt.fetchOptions.onSuccess(context);
+				/**
+				* We trigger listeners
+				*/
+				const matches = this.atomListeners?.filter((s) => s.matcher(this.path));
+				if (!matches?.length) return;
+				for (const match of matches) {
+					const signal = this.atoms?.[match.signal];
+					if (!signal) return;
+					/**
+					* To avoid race conditions we set the signal in a setTimeout
+					*/
+					const val = signal.get();
+					setTimeout(() => signal.set(!val), 10);
+				}
+			}
+		});
+	};
+};
+const createHonoClient = (options, routes, $fetch, atoms, atomListeners) => createProxy(function proxyCallback(opts) {
+	const parts = opts.path.map((segment) => segment.replace(/[A-Z]/g, (letter) => `-${letter.toLowerCase()}`));
+	const lastParts = parts.slice(-3).reverse();
+	if (lastParts[0] === "toString") {
+		if (lastParts[1] === "name") return lastParts[2] ?? "";
+		return proxyCallback.toString();
+	}
+	if (lastParts[0] === "valueOf") {
+		if (lastParts[1] === "name") return lastParts[2] ?? "";
+		return proxyCallback;
+	}
+	let method = "";
+	if (/^\$/.test(lastParts[0])) {
+		const last = parts.pop();
+		if (last) method = last.replace(/^\$/, "");
+	}
+	const { input, clientOpts } = isInputOpts(opts.args[0]) ? {
+		input: opts.args[0] ?? {},
+		clientOpts: opts.args[1] ?? {}
+	} : {
+		input: {},
+		clientOpts: opts.args[0] ?? {}
+	};
+	const path = `/${parts.join("/")}`;
+	const url = require_request.mergePath(options.baseURL, path);
+	clientOpts.headers = require_request.mergeHeaders(options?.createFetchOptions?.headers, clientOpts.fetchOptions?.headers, clientOpts.headers);
+	if (method === "url" || method === "path") {
+		let result = url;
+		if (input.param) result = require_request.replaceUrlParam(url, input.param);
+		if (input.query) {
+			const sp = require_request.buildSearchParams(input.query);
+			if (sp.size > 0) result += "?" + sp.toString();
+		}
+		result = require_request.removeIndexString(result);
+		if (method === "url") return new URL(result);
+		const base = (options.baseURL ?? "").replace(/\/+$/, "");
+		return result.slice(base.length).replace(/^\/?/, "/");
+	}
+	if (method === "ws") {
+		const webSocketUrl = require_request.replaceUrlProtocol(input.param ? require_request.replaceUrlParam(url, input.param) : url, "ws");
+		const targetUrl = new URL(webSocketUrl);
+		const queryParams = input.query;
+		if (queryParams) Object.entries(queryParams).forEach(([key, value]) => {
+			if (Array.isArray(value)) value.forEach((item) => targetUrl.searchParams.append(key, item));
+			else targetUrl.searchParams.set(key, value);
+		});
+		const establishWebSocket = (...args) => {
+			if (options?.webSocket !== void 0 && typeof options.webSocket === "function") return options.webSocket(...args);
+			return new WebSocket(...args);
+		};
+		return establishWebSocket(targetUrl.toString());
+	}
+	const req = new ClientRequestImpl(url, path, method, $fetch, atoms, atomListeners);
+	clientOpts.fetchOptions = require_defu.defu(clientOpts.fetchOptions, options.createFetchOptions);
+	return req.fetch(input, clientOpts);
+}, [], routes);
+
+//#endregion
+Object.defineProperty(exports, 'createHonoClient', {
+  enumerable: true,
+  get: function () {
+    return createHonoClient;
+  }
+});
+Object.defineProperty(exports, 'getClientConfig', {
+  enumerable: true,
+  get: function () {
+    return getClientConfig;
+  }
+});
+Object.defineProperty(exports, 'useAuthQuery', {
+  enumerable: true,
+  get: function () {
+    return useAuthQuery;
+  }
+});

package/dist/hono-Cdukwu5K.cjs

@@ -0,0 +1,13 @@
+const require_chunk = require('./chunk-oakRccI5.cjs');
+let hono_context_storage = require("hono/context-storage");
+
+//#region src/context/hono.ts
+const getContext = () => (0, hono_context_storage.getContext)();
+
+//#endregion
+Object.defineProperty(exports, 'getContext', {
+  enumerable: true,
+  get: function () {
+    return getContext;
+  }
+});

package/dist/hono-CoKYWnXA.mjs

@@ -0,0 +1,7 @@
+import { contextStorage, getContext } from "hono/context-storage";
+
+//#region src/context/hono.ts
+const getContext$1 = () => getContext();
+
+//#endregion
+export { getContext$1 as n, contextStorage as t };