@websolutespa/bom-mixer-models 2.0.2 → 3.0.1

package/dist/exports/server.js

@@ -0,0 +1,960 @@
+import { newRouteLink, resolveRoute, routeToRouteLink } from "../route-k0W3AKyo.js";
+import { asCategoryId, asServerProps, defaultLocale, defaultMarket, eachMarketLocale, findRouteOfCategory, getCategorySegments, getOrigin, getRootCategory, isDevelopment } from "@websolutespa/bom-core";
+import { BuildStrategy, StoreStrategy, buildStrategy, storeStrategy } from "@websolutespa/bom-mixer-store";
+import { apiHandler, getStore } from "@websolutespa/bom-mixer-store/server";
+import { getIronSession } from "iron-session";
+
+//#region src/country/country.service.ts
+async function getCountries(locale) {
+	const store = await getStore();
+	const items = await store.i18n_country.findMany({ locale });
+	return items;
+}
+async function getCountry(id, params = {}) {
+	const store = await getStore();
+	const item = await store.i18n_country.findOne(id, params);
+	return item;
+}
+async function getCountriesPagination(params = {}) {
+	const store = await getStore();
+	const pagination = await store.i18n_country.findPaged(params);
+	return pagination;
+}
+
+//#endregion
+//#region src/province/province.service.ts
+async function getProvinces(locale) {
+	const store = await getStore();
+	const items = await store.i18n_province.findMany({ locale });
+	return items;
+}
+async function getProvince(id, params = {}) {
+	const store = await getStore();
+	const item = await store.i18n_province.findOne(id, params);
+	return item;
+}
+async function getProvincesPagination(params = {}) {
+	const store = await getStore();
+	const pagination = await store.i18n_province.findPaged(params);
+	return pagination;
+}
+
+//#endregion
+//#region src/region/region.service.ts
+async function getRegions(locale) {
+	const store = await getStore();
+	const items = await store.i18n_region.findMany({ locale });
+	return items;
+}
+async function getRegion(id, params = {}) {
+	const store = await getStore();
+	const item = await store.i18n_region.findOne(id, params);
+	return item;
+}
+async function getRegionsPagination(params = {}) {
+	const store = await getStore();
+	const pagination = await store.i18n_region.findPaged(params);
+	return pagination;
+}
+
+//#endregion
+//#region src/address/address.service.ts
+async function getAddressOptions(locale) {
+	const countries = await getCountries(locale);
+	const provinces = await getProvinces(locale);
+	const regions = await getRegions(locale);
+	return {
+		countries,
+		regions,
+		provinces
+	};
+}
+
+//#endregion
+//#region src/app/app.service.ts
+async function getApp(params = {}) {
+	const store = await getStore();
+	const item = await store.app.findGlobal(params);
+	return item;
+}
+
+//#endregion
+//#region src/captions/captions.handler.ts
+const getCaptionsVttProps = async (context) => {
+	const { req, res, params, query } = context;
+	query?.locale;
+	const title = query?.title;
+	const captions = `WEBVTT
+
+00:00:01.000 --> 00:00:03.000
+- This video has no audio.
+
+${title ? `
+00:00:04.000 --> 00:00:06.000
+- The title of the video is "${title}".
+` : ""}`;
+	res.setHeader("Content-Type", "text/plain; charset=UTF-8");
+	res.setHeader("X-Frame-Options", "SAMEORIGIN");
+	res.setHeader("X-Robots-Tag", "noindex, follow");
+	res.write(captions);
+	res.end();
+	return { props: {} };
+};
+
+//#endregion
+//#region src/category/category.service.ts
+async function getCategories(params = {}) {
+	const store = await getStore();
+	const categories = await store.category.findMany(params);
+	return categories;
+}
+async function getCategory(id, params = {}) {
+	const store = await getStore();
+	const item = await store.category.findOne(id, params);
+	return item;
+}
+async function getSegments(item, params = {}) {
+	const categories = await getCategories(params);
+	return getCategorySegments(categories, item);
+}
+
+//#endregion
+//#region src/consent_preference/consent_preference.service.ts
+async function getConsentPreference(id, params = {}) {
+	const store = await getStore();
+	const item = await store.consent_preference.findOne(id, params);
+	return item;
+}
+async function getConsentPreferences(params = {}) {
+	const store = await getStore();
+	const items = await store.consent_preference.findMany(params);
+	return items;
+}
+async function getConsentPreferencesPagination(params = {}) {
+	const store = await getStore();
+	const pagination = await store.consent_preference.findPaged(params);
+	return pagination;
+}
+
+//#endregion
+//#region src/label/label.service.ts
+async function getLabels(params = {}) {
+	const store = await getStore();
+	const items = await store.label.findMany(params);
+	return items;
+}
+async function getLabel(id, params = {}) {
+	const store = await getStore();
+	const item = await store.label.findOne(id, params);
+	return item;
+}
+function resolveLabel(labels, id) {
+	const label = labels.find((x) => x.id === id);
+	return label && label.text ? label.text.toString() : id;
+}
+
+//#endregion
+//#region src/locale/locale.service.ts
+async function getLocales(params = {}) {
+	const store = await getStore();
+	const items = await store.locale.findMany(params);
+	return items;
+}
+async function getLocale(id, params = {}) {
+	const store = await getStore();
+	const item = await store.locale.findOne(id, params);
+	return item;
+}
+
+//#endregion
+//#region src/market/market.service.ts
+async function getMarkets(params = {}) {
+	const store = await getStore();
+	const items = await store.market.findMany(params);
+	return items;
+}
+async function getMarket(id, params = {}) {
+	const store = await getStore();
+	const item = await store.market.findOne(id, params);
+	return item;
+}
+
+//#endregion
+//#region src/menu/menu.service.ts
+async function getMenus(params = {}) {
+	const store = await getStore();
+	const items = await store.menu.findMany(params);
+	return items;
+}
+async function getMenu(id, params = {}) {
+	const store = await getStore();
+	const item = await store.menu.findOne(id, params);
+	return item;
+}
+
+//#endregion
+//#region src/route/route.service.ts
+async function getRoutes(params = {}) {
+	const store = await getStore();
+	const routes = await store.route.findMany(params);
+	return routes;
+}
+async function getRoute(id) {
+	const store = await getStore();
+	const route = await store.route.findOne(id);
+	return route;
+}
+async function getRoutesForSchemas(schemas, market, locale) {
+	const store = await getStore();
+	const routes = await store.route.findMany({ where: {
+		schema: { in: schemas },
+		market: { equals: market },
+		locale: { equals: locale }
+	} });
+	const items = {};
+	routes.forEach((route) => {
+		items[route.schema] = route.id;
+	});
+	return items;
+}
+async function getRoutesForTemplates(templates, market, locale) {
+	const store = await getStore();
+	const routes = await store.route.findMany({ where: {
+		template: { in: templates },
+		market: { equals: market },
+		locale: { equals: locale }
+	} });
+	const items = {};
+	routes.forEach((route) => {
+		if (route.template) items[route.template] = route.id;
+	});
+	return items;
+}
+async function getStaticPathsForSchema(schema, template) {
+	if (buildStrategy === BuildStrategy.Runtime) return [];
+	const store = await getStore();
+	const routes = await store.route.findMany({ where: template ? { and: [{ template: { equals: template } }, { schema: { equals: schema } }] } : { schema: { equals: schema } } });
+	return routes.map((x) => ({ params: {
+		id: x.page.toString(),
+		market: x.market,
+		locale: x.locale
+	} }));
+}
+async function getStaticPathsForSchemaAndFallback(schema, fallback = "blocking", template) {
+	if (buildStrategy === BuildStrategy.Runtime || fallback === "blocking" && storeStrategy !== StoreStrategy.Mock) return {
+		paths: [],
+		fallback
+	};
+	const paths = await getStaticPathsForSchema(schema, template);
+	return {
+		paths,
+		fallback
+	};
+}
+async function getBreadcrumbFromSegments(segments, route) {
+	const market = route.market || defaultMarket;
+	const locale = route.locale || defaultLocale;
+	const routes = await getRoutes({ where: {
+		market: { equals: market },
+		locale: { equals: locale }
+	} });
+	const tree = segments.map((segment) => {
+		const route$1 = findRouteOfCategory(routes, segment.id);
+		return {
+			segment,
+			route: route$1
+		};
+	}).filter((x) => Boolean(x.route)).map((x) => {
+		const category = x.segment;
+		const route$1 = x.route;
+		const routeLink = newRouteLink(category, route$1, locale);
+		return routeLink;
+	});
+	if (!route.isDefault) tree.push(routeToRouteLink(route));
+	return tree;
+}
+async function getRouteLinkTree(market, locale) {
+	const store = await getStore();
+	const routes = await store.route.findMany({ where: {
+		market: { equals: market },
+		locale: { equals: locale }
+	} });
+	const categories = await store.category.findMany({
+		market,
+		locale
+	});
+	const rootCategory = getRootCategory(categories);
+	if (rootCategory) {
+		const root = getRouteLinkCategory(locale, routes, categories, rootCategory, rootCategory);
+		return root;
+	}
+	return void 0;
+}
+function getRouteLinkCategory(locale, routes, categories, rootCategory, category) {
+	const route = findRouteOfCategory(routes, category.id);
+	const otherCategories = categories.filter((x) => x.id !== category.id);
+	const childCategories = otherCategories.filter((x) => asCategoryId(x.category) === category.id);
+	const routeLink = newRouteLink(category, route, locale);
+	const items = [];
+	for (const childCategory of childCategories) {
+		const itemOrItems = getRouteLinkCategory(locale, routes, otherCategories, rootCategory, childCategory);
+		if (Array.isArray(itemOrItems)) items.push(...itemOrItems);
+		else if (itemOrItems) items.push(itemOrItems);
+	}
+	if (!route || category.isHidden && category.id !== rootCategory.id) return items;
+	routeLink.items = items;
+	return routeLink;
+}
+
+//#endregion
+//#region src/layout/layout.service.ts
+async function getLayout(market, locale) {
+	const markets = await getMarkets({ locale });
+	const locales = await getLocales({ locale });
+	const labels = await getLabels({ locale });
+	const app = await getApp({ locale }) || {};
+	const tree = await getRouteLinkTree(market, locale);
+	const firstLevelRoutes = tree?.items || [];
+	const flatTopLevelRoutes = tree ? [tree, ...firstLevelRoutes] : [];
+	const topLevelRoutes = flatTopLevelRoutes.reduce((object, routeLink) => {
+		if (!object[routeLink.schema] || routeLink.schema === routeLink.category) object[routeLink.schema] = routeLink;
+		return object;
+	}, {});
+	const topLevelHrefs = flatTopLevelRoutes.reduce((object, routeLink) => {
+		if (routeLink.href && (!object[routeLink.schema] || routeLink.schema === routeLink.category)) object[routeLink.schema] = routeLink.href;
+		return object;
+	}, {});
+	const menu = {};
+	const menus = await getMenus({
+		market,
+		locale
+	});
+	menus.forEach((x) => {
+		menu[x.id] = x;
+	});
+	return {
+		labels,
+		locale,
+		locales,
+		market,
+		markets,
+		app,
+		menu,
+		topLevelHrefs,
+		topLevelRoutes,
+		tree
+	};
+}
+
+//#endregion
+//#region src/lazy/lazy.service.ts
+const LAZY_PROPS = {};
+async function withLazyProps(key, getComponentProps) {
+	LAZY_PROPS[key] = getComponentProps;
+}
+async function getDecoratedComponents(props, extraComponents) {
+	const page = props.page;
+	const components = [...page.components || [], ...extraComponents || []];
+	const decoratedComponents = [];
+	for (const component of components) {
+		const key = component.blockType || component.schema || "unkown_type";
+		const getComponentProps = LAZY_PROPS[key];
+		if (typeof getComponentProps === "function") {
+			const decoratedComponent = await getComponentProps({
+				...props,
+				component
+			});
+			decoratedComponents.push(decoratedComponent);
+		} else decoratedComponents.push(component);
+	}
+	page.components = decoratedComponents;
+}
+
+//#endregion
+//#region src/page/page.service.ts
+async function findOnePage(schema, id, params) {
+	const store = await getStore();
+	const collection = store[schema];
+	if (!collection) throw `PageService.findOnePage: Collection not found [${schema}]`;
+	const page = await collection.findOne(id, params);
+	if (page) return page;
+	else {
+		console.log("PageService.findOnePage.notfound", schema, params);
+		return;
+	}
+}
+async function findManyPages(schema, params) {
+	const store = await getStore();
+	const collection = store[schema];
+	if (!collection) throw `PageService.findManyPages: Collection not found [${schema}]`;
+	const pages = await collection.findMany(params);
+	return pages;
+}
+async function getPage(schema, id, market, locale, options) {
+	const { depth = 3, draftMode = false, previewData } = options || {};
+	const draft = draftMode === true;
+	const page = await findOnePage(schema, id, {
+		market,
+		locale,
+		depth,
+		draft
+	});
+	if (page) {
+		const routes = await getPageRoutes(schema, id);
+		const currentRoute = routes.find((x) => x.market === market && x.locale === locale);
+		const alternates = routes;
+		const segments = await getSegments(page, {
+			market,
+			locale
+		});
+		const breadcrumb = currentRoute ? await getBreadcrumbFromSegments(segments, currentRoute) : [];
+		const parentRoute = breadcrumb.length > 1 ? breadcrumb[breadcrumb.length - 2] : void 0;
+		const pageResult = {
+			...page,
+			href: currentRoute?.id,
+			alternates,
+			breadcrumb,
+			parentRoute
+		};
+		return pageResult;
+	} else {
+		console.log("PageService.getPage.notfound", schema, id, locale);
+		return;
+	}
+}
+async function getSchemaRoutes(schema, market, locale) {
+	const routes = await getRoutes({ where: {
+		market: { equals: market },
+		locale: { equals: locale },
+		schema: { equals: schema }
+	} });
+	return routes;
+}
+async function getNotFoundRoute(market, locale) {
+	const routes = await getRoutes({ where: {
+		market: { equals: market },
+		locale: { equals: locale },
+		schema: { equals: "notfound" }
+	} });
+	if (routes.length > 0) return routes[0];
+}
+async function NotFound(market, locale) {
+	const routes = await getRoutes({ where: {
+		market: { equals: market },
+		locale: { equals: locale },
+		schema: { equals: "notfound" }
+	} });
+	if (routes.length > 0) return { redirect: {
+		destination: routes[0].id,
+		permanent: false
+	} };
+}
+async function getPageRoutes(schema, id) {
+	const store = await getStore();
+	let routes = [];
+	try {
+		routes = await store.route.findMany({ where: {
+			page: { equals: id },
+			schema: { equals: schema }
+		} });
+	} catch (error) {
+		console.error("No routes found for page " + schema + ":" + id);
+	}
+	return routes;
+}
+async function getPageCategory(schema, page, market, locale) {
+	if (!page) return;
+	const store = await getStore();
+	const pages = await findManyPages(schema, {
+		where: { category: { equals: asCategoryId(page.category) } },
+		market,
+		locale
+	});
+	const category = pages.length ? pages[0] : null;
+	if (category) {
+		const routes = await store.route.findMany({ where: {
+			schema: { equals: schema },
+			page: { equals: category.id }
+		} });
+		const currentRoute = routes.find((x) => x.market === market && x.locale === locale);
+		if (!currentRoute) throw "No route found for page " + schema + ":" + category.id + " in market " + market + " and locale " + locale;
+		return {
+			...category,
+			href: currentRoute.id
+		};
+	} else {
+		console.log("PageService.getPageCategory.notfound", schema, locale);
+		return;
+	}
+}
+async function getErrorPageLayout() {
+	const layout = await getLayout(defaultMarket, defaultLocale);
+	const title = resolveLabel(layout.labels, "notfound.title");
+	const abstract = resolveLabel(layout.labels, "notfound.abstract");
+	const category = layout.tree ? {
+		id: layout.tree.category,
+		title: layout.tree.title,
+		href: layout.tree.href,
+		slug: ""
+	} : {
+		id: "homepage",
+		title: "Homepage",
+		slug: "",
+		href: "/"
+	};
+	const page = {
+		abstract,
+		alternates: [],
+		breadcrumb: [],
+		category,
+		slug: "",
+		href: "",
+		id: "notfound",
+		locale: layout.locale,
+		market: layout.market,
+		markets: [],
+		meta: {
+			title,
+			description: abstract,
+			keywords: "",
+			robots: "all"
+		},
+		schema: "notfound",
+		title
+	};
+	return {
+		layout,
+		page
+	};
+}
+async function getPageProps(props, extraComponents) {
+	if (props.page) await getDecoratedComponents(props, extraComponents);
+	return asServerProps(props);
+}
+function getPublicUrl() {
+	const publicUrl = process.env && process.env.NEXT_PUBLIC_URL ? process.env.NEXT_PUBLIC_URL : "";
+	return publicUrl;
+}
+function resolveHref(href) {
+	href = href || "";
+	return href.startsWith("http") ? href : `${getPublicUrl()}${href}`;
+}
+
+//#endregion
+//#region src/redirect/redirect.service.ts
+async function getRedirects(locale) {
+	const store = await getStore();
+	const items = await store.redirect.findMany({ locale });
+	return items;
+}
+async function getRedirect(id, params = {}) {
+	const store = await getStore();
+	const item = await store.redirect.findOne(id, params);
+	return item;
+}
+async function getRedirectsPagination(params = {}) {
+	const store = await getStore();
+	const pagination = await store.redirect.findPaged(params);
+	return pagination;
+}
+function redirectTo(layout, key = "not_found") {
+	return { redirect: {
+		permanent: false,
+		destination: layout.topLevelHrefs[key] || "/"
+	} };
+}
+
+//#endregion
+//#region src/route/route-revalidate.handler.ts
+function routeRevalidateHandler() {
+	return apiHandler({ post: async (request, response) => {
+		const authorization = request.headers.authorization;
+		const bearer = authorization && authorization.replace("Bearer ", "");
+		if (bearer !== process.env.MIXER_SECRET) return response.status(401).json({ message: "Invalid token" });
+		try {
+			const { href, schema, page } = request.body || {};
+			let where;
+			if (href) where = { id: { equals: href } };
+			else if (schema && page) where = {
+				schema: { equals: schema },
+				page: { equals: page }
+			};
+			else return response.status(400).send("Missing href or schema and page");
+			const routes = await getRoutes({ where });
+			if (routes.length === 0) {
+				const notFoundTarget = href || `${schema}:${page}`;
+				return response.status(404).send(`routeRevalidateHandler.notFound ${notFoundTarget}`);
+			}
+			for (const route of routes) {
+				const resolvedRoute = resolveRoute(route);
+				await response.revalidate(resolvedRoute);
+			}
+			return response.json({ revalidated: true });
+		} catch (error) {
+			return response.status(500).send("Error revalidating");
+		}
+	} });
+}
+
+//#endregion
+//#region src/session/session.service.ts
+function getSessionSecret() {
+	const secret = process.env.MIXER_SECRET || "";
+	if (!secret) throw "getSessionSecret MIXER_SECRET not defined";
+	return secret;
+}
+async function getSession(request, response) {
+	const cookieName = "websolutespa-next-js";
+	const password = getSessionSecret();
+	const sessionOptions = {
+		cookieName,
+		password,
+		cookieOptions: { secure: !isDevelopment }
+	};
+	const session = await getIronSession(request, response, sessionOptions);
+	return session;
+}
+async function getSessionToken(request, response) {
+	const session = await getSession(request, response);
+	if (session.token && session.exp && session.exp > Math.floor((/* @__PURE__ */ new Date()).getTime() / 1e3)) return session.token;
+	else {
+		session.token = void 0;
+		session.exp = void 0;
+		await session.save();
+		session.destroy();
+		return;
+	}
+}
+
+//#endregion
+//#region src/sitemap/sitemap.service.ts
+async function getSiteMapIndex(origin) {
+	let markets = await getMarkets();
+	let locales = await getLocales();
+	markets = markets.filter((x) => x.isActive !== false);
+	locales = locales.filter((x) => x.isActive !== false);
+	const routes = await getRoutes();
+	const sitemaps = [];
+	const getTime = (date) => {
+		return typeof date !== "undefined" ? (typeof date === "string" ? new Date(date) : date).getTime() : 0;
+	};
+	eachMarketLocale(markets, locales, (market, locale, markets$1, locales$1) => {
+		const sitemapRoutes = routes.filter((x) => x.market === market.id && x.locale === locale.id);
+		sitemapRoutes.sort((a, b) => getTime(a.updatedAt) - getTime(b.updatedAt));
+		sitemaps.push({
+			id: `/${market.id}/${locale.id}/sitemap.xml`,
+			updatedAt: sitemapRoutes.length > 0 ? sitemapRoutes[sitemapRoutes.length - 1].updatedAt : void 0
+		});
+	});
+	return `<?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet type="text/xsl" href="${origin}/sitemap.xsl"?>
+<sitemapindex xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
+${sitemaps.map((sitemap) => `
+  <sitemap>
+    <loc>${escapeHtml(encodeURI(`${origin}${sitemap.id}`))}</loc>${sitemap.updatedAt ? `
+    <lastmod>${escapeHtml(String(sitemap.updatedAt))}</lastmod>` : ""}
+  </sitemap>
+`).join("")}
+</sitemapindex>`;
+}
+function getSiteMapXMLLastMod(canonical) {
+	return canonical.updatedAt ? `
+    <lastmod>${escapeHtml(String(canonical.updatedAt))}</lastmod>` : "";
+}
+function getSiteMapXMLImage(canonical) {
+	return canonical.media ? `
+    <image:image>
+      <image:loc>${escapeHtml(encodeURI(`${canonical.media.src || canonical.media.url}`))}</image:loc>
+    </image:image>` : "";
+}
+function getSiteMapXMLAlternates(origin, canonical) {
+	return canonical.alternates.map((alternate) => `
+    <xhtml:link href="${escapeHtml(encodeURI(`${origin}${alternate.id}`))}" hreflang="${alternate.locale}-${alternate.market}" rel="alternate" />`).join("");
+}
+function getSiteMapXMLUrl(origin, canonical) {
+	return `
+  <url>
+    <loc>${escapeHtml(encodeURI(`${origin}${canonical.id}`))}</loc>${getSiteMapXMLLastMod(canonical)}${getSiteMapXMLAlternates(origin, canonical)}${getSiteMapXMLImage(canonical)}
+  </url>`;
+}
+function escapeHtml(string) {
+	const matchHtmlRegExp = /["'&<>]/;
+	const str = "" + string;
+	const match = matchHtmlRegExp.exec(str);
+	if (!match) return str;
+	let escape;
+	let html = "";
+	let index = 0;
+	let lastIndex = 0;
+	for (index = match.index; index < str.length; index++) {
+		switch (str.charCodeAt(index)) {
+			case 34:
+				escape = "&quot;";
+				break;
+			case 38:
+				escape = "&amp;";
+				break;
+			case 39:
+				escape = "&#39;";
+				break;
+			case 60:
+				escape = "&lt;";
+				break;
+			case 62:
+				escape = "&gt;";
+				break;
+			default: continue;
+		}
+		if (lastIndex !== index) html += str.substring(lastIndex, index);
+		lastIndex = index + 1;
+		html += escape;
+	}
+	return lastIndex !== index ? html + str.substring(lastIndex, index) : html;
+}
+function getSiteMapXMLUrls(origin, canonicalRoutes) {
+	return canonicalRoutes.map((canonicalRoute) => getSiteMapXMLUrl(origin, canonicalRoute)).join("");
+}
+async function getSiteMapXML(origin, marketId, localeId) {
+	let markets = await getMarkets();
+	let locales = await getLocales();
+	markets = markets.filter((x) => x.isActive !== false);
+	locales = locales.filter((x) => x.isActive !== false);
+	const defaultMarket$1 = markets.find((x) => marketId ? x.id === marketId : x.isDefault) || markets[0];
+	const defaultLocale$1 = locales.find((x) => localeId ? x.id === localeId : x.isDefault) || locales[0];
+	const defaultMarketLocale = defaultMarket$1 && defaultMarket$1.defaultLanguage ? defaultMarket$1.defaultLanguage : defaultLocale$1.id;
+	const routes = await getRoutes();
+	const isCanonicalRoute = marketId && localeId ? (route) => {
+		return route.noindex !== true && route.market === defaultMarket$1.id && route.locale === defaultLocale$1.id;
+	} : (route) => {
+		return route.noindex !== true && route.market === defaultMarket$1.id && route.locale === defaultMarketLocale;
+	};
+	const getCanonicalAlternates = marketId && localeId ? (canonical) => {
+		return [];
+	} : (canonical) => {
+		return routes.filter((alternate) => {
+			return alternate !== canonical && alternate.schema === canonical.schema && alternate.page === canonical.page;
+		});
+	};
+	const routeToRouteCanonical = (canonical) => {
+		const alternates = getCanonicalAlternates(canonical);
+		return {
+			...canonical,
+			alternates
+		};
+	};
+	const canonicalRoutes = routes.filter(isCanonicalRoute).map(routeToRouteCanonical);
+	return `<?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet type="text/xsl" href="${origin}/sitemap.xsl"?>
+<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9"
+        xmlns:xhtml="http://www.w3.org/1999/xhtml"
+        xmlns:image="http://www.google.com/schemas/sitemap-image/1.1">
+${getSiteMapXMLUrls(origin, canonicalRoutes)}
+</urlset>
+ `;
+}
+async function getSiteMapXSL(localeId) {
+	let locales = await getLocales();
+	locales = locales.filter((x) => x.isActive !== false);
+	const locale = locales.find((x) => localeId ? x.id === localeId : x.isDefault) || locales[0];
+	return `<?xml version="1.0" encoding="UTF-8"?>
+	<xsl:stylesheet version="2.0"
+		xmlns:html="http://www.w3.org/TR/REC-html40"
+		xmlns:image="http://www.google.com/schemas/sitemap-image/1.1"
+		xmlns:sitemap="http://www.sitemaps.org/schemas/sitemap/0.9"
+		xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
+	<xsl:output method="html" version="1.0" encoding="UTF-8" indent="yes"/>
+	<xsl:template match="/">
+		<html lang="${locale.id}" xmlns="http://www.w3.org/1999/xhtml">
+		<head>
+			<title>XML Sitemap</title>
+			<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
+			<style type="text/css">
+        html {
+          padding: 0;
+          background: #09090A;
+					color: #fefefe;
+        }
+				body {
+          padding: 15px;
+					font-family: Inter,-apple-system,'Helvetica Neue','Segoe UI',Roboto,Arial,'Noto Sans',sans-serif;
+					font-size: 13px;
+          background: #09090A;
+					color: #fefefe;
+				}
+				.container {
+					margin: 0 auto;
+					max-width: 1280px;
+				}
+				a {
+					color: #fefefe;
+					text-decoration: none;
+				}
+				a:visited {
+					color: #9e9e9e;
+				}
+				a:hover {
+					text-decoration: underline;
+				}
+				table {
+          width: 100%;
+          margin: 10px 0;
+					border: none;
+					border-collapse: collapse;
+				}
+				td,
+        th {
+					text-align: left;
+					font-size: 12px;
+          padding: 3px;
+				}
+				th:not(:last-child),
+        td:not(:last-child) {
+					padding-right: 30px;
+				}
+				thead th {
+					border-bottom: 1px solid #0e0e0f;
+				}
+				#sitemap tr:nth-child(odd) td {
+					background-color: #0e0e0f;
+				}
+				#sitemap tbody tr:hover td {
+					background-color: #1A1A1B;
+				}
+				#sitemap tbody tr:hover td,
+        #sitemap tbody tr:hover td a {
+					color: #fefefe;
+				}
+				.wysiwyg {
+          margin: 0;
+					padding: 0 0 10px 0;
+					line-height: 1.2em;
+				}
+				.wysiwyg a {
+					color: #00ea4e;
+					font-weight: 600;
+				}
+				.wysiwyg a:visited {
+					color: #00ea4e;
+				}
+			</style>
+		</head>
+		<body>
+		<div class="container">
+			<h1>XML Sitemap</h1>
+			<p class="wysiwyg">
+        This is an XML Sitemap meant for consumption by search engines, generated by <a href="https://github.com/websolutespa/bom" target="_blank" rel="noopener">Mixer</a>.
+      </p>
+      <p class="wysiwyg">
+				You can find more information about XML sitemaps on <a href="https://sitemaps.org" target="_blank" rel="noopener">sitemaps.org</a>.
+			</p>
+			<xsl:if test="count(sitemap:sitemapindex/sitemap:sitemap) &gt; 0">
+				<p class="wysiwyg">
+					This sitemap index file contains <xsl:value-of select="count(sitemap:sitemapindex/sitemap:sitemap)"/> sitemaps.
+				</p>
+				<table id="sitemap" cellpadding="3">
+					<thead>
+            <tr>
+              <th width="75%">Sitemap</th>
+              <th width="25%" title="Last Modification Time">Updated At</th>
+            </tr>
+					</thead>
+					<tbody>
+					<xsl:for-each select="sitemap:sitemapindex/sitemap:sitemap">
+						<xsl:variable name="sitemapURL">
+							<xsl:value-of select="sitemap:loc"/>
+						</xsl:variable>
+						<tr>
+							<td>
+								<a href="{$sitemapURL}"><xsl:value-of select="sitemap:loc"/></a>
+							</td>
+							<td>
+								<xsl:value-of select="concat(substring(sitemap:lastmod,0,11),concat(' ', substring(sitemap:lastmod,12,5)),concat(' ', substring(sitemap:lastmod,20,6)))"/>
+							</td>
+						</tr>
+					</xsl:for-each>
+					</tbody>
+				</table>
+			</xsl:if>
+			<xsl:if test="count(sitemap:sitemapindex/sitemap:sitemap) &lt; 1">
+				<p class="wysiwyg">
+					This sitemap contains <xsl:value-of select="count(sitemap:urlset/sitemap:url)"/> URLs.
+				</p>
+				<table id="sitemap" cellpadding="3">
+					<thead>
+					<tr>
+						<th width="75%">URL</th>
+						<th width="15%" title="Last Modification Time">Updated At</th>
+						<th width="10%">Images</th>
+					</tr>
+					</thead>
+					<tbody>
+					<xsl:variable name="lower" select="'abcdefghijklmnopqrstuvwxyz'"/>
+					<xsl:variable name="upper" select="'ABCDEFGHIJKLMNOPQRSTUVWXYZ'"/>
+					<xsl:for-each select="sitemap:urlset/sitemap:url">
+						<tr>
+							<td>
+								<xsl:variable name="itemURL">
+									<xsl:value-of select="sitemap:loc"/>
+								</xsl:variable>
+								<a href="{$itemURL}">
+									<xsl:value-of select="sitemap:loc"/>
+								</a>
+							</td>
+							<td>
+								<xsl:value-of select="concat(substring(sitemap:lastmod,0,11),concat(' ', substring(sitemap:lastmod,12,5)),concat(' ', substring(sitemap:lastmod,20,6)))"/>
+							</td>
+							<td>
+								<xsl:value-of select="count(image:image)"/>
+							</td>
+						</tr>
+					</xsl:for-each>
+					</tbody>
+				</table>
+			</xsl:if>
+		</div>
+		</body>
+		</html>
+	</xsl:template>
+	</xsl:stylesheet>`;
+}
+
+//#endregion
+//#region src/sitemap/sitemap.handler.ts
+const getSiteMapIndexProps = async (context) => {
+	const { req, res } = context;
+	const sitemap = await getSiteMapIndex(getOrigin(req.headers));
+	res.setHeader("Content-Type", "application/xml; charset=UTF-8");
+	res.setHeader("X-Frame-Options", "SAMEORIGIN");
+	res.setHeader("X-Robots-Tag", "noindex, follow");
+	res.write(sitemap);
+	res.end();
+	return { props: {} };
+};
+const getSiteMapXMLProps = async (context) => {
+	const { req, res } = context;
+	const params = context.params;
+	const market = params?.market;
+	const locale = params?.locale;
+	const sitemap = await getSiteMapXML(getOrigin(req.headers), market, locale);
+	res.setHeader("Content-Type", "application/xml; charset=UTF-8");
+	res.setHeader("X-Frame-Options", "SAMEORIGIN");
+	res.setHeader("X-Robots-Tag", "noindex, follow");
+	res.write(sitemap);
+	res.end();
+	return { props: {} };
+};
+const getSiteMapXSLProps = async (context) => {
+	const { req, res } = context;
+	const params = context.params;
+	params?.market;
+	const locale = params?.locale;
+	const sitemap = await getSiteMapXSL(locale);
+	res.setHeader("Content-Type", "application/xml; charset=UTF-8");
+	res.setHeader("X-Frame-Options", "SAMEORIGIN");
+	res.setHeader("X-Robots-Tag", "noindex, follow");
+	res.write(sitemap);
+	res.end();
+	return { props: {} };
+};
+
+//#endregion
+export { LAZY_PROPS, NotFound, escapeHtml, findManyPages, findOnePage, getAddressOptions, getApp, getBreadcrumbFromSegments, getCaptionsVttProps, getCategories, getCategory, getConsentPreference, getConsentPreferences, getConsentPreferencesPagination, getCountries, getCountriesPagination, getCountry, getDecoratedComponents, getErrorPageLayout, getLabel, getLabels, getLayout, getLocale, getLocales, getMarket, getMarkets, getMenu, getMenus, getNotFoundRoute, getPage, getPageCategory, getPageProps, getPageRoutes, getProvince, getProvinces, getProvincesPagination, getPublicUrl, getRedirect, getRedirects, getRedirectsPagination, getRegion, getRegions, getRegionsPagination, getRoute, getRouteLinkCategory, getRouteLinkTree, getRoutes, getRoutesForSchemas, getRoutesForTemplates, getSchemaRoutes, getSegments, getSession, getSessionToken, getSiteMapIndex, getSiteMapIndexProps, getSiteMapXML, getSiteMapXMLProps, getSiteMapXSL, getSiteMapXSLProps, getStaticPathsForSchema, getStaticPathsForSchemaAndFallback, redirectTo, resolveHref, resolveLabel, routeRevalidateHandler, withLazyProps };
+//# sourceMappingURL=server.js.map