@stackframe/tanstack-start 0.0.1 → 2.8.92

package/dist/lib/cookie.d.ts

@@ -0,0 +1,50 @@
+//#region src/lib/cookie.d.ts
+type SetCookieOptions = {
+  maxAge: number | "session";
+  noOpIfServerComponent?: boolean;
+  domain?: string;
+  secure?: boolean;
+};
+type DeleteCookieOptions = {
+  noOpIfServerComponent?: boolean;
+  domain?: string;
+};
+declare global {
+  interface ImportMetaEnv {
+    SSR: boolean;
+  }
+  interface ImportMeta {
+    readonly env: ImportMetaEnv;
+  }
+}
+type CookieHelper = {
+  get: (name: string) => string | null;
+  getAll: () => Record<string, string>;
+  set: (name: string, value: string, options: SetCookieOptions) => void;
+  setOrDelete: (name: string, value: string | null, options: SetCookieOptions & DeleteCookieOptions) => void;
+  delete: (name: string, options: DeleteCookieOptions) => void;
+};
+declare function createPlaceholderCookieHelper(): Promise<CookieHelper>;
+declare function createCookieHelper(): Promise<CookieHelper>;
+declare function createCookieHelperSync(): CookieHelper;
+declare function createBrowserCookieHelper(): CookieHelper;
+declare function getCookieClient(name: string): string | null;
+declare function getAllCookiesClient(): Record<string, string>;
+declare function getCookie(name: string): Promise<string | null>;
+declare function isSecure(): Promise<boolean>;
+declare function setOrDeleteCookieClient(name: string, value: string | null, options: SetCookieOptions & DeleteCookieOptions): void;
+declare function setOrDeleteCookie(name: string, value: string | null, options: SetCookieOptions & DeleteCookieOptions): Promise<void>;
+declare function deleteCookieClient(name: string, options: DeleteCookieOptions): void;
+declare function deleteCookie(name: string, options: DeleteCookieOptions): Promise<void>;
+declare function setCookieClient(name: string, value: string, options: SetCookieOptions): void;
+declare function setCookie(name: string, value: string, options: SetCookieOptions): Promise<void>;
+declare function saveVerifierAndState(): Promise<{
+  codeChallenge: string;
+  state: string;
+}>;
+declare function consumeVerifierAndStateCookie(state: string): {
+  codeVerifier: string;
+} | null;
+//#endregion
+export { CookieHelper, consumeVerifierAndStateCookie, createBrowserCookieHelper, createCookieHelper, createCookieHelperSync, createPlaceholderCookieHelper, deleteCookie, deleteCookieClient, getAllCookiesClient, getCookie, getCookieClient, isSecure, saveVerifierAndState, setCookie, setCookieClient, setOrDeleteCookie, setOrDeleteCookieClient };
+//# sourceMappingURL=cookie.d.ts.map

package/dist/lib/cookie.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cookie.d.ts","names":[],"sources":["../../src/lib/cookie.ts"],"mappings":";KAsEK,gBAAA;EAAqB,MAAA;EAA4B,qBAAA;EAAiC,MAAA;EAAiB,MAAA;AAAA;AAAA,KACnG,mBAAA;EAAwB,qBAAA;EAAiC,MAAA;AAAA;AAAA,QA8BtD,MAAA;EAAA,UAEI,aAAA;IACR,GAAA;EAAA;EAAA,UAIQ,UAAA;IAAA,SACC,GAAA,EAAK,aAAA;EAAA;AAAA;AAAA,KAWN,YAAA;EACV,GAAA,GAAM,IAAA;EACN,MAAA,QAAc,MAAA;EACd,GAAA,GAAM,IAAA,UAAc,KAAA,UAAe,OAAA,EAAS,gBAAA;EAC5C,WAAA,GAAc,IAAA,UAAc,KAAA,iBAAsB,OAAA,EAAS,gBAAA,GAAmB,mBAAA;EAC9E,MAAA,GAAS,IAAA,UAAc,OAAA,EAAS,mBAAA;AAAA;AAAA,iBAIZ,6BAAA,CAAA,GAAiC,OAAA,CAAQ,YAAA;AAAA,iBAuBzC,kBAAA,CAAA,GAAsB,OAAA,CAAQ,YAAA;AAAA,iBAcpC,sBAAA,CAAA,GAA0B,YAAA;AAAA,iBAoE1B,yBAAA,CAAA,GAA6B,YAAA;AAAA,iBAuB7B,eAAA,CAAgB,IAAA;AAAA,iBAKhB,mBAAA,CAAA,GAAuB,MAAA;AAAA,iBAOjB,SAAA,CAAU,IAAA,WAAe,OAAA;AAAA,iBAKzB,QAAA,CAAA,GAAY,OAAA;AAAA,iBAwFlB,uBAAA,CAAwB,IAAA,UAAc,KAAA,iBAAsB,OAAA,EAAS,gBAAA,GAAmB,mBAAA;AAAA,iBASlF,iBAAA,CAAkB,IAAA,UAAc,KAAA,iBAAsB,OAAA,EAAS,gBAAA,GAAmB,mBAAA,GAAmB,OAAA;AAAA,iBAK3G,kBAAA,CAAmB,IAAA,UAAc,OAAA,EAAS,mBAAA;AAAA,iBAKpC,YAAA,CAAa,IAAA,UAAc,OAAA,EAAS,mBAAA,GAAmB,OAAA;AAAA,iBAK7D,eAAA,CAAgB,IAAA,UAAc,KAAA,UAAe,OAAA,EAAS,gBAAA;AAAA,iBAKhD,SAAA,CAAU,IAAA,UAAc,KAAA,UAAe,OAAA,EAAS,gBAAA,GAAgB,OAAA;AAAA,iBAKhE,oBAAA,CAAA,GAAoB,OAAA;;;;iBAa1B,6BAAA,CAA8B,KAAA;EAAA,YAAA;AAAA"}

