@riverbankcms/sdk 0.152.0 → 0.154.0

package/dist/server/date-time.mjs

@@ -1,3 +1,29 @@
+//#region ../core/src/date-time-formatter.ts
+/** Shared Intl engine, internal to core's date presentation owners. */
+const FORMATTER_CACHE_LIMIT$1 = 100;
+const dateTimeFormatterCache = /* @__PURE__ */ new Map();
+function getDateTimeFormatter(locale, timeZone, format) {
+	const key = `${locale}\u0000${timeZone}\u0000${JSON.stringify(Object.entries(format).sort(([left], [right]) => left.localeCompare(right)))}`;
+	const cached = dateTimeFormatterCache.get(key);
+	if (cached !== void 0) return cached;
+	if (typeof locale !== "string" || Intl.DateTimeFormat.supportedLocalesOf([locale]).length === 0) throw new RangeError("An explicit supported locale is required");
+	if (typeof timeZone !== "string" || timeZone.length === 0) throw new RangeError("An explicit time zone is required");
+	const formatter = new Intl.DateTimeFormat(locale, {
+		...format,
+		timeZone
+	});
+	if (dateTimeFormatterCache.size >= FORMATTER_CACHE_LIMIT$1) dateTimeFormatterCache.clear();
+	dateTimeFormatterCache.set(key, formatter);
+	return formatter;
+}
+function formatIntlRange(formatter, start, end) {
+	const nativeFormatRange = Reflect.get(formatter, "formatRange");
+	if (typeof nativeFormatRange !== "function") throw new Error("Intl.DateTimeFormat.formatRange is required");
+	const output = Reflect.apply(nativeFormatRange, formatter, [start, end]);
+	if (typeof output !== "string") throw new Error("Intl.DateTimeFormat.formatRange returned a non-string value");
+	return output;
+}
+//#endregion
 //#region ../core/src/result.ts
 function ok(value) {
 	return {
@@ -40,26 +66,37 @@ function parseBookingTimeZone(timeZone) {
 }
 //#endregion
 //#region ../core/src/booking-date-time.ts
-const DATE_TIME_FORMATTER_CACHE_LIMIT = 100;
-const dateTimeFormatterCache$1 = /* @__PURE__ */ new Map();
+const FALLBACK_TIMEZONE = "UTC";
+function getSafeTimeZone(timeZone) {
+	const normalized = typeof timeZone === "string" ? timeZone.trim() : "";
+	return normalized.length > 0 && isValidBookingTimeZone(normalized) ? normalized : FALLBACK_TIMEZONE;
+}
 function parseStrictBookingTimeZone(timeZone) {
 	const parsed = parseBookingTimeZone(timeZone);
 	return parsed.ok ? parsed.value : null;
 }
 function formatToPartsLookup(date, locale, timeZone, format) {
-	return new Map(getCachedDateTimeFormatter(locale, timeZone, format).formatToParts(date).map((part) => [part.type, part.value]));
+	return new Map(getDateTimeFormatter(locale, timeZone, format).formatToParts(date).map((part) => [part.type, part.value]));
 }
-function getCachedDateTimeFormatter(locale, timeZone, format) {
-	const key = `${locale}\u0000${timeZone}\u0000${JSON.stringify(Object.entries(format).sort(([left], [right]) => left.localeCompare(right)))}`;
-	const cached = dateTimeFormatterCache$1.get(key);
-	if (cached !== void 0) return cached;
-	const formatter = new Intl.DateTimeFormat(locale, {
-		...format,
-		timeZone
+function getZonedDateTimeParts(date, timeZone) {
+	const parts = formatToPartsLookup(date, "en-GB", timeZone, {
+		year: "numeric",
+		month: "2-digit",
+		day: "2-digit",
+		hour: "2-digit",
+		minute: "2-digit",
+		second: "2-digit",
+		hour12: false
 	});
-	if (dateTimeFormatterCache$1.size >= DATE_TIME_FORMATTER_CACHE_LIMIT) dateTimeFormatterCache$1.clear();
-	dateTimeFormatterCache$1.set(key, formatter);
-	return formatter;
+	const read = (type) => Number(parts.get(type) ?? "");
+	return {
+		year: read("year"),
+		month: read("month"),
+		day: read("day"),
+		hour: read("hour"),
+		minute: read("minute"),
+		second: read("second")
+	};
 }
 function parseUtcIsoDateTimeString(value) {
 	const normalized = value.trim();
@@ -151,10 +188,172 @@ function formatBookingCompactEnglishTime(input) {
 	if (hour === void 0 || minute === void 0 || dayPeriod === void 0) return input.startsAt;
 	return `${minute === "00" ? hour : `${hour}:${minute}`}${dayPeriod.toLowerCase()}`;
 }
+function compareLocalScheduleDates(left, right) {
+	return Date.UTC(left.year, left.month - 1, left.day) - Date.UTC(right.year, right.month - 1, right.day);
+}
+function getLocalScheduleDate(date, timeZone) {
+	const parts = getZonedDateTimeParts(date, getSafeTimeZone(timeZone));
+	return {
+		year: parts.year,
+		month: parts.month,
+		day: parts.day
+	};
+}
+//#endregion
+//#region ../core/src/date-display.ts
+const SDK_STANDARD_TIME_FORMAT = {
+	hour: "numeric",
+	minute: "2-digit"
+};
+/** Public SDK option policy lives beside the display profile, never in its adapter. */
+function sdkPresentationProfile(context, dateFormat, time = {}) {
+	const compact = time.timePresentation !== "standard" && new Intl.Locale(context.locale).language === "en";
+	const standard = time.timePresentation === "standard" ? time.format ?? SDK_STANDARD_TIME_FORMAT : SDK_STANDARD_TIME_FORMAT;
+	return {
+		kind: "sdk",
+		dateFormat,
+		clock: compact ? {
+			kind: "compact",
+			localeSource: "context"
+		} : {
+			kind: "intl",
+			format: standard
+		},
+		zone: "omit"
+	};
+}
+/** Sole date projection/typography owner, used by display and scheduled adapters. */
+function presentDate(value, context, profile) {
+	const date = dateCarrier(value);
+	const zone = value.kind === "civil" ? "UTC" : context.timeZone;
+	const output = getDateTimeFormatter(context.locale, zone, profile.dateFormat).format(date);
+	if (profile.kind === "sdk") return output;
+	const normalized = normalizeDisplay(output);
+	return profile.dateFormat.weekday && new Intl.Locale(context.locale).language === "en" ? normalized.replace(/^([^,]+), /u, "$1 ") : normalized;
+}
+function presentDateRange(start, end, context, profile) {
+	if (dateCarrier(end).getTime() < dateCarrier(start).getTime()) throw new RangeError("Date range end must be on or after its start");
+	if (profile.kind === "display" && compareLocalScheduleDates(projectDate(start, context), projectDate(end, context)) === 0) return presentDate(start, context, profile);
+	const output = formatIntlRange(getDateTimeFormatter(context.locale, start.kind === "civil" ? "UTC" : context.timeZone, profile.dateFormat), dateCarrier(start), dateCarrier(end));
+	if (profile.kind === "sdk") return output;
+	const startDate = projectDate(start, context);
+	const endDate = projectDate(end, context);
+	const separator = startDate.month === endDate.month && startDate.year === endDate.year ? "–" : " – ";
+	return normalizeDisplay(output).replace(/\s*–\s*/gu, separator);
+}
+function presentTime(value, context, profile) {
+	const clock = presentClock(value, context, profile.clock);
+	return profile.zone === "always" ? `${clock} ${zoneLabel(value, context)}` : clock;
+}
+function presentDateTime(value, context, profile) {
+	if (profile.clock.kind === "intl") return getDateTimeFormatter(context.locale, context.timeZone, combinedFormat(profile.dateFormat, profile.clock)).format(new Date(value));
+	return `${presentDate({
+		kind: "instant",
+		value
+	}, context, profile)}, ${presentTime(value, context, profile)}`;
+}
+function presentTimeRange(span, context, profile) {
+	assertOrdered(span.start, span.end);
+	if (profile.clock.kind === "intl") return presentNativeRange(span, context, profile.clock.format);
+	const startClock = presentClock(span.start, context, profile.clock);
+	const endClock = presentClock(span.end, context, profile.clock);
+	const clocks = (profile.kind === "sdk" ? startClock === endClock : span.start === span.end) ? startClock : `${startClock}–${endClock}`;
+	const labels = decideRangeLabels(span, context, profile);
+	switch (labels.kind) {
+		case "omit": return clocks;
+		case "shared": return `${clocks} ${labels.label}`;
+		case "endpoints": return `${startClock} ${labels.start} – ${endClock} ${labels.end}`;
+	}
+}
+function presentDateTimeRange(span, context, profile) {
+	assertOrdered(span.start, span.end);
+	if (profile.clock.kind === "intl") return presentNativeRange(span, context, combinedFormat(profile.dateFormat, profile.clock));
+	const startDate = getLocalScheduleDate(new Date(span.start), context.timeZone);
+	const endDate = getLocalScheduleDate(new Date(span.end), context.timeZone);
+	if (compareLocalScheduleDates(startDate, endDate) === 0) return `${presentDate({
+		kind: "instant",
+		value: span.start
+	}, context, profile)}, ${presentTimeRange(span, context, profile)}`;
+	const labels = decideRangeLabels(span, context, profile);
+	const startProfile = profile.kind === "display" && startDate.year === endDate.year ? {
+		...profile,
+		dateFormat: {
+			...profile.dateFormat,
+			year: void 0
+		}
+	} : profile;
+	const start = presentRangeEndpoint(span.start, context, startProfile, labels.kind === "endpoints" ? labels.start : void 0);
+	const end = presentRangeEndpoint(span.end, context, profile, labels.kind === "endpoints" ? labels.end : void 0);
+	const separator = profile.kind === "sdk" ? "–" : " – ";
+	return profile.kind === "sdk" && start === end ? start : `${start}${separator}${end}`;
+}
+/** Offset changes override ordinary venue omission for the approved display profile. */
+function decideRangeLabels(span, context, profile) {
+	if (profile.kind === "sdk") return { kind: "omit" };
+	const offsetsDiffer = offsetToken(span.start, context) !== offsetToken(span.end, context);
+	if (!offsetsDiffer && profile.zone === "omit") return { kind: "omit" };
+	const start = zoneLabel(span.start, context);
+	const end = zoneLabel(span.end, context);
+	return offsetsDiffer || start !== end ? {
+		kind: "endpoints",
+		start,
+		end
+	} : {
+		kind: "shared",
+		label: start
+	};
+}
+function presentRangeEndpoint(value, context, profile, label) {
+	return `${presentDate({
+		kind: "instant",
+		value
+	}, context, profile)}, ${label === void 0 ? presentTime(value, context, profile) : `${presentClock(value, context, profile.clock)} ${label}`}`;
+}
+function presentNativeRange(span, context, format) {
+	return formatIntlRange(getDateTimeFormatter(context.locale, context.timeZone, format), new Date(span.start), new Date(span.end));
+}
+function combinedFormat(date, clock) {
+	return {
+		...date,
+		...clock.format
+	};
+}
+function dateCarrier(value) {
+	return value.kind === "civil" ? civilCarrier(value.value) : new Date(value.value);
+}
+function presentClock(value, context, clock) {
+	return clock.kind === "compact" ? formatBookingCompactEnglishTime({
+		startsAt: value,
+		timeZone: context.timeZone,
+		locale: clock.localeSource === "product" ? "en-GB" : context.locale
+	}) : getDateTimeFormatter(context.locale, context.timeZone, clock.format).format(new Date(value));
+}
+function offsetToken(value, context) {
+	return getDateTimeFormatter("en-GB", context.timeZone, { timeZoneName: "longOffset" }).formatToParts(new Date(value)).find((part) => part.type === "timeZoneName")?.value ?? "";
+}
+function civilCarrier(value) {
+	return new Date(Date.UTC(value.year, value.month - 1, value.day, 12));
+}
+function projectDate(value, context) {
+	return value.kind === "civil" ? value.value : getLocalScheduleDate(new Date(value.value), context.timeZone);
+}
+function normalizeDisplay(value) {
+	return value.replace(/[\u00a0\u202f]/gu, " ");
+}
+function zoneToken(value, context, locale) {
+	return getDateTimeFormatter(locale, context.timeZone, { timeZoneName: "short" }).formatToParts(new Date(value)).find((part) => part.type === "timeZoneName")?.value ?? "";
+}
+function zoneLabel(value, context) {
+	const abbreviation = [zoneToken(value, context, "en-GB"), zoneToken(value, context, "en-US")].find((token) => /^[A-Z]{2,6}$/u.test(token));
+	const fallback = context.timeZone.startsWith("Etc/") ? "local time" : `${context.timeZone.split("/").slice(-1)[0]?.replace(/_/gu, " ") ?? context.timeZone} time`;
+	return abbreviation ?? fallback;
+}
+function assertOrdered(start, end) {
+	if (new Date(end).getTime() < new Date(start).getTime()) throw new RangeError("Date/time range end must be on or after its start");
+}
 //#endregion
-//#region src/date-time/index.ts
+//#region ../core/src/scheduled-date-time.ts
 const DEFAULT_LOCALE = "en-GB";
-const COMPACT_ENGLISH_RANGE_SEPARATOR = "–";
 const FORMATTER_CACHE_LIMIT = 100;
 const DEFAULT_DATE_FORMAT = {
 	weekday: "long",
@@ -168,11 +367,6 @@ const DEFAULT_RANGE_DATE_FORMAT = {
 	month: "short",
 	day: "numeric"
 };
-const DEFAULT_STANDARD_TIME_FORMAT = {
-	hour: "numeric",
-	minute: "2-digit"
-};
-const dateTimeFormatterCache = /* @__PURE__ */ new Map();
 const parsedLocaleCache = /* @__PURE__ */ new Map();
 var RiverbankDateTimeFormatError = class extends Error {
 	constructor(details) {
@@ -183,40 +377,51 @@ var RiverbankDateTimeFormatError = class extends Error {
 		this.value = details.value;
 	}
 };
+/** Public contract adapters: admission/options here, all presentation in date-display. */
 function formatScheduledDate(input, options = {}) {
-	return formatInstant(parseDateTime(input), options.format ?? DEFAULT_DATE_FORMAT);
+	const parsed = parseDateTime(input);
+	return presentDate({
+		kind: "instant",
+		value: parsed.startsAt
+	}, scheduledContext(parsed), sdkPresentationProfile(scheduledContext(parsed), options.format ?? DEFAULT_DATE_FORMAT));
 }
 function formatScheduledTime(input, options = {}) {
-	return formatTime(parseDateTime(input), options);
+	const parsed = parseDateTime(input);
+	return presentTime(parsed.startsAt, scheduledContext(parsed), sdkPresentationProfile(scheduledContext(parsed), {}, options));
 }
 function formatScheduledDateTime(input, options = {}) {
-	return formatDateTime(parseDateTime(input), options, DEFAULT_DATE_FORMAT);
+	const parsed = parseDateTime(input);
+	return presentDateTime(parsed.startsAt, scheduledContext(parsed), sdkPresentationProfile(scheduledContext(parsed), options.dateFormat ?? DEFAULT_DATE_FORMAT, options.time));
 }
 function formatScheduledDateRange(input, options = {}) {
-	const range = parseDateRange(input);
-	return formatRange(rangeStart(range), rangeEnd(range), options.format ?? DEFAULT_RANGE_DATE_FORMAT);
+	const parsed = parseDateRange(input);
+	return presentDateRange({
+		kind: "instant",
+		value: parsed.startsAt
+	}, {
+		kind: "instant",
+		value: parsed.endsAt
+	}, scheduledContext(parsed), sdkPresentationProfile(scheduledContext(parsed), options.format ?? DEFAULT_RANGE_DATE_FORMAT));
 }
 function formatScheduledTimeRange(input, options = {}) {
-	const range = parseDateRange(input);
-	const start = rangeStart(range);
-	const end = rangeEnd(range);
-	if (!usesCompactEnglishTime(start, options)) return formatRange(start, end, resolveStandardTimeFormat(options));
-	const startTime = formatTime(start, options);
-	const endTime = formatTime(end, options);
-	return startTime === endTime ? startTime : `${startTime}${COMPACT_ENGLISH_RANGE_SEPARATOR}${endTime}`;
+	const parsed = parseDateRange(input);
+	return presentTimeRange({
+		start: parsed.startsAt,
+		end: parsed.endsAt
+	}, scheduledContext(parsed), sdkPresentationProfile(scheduledContext(parsed), {}, options));
 }
 function formatScheduledDateTimeRange(input, options = {}) {
-	const range = parseDateRange(input);
-	const start = rangeStart(range);
-	const end = rangeEnd(range);
-	if (!usesCompactEnglishTime(start, options.time ?? {})) return formatRange(start, end, resolveCombinedFormat(options, DEFAULT_RANGE_DATE_FORMAT));
-	const startDate = formatInstant(start, options.dateFormat ?? DEFAULT_RANGE_DATE_FORMAT);
-	const startTime = formatTime(start, options.time ?? {});
-	const endTime = formatTime(end, options.time ?? {});
-	const startDateTime = `${startDate}, ${startTime}`;
-	if (sameLocalDate(start, end)) return startTime === endTime ? startDateTime : `${startDate}, ${startTime}${COMPACT_ENGLISH_RANGE_SEPARATOR}${endTime}`;
-	const endDateTime = `${formatInstant(end, options.dateFormat ?? DEFAULT_RANGE_DATE_FORMAT)}, ${endTime}`;
-	return startDateTime === endDateTime ? startDateTime : `${startDateTime}${COMPACT_ENGLISH_RANGE_SEPARATOR}${endDateTime}`;
+	const parsed = parseDateRange(input);
+	return presentDateTimeRange({
+		start: parsed.startsAt,
+		end: parsed.endsAt
+	}, scheduledContext(parsed), sdkPresentationProfile(scheduledContext(parsed), options.dateFormat ?? DEFAULT_RANGE_DATE_FORMAT, options.time));
+}
+function scheduledContext(input) {
+	return {
+		locale: input.locale,
+		timeZone: input.timeZone
+	};
 }
 function parseDateTime(input) {
 	const locale = parseLocale(input.locale);
@@ -234,11 +439,7 @@ function parseDateTime(input) {
 function parseDateRange(input) {
 	const locale = parseLocale(input.locale);
 	assertStringTimeZone(input.timeZone);
-	if (input.endsAt === null || input.endsAt === void 0) throw new RiverbankDateTimeFormatError({
-		code: "missing_ends_at",
-		field: "endsAt",
-		value: ""
-	});
+	assertRequiredEnd(input.endsAt);
 	const result = parseScheduledBookingDateRange({
 		...input,
 		locale: locale.locale
@@ -260,6 +461,13 @@ function parseDateRange(input) {
 		locale: locale.locale
 	};
 }
+function assertRequiredEnd(value) {
+	if (value === null || value === void 0) throw new RiverbankDateTimeFormatError({
+		code: "missing_ends_at",
+		field: "endsAt",
+		value: ""
+	});
+}
 function parseLocale(value) {
 	const locale = value === void 0 ? DEFAULT_LOCALE : value;
 	if (typeof locale !== "string") throw new RiverbankDateTimeFormatError({
@@ -270,13 +478,9 @@ function parseLocale(value) {
 	const cached = parsedLocaleCache.get(locale);
 	if (cached !== void 0) return cached;
 	try {
-		const parsed = new Intl.Locale(locale);
-		const canonical = parsed.toString();
+		const canonical = new Intl.Locale(locale).toString();
 		if (Intl.DateTimeFormat.supportedLocalesOf([canonical]).length === 0) throw new RangeError("Unsupported locale");
-		const result = {
-			locale: canonical,
-			language: parsed.language
-		};
+		const result = { locale: canonical };
 		if (parsedLocaleCache.size >= FORMATTER_CACHE_LIMIT) parsedLocaleCache.clear();
 		parsedLocaleCache.set(locale, result);
 		return result;
@@ -326,68 +530,6 @@ function formatErrorMessage(details) {
 		default: return assertNever(details);
 	}
 }
-function formatDateTime(input, options, defaultDateFormat) {
-	if (!usesCompactEnglishTime(input, options.time ?? {})) return formatInstant(input, resolveCombinedFormat(options, defaultDateFormat));
-	return `${formatInstant(input, options.dateFormat ?? defaultDateFormat)}, ${formatTime(input, options.time ?? {})}`;
-}
-function formatTime(input, options) {
-	if (usesCompactEnglishTime(input, options)) return formatBookingCompactEnglishTime(input);
-	return formatInstant(input, resolveStandardTimeFormat(options));
-}
-function usesCompactEnglishTime(input, options) {
-	return options.timePresentation !== "standard" && parseLocale(input.locale).language === "en";
-}
-function resolveStandardTimeFormat(options) {
-	return options.timePresentation === "standard" ? options.format ?? DEFAULT_STANDARD_TIME_FORMAT : DEFAULT_STANDARD_TIME_FORMAT;
-}
-function resolveCombinedFormat(options, defaultDateFormat) {
-	return {
-		...options.dateFormat ?? defaultDateFormat,
-		...resolveStandardTimeFormat(options.time ?? {})
-	};
-}
-function formatInstant(input, format) {
-	return getFormatter(input, format).format(new Date(input.startsAt));
-}
-function formatRange(start, end, format) {
-	const formatter = getFormatter(start, format);
-	const nativeFormatRange = Reflect.get(formatter, "formatRange");
-	if (typeof nativeFormatRange !== "function") throw new Error("Intl.DateTimeFormat.formatRange is required");
-	const output = Reflect.apply(nativeFormatRange, formatter, [new Date(start.startsAt), new Date(end.startsAt)]);
-	if (typeof output !== "string") throw new Error("Intl.DateTimeFormat.formatRange returned a non-string value");
-	return output;
-}
-function getFormatter(input, format) {
-	const formatKey = JSON.stringify(Object.entries(format).sort(([left], [right]) => left.localeCompare(right)));
-	const key = `${input.locale}\u0000${input.timeZone}\u0000${formatKey}`;
-	const cached = dateTimeFormatterCache.get(key);
-	if (cached !== void 0) return cached;
-	const formatter = new Intl.DateTimeFormat(input.locale, {
-		...format,
-		timeZone: input.timeZone
-	});
-	if (dateTimeFormatterCache.size >= FORMATTER_CACHE_LIMIT) dateTimeFormatterCache.clear();
-	dateTimeFormatterCache.set(key, formatter);
-	return formatter;
-}
-function rangeStart(range) {
-	return range;
-}
-function rangeEnd(range) {
-	return {
-		startsAt: range.endsAt,
-		timeZone: range.timeZone,
-		locale: range.locale
-	};
-}
-function sameLocalDate(start, end) {
-	const format = {
-		year: "numeric",
-		month: "2-digit",
-		day: "2-digit"
-	};
-	return formatInstant(start, format) === formatInstant(end, format);
-}
 function assertNever(value) {
 	throw new Error(`Unhandled date-time variant: ${String(value)}`);
 }