@wix/astro 2.27.0 → 2.28.0

package/build/dependencies/astro-auth/backend-runtime/middleware/localization.d.mts

@@ -0,0 +1,6 @@
+import { MiddlewareHandler } from "astro";
+
+//#region src/middleware/localization.d.ts
+declare const onRequest: MiddlewareHandler;
+//#endregion
+export { onRequest };

package/build/dependencies/astro-auth/backend-runtime/middleware/localization.mjs

@@ -0,0 +1,193 @@
+import { n as authAsyncLocalStorage, t as createHost } from "../host-utils-B2Fs_Z4S.mjs";
+import { MULTILINGUAL_COOKIE_HEADER_KEY, getLocalizationData } from "@wix/headless-localization-utils";
+import { scripts } from "@wix/headless-site-assets";
+
+//#region rolldown:runtime
+var __commonJSMin = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+
+//#endregion
+//#region ../request-transform-utils/src/transformStreamUtils.ts
+function injectBeforeTransformStream(predicate, htmlToInject) {
+	let hasInjected = false;
+	return new TransformStream({ transform: (chunk, controller) => {
+		if (!hasInjected) {
+			const index = chunk.indexOf(predicate);
+			if (index > -1) {
+				chunk = chunk.slice(0, index) + htmlToInject + chunk.slice(index);
+				hasInjected = true;
+			}
+		}
+		controller.enqueue(chunk);
+	} });
+}
+
+//#endregion
+//#region ../request-transform-utils/src/index.ts
+const headTransformStream = (htmlToInject) => injectBeforeTransformStream("</head>", htmlToInject);
+
+//#endregion
+//#region ../../node_modules/outdent/lib/index.js
+var require_lib = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.outdent = void 0;
+	function noop() {
+		var args = [];
+		for (var _i = 0; _i < arguments.length; _i++) args[_i] = arguments[_i];
+	}
+	function createWeakMap() {
+		if (typeof WeakMap !== "undefined") return /* @__PURE__ */ new WeakMap();
+		else return fakeSetOrMap();
+	}
+	/**
+	* Creates and returns a no-op implementation of a WeakMap / WeakSet that never stores anything.
+	*/
+	function fakeSetOrMap() {
+		return {
+			add: noop,
+			delete: noop,
+			get: noop,
+			set: noop,
+			has: function(k) {
+				return false;
+			}
+		};
+	}
+	var hop = Object.prototype.hasOwnProperty;
+	var has = function(obj, prop) {
+		return hop.call(obj, prop);
+	};
+	function extend(target, source) {
+		for (var prop in source) if (has(source, prop)) target[prop] = source[prop];
+		return target;
+	}
+	var reLeadingNewline = /^[ \t]*(?:\r\n|\r|\n)/;
+	var reTrailingNewline = /(?:\r\n|\r|\n)[ \t]*$/;
+	var reStartsWithNewlineOrIsEmpty = /^(?:[\r\n]|$)/;
+	var reDetectIndentation = /(?:\r\n|\r|\n)([ \t]*)(?:[^ \t\r\n]|$)/;
+	var reOnlyWhitespaceWithAtLeastOneNewline = /^[ \t]*[\r\n][ \t\r\n]*$/;
+	function _outdentArray(strings, firstInterpolatedValueSetsIndentationLevel, options) {
+		var indentationLevel = 0;
+		var match = strings[0].match(reDetectIndentation);
+		if (match) indentationLevel = match[1].length;
+		var reSource = "(\\r\\n|\\r|\\n).{0," + indentationLevel + "}";
+		var reMatchIndent = new RegExp(reSource, "g");
+		if (firstInterpolatedValueSetsIndentationLevel) strings = strings.slice(1);
+		var newline = options.newline, trimLeadingNewline = options.trimLeadingNewline, trimTrailingNewline = options.trimTrailingNewline;
+		var normalizeNewlines = typeof newline === "string";
+		var l = strings.length;
+		return strings.map(function(v, i) {
+			v = v.replace(reMatchIndent, "$1");
+			if (i === 0 && trimLeadingNewline) v = v.replace(reLeadingNewline, "");
+			if (i === l - 1 && trimTrailingNewline) v = v.replace(reTrailingNewline, "");
+			if (normalizeNewlines) v = v.replace(/\r\n|\n|\r/g, function(_) {
+				return newline;
+			});
+			return v;
+		});
+	}
+	function concatStringsAndValues(strings, values) {
+		var ret = "";
+		for (var i = 0, l = strings.length; i < l; i++) {
+			ret += strings[i];
+			if (i < l - 1) ret += values[i];
+		}
+		return ret;
+	}
+	function isTemplateStringsArray(v) {
+		return has(v, "raw") && has(v, "length");
+	}
+	/**
+	* It is assumed that opts will not change.  If this is a problem, clone your options object and pass the clone to
+	* makeInstance
+	* @param options
+	* @return {outdent}
+	*/
+	function createInstance(options) {
+		/** Cache of pre-processed template literal arrays */
+		var arrayAutoIndentCache = createWeakMap();
+		/**
+		* Cache of pre-processed template literal arrays, where first interpolated value is a reference to outdent,
+		* before interpolated values are injected.
+		*/
+		var arrayFirstInterpSetsIndentCache = createWeakMap();
+		function outdent(stringsOrOptions) {
+			var values = [];
+			for (var _i = 1; _i < arguments.length; _i++) values[_i - 1] = arguments[_i];
+			if (isTemplateStringsArray(stringsOrOptions)) {
+				var strings = stringsOrOptions;
+				var firstInterpolatedValueSetsIndentationLevel = (values[0] === outdent || values[0] === defaultOutdent) && reOnlyWhitespaceWithAtLeastOneNewline.test(strings[0]) && reStartsWithNewlineOrIsEmpty.test(strings[1]);
+				var cache = firstInterpolatedValueSetsIndentationLevel ? arrayFirstInterpSetsIndentCache : arrayAutoIndentCache;
+				var renderedArray = cache.get(strings);
+				if (!renderedArray) {
+					renderedArray = _outdentArray(strings, firstInterpolatedValueSetsIndentationLevel, options);
+					cache.set(strings, renderedArray);
+				}
+				/** If no interpolated values, skip concatenation step */
+				if (values.length === 0) return renderedArray[0];
+				return concatStringsAndValues(renderedArray, firstInterpolatedValueSetsIndentationLevel ? values.slice(1) : values);
+			} else return createInstance(extend(extend({}, options), stringsOrOptions || {}));
+		}
+		return extend(outdent, { string: function(str) {
+			return _outdentArray([str], false, options)[0];
+		} });
+	}
+	var defaultOutdent = createInstance({
+		trimLeadingNewline: true,
+		trimTrailingNewline: true
+	});
+	exports.outdent = defaultOutdent;
+	exports.default = defaultOutdent;
+	if (typeof module !== "undefined") try {
+		module.exports = defaultOutdent;
+		Object.defineProperty(defaultOutdent, "__esModule", { value: true });
+		defaultOutdent.default = defaultOutdent;
+		defaultOutdent.outdent = defaultOutdent;
+	} catch (e) {}
+}));
+
+//#endregion
+//#region src/utils/localizationUtils.ts
+var import_lib = require_lib();
+async function getLocalizationData$1(context) {
+	return getLocalizationData(context.url, context.request.headers, (await scripts.getSiteMetadata()).properties ?? {});
+}
+function setMultilingualCookie(context, language) {
+	if (context.cookies.get(MULTILINGUAL_COOKIE_HEADER_KEY)?.value !== language) context.cookies.set(MULTILINGUAL_COOKIE_HEADER_KEY, language, {
+		httpOnly: false,
+		path: "/",
+		sameSite: "lax"
+	});
+}
+
+//#endregion
+//#region \0@oxc-project+runtime@0.110.0/helpers/taggedTemplateLiteral.js
+function _taggedTemplateLiteral(e, t) {
+	return t || (t = e.slice(0)), Object.freeze(Object.defineProperties(e, { raw: { value: Object.freeze(t) } }));
+}
+
+//#endregion
+//#region src/middleware/localization.ts
+var _templateObject;
+const onRequest = async (context, next) => {
+	const store = authAsyncLocalStorage.getStore();
+	if (!store) return next();
+	let localizationData;
+	try {
+		localizationData = await getLocalizationData$1(context);
+	} catch {
+		return next();
+	}
+	const { cleanUrl, essentials } = localizationData;
+	if (essentials.language == null || essentials.multilingual === void 0) return next();
+	store.sdkHost = createHost(context.request, essentials);
+	setMultilingualCookie(context, essentials.language);
+	return modifyHtmlEmbed(cleanUrl !== context.url.href ? await next(cleanUrl) : await next(), context, essentials);
+};
+function modifyHtmlEmbed(response, context, essentials) {
+	if (response.headers.get("Content-Type") !== "text/html" || context.url.pathname.startsWith("/_wix") || !response.body) return response;
+	const essentialsScript = (0, import_lib.outdent)(_templateObject || (_templateObject = _taggedTemplateLiteral(["\n    <script>window.essentials = ", ";<\/script>\n  "])), JSON.stringify(essentials));
+	return new Response(response.body.pipeThrough(new TextDecoderStream()).pipeThrough(headTransformStream(essentialsScript)).pipeThrough(new TextEncoderStream()), response);
+}
+
+//#endregion
+export { onRequest };