package/dist/lib/cookie.js

@@ -0,0 +1,366 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_chunk = require('../chunk-BE-pF4vm.js');
+let _stackframe_stack_shared_dist_utils_errors = require("@stackframe/stack-shared/dist/utils/errors");
+let _stackframe_stack_shared_dist_utils_env = require("@stackframe/stack-shared/dist/utils/env");
+let _stackframe_tanstack_start_tanstack_start_server_context = require("@stackframe/tanstack-start/tanstack-start-server-context");
+_stackframe_tanstack_start_tanstack_start_server_context = require_chunk.__toESM(_stackframe_tanstack_start_tanstack_start_server_context);
+let js_cookie = require("js-cookie");
+js_cookie = require_chunk.__toESM(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 } = _stackframe_tanstack_start_tanstack_start_server_context;
+	if (deleteCookie == null || getCookie == null || getCookies == null || getRequestHeader == null || setCookie == null) throw new _stackframe_stack_shared_dist_utils_errors.StackAssertionError("TanStack Start server context is only available during server rendering");
+	return {
+		deleteCookie,
+		getCookie,
+		getCookies,
+		getRequestHeader,
+		setCookie
+	};
+}
+function ensureClient() {
+	if (!(0, _stackframe_stack_shared_dist_utils_env.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 _stackframe_stack_shared_dist_utils_errors.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 _stackframe_stack_shared_dist_utils_errors.StackAssertionError("__Host- cookies must not specify a Domain attribute");
+}
+async function createCookieHelper() {
+	if ((0, _stackframe_stack_shared_dist_utils_env.isBrowserLike)()) return createBrowserCookieHelper();
+	else {
+		if ({}.env.SSR) {
+			const cookieHelperPromise = tanStackStartCookieHelperPromise ?? Promise.resolve(createTanStackStartCookieHelper(getTanStackStartServerContext()));
+			tanStackStartCookieHelperPromise = cookieHelperPromise;
+			return await cookieHelperPromise;
+		}
+		return await createPlaceholderCookieHelper();
+	}
+}
+function createCookieHelperSync() {
+	if ((0, _stackframe_stack_shared_dist_utils_env.isBrowserLike)()) return createBrowserCookieHelper();
+	function throwError() {
+		throw new _stackframe_stack_shared_dist_utils_errors.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();
+	js_cookie.default.set("stack-is-https", "true", {
+		secure: true,
+		expires: new Date(Date.now() + 1e3 * 60 * 60 * 24 * 365)
+	});
+	return js_cookie.default.get();
+}
+async function getCookie(name) {
+	return (await createCookieHelper()).get(name);
+}
+async function isSecure() {
+	if ((0, _stackframe_stack_shared_dist_utils_env.isBrowserLike)()) return determineSecureFromClientContext();
+	if ({}.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();
+	js_cookie.default.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) js_cookie.default.remove(name, {
+			domain: options.domain,
+			secure: determineSecureFromClientContext(),
+			partitioned,
+			path: "/"
+		});
+		js_cookie.default.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
+exports.consumeVerifierAndStateCookie = consumeVerifierAndStateCookie;
+exports.createBrowserCookieHelper = createBrowserCookieHelper;
+exports.createCookieHelper = createCookieHelper;
+exports.createCookieHelperSync = createCookieHelperSync;
+exports.createPlaceholderCookieHelper = createPlaceholderCookieHelper;
+exports.deleteCookie = deleteCookie;
+exports.deleteCookieClient = deleteCookieClient;
+exports.getAllCookiesClient = getAllCookiesClient;
+exports.getCookie = getCookie;
+exports.getCookieClient = getCookieClient;
+exports.isSecure = isSecure;
+exports.saveVerifierAndState = saveVerifierAndState;
+exports.setCookie = setCookie;
+exports.setCookieClient = setCookieClient;
+exports.setOrDeleteCookie = setOrDeleteCookie;
+exports.setOrDeleteCookieClient = setOrDeleteCookieClient;
+//# sourceMappingURL=cookie.js.map