@stackframe/tanstack-start 0.0.1 → 2.8.91

package/dist/esm/lib/cookie.js

@@ -0,0 +1,347 @@
+import { StackAssertionError } from "@stackframe/stack-shared/dist/utils/errors";
+import { isBrowserLike } from "@stackframe/stack-shared/dist/utils/env";
+import * as tanstackStartServerContext from "@stackframe/tanstack-start/tanstack-start-server-context";
+import Cookies from "js-cookie";
+
+//#region ../../node_modules/.pnpm/oauth4webapi@3.8.5/node_modules/oauth4webapi/build/index.js
+let USER_AGENT;
+if (typeof navigator === "undefined" || !navigator.userAgent?.startsWith?.("Mozilla/5.0 ")) USER_AGENT = `oauth4webapi/v3.8.5`;
+const ERR_INVALID_ARG_VALUE = "ERR_INVALID_ARG_VALUE";
+const ERR_INVALID_ARG_TYPE = "ERR_INVALID_ARG_TYPE";
+function CodedTypeError(message, code, cause) {
+	const err = new TypeError(message, { cause });
+	Object.assign(err, { code });
+	return err;
+}
+const encoder = new TextEncoder();
+const decoder = new TextDecoder();
+function buf(input) {
+	if (typeof input === "string") return encoder.encode(input);
+	return decoder.decode(input);
+}
+let encodeBase64Url;
+if (Uint8Array.prototype.toBase64) encodeBase64Url = (input) => {
+	if (input instanceof ArrayBuffer) input = new Uint8Array(input);
+	return input.toBase64({
+		alphabet: "base64url",
+		omitPadding: true
+	});
+};
+else {
+	const CHUNK_SIZE = 32768;
+	encodeBase64Url = (input) => {
+		if (input instanceof ArrayBuffer) input = new Uint8Array(input);
+		const arr = [];
+		for (let i = 0; i < input.byteLength; i += CHUNK_SIZE) arr.push(String.fromCharCode.apply(null, input.subarray(i, i + CHUNK_SIZE)));
+		return btoa(arr.join("")).replace(/=/g, "").replace(/\+/g, "-").replace(/\//g, "_");
+	};
+}
+let decodeBase64Url;
+if (Uint8Array.fromBase64) decodeBase64Url = (input) => {
+	try {
+		return Uint8Array.fromBase64(input, { alphabet: "base64url" });
+	} catch (cause) {
+		throw CodedTypeError("The input to be decoded is not correctly encoded.", ERR_INVALID_ARG_VALUE, cause);
+	}
+};
+else decodeBase64Url = (input) => {
+	try {
+		const binary = atob(input.replace(/-/g, "+").replace(/_/g, "/").replace(/\s/g, ""));
+		const bytes = new Uint8Array(binary.length);
+		for (let i = 0; i < binary.length; i++) bytes[i] = binary.charCodeAt(i);
+		return bytes;
+	} catch (cause) {
+		throw CodedTypeError("The input to be decoded is not correctly encoded.", ERR_INVALID_ARG_VALUE, cause);
+	}
+};
+function b64u(input) {
+	if (typeof input === "string") return decodeBase64Url(input);
+	return encodeBase64Url(input);
+}
+var OperationProcessingError = class extends Error {
+	code;
+	constructor(message, options) {
+		super(message, options);
+		this.name = this.constructor.name;
+		if (options?.code) this.code = options?.code;
+		Error.captureStackTrace?.(this, this.constructor);
+	}
+};
+function OPE(message, code, cause) {
+	return new OperationProcessingError(message, {
+		code,
+		cause
+	});
+}
+function assertString(input, it, code, cause) {
+	try {
+		if (typeof input !== "string") throw CodedTypeError(`${it} must be a string`, ERR_INVALID_ARG_TYPE, cause);
+		if (input.length === 0) throw CodedTypeError(`${it} must not be empty`, ERR_INVALID_ARG_VALUE, cause);
+	} catch (err) {
+		if (code) throw OPE(err.message, code, cause);
+		throw err;
+	}
+}
+function randomBytes() {
+	return b64u(crypto.getRandomValues(new Uint8Array(32)));
+}
+function generateRandomCodeVerifier() {
+	return randomBytes();
+}
+function generateRandomState() {
+	return randomBytes();
+}
+async function calculatePKCECodeChallenge(codeVerifier) {
+	assertString(codeVerifier, "codeVerifier");
+	return b64u(await crypto.subtle.digest("SHA-256", buf(codeVerifier)));
+}
+const URLParse = URL.parse ? (url, base) => URL.parse(url, base) : (url, base) => {
+	try {
+		return new URL(url, base);
+	} catch {
+		return null;
+	}
+};
+const tokenMatch = "[a-zA-Z0-9!#$%&\\'\\*\\+\\-\\.\\^_`\\|~]+";
+const token68Match = "[a-zA-Z0-9\\-\\._\\~\\+\\/]+={0,2}";
+const quotedParamMatcher = "(" + tokenMatch + ")\\s*=\\s*\"((?:[^\"\\\\]|\\\\[\\s\\S])*)\"";
+const paramMatcher = "(" + tokenMatch + ")\\s*=\\s*([a-zA-Z0-9!#$%&\\'\\*\\+\\-\\.\\^_`\\|~]+)";
+const schemeRE = new RegExp("^[,\\s]*(" + tokenMatch + ")");
+const quotedParamRE = new RegExp("^[,\\s]*" + quotedParamMatcher + "[,\\s]*(.*)");
+const unquotedParamRE = new RegExp("^[,\\s]*" + paramMatcher + "[,\\s]*(.*)");
+const token68ParamRE = new RegExp("^(" + token68Match + ")(?:$|[,\\s])(.*)");
+
+//#endregion
+//#region src/lib/cookie.ts
+let tanStackStartCookieHelperPromise = null;
+function getTanStackStartServerContext() {
+	const { deleteCookie, getCookie, getCookies, getRequestHeader, setCookie } = tanstackStartServerContext;
+	if (deleteCookie == null || getCookie == null || getCookies == null || getRequestHeader == null || setCookie == null) throw new StackAssertionError("TanStack Start server context is only available during server rendering");
+	return {
+		deleteCookie,
+		getCookie,
+		getCookies,
+		getRequestHeader,
+		setCookie
+	};
+}
+function ensureClient() {
+	if (!isBrowserLike()) throw new Error("cookieClient functions can only be called in a browser environment, yet window is undefined");
+}
+async function createPlaceholderCookieHelper() {
+	function throwError() {
+		throw new StackAssertionError("Throwing cookie helper is just a placeholder. This should never be called");
+	}
+	return {
+		get: throwError,
+		getAll: throwError,
+		set: throwError,
+		setOrDelete: throwError,
+		delete: throwError
+	};
+}
+function requiresSecureAttribute(name) {
+	return name.startsWith("__Host-");
+}
+function validateCookieOptions(name, options) {
+	if (requiresSecureAttribute(name) && options.domain !== void 0) throw new StackAssertionError("__Host- cookies must not specify a Domain attribute");
+}
+async function createCookieHelper() {
+	if (isBrowserLike()) return createBrowserCookieHelper();
+	else {
+		if (import.meta.env.SSR) {
+			const cookieHelperPromise = tanStackStartCookieHelperPromise ?? Promise.resolve(createTanStackStartCookieHelper(getTanStackStartServerContext()));
+			tanStackStartCookieHelperPromise = cookieHelperPromise;
+			return await cookieHelperPromise;
+		}
+		return await createPlaceholderCookieHelper();
+	}
+}
+function createCookieHelperSync() {
+	if (isBrowserLike()) return createBrowserCookieHelper();
+	function throwError() {
+		throw new StackAssertionError("Synchronous server cookie helpers are not available on this platform");
+	}
+	return {
+		get: throwError,
+		getAll: throwError,
+		set: throwError,
+		setOrDelete: throwError,
+		delete: throwError
+	};
+}
+function determineSecureFromTanStackStartContext(api) {
+	return api.getRequestHeader("x-forwarded-proto") === "https" || api.getCookie("stack-is-https") !== void 0;
+}
+function refreshTanStackStartIsHttpsCookie(api) {
+	api.setCookie("stack-is-https", "true", {
+		secure: true,
+		maxAge: 3600 * 24 * 365,
+		sameSite: "lax",
+		path: "/"
+	});
+}
+function createTanStackStartCookieHelper(api) {
+	const helper = {
+		get: (name) => {
+			return helper.getAll()[name] ?? null;
+		},
+		getAll: () => {
+			refreshTanStackStartIsHttpsCookie(api);
+			return api.getCookies();
+		},
+		set: (name, value, options) => {
+			validateCookieOptions(name, options);
+			api.setCookie(name, value, {
+				secure: requiresSecureAttribute(name) || (options.secure ?? determineSecureFromTanStackStartContext(api)),
+				maxAge: options.maxAge === "session" ? void 0 : options.maxAge,
+				domain: options.domain,
+				sameSite: "lax",
+				path: "/"
+			});
+		},
+		setOrDelete: (name, value, options) => {
+			if (value === null) helper.delete(name, options);
+			else helper.set(name, value, options);
+		},
+		delete: (name, options) => {
+			validateCookieOptions(name, options);
+			const secure = requiresSecureAttribute(name) || determineSecureFromTanStackStartContext(api);
+			api.deleteCookie(name, {
+				secure,
+				domain: options.domain,
+				path: "/"
+			});
+		}
+	};
+	return helper;
+}
+function createBrowserCookieHelper() {
+	return {
+		get: getCookieClient,
+		getAll: getAllCookiesClient,
+		set: setCookieClient,
+		setOrDelete: setOrDeleteCookieClient,
+		delete: deleteCookieClient
+	};
+}
+function getCookieClient(name) {
+	return getAllCookiesClient()[name] ?? null;
+}
+function getAllCookiesClient() {
+	ensureClient();
+	Cookies.set("stack-is-https", "true", {
+		secure: true,
+		expires: new Date(Date.now() + 1e3 * 60 * 60 * 24 * 365)
+	});
+	return Cookies.get();
+}
+async function getCookie(name) {
+	return (await createCookieHelper()).get(name);
+}
+async function isSecure() {
+	if (isBrowserLike()) return determineSecureFromClientContext();
+	if (import.meta.env.SSR) return determineSecureFromTanStackStartContext(getTanStackStartServerContext());
+	return false;
+}
+function determineSecureFromClientContext() {
+	return typeof window !== "undefined" && window.location.protocol === "https:";
+}
+let _shouldSetPartitionedClientCache = void 0;
+function shouldSetPartitionedClient() {
+	return _shouldSetPartitionedClientCache ??= _internalShouldSetPartitionedClient();
+}
+function _internalShouldSetPartitionedClient() {
+	ensureClient();
+	if (!determineSecureFromClientContext()) return false;
+	const cookie1Name = "__Host-stack-temporary-chips-test-" + Math.random().toString(36).substring(2, 15);
+	document.cookie = `${cookie1Name}=value1; Secure; path=/`;
+	const cookies1 = document.cookie.split("; ");
+	document.cookie = `${cookie1Name}=delete1; Secure; path=/; expires=Thu, 01 Jan 1970 00:00:00 UTC;`;
+	if (cookies1.some((c) => c.startsWith(cookie1Name + "="))) return false;
+	const cookie2Name = "__Host-stack-temporary-chips-test-" + Math.random().toString(36).substring(2, 15);
+	document.cookie = `${cookie2Name}=delete1; Secure; SameSite=None; Partitioned; expires=Thu, 01 Jan 1970 00:00:00 UTC; path=/`;
+	document.cookie = `${cookie2Name}=delete2; Secure; SameSite=None; expires=Thu, 01 Jan 1970 00:00:00 UTC; path=/`;
+	document.cookie = `${cookie2Name}=set1; Secure; SameSite=None; Partitioned; path=/`;
+	document.cookie = `${cookie2Name}=set2; Secure; SameSite=None; path=/`;
+	const numberOfCookiesWithThisName = document.cookie.split("; ").filter((c) => c.startsWith(cookie2Name + "=")).length;
+	document.cookie = `${cookie2Name}=delete3; Secure; SameSite=None; Partitioned; expires=Thu, 01 Jan 1970 00:00:00 UTC; path=/`;
+	document.cookie = `${cookie2Name}=delete4; Secure; SameSite=None; expires=Thu, 01 Jan 1970 00:00:00 UTC; path=/`;
+	return numberOfCookiesWithThisName === 2;
+}
+function setCookieClientInternal(name, value, options) {
+	validateCookieOptions(name, options);
+	const secure = requiresSecureAttribute(name) || (options.secure ?? determineSecureFromClientContext());
+	const partitioned = shouldSetPartitionedClient();
+	Cookies.set(name, value, {
+		expires: options.maxAge === "session" ? void 0 : new Date(Date.now() + options.maxAge * 1e3),
+		domain: options.domain,
+		secure,
+		path: "/",
+		sameSite: "Lax",
+		...partitioned ? {
+			partitioned,
+			sameSite: "None"
+		} : {}
+	});
+}
+function deleteCookieClientInternal(name, options) {
+	validateCookieOptions(name, options);
+	for (const partitioned of [true, false]) {
+		if (options.domain !== void 0) Cookies.remove(name, {
+			domain: options.domain,
+			secure: determineSecureFromClientContext(),
+			partitioned,
+			path: "/"
+		});
+		Cookies.remove(name, {
+			secure: requiresSecureAttribute(name) || determineSecureFromClientContext(),
+			partitioned,
+			path: "/"
+		});
+	}
+}
+function setOrDeleteCookieClient(name, value, options) {
+	ensureClient();
+	if (value === null) deleteCookieClientInternal(name, options);
+	else setCookieClientInternal(name, value, options);
+}
+async function setOrDeleteCookie(name, value, options) {
+	(await createCookieHelper()).setOrDelete(name, value, options);
+}
+function deleteCookieClient(name, options) {
+	ensureClient();
+	deleteCookieClientInternal(name, options);
+}
+async function deleteCookie(name, options) {
+	(await createCookieHelper()).delete(name, options);
+}
+function setCookieClient(name, value, options) {
+	ensureClient();
+	setCookieClientInternal(name, value, options);
+}
+async function setCookie(name, value, options) {
+	(await createCookieHelper()).set(name, value, options);
+}
+async function saveVerifierAndState() {
+	const codeVerifier = generateRandomCodeVerifier();
+	const codeChallenge = await calculatePKCECodeChallenge(codeVerifier);
+	const state = generateRandomState();
+	await setCookie("stack-oauth-outer-" + state, codeVerifier, { maxAge: 3600 });
+	return {
+		codeChallenge,
+		state
+	};
+}
+function consumeVerifierAndStateCookie(state) {
+	ensureClient();
+	const cookieName = "stack-oauth-outer-" + state;
+	const codeVerifier = getCookieClient(cookieName);
+	if (!codeVerifier) return null;
+	deleteCookieClient(cookieName, {});
+	return { codeVerifier };
+}
+
+//#endregion
+export { consumeVerifierAndStateCookie, createBrowserCookieHelper, createCookieHelper, createCookieHelperSync, createPlaceholderCookieHelper, deleteCookie, deleteCookieClient, getAllCookiesClient, getCookie, getCookieClient, isSecure, saveVerifierAndState, setCookie, setCookieClient, setOrDeleteCookie, setOrDeleteCookieClient };
+//# sourceMappingURL=cookie.js.map