package/build/dependencies/astro-auth/backend-runtime/routes/callback.d.mts

@@ -0,0 +1,6 @@
+import { APIRoute } from "astro";
+
+//#region src/routes/callback.d.ts
+declare const GET: APIRoute;
+//#endregion
+export { GET };

package/build/dependencies/astro-auth/backend-runtime/routes/callback.mjs

@@ -0,0 +1,34 @@
+import { t as saveSessionTokensToCookie } from "../saveSessionTokensToCookie-DK3xvtzk.mjs";
+import { n as object, r as string } from "../schemas-XrMhpOYn.mjs";
+import { t as oAuthStateCookieName } from "../constants-Dbkf3D5f.mjs";
+import { getContextualAuth } from "@wix/sdk-runtime/context";
+
+//#region src/routes/callback.ts
+const oauthCookieSchema = object({
+	codeChallenge: string(),
+	codeVerifier: string(),
+	originalUri: string(),
+	redirectUri: string(),
+	state: string()
+});
+const GET = async (context) => {
+	const oauthStateCookie = context.cookies.get(oAuthStateCookieName);
+	if (oauthStateCookie == null) throw new Error(`Missing \`${oAuthStateCookieName}\` cookie`);
+	const oauthData = oauthCookieSchema.parse(JSON.parse(oauthStateCookie.value));
+	if (!oauthData.originalUri.startsWith("/")) throw new Error("Invalid `originalUri` cookie param, only relative URLs are allowed");
+	const auth = getContextualAuth();
+	const { code, error, errorDescription, state } = auth.parseFromUrl(context.url.toString(), "query");
+	if (error != null) throw new Error(`Error while authenticating: \`${errorDescription}\``);
+	const memberTokens = await auth.getMemberTokens(code, state, oauthData);
+	context.cookies.delete(oAuthStateCookieName, {
+		httpOnly: true,
+		path: "/",
+		sameSite: "lax",
+		secure: true
+	});
+	saveSessionTokensToCookie(context, memberTokens);
+	return context.redirect(oauthData.originalUri);
+};
+
+//#endregion
+export { GET };

