@hexclave/next 1.0.0

package/dist/esm/lib/cookie.js

@@ -0,0 +1,356 @@
+import { HexclaveAssertionError } from "@hexclave/shared/dist/utils/errors";
+import { cookies, headers } from "@hexclave/sc/force-react-server";
+import { isBrowserLike } from "@hexclave/shared/dist/utils/env";
+import Cookies from "js-cookie";
+
+//#region ../../node_modules/.pnpm/oauth4webapi@3.8.3/node_modules/oauth4webapi/build/index.js
+let USER_AGENT;
+if (typeof navigator === "undefined" || !navigator.userAgent?.startsWith?.("Mozilla/5.0 ")) USER_AGENT = `oauth4webapi/v3.8.3`;
+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
+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 HexclaveAssertionError("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 HexclaveAssertionError("__Host- cookies must not specify a Domain attribute");
+}
+async function createCookieHelper() {
+	if (isBrowserLike()) return createBrowserCookieHelper();
+	else return createNextCookieHelper(await cookies(), await headers());
+}
+function createCookieHelperSync() {
+	if (isBrowserLike()) return createBrowserCookieHelper();
+	function throwError() {
+		throw new HexclaveAssertionError("Synchronous server cookie helpers are not available on this platform");
+	}
+	return {
+		get: throwError,
+		getAll: throwError,
+		set: throwError,
+		setOrDelete: throwError,
+		delete: throwError
+	};
+}
+function createBrowserCookieHelper() {
+	return {
+		get: getCookieClient,
+		getAll: getAllCookiesClient,
+		set: setCookieClient,
+		setOrDelete: setOrDeleteCookieClient,
+		delete: deleteCookieClient
+	};
+}
+function handleCookieError(e, options) {
+	if (e instanceof Error && e.message.includes("Cookies can only be modified in")) if (options.noOpIfServerComponent) {} else throw new HexclaveAssertionError("Attempted to set cookie in server component. Pass { noOpIfServerComponent: true } in the options of Stack's cookie functions if this is intentional and you want to ignore this error. Read more: https://nextjs.org/docs/app/api-reference/functions/cookies#options");
+	else throw e;
+}
+function createNextCookieHelper(rscCookiesAwaited, rscHeadersAwaited) {
+	const cookieHelper = {
+		get: (name) => {
+			return cookieHelper.getAll()[name] ?? null;
+		},
+		getAll: () => {
+			try {
+				rscCookiesAwaited.set("hexclave-is-https", "true", {
+					secure: true,
+					expires: new Date(Date.now() + 1e3 * 60 * 60 * 24 * 365)
+				});
+				rscCookiesAwaited.set("stack-is-https", "true", {
+					secure: true,
+					expires: new Date(Date.now() + 1e3 * 60 * 60 * 24 * 365)
+				});
+			} catch (e) {
+				if (typeof e === "object" && e !== null && "message" in e && typeof e.message === "string" && e.message.includes("Cookies can only be modified in a Server Action or Route Handler")) {} else throw e;
+			}
+			return rscCookiesAwaited.getAll().reduce((acc, entry) => {
+				acc[entry.name] = entry.value;
+				return acc;
+			}, {});
+		},
+		set: (name, value, options) => {
+			validateCookieOptions(name, options);
+			const isSecureCookie = determineSecureFromServerContext(rscCookiesAwaited, rscHeadersAwaited);
+			try {
+				rscCookiesAwaited.set(name, value, {
+					secure: requiresSecureAttribute(name) || isSecureCookie,
+					maxAge: options.maxAge === "session" ? void 0 : options.maxAge,
+					domain: options.domain,
+					sameSite: "lax",
+					path: "/"
+				});
+			} catch (e) {
+				handleCookieError(e, options);
+			}
+		},
+		setOrDelete(name, value, options) {
+			if (value === null) this.delete(name, options);
+			else this.set(name, value, options);
+		},
+		delete(name, options) {
+			try {
+				validateCookieOptions(name, options);
+				if (options.domain !== void 0) rscCookiesAwaited.delete({
+					name,
+					domain: options.domain,
+					path: "/"
+				});
+				else rscCookiesAwaited.delete({
+					name,
+					path: "/"
+				});
+			} catch (e) {
+				handleCookieError(e, options);
+			}
+		}
+	};
+	return cookieHelper;
+}
+function getCookieClient(name) {
+	return getAllCookiesClient()[name] ?? null;
+}
+function getAllCookiesClient() {
+	ensureClient();
+	Cookies.set("hexclave-is-https", "true", {
+		secure: true,
+		expires: new Date(Date.now() + 1e3 * 60 * 60 * 24 * 365)
+	});
+	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();
+	return determineSecureFromServerContext(await cookies(), await headers());
+}
+function determineSecureFromClientContext() {
+	return typeof window !== "undefined" && window.location.protocol === "https:";
+}
+function determineSecureFromServerContext(cookies, headers) {
+	return cookies.has("hexclave-is-https") || cookies.has("stack-is-https") || headers.get("x-forwarded-proto") === "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("hexclave-oauth-outer-" + state, codeVerifier, { maxAge: 3600 });
+	await setCookie("stack-oauth-outer-" + state, codeVerifier, { maxAge: 3600 });
+	return {
+		codeChallenge,
+		state
+	};
+}
+function consumeVerifierAndStateCookie(state) {
+	ensureClient();
+	const hexclaveCookieName = "hexclave-oauth-outer-" + state;
+	const stackCookieName = "stack-oauth-outer-" + state;
+	const codeVerifier = getCookieClient(hexclaveCookieName) ?? getCookieClient(stackCookieName);
+	if (!codeVerifier) return null;
+	deleteCookieClient(hexclaveCookieName, {});
+	deleteCookieClient(stackCookieName, {});
+	return { codeVerifier };
+}
+
+//#endregion
+export { consumeVerifierAndStateCookie, createBrowserCookieHelper, createCookieHelper, createCookieHelperSync, createPlaceholderCookieHelper, deleteCookie, deleteCookieClient, getAllCookiesClient, getCookie, getCookieClient, isSecure, saveVerifierAndState, setCookie, setCookieClient, setOrDeleteCookie, setOrDeleteCookieClient };
+//# sourceMappingURL=cookie.js.map