@v-office/website-headless 0.0.3 → 0.1.0

package/dist/index.mjs

@@ -1,3 +1,5 @@
+import { createWebsiteSDK } from "@v-office/website-sdk";
+import { getSupportedPeriodQueryKeys } from "@v-office/website-sdk/capabilities/search";
 //#region src/store/index.ts
 function createStore(initial) {
 	let state = initial;
@@ -21,6 +23,71 @@ function createStore(initial) {
 //#endregion
 //#region src/sdk.ts
 /**
+* The SDK seam every module in this package shares.
+*
+* The package NEVER constructs a WebsiteSDK itself — construction needs the
+* site's credentials and backend choice, which live in the site's own
+* `src/lib/voffice.ts` (one construction point per site). Every function here
+* takes the instance (or a `getSdk` thunk) from the caller instead. That is the
+* package's one hard rule: behavior lives here, wiring lives in the site.
+*/
+/** Deployment stage: selects the public endpoint set below. */
+const STAGES = ["development", "production"];
+/** Public endpoints of the v10 backend per stage. */
+const VOFFICE_ENDPOINTS = {
+	development: {
+		apiEndpoint: "https://api.development.v-office.io",
+		imageBaseUrl: "https://images.development.v-office.io",
+		searchEndpoint: "https://search.development.v-office.io/search"
+	},
+	production: {
+		apiEndpoint: "https://api.production.v-office.io",
+		imageBaseUrl: "https://images.production.v-office.io",
+		searchEndpoint: "https://search.production.v-office.io/search"
+	}
+};
+/** Public endpoints of the v9 backend per stage; API URLs derive from `apiBaseUrl`. */
+const HUB_ENDPOINTS = {
+	development: {
+		apiBaseUrl: "https://api.voffice.demo-on.de",
+		imageProxyBaseUrl: "https://imgproxy.voffice.demo-on.de"
+	},
+	production: {
+		apiBaseUrl: "https://api.voffice.be-on.io",
+		imageProxyBaseUrl: "https://imgproxy.voffice.be-on.io"
+	}
+};
+/** The three values a site actually decides — backend, stage, its token — as
+*  a full `SdkConfig`, with the endpoints the platform owns. */
+function sdkConfigFor({ backend, stage, token }) {
+	if (backend === "v9") {
+		const { apiBaseUrl, imageProxyBaseUrl } = HUB_ENDPOINTS[stage];
+		return {
+			backend,
+			imageProxyBaseUrl,
+			v0ApiBaseUrl: `${apiBaseUrl}/api/v0`,
+			v1ApiBaseUrl: `${apiBaseUrl}/api/v1`,
+			graphqlUrl: `${apiBaseUrl}/graphql`,
+			apiKey: token
+		};
+	}
+	return {
+		backend,
+		...VOFFICE_ENDPOINTS[stage],
+		accessToken: token
+	};
+}
+/** Build an SDK instance from a config (+ the SDK's options: translation
+*  overrides, custom attributes, highlight prioritization). The caller owns the
+*  lifecycle and calls `await sdk.dispose()` when done. The API is rate-limited
+*  (1/s), so a browser surface keeps ONE instance for its lifetime. */
+function createSdk(config, options) {
+	return createWebsiteSDK(options ? {
+		config,
+		options
+	} : { config });
+}
+/**
 * Render `error` and its whole cause chain as indented JSON.
 *
 * Walks the chain because a cause nests (a `CoreSDKError` wrapping a thrown
@@ -224,9 +291,9 @@ function adaptGuestQuote(quote) {
 /** Price a stay for `rentalId`. The caller owns the SDK instance and its
 *  lifecycle — pass a shared one to reuse its queue + cache across the caller's
 *  lifetime. `voucher` re-prices with a code (the PMS decides what it's worth). */
-async function fetchQuote(rentalId, period, occupancy, sdk, voucher) {
+async function fetchQuote(rentalId, period, occupancy, sdk, locale, voucher) {
 	const result = await sdk.live.quote.quote({
-		locale: "de-DE",
+		locale,
 		rentalId,
 		period,
 		occupancy: {
@@ -546,7 +613,7 @@ const CHECKOUT_RETURN_PATH = "/buchen/bestaetigung";
 * real. Throws on transport/backend errors (the caller renders an honest
 * retry message; nothing was necessarily booked when it throws).
 */
-async function submitBooking(quote, contact, sdk) {
+async function submitBooking(quote, contact, sdk, returnPath = CHECKOUT_RETURN_PATH) {
 	const out = await sdk.live.booking.book({
 		quote,
 		contact: {
@@ -566,7 +633,7 @@ async function submitBooking(quote, contact, sdk) {
 			} : { email: contact.email },
 			...contact.note ? { note: contact.note } : {}
 		},
-		relativeRedirectUrl: CHECKOUT_RETURN_PATH
+		relativeRedirectUrl: returnPath
 	}).catch((error) => {
 		logSdkFailure("booking.book", error);
 		throw error;
@@ -884,7 +951,7 @@ function createCheckoutFlow(initialOptions) {
 			const result = await fetchQuote(rentalId, {
 				start: isoDate(targetStay.start),
 				end: isoDate(targetStay.end)
-			}, occupancyOf(targetStay), getSdk(), voucher ?? void 0);
+			}, occupancyOf(targetStay), getSdk(), opts.locale, voucher ?? void 0);
 			if (myGen !== gen) return;
 			if (result.status !== "available") {
 				const rateFault = isRateConfigurationFault(result.code);
@@ -1041,7 +1108,7 @@ function createCheckoutFlow(initialOptions) {
 					const result = await fetchQuote(rentalId, {
 						start: isoDate(stay.start),
 						end: isoDate(stay.end)
-					}, occupancyOf(stay), getSdk(), code ?? void 0);
+					}, occupancyOf(stay), getSdk(), opts.locale, code ?? void 0);
 					if (result.status !== "available") {
 						patch({ voucherError: isRateConfigurationFault(result.code) ? opts.messages.rateFault : result.reason || opts.messages.voucherFailed });
 						return;
@@ -1118,7 +1185,7 @@ function createCheckoutFlow(initialOptions) {
 					quote = res.quote;
 					updateFromLive(quote);
 				}
-				return submitBooking(quote, contact, getSdk());
+				return submitBooking(quote, contact, getSdk(), opts.returnPath);
 			};
 			submit().then((result) => {
 				patch({
@@ -1203,11 +1270,11 @@ function derive(raw, opts) {
 }
 //#endregion
 //#region src/checkout/validation.ts
-function normalizePhone(raw, dial = "49") {
+function normalizePhone(raw, dial) {
 	const v = raw.replace(/[-./()]+/g, " ").replace(/\s+/g, " ").trim();
 	if (!v) return "";
 	if (v.startsWith("00")) return "+" + v.slice(2);
-	if (v.startsWith("0")) return "+" + dial + " " + v.slice(1);
+	if (v.startsWith("0") && dial) return "+" + dial + " " + v.slice(1);
 	return v;
 }
 function phoneError(raw, dial, c) {
@@ -1271,10 +1338,11 @@ const VALIDATED_FIELDS = [
 	"city"
 ];
 /** Validate one named field. Takes the selected COUNTRY plus its calling code
-*  (`dial`): two validators depend on the country — the phone via the dial
-*  code, the PLZ via its format rule. The dial code is passed in rather than
-*  looked up because the ISO→dial mapping lives with the site's country
-*  register (its localized "Land" options), not here. */
+*  (`dial`, undefined when the register has none for it): two validators depend
+*  on the country — the phone via the dial code, the PLZ via its format rule.
+*  The dial code is passed in rather than looked up because the ISO→dial
+*  mapping lives with the site's country register (its localized "Land"
+*  options), not here. */
 function fieldError(name, value, country, dial, c) {
 	if (name === "email") return emailError(value, c);
 	if (name === "phone") return phoneError(value, dial, c);
@@ -1420,4 +1488,598 @@ function assertCheckoutStructure(root) {
 	return violations;
 }
 //#endregion
-export { BOOKING_SNAPSHOT_KEY, BUTTON_SOLUTION_PATTERN, CHECKOUT_CONTEXT_KEY, CHECKOUT_PARTS, CHECKOUT_RETURN_PATH, CHECKOUT_STRUCTURE, MULTI_RATE_CODES, NO_INSURANCE_DOCS, VALIDATED_FIELDS, adaptGuestQuote, addQuoteService, assertCheckoutStructure, clearQuoteServices, createCheckoutFlow, createStore, describeSdkError, detectCountry, emailError, fetchQuote, fieldError, freeCancellationUntil, fullRefundRule, insuranceDocsPending, insuranceIdToReapply, insuranceProductKey, isRateConfigurationFault, isSubmittableOption, isoDate, logSdkFailure, normalizePhone, occupancyOf, payWithOption, phoneError, policyFreeCancellationUntil, postalcodeError, pricePolicyBranches, removeQuoteService, saveBookingSnapshot, saveCheckoutContext, selectQuoteInsurance, selectQuotePolicy, selectableInsuranceOptions, selectedInsuranceOption, shownInsuranceResources, stabilizeCardOrder, stayKeyOf, stayParams, streetWarning, submitBooking };
+//#region src/dates.ts
+const localDate = (y, m, d) => {
+	const date = new Date(y, m - 1, d);
+	return date.getFullYear() === y && date.getMonth() === m - 1 && date.getDate() === d ? date : void 0;
+};
+function parseParam(value) {
+	const m = /^(\d{4})-(\d{2})-(\d{2})$/.exec(value ?? "");
+	return m ? localDate(Number(m[1]), Number(m[2]), Number(m[3])) : void 0;
+}
+function parseGermanParam(value) {
+	const m = /^(\d{2})-(\d{2})-(\d{4})$/.exec(value ?? "");
+	return m ? localDate(Number(m[3]), Number(m[2]), Number(m[1])) : void 0;
+}
+/** A flexible-length stay ("3–5 Nächte") as the URL carries it. Off until the
+*  search UI offers it; the keys are reserved so a site can enable it. */
+const NIGHT_RANGE_ENABLED = false;
+const NIGHT_RANGE_KEYS = [
+	"minNights",
+	"maxNights",
+	"nights_min",
+	"nights_max"
+];
+function parseNightRange(params) {
+	return null;
+}
+//#endregion
+//#region src/format.ts
+/**
+* Display tidy for an SDK pre-formatted German-locale price ("1.234,00 €").
+* Nearly every stay is whole euros, so the trailing ",00" is noise — dropped only
+* when it is the zero-cents group at the end, so real cents ("1.234,50 €") stay.
+* A real value formatted for display, nothing fabricated; other formats pass.
+*/
+function tidyPrice(formatted) {
+	return formatted.replace(/,00(?=\D*$)/, "");
+}
+//#endregion
+//#region src/availability.ts
+/**
+* The per-night price a calendar CELL shows, rounded to whole euros:
+* "116,43 €" -> "116 €", "116,50 €" -> "117 €".
+*
+* A month grid is thirty-odd numbers seen at a glance and acted on by NONE of
+* them — the guest picks a range, and the quote under the calendar then states
+* the stay to the last cent. Two decimals in every cell buy precision nobody
+* reads, at the one size where the digits are already tight.
+*
+* ROUNDS TO NEAREST, AND THAT IS THE POINT OF THE FUNCTION. Stripping the cents
+* with a regex is one line and understates every priced night by up to 99
+* cents, always in the direction that flatters the price. That is the shape of
+* claim a host has to stand behind, so the error goes both ways here and is
+* capped at 50 cents on a figure that is explicitly indicative.
+*
+* Parses the German format rather than doing string surgery on it: "." groups
+* thousands, "," is the decimal. Anything that does not match that shape —
+* another locale, no decimal group, a price the SDK formatted differently — is
+* returned UNCHANGED. A display tidy must never turn a price it did not
+* understand into a wrong one.
+*
+* This runs where `priceByDay` is BUILT rather than where a cell renders it, so
+* every calendar fed from this map agrees: the widget's picker and the
+* checkout's copy, which reads the same shape.
+*/
+function nightlyPrice(formatted, locale = "de-DE") {
+	const m = formatted.match(/(\d{1,3}(?:\.\d{3})*|\d+),(\d{2})(?=\D*$)/);
+	if (!m) return formatted;
+	const euros = Number(m[1].replace(/\./g, ""));
+	const cents = Number(m[2]);
+	if (!Number.isFinite(euros) || !Number.isFinite(cents)) return formatted;
+	return formatted.replace(m[0], (euros + (cents >= 50 ? 1 : 0)).toLocaleString(locale));
+}
+/** SDK day statuses that mean the rental is genuinely unbookable on that day
+*  (booked / closed / past the bookable horizon) — as opposed to a day that is
+*  generally available but fails a RULE for the current selection (min-stay,
+*  check-out-not-allowed, …). The picker strikes the former through; the latter
+*  it only dims. Spans both calls' status enums
+*  (node_modules/@v-office/website-sdk/instructions/availability.md,
+*  "Common statuses"). */
+const HARD_UNAVAILABLE_STATUS = /* @__PURE__ */ new Set([
+	"unavailable",
+	"after_last_bookable_date",
+	"range_crosses_unavailable_date_and_is_unavailable"
+]);
+/** Possible check-in days + occupancy caps for `rentalId` across the window.
+*  The caller's SDK instance is reused so its 30s per-rental cache spans the
+*  picker's lifetime. */
+async function fetchInitialAvailability(sdk, rentalId, calculateFromDate, calculateThroughDate, locale) {
+	{
+		const out = await sdk.live.availability.getInitialAvailability({
+			locale,
+			rentalId,
+			calculateFromDate,
+			calculateThroughDate
+		});
+		const canStart = /* @__PURE__ */ new Set();
+		const hardBlocked = /* @__PURE__ */ new Set();
+		const priceByDay = /* @__PURE__ */ new Map();
+		const tooltipByDay = /* @__PURE__ */ new Map();
+		for (const [iso, day] of Object.entries(out.calendarDays)) {
+			if (day.canBeStartDate) canStart.add(iso);
+			if (day.status && HARD_UNAVAILABLE_STATUS.has(day.status)) hardBlocked.add(iso);
+			if (day.formattedPrice) priceByDay.set(iso, nightlyPrice(day.formattedPrice, locale));
+			if (day.tooltip) tooltipByDay.set(iso, day.tooltip);
+		}
+		return {
+			canStart,
+			hardBlocked,
+			priceByDay,
+			tooltipByDay,
+			maxPersons: out.maxPersons ?? null,
+			maxAdults: out.maxAdults ?? null
+		};
+	}
+}
+/** Possible check-out days for a chosen `selectedStartDate`. */
+async function fetchEndAvailability(sdk, rentalId, calculateFromDate, calculateThroughDate, selectedStartDate, locale) {
+	{
+		const out = await sdk.live.availability.getStartDateSelectedAvailability({
+			locale,
+			rentalId,
+			calculateFromDate,
+			calculateThroughDate,
+			selectedStartDate
+		});
+		const canEnd = /* @__PURE__ */ new Set();
+		const hardBlocked = /* @__PURE__ */ new Set();
+		const tooltipByDay = /* @__PURE__ */ new Map();
+		for (const [iso, day] of Object.entries(out.calendarDays)) {
+			if (day.canBeEndDate) canEnd.add(iso);
+			if (day.status && HARD_UNAVAILABLE_STATUS.has(day.status)) hardBlocked.add(iso);
+			if (day.tooltip) tooltipByDay.set(iso, day.tooltip);
+		}
+		return {
+			canEnd,
+			hardBlocked,
+			tooltipByDay
+		};
+	}
+}
+//#endregion
+//#region src/filters.ts
+/** A boolean filter is active when its param is present and truthy. */
+const isBooleanFilterActive = (value) => value !== "" && value !== "false" && value !== "0";
+/**
+* The filters currently applied in the query, in the order the defs are
+* declared — the removable chips. An `int` label is prefixed with the localized
+* "minimum" wording, because its value is a lower bound.
+*/
+function activeFiltersFromQuery(searchParams, defs, minimumPrefix) {
+	const active = [];
+	for (const def of defs) {
+		const value = searchParams.get(def.key);
+		if (value === null) continue;
+		if (def.type === "boolean") {
+			if (isBooleanFilterActive(value)) active.push({
+				key: def.key,
+				label: def.label
+			});
+			continue;
+		}
+		const count = Number.parseInt(value, 10);
+		if (Number.isFinite(count) && count > 0) active.push({
+			key: def.key,
+			label: `${minimumPrefix} ${count} ${def.label}`
+		});
+	}
+	return active;
+}
+/** The dog-friendly search as the URL carries it: `pets=true` (or a count) and,
+*  from an older vocabulary, `petsCount=N`. Read by the live search. */
+const PETS_PARAM = "pets";
+const PETS_COUNT_PARAM = "petsCount";
+function petsCountInQuery(search) {
+	const params = new URLSearchParams(search);
+	const count = Number.parseInt(params.get("petsCount") ?? "", 10);
+	if (Number.isFinite(count) && count > 0) return count;
+	const flag = params.get(PETS_PARAM);
+	if (flag === "true") return 1;
+	const n = Number.parseInt(flag ?? "", 10);
+	return Number.isFinite(n) && n > 0 ? n : 0;
+}
+//#endregion
+//#region src/sort.ts
+/** URL param. A client-side scope like `property`/`region`, NOT an SDK query
+*  key — it is dropped from the SDK query string in search.ts's DROP_KEYS and
+*  travels as the separate `sort` input instead. */
+const SORT_PARAM = "sort";
+/** The backend's own order. Emits no `sort` at all, so it is exactly the
+*  ordering the page has always shown. Typed as the literal (not `SortValue`)
+*  so `value === DEFAULT_SORT` narrows the rest away for `SDK_SORT`. */
+const DEFAULT_SORT = "empfohlen";
+const SORT_OPTIONS = [
+	{
+		value: "empfohlen",
+		label: "Empfohlen"
+	},
+	{
+		value: "preis-auf",
+		label: "Preis aufsteigend",
+		pricedOnly: true
+	},
+	{
+		value: "preis-ab",
+		label: "Preis absteigend",
+		pricedOnly: true
+	}
+];
+/** Value → the SDK's discriminated `sort` input. `empfohlen` is absent by
+*  design: no key means no `sort` sent. */
+const SDK_SORT = {
+	"preis-auf": {
+		by: "price",
+		direction: "ASC"
+	},
+	"preis-ab": {
+		by: "price",
+		direction: "DESC"
+	}
+};
+function isSortValue(value) {
+	return value != null && SORT_OPTIONS.some((o) => o.value === value);
+}
+/** The sort in the URL, or the default when absent/unknown. */
+function activeSort(search) {
+	const raw = new URLSearchParams(search).get(SORT_PARAM);
+	return isSortValue(raw) ? raw : DEFAULT_SORT;
+}
+/**
+* Can this query be priced? Mirrors the SDK's own precondition: a fixed period
+* (`start`+`end`) or a flexible window (`dates`/`month`/`weekend`), AND
+* occupancy. Without both, the backend returns no totals and the SDK rejects
+* price ordering before it reaches the wire.
+*
+* Period keys count only with a value: the search's `buildQuery` drops empty
+* params (`?start=&end=`), so a key that is merely present would pass this
+* gate and still reach the SDK undated. `weekend` is the exception — it is a
+* presence-only flag on both sides.
+*/
+function isPricedQuery(search) {
+	const params = new URLSearchParams(search);
+	const hasValue = (key) => (params.get(key) ?? "").trim() !== "";
+	const period = hasValue("start") && hasValue("end") || hasValue("dates") || hasValue("month") || params.has("weekend");
+	const adults = Number.parseInt(params.get("adults") ?? "", 10);
+	return period && Number.isFinite(adults) && adults > 0;
+}
+/** Is this option selectable for the current query? */
+function isSortAvailable(option, search) {
+	return !option.pricedOnly || isPricedQuery(search);
+}
+/**
+* The `sort` to hand the SDK for this URL, or `undefined` for the backend's
+* own order. Falls back to `undefined` (rather than throwing) when a price
+* sort survives in the URL after the dates were cleared.
+*/
+function resolveSdkSort(search) {
+	const value = activeSort(search);
+	if (value === "empfohlen") return void 0;
+	const option = SORT_OPTIONS.find((o) => o.value === value);
+	if (option && !isSortAvailable(option, search)) return void 0;
+	return SDK_SORT[value];
+}
+//#endregion
+//#region src/search.ts
+const DROP_KEYS = /* @__PURE__ */ new Set([
+	"unterkunft",
+	"flex",
+	"property",
+	"region",
+	"sort"
+]);
+const ALL_PERIOD_QUERY_KEYS = /* @__PURE__ */ new Set([...getSupportedPeriodQueryKeys("v9"), ...getSupportedPeriodQueryKeys("v10")]);
+const NIGHT_RANGE_KEY_SET = new Set(NIGHT_RANGE_KEYS);
+/** URL slug: German-transliterated, lowercased, hyphenated, capped. Mirrors
+*  the slug base assigned in src/lib/rentals.ts so a result links to its
+*  detail page. URL generation, not rental content. */
+function slugify(input) {
+	return input.trim().toLowerCase().replace(/ä/g, "ae").replace(/ö/g, "oe").replace(/ü/g, "ue").replace(/ß/g, "ss").normalize("NFKD").replace(/[\u0300-\u036f]/g, "").replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 60).replace(/-+$/g, "");
+}
+/** First integer captured by `re` across the SDK highlights ("78 m²" → 78).
+*  Reads the number the SDK already states; it does not invent one. */
+function firstInt(items, re) {
+	for (const s of items) {
+		const m = re.exec(s);
+		if (m) return Number.parseInt(m[1], 10);
+	}
+	return 0;
+}
+/** Parse an SDK/picker date string to a Date, or null. Accepts both formats the
+*  feed and pickers emit: ISO `YYYY-MM-DD` (start/end params, SDK periods) and
+*  German `DD-MM-YYYY` (the `dates=` path). Single source for both the date
+*  label and the nights math so the two never diverge on format. */
+function parseSdkDate(value) {
+	if (!value) return null;
+	const trimmed = value.trim();
+	const germanDate = /^(\d{2})-(\d{2})-(\d{4})$/.exec(trimmed);
+	const date = germanDate ? new Date(Number.parseInt(germanDate[3], 10), Number.parseInt(germanDate[2], 10) - 1, Number.parseInt(germanDate[1], 10)) : new Date(trimmed);
+	return Number.isNaN(date.getTime()) ? null : date;
+}
+/** Whole nights between two SDK date strings (either accepted format), or null
+*  when a date is missing/unparseable or the span is non-positive. */
+function nightsBetween(start, end) {
+	const from = parseSdkDate(start);
+	const to = parseSdkDate(end);
+	if (!from || !to) return null;
+	const nights = Math.round((to.getTime() - from.getTime()) / 864e5);
+	return nights > 0 ? nights : null;
+}
+function computeNights(params) {
+	if (parseNightRange(params) !== null) return null;
+	const exact = nightsBetween(params.get("start"), params.get("end"));
+	if (exact != null) return exact;
+	const flexible = Number.parseInt(params.get("nights") ?? "", 10);
+	return Number.isFinite(flexible) && flexible > 0 ? flexible : null;
+}
+function formatDateLabel(value, locale) {
+	const date = parseSdkDate(value);
+	if (!date) return null;
+	return new Intl.DateTimeFormat(locale, {
+		day: "numeric",
+		month: "short"
+	}).format(date);
+}
+function formatPeriodLabel(value, locale) {
+	if (!value) return null;
+	if (typeof value === "string") return value.trim() || null;
+	const label = value.label?.trim();
+	if (label) return label;
+	const start = formatDateLabel(value.start ?? value.from, locale);
+	const end = formatDateLabel(value.end ?? value.till ?? value.to, locale);
+	if (start && end) return `${start} – ${end}`;
+	return start ?? end;
+}
+/** Forward the page's URL params to the SDK query string. The picker param
+*  names already match the SDK's stable keys; only the UI-only fields and
+*  empties are dropped. Repeated keys (e.g. several `month=` from a flexible
+*  search) are preserved. Date formats pass straight through: the SDK accepts
+*  both the picker's ISO `start`/`end` (`YYYY-MM-DD`) and the `DD-MM-YYYY`
+*  the `dates=` path emits (verified directly against the live API — both
+*  return identical results). `weekend` is a presence-only flag: the picker
+*  posts `weekend=1` so the GET form keeps it, but the SDK wants the bare
+*  `weekend` token (a `weekend=false`/`weekend=1` value would be rejected). */
+function buildQuery(params, supportedPeriodKeys) {
+	const query = new URLSearchParams();
+	let weekend = false;
+	const nightRange = parseNightRange(params);
+	const hasPetsCount = params.has("petsCount");
+	for (const [key, value] of params) {
+		if (DROP_KEYS.has(key)) continue;
+		if (key === "pets") continue;
+		if (ALL_PERIOD_QUERY_KEYS.has(key) && !supportedPeriodKeys.has(key)) continue;
+		if (NIGHT_RANGE_KEY_SET.has(key)) continue;
+		if (key === "weekend") {
+			weekend = true;
+			continue;
+		}
+		if (value === "") continue;
+		query.append(key, value);
+	}
+	if (!hasPetsCount) {
+		const legacyPets = petsCountInQuery(params.toString());
+		if (legacyPets > 0) query.set("petsCount", String(legacyPets));
+	}
+	if (nightRange && !weekend && query.has("start") && query.has("end") && !query.has("month") && !query.has("dates") && !query.has("nights") && supportedPeriodKeys.has("minNights")) {
+		query.set("minNights", String(nightRange.min));
+		query.set("maxNights", String(nightRange.max));
+	}
+	const base = query.toString();
+	if (!weekend) return base;
+	return base ? `${base}&weekend` : "weekend";
+}
+const HANDOVER_KEYS = [
+	"start",
+	"end",
+	"adults",
+	"children",
+	"childrenAges",
+	"babies",
+	"pets"
+];
+/** Build the `?…` suffix appended to a result card's detail link so the search
+*  context survives the click. Forwards only the booking-context keys
+*  (`HANDOVER_KEYS`), preserving repeated values (e.g. several `childrenAges`).
+*  Pass `dates` to override `start`/`end` with an alternative-period card's
+*  concrete suggested window — its bookable dates, not the user's original
+*  query (which had none for a flexible search). Returns "" when nothing
+*  applies, so the link stays clean. */
+function buildHandover(params, dates) {
+	const out = new URLSearchParams();
+	const windowOnly = dates == null && parseNightRange(params) !== null;
+	for (const key of HANDOVER_KEYS) {
+		if ((dates || windowOnly) && (key === "start" || key === "end")) continue;
+		if (key === "pets") continue;
+		for (const value of params.getAll(key)) if (value !== "") out.append(key, value);
+	}
+	const pets = petsCountInQuery(params.toString());
+	if (pets > 0) out.set("pets", String(pets));
+	if (dates?.start) out.set("start", dates.start);
+	if (dates?.end) out.set("end", dates.end);
+	const suffix = out.toString();
+	return suffix ? `?${suffix}` : "";
+}
+function mapBase(item) {
+	const name = item.nameOrLabel.trim();
+	const highlights = item.highlights ?? [];
+	return {
+		id: item.id,
+		name,
+		location: item.address?.city?.trim() ?? "",
+		href: `/unterkuenfte/${slugify(name)}`,
+		images: (item.images ?? []).map((img) => ({
+			src: img.src,
+			srcset: img.srcset?.trim() || void 0,
+			alt: img.alt?.trim() || name
+		})),
+		guests: firstInt(highlights, /^(\d+)\s+Maximale Personenzahl$/),
+		bedrooms: firstInt(highlights, /^(\d+)\s+Schlafzimmer$/),
+		area: firstInt(highlights, /^(\d+)\s*m²$/),
+		pills: [...highlights],
+		coords: item.location ? {
+			lat: item.location.latitude,
+			lng: item.location.longitude
+		} : null,
+		propertyId: item.property?.id ?? null,
+		isNew: false
+	};
+}
+/** Null-safe wrapper around the shared `tidyPrice` (drops the noise ",00" from
+*  the SDK's pre-formatted total) for the search-result card price label. */
+function tidyTotal(formatted) {
+	const s = formatted?.trim();
+	if (!s) return null;
+	return tidyPrice(s);
+}
+/** The offer half of a card, read from the SDK `discount` that sits beside the
+*  total this card prints. Pass the discount from the SAME place the price came
+*  from — the period's for an alternative card, the item's for an exact one.
+*
+*  Three separate gates, because the feed states three separate facts and can
+*  state any one without the others: the badge shows on the discount EXISTING,
+*  the struck-through total needs `formattedOriginalTotal`, and naming the offer
+*  needs a non-empty `applied`. A discount whose `applied` is empty is a real
+*  discount we cannot name — it keeps its badge and its "was" price and simply
+*  says nothing more. Labels are the PMS's words, trimmed and passed through;
+*  an entry with no label is dropped rather than given one. */
+function mapDiscount(discount) {
+	return {
+		isOffer: Boolean(discount),
+		offerOriginalPriceLabel: tidyTotal(discount?.formattedOriginalTotal),
+		offers: (discount?.applied ?? []).flatMap((applied) => {
+			const label = applied.label?.trim();
+			if (!label) return [];
+			return [{
+				label,
+				amount: tidyTotal(applied.formattedAmount)
+			}];
+		})
+	};
+}
+function mapItem(item, params, locale) {
+	const scopeType = typeof item.scope === "string" ? item.scope : item.scope?.type;
+	const alternativePeriodLabel = formatPeriodLabel(item.alternativePeriod ?? (typeof item.scope === "object" ? item.scope.alternativePeriod : void 0), locale);
+	const isAlternativePeriod = alternativePeriodLabel != null || scopeType === "alternativePeriod" || scopeType === "alternative-period";
+	const base = mapBase(item);
+	return {
+		...base,
+		href: `${base.href}${buildHandover(params)}`,
+		priceLabel: tidyTotal(item.formattedTotal),
+		...mapDiscount(item.discount),
+		alternativePeriodLabel,
+		isAlternativePeriod,
+		alternativePeriods: [],
+		nights: null
+	};
+}
+/** Map a root-level alternative-period entry into the same card shape. The
+*  rental fields come from `entry.item`; the price and the "Frei im Zeitraum …"
+*  label come from the first candidate period (the SDK returns them best-first,
+*  `boost`-ordered). Always flagged as an alternative so the card shows the
+*  period pill instead of treating it as an exact total. */
+function mapAlternativeEntry(entry, params, locale) {
+	const base = mapBase(entry.item);
+	const periods = (entry.alternativePeriods ?? []).flatMap((candidate) => {
+		const label = formatPeriodLabel({
+			start: candidate.start,
+			end: candidate.end
+		}, locale);
+		if (!label) return [];
+		return [{
+			label,
+			href: `${base.href}${buildHandover(params, {
+				start: candidate.start,
+				end: candidate.end
+			})}`,
+			priceLabel: tidyTotal(candidate.formattedTotal),
+			nights: nightsBetween(candidate.start, candidate.end),
+			...mapDiscount(candidate.discount)
+		}];
+	});
+	const period = entry.alternativePeriods?.[0];
+	const periodPrice = tidyTotal(period?.formattedTotal);
+	const priced = periodPrice != null ? period : entry.item;
+	return {
+		...base,
+		href: `${base.href}${buildHandover(params, {
+			start: period?.start,
+			end: period?.end
+		})}`,
+		priceLabel: periodPrice ?? tidyTotal(entry.item.formattedTotal),
+		...mapDiscount(priced?.discount),
+		alternativePeriodLabel: formatPeriodLabel(period ? {
+			start: period.start,
+			end: period.end
+		} : void 0, locale),
+		isAlternativePeriod: true,
+		alternativePeriods: periods,
+		nights: nightsBetween(period?.start, period?.end)
+	};
+}
+/**
+* Run a live search for the given URL query string (e.g.
+* `window.location.search`). Builds the SDK query from the picker params,
+* calls the rate-limited live API once, and maps the items. Pass an SDK
+* instance to reuse its internal cache across an eager pagination walk;
+* otherwise this function owns a short-lived instance for a single call.
+*
+* Pass `cursor` (the previous page's `pageInfo.nextCursor`, treated as
+* opaque) to fetch the next page. The returned `cursor`/`hasNextPage` are
+* the SDK's `pageInfo` straight through, so the caller can keep paging.
+*/
+async function runLiveSearch(sdk, searchString, locale, cursor) {
+	const params = new URLSearchParams(searchString);
+	const nights = computeNights(params);
+	const sort = resolveSdkSort(searchString);
+	const query = buildQuery(params, getSupportedPeriodQueryKeys(sdk.backend));
+	{
+		const search = sdk.live.search.search;
+		const result = await search({
+			locale,
+			query,
+			...sort ? { sort } : {},
+			...cursor ? { cursor } : {}
+		});
+		const exact = result.items.map((item) => mapItem(item, params, locale));
+		const exactIds = new Set(exact.map((item) => item.id));
+		const alternatives = (result.alternatives ?? []).filter((entry) => entry?.item?.id && !exactIds.has(entry.item.id)).map((entry) => mapAlternativeEntry(entry, params, locale));
+		const items = exact.concat(alternatives);
+		return {
+			items,
+			nights,
+			alternativePeriodCount: items.filter((item) => item.isAlternativePeriod).length,
+			cursor: result.pageInfo.nextCursor ?? null,
+			hasNextPage: result.pageInfo.hasNextPage
+		};
+	}
+}
+//#endregion
+//#region src/regions.ts
+/**
+* The "Region" scope of the live search.
+*
+* "Region" is a v10 custom attribute (MULTI_SELECT, PUBLIC) set per rental in
+* v-office — e.g. Duhnen, Döse. The live search has no usable server-side key
+* for it: the SDK filters a custom attribute only on an exact raw match of its
+* stored JSON-array value, and registering the definition would fold a
+* `Region: ["…"]` string into every card and detail highlight (verified). So
+* `region` is dropped from the SDK query (search.ts, DROP_KEYS) and applied
+* here, client-side, against the per-rental regions the site hydrates from its
+* static catalogue at build time — the same channel as the other facts the
+* search projection does not carry.
+*/
+/** URL query key carrying the active region scope. Repeatable: several
+*  `region=<name>` values OR together (show rentals in ANY selected region). */
+const REGION_PARAM = "region";
+/** The regions active in a URL query string: the `region` values, trimmed,
+*  de-duplicated, order preserved. Absent or empty → `[]`. */
+function activeRegions(search) {
+	const seen = /* @__PURE__ */ new Set();
+	for (const value of new URLSearchParams(search).getAll(REGION_PARAM)) {
+		const region = value.trim();
+		if (region) seen.add(region);
+	}
+	return [...seen];
+}
+/**
+* The results inside the region scope. A rental may carry several regions
+* (MULTI_SELECT) and matches when any of them is selected; with no active
+* region every result stays. A rental the map does not know is outside every
+* region, so it drops out of a scoped search rather than passing unseen.
+*/
+function scopeToRegions(items, active, regionsByRentalId) {
+	if (active.length === 0) return [...items];
+	return items.filter((item) => regionsByRentalId(item.id)?.some((r) => active.includes(r)));
+}
+//#endregion
+export { BOOKING_SNAPSHOT_KEY, BUTTON_SOLUTION_PATTERN, CHECKOUT_CONTEXT_KEY, CHECKOUT_PARTS, CHECKOUT_RETURN_PATH, CHECKOUT_STRUCTURE, DEFAULT_SORT, HUB_ENDPOINTS, MULTI_RATE_CODES, NIGHT_RANGE_ENABLED, NIGHT_RANGE_KEYS, NO_INSURANCE_DOCS, PETS_COUNT_PARAM, PETS_PARAM, REGION_PARAM, SORT_OPTIONS, SORT_PARAM, STAGES, VALIDATED_FIELDS, VOFFICE_ENDPOINTS, activeFiltersFromQuery, activeRegions, activeSort, adaptGuestQuote, addQuoteService, assertCheckoutStructure, clearQuoteServices, createCheckoutFlow, createSdk, createStore, describeSdkError, detectCountry, emailError, fetchEndAvailability, fetchInitialAvailability, fetchQuote, fieldError, freeCancellationUntil, fullRefundRule, insuranceDocsPending, insuranceIdToReapply, insuranceProductKey, isBooleanFilterActive, isPricedQuery, isRateConfigurationFault, isSortAvailable, isSubmittableOption, isoDate, logSdkFailure, nightlyPrice, normalizePhone, occupancyOf, parseGermanParam, parseNightRange, parseParam, payWithOption, petsCountInQuery, phoneError, policyFreeCancellationUntil, postalcodeError, pricePolicyBranches, removeQuoteService, resolveSdkSort, runLiveSearch, saveBookingSnapshot, saveCheckoutContext, scopeToRegions, sdkConfigFor, selectQuoteInsurance, selectQuotePolicy, selectableInsuranceOptions, selectedInsuranceOption, shownInsuranceResources, stabilizeCardOrder, stayKeyOf, stayParams, streetWarning, submitBooking, tidyPrice };