package/build/dependencies/astro-auth/backend-runtime/routes/login.d.mts

@@ -0,0 +1,6 @@
+import { APIRoute } from "astro";
+
+//#region src/routes/login.d.ts
+declare const GET: APIRoute;
+//#endregion
+export { GET };

package/build/dependencies/astro-auth/backend-runtime/routes/login.mjs

@@ -0,0 +1,32 @@
+import { n as object, r as string, t as _enum } from "../schemas-XrMhpOYn.mjs";
+import { t as oAuthStateCookieName } from "../constants-Dbkf3D5f.mjs";
+import { getContextualAuth } from "@wix/sdk-runtime/context";
+
+//#region src/routes/login.ts
+const loginSearchParams = object({
+	prompt: _enum(["login", "none"]).optional(),
+	returnToUrl: string().optional()
+});
+const GET = async ({ request, url }) => {
+	const { prompt, returnToUrl = "/" } = loginSearchParams.parse(Object.fromEntries(url.searchParams.entries()));
+	const callbackUrl = new URL("/api/auth/callback", url);
+	const referer = request.headers.get("referer");
+	if (referer != null) callbackUrl.protocol = new URL(referer).protocol;
+	const auth = getContextualAuth();
+	const oauthData = auth.generateOAuthData(callbackUrl.toString(), returnToUrl);
+	const { authUrl } = await auth.getAuthUrl(oauthData, {
+		prompt,
+		responseMode: "query"
+	});
+	const sameSite = import.meta.env.DEV ? "None" : "Lax";
+	return new Response(null, {
+		headers: {
+			Location: authUrl,
+			"Set-Cookie": `${oAuthStateCookieName}=${JSON.stringify(oauthData)}; Max-Age=1800; Path=/; HttpOnly; Secure; SameSite=${sameSite}`
+		},
+		status: 302
+	});
+};
+
+//#endregion
+export { GET };

package/build/dependencies/astro-auth/backend-runtime/routes/logout-callback.d.mts

@@ -0,0 +1,6 @@
+import { APIRoute } from "astro";
+
+//#region src/routes/logout-callback.d.ts
+declare const GET: APIRoute;
+//#endregion
+export { GET };

package/build/dependencies/astro-auth/backend-runtime/routes/logout-callback.mjs

@@ -0,0 +1,14 @@
+import { t as saveSessionTokensToCookie } from "../saveSessionTokensToCookie-DK3xvtzk.mjs";
+import { n as returnToQueryParamName } from "../constants-Dbkf3D5f.mjs";
+import { getContextualAuth } from "@wix/sdk-runtime/context";
+
+//#region src/routes/logout-callback.ts
+const GET = async (context) => {
+	const returnTo = context.url.searchParams.get(returnToQueryParamName) ?? "/";
+	if (!returnTo.startsWith("/")) throw new Error(`Invalid \`${returnToQueryParamName}\` query param, only relative URLs are allowed`);
+	saveSessionTokensToCookie(context, await getContextualAuth().generateVisitorTokens());
+	return context.redirect(returnTo);
+};
+
+//#endregion
+export { GET };

package/build/dependencies/astro-auth/backend-runtime/routes/logout.d.mts

@@ -0,0 +1,6 @@
+import { APIRoute } from "astro";
+
+//#region src/routes/logout.d.ts
+declare const POST: APIRoute;
+//#endregion
+export { POST };

package/build/dependencies/astro-auth/backend-runtime/routes/logout.mjs

@@ -0,0 +1,19 @@
+import { n as object, r as string } from "../schemas-XrMhpOYn.mjs";
+import { n as returnToQueryParamName } from "../constants-Dbkf3D5f.mjs";
+import { getContextualAuth } from "@wix/sdk-runtime/context";
+
+//#region src/routes/logout.ts
+const logoutSearchParams = object({ returnToUrl: string().optional() });
+const POST = async ({ redirect, request, url }) => {
+	const { returnToUrl = "/" } = logoutSearchParams.parse(Object.fromEntries(url.searchParams.entries()));
+	const baseUrl = `${new URL(request.url).origin}/${import.meta.env.BASE_URL}`;
+	const postFlowUrl = new URL("/api/auth/logout-callback", baseUrl);
+	const referer = request.headers.get("referer");
+	if (referer != null) postFlowUrl.protocol = new URL(referer).protocol;
+	postFlowUrl.searchParams.set(returnToQueryParamName, returnToUrl);
+	const { logoutUrl } = await getContextualAuth().logout(postFlowUrl.toString());
+	return redirect(logoutUrl);
+};
+
+//#endregion
+export { POST };

package/build/dependencies/astro-auth/backend-runtime/runtime/backend/setupContextualClient.d.mts

@@ -0,0 +1 @@
+export { };

package/build/dependencies/astro-auth/backend-runtime/runtime/backend/setupContextualClient.mjs

@@ -0,0 +1,8 @@
+import { n as contextualClient, t as elevatedContextualClient } from "../../elevatedContextualClient-tJx9dIn_.mjs";
+
+//#region src/runtime/backend/setupContextualClient.ts
+contextualClient.enableContext("module");
+elevatedContextualClient.enableContext("module", { elevated: true });
+
+//#endregion
+export {  };

package/build/dependencies/astro-auth/backend-runtime/saveSessionTokensToCookie-DK3xvtzk.mjs

@@ -0,0 +1,24 @@
+import { WIX_CLIENT_ID } from "astro:env/client";
+
+//#region src/utils/sessionCookie.ts
+const SESSION_COOKIE_NAME = "wixSession";
+const SESSION_COOKIE_OPTIONS = {
+	path: "/",
+	secure: true,
+	...import.meta.env.DEV && {
+		maxAge: 10800,
+		sameSite: "none"
+	}
+};
+
+//#endregion
+//#region src/utils/saveSessionTokensToCookie.ts
+function saveSessionTokensToCookie(context, tokens) {
+	context.cookies.set(SESSION_COOKIE_NAME, {
+		clientId: WIX_CLIENT_ID,
+		tokens
+	}, SESSION_COOKIE_OPTIONS);
+}
+
+//#endregion
+export { saveSessionTokensToCookie as t };