@riverbankcms/sdk 0.108.0 → 0.111.0

package/dist/server/date-time.mjs

@@ -0,0 +1,386 @@
+//#region ../core/src/result.ts
+function ok(value) {
+	return {
+		ok: true,
+		value
+	};
+}
+function err(error) {
+	return {
+		ok: false,
+		error
+	};
+}
+//#endregion
+//#region ../core/src/booking-date-time.ts
+const DEFAULT_LOCALE$1 = "en-US";
+const DATE_TIME_FORMATTER_CACHE_LIMIT = 100;
+const dateTimeFormatterCache$1 = /* @__PURE__ */ new Map();
+const timeZoneValidityCache = /* @__PURE__ */ new Map();
+function isValidTimeZone(timeZone) {
+	const cached = timeZoneValidityCache.get(timeZone);
+	if (cached !== void 0) return cached;
+	let isValid;
+	try {
+		new Intl.DateTimeFormat(DEFAULT_LOCALE$1, { timeZone }).format(/* @__PURE__ */ new Date());
+		isValid = true;
+	} catch {
+		isValid = false;
+	}
+	if (timeZoneValidityCache.size >= DATE_TIME_FORMATTER_CACHE_LIMIT) timeZoneValidityCache.clear();
+	timeZoneValidityCache.set(timeZone, isValid);
+	return isValid;
+}
+function parseStrictBookingTimeZone(timeZone) {
+	if (typeof timeZone !== "string") return null;
+	const normalized = timeZone.trim();
+	if (normalized.length === 0 || !isValidTimeZone(normalized)) return null;
+	return normalized;
+}
+function formatToPartsLookup(date, locale, timeZone, format) {
+	return new Map(getCachedDateTimeFormatter(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
+	});
+	if (dateTimeFormatterCache$1.size >= DATE_TIME_FORMATTER_CACHE_LIMIT) dateTimeFormatterCache$1.clear();
+	dateTimeFormatterCache$1.set(key, formatter);
+	return formatter;
+}
+function parseUtcIsoDateTimeString(value) {
+	const normalized = value.trim();
+	const hasUtcSuffix = normalized.endsWith("Z");
+	const hasExplicitOffset = /[+-]\d{2}:\d{2}$/u.test(normalized);
+	if (!hasUtcSuffix && !hasExplicitOffset) return err("missing-timezone-offset");
+	const date = new Date(normalized);
+	if (Number.isNaN(date.getTime())) return err("invalid-date-time");
+	return ok(date.toISOString());
+}
+function toUtcIsoDateTimeString(value) {
+	const parsed = parseUtcIsoDateTimeString(value);
+	if (!parsed.ok) {
+		const message = parsed.error === "missing-timezone-offset" ? `Expected an offset-aware ISO datetime, received "${value}"` : `Expected a valid ISO datetime, received "${value}"`;
+		throw new Error(message);
+	}
+	return parsed.value;
+}
+function parseScheduledBookingDateTime(input) {
+	let startsAt;
+	try {
+		startsAt = toUtcIsoDateTimeString(input.startsAt);
+	} catch {
+		return {
+			ok: false,
+			field: "startsAt",
+			reason: "invalid_starts_at",
+			value: input.startsAt
+		};
+	}
+	const timeZone = parseStrictBookingTimeZone(input.timeZone);
+	if (timeZone === null) return {
+		ok: false,
+		field: "timeZone",
+		reason: "invalid_time_zone",
+		value: typeof input.timeZone === "string" ? input.timeZone : ""
+	};
+	return {
+		ok: true,
+		value: {
+			startsAt,
+			timeZone,
+			locale: input.locale
+		}
+	};
+}
+function parseScheduledBookingDateRange(input) {
+	const start = parseScheduledBookingDateTime(input);
+	if (!start.ok) return start;
+	if (input.endsAt == null) return {
+		ok: true,
+		value: start.value
+	};
+	try {
+		return {
+			ok: true,
+			value: {
+				...start.value,
+				endsAt: toUtcIsoDateTimeString(input.endsAt)
+			}
+		};
+	} catch {
+		return {
+			ok: false,
+			field: "endsAt",
+			reason: "invalid_ends_at",
+			value: input.endsAt
+		};
+	}
+}
+/**
+* Formats the compact English event-time presentation used by public surfaces.
+*
+* This intentionally owns the lowercase day-period token and zero-minute
+* omission instead of depending on locale-specific spacing or punctuation.
+* Callers must only use it for an English presentation contract.
+*/
+function formatBookingCompactEnglishTime(input) {
+	const date = new Date(input.startsAt);
+	if (Number.isNaN(date.getTime())) return input.startsAt;
+	const parts = formatToPartsLookup(date, input.locale ?? "en-GB", input.timeZone, {
+		hour: "numeric",
+		minute: "2-digit",
+		hour12: true
+	});
+	const hour = parts.get("hour");
+	const minute = parts.get("minute");
+	const dayPeriod = parts.get("dayPeriod");
+	if (hour === void 0 || minute === void 0 || dayPeriod === void 0) return input.startsAt;
+	return `${minute === "00" ? hour : `${hour}:${minute}`}${dayPeriod.toLowerCase()}`;
+}
+//#endregion
+//#region src/date-time/index.ts
+const DEFAULT_LOCALE = "en-GB";
+const COMPACT_ENGLISH_RANGE_SEPARATOR = "–";
+const FORMATTER_CACHE_LIMIT = 100;
+const DEFAULT_DATE_FORMAT = {
+	weekday: "long",
+	year: "numeric",
+	month: "long",
+	day: "numeric"
+};
+const DEFAULT_RANGE_DATE_FORMAT = {
+	weekday: "short",
+	year: "numeric",
+	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) {
+		super(formatErrorMessage(details));
+		this.name = "RiverbankDateTimeFormatError";
+		this.code = details.code;
+		this.field = details.field;
+		this.value = details.value;
+	}
+};
+function formatScheduledDate(input, options = {}) {
+	return formatInstant(parseDateTime(input), options.format ?? DEFAULT_DATE_FORMAT);
+}
+function formatScheduledTime(input, options = {}) {
+	return formatTime(parseDateTime(input), options);
+}
+function formatScheduledDateTime(input, options = {}) {
+	return formatDateTime(parseDateTime(input), options, DEFAULT_DATE_FORMAT);
+}
+function formatScheduledDateRange(input, options = {}) {
+	const range = parseDateRange(input);
+	return formatRange(rangeStart(range), rangeEnd(range), 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}`;
+}
+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}`;
+}
+function parseDateTime(input) {
+	const locale = parseLocale(input.locale);
+	assertStringTimeZone(input.timeZone);
+	const result = parseScheduledBookingDateTime({
+		...input,
+		locale: locale.locale
+	});
+	if (result.ok) return {
+		...result.value,
+		locale: locale.locale
+	};
+	throw fromCoreParseError(result);
+}
+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: ""
+	});
+	const result = parseScheduledBookingDateRange({
+		...input,
+		locale: locale.locale
+	});
+	if (!result.ok) throw fromCoreParseError(result);
+	if (result.value.endsAt === null || result.value.endsAt === void 0) throw new RiverbankDateTimeFormatError({
+		code: "missing_ends_at",
+		field: "endsAt",
+		value: ""
+	});
+	if (new Date(result.value.endsAt).getTime() < new Date(result.value.startsAt).getTime()) throw new RiverbankDateTimeFormatError({
+		code: "end_before_start",
+		field: "endsAt",
+		value: input.endsAt
+	});
+	return {
+		...result.value,
+		endsAt: result.value.endsAt,
+		locale: locale.locale
+	};
+}
+function parseLocale(value) {
+	const locale = value === void 0 ? DEFAULT_LOCALE : value;
+	if (typeof locale !== "string") throw new RiverbankDateTimeFormatError({
+		code: "invalid_locale",
+		field: "locale",
+		value: ""
+	});
+	const cached = parsedLocaleCache.get(locale);
+	if (cached !== void 0) return cached;
+	try {
+		const parsed = new Intl.Locale(locale);
+		const canonical = parsed.toString();
+		if (Intl.DateTimeFormat.supportedLocalesOf([canonical]).length === 0) throw new RangeError("Unsupported locale");
+		const result = {
+			locale: canonical,
+			language: parsed.language
+		};
+		if (parsedLocaleCache.size >= FORMATTER_CACHE_LIMIT) parsedLocaleCache.clear();
+		parsedLocaleCache.set(locale, result);
+		return result;
+	} catch {
+		throw new RiverbankDateTimeFormatError({
+			code: "invalid_locale",
+			field: "locale",
+			value: typeof value === "string" ? value : ""
+		});
+	}
+}
+function assertStringTimeZone(value) {
+	if (typeof value !== "string") throw new RiverbankDateTimeFormatError({
+		code: "invalid_time_zone",
+		field: "timeZone",
+		value: ""
+	});
+}
+function fromCoreParseError(error) {
+	switch (error.reason) {
+		case "invalid_starts_at": return new RiverbankDateTimeFormatError({
+			code: error.reason,
+			field: error.field,
+			value: typeof error.value === "string" ? error.value : ""
+		});
+		case "invalid_ends_at": return new RiverbankDateTimeFormatError({
+			code: error.reason,
+			field: error.field,
+			value: typeof error.value === "string" ? error.value : ""
+		});
+		case "invalid_time_zone": return new RiverbankDateTimeFormatError({
+			code: error.reason,
+			field: error.field,
+			value: error.value
+		});
+		default: return assertNever(error);
+	}
+}
+function formatErrorMessage(details) {
+	switch (details.code) {
+		case "invalid_starts_at": return `Expected startsAt to be a valid offset-aware ISO datetime, received "${details.value}"`;
+		case "invalid_ends_at": return `Expected endsAt to be a valid offset-aware ISO datetime, received "${details.value}"`;
+		case "missing_ends_at": return "Expected endsAt to be provided for a scheduled range";
+		case "invalid_time_zone": return `Expected timeZone to be a valid IANA timezone, received "${details.value}"`;
+		case "invalid_locale": return `Expected locale to be a supported BCP 47 locale, received "${details.value}"`;
+		case "end_before_start": return `Expected endsAt to be on or after startsAt, received "${details.value}"`;
+		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)}`);
+}
+//#endregion
+export { RiverbankDateTimeFormatError, formatScheduledDate, formatScheduledDateRange, formatScheduledDateTime, formatScheduledDateTimeRange, formatScheduledTime, formatScheduledTimeRange };

package/dist/server/index.mjs

@@ -2260,6 +2260,24 @@ const API_ENDPOINTS$1 = {
 		auth: "user",
 		responseKind: "json"
 	},
+	publishEventOfferingPageSurface: {
+		path: "/sites/{siteId}/page-surfaces/{pageSurfaceId}/publication",
+		method: "POST",
+		errors: [
+			"auth:forbidden",
+			"validation:invalid_input",
+			"resource:not_found",
+			"resource:conflict",
+			"server:internal_error"
+		],
+		tags: [
+			TAG_TEMPLATES.siteCollection,
+			TAG_TEMPLATES.siteRoutableContent,
+			TAG_TEMPLATES.pageSurfaceById
+		],
+		auth: "user",
+		responseKind: "json"
+	},
 	runSdkWorkflow: {
 		path: "/sites/{siteId}/content/{type}/{entryId}/workflows/{workflowId}/run",
 		method: "POST",
@@ -6122,8 +6140,8 @@ const API_ENDPOINTS$1 = {
 		auth: "user",
 		responseKind: "blob"
 	},
-	adminSiteCost: {
-		path: "/admin/sites/{siteId}/cost",
+	adminSiteBillingArrangement: {
+		path: "/admin/sites/{siteId}/billing/arrangement",
 		method: "GET",
 		tags: [
 			"admin",
@@ -6131,10 +6149,16 @@ const API_ENDPOINTS$1 = {
 			"billing"
 		],
 		auth: "admin",
-		responseKind: "json"
+		responseKind: "json",
+		errors: [
+			"validation:invalid_input",
+			"auth:forbidden",
+			"resource:not_found",
+			"server:internal_error"
+		]
 	},
-	adminUpdateSiteCost: {
-		path: "/admin/sites/{siteId}/cost",
+	adminUpdateSiteBillingArrangement: {
+		path: "/admin/sites/{siteId}/billing/arrangement",
 		method: "POST",
 		tags: [
 			"admin",
@@ -6142,7 +6166,14 @@ const API_ENDPOINTS$1 = {
 			"billing"
 		],
 		auth: "admin",
-		responseKind: "json"
+		responseKind: "json",
+		errors: [
+			"validation:invalid_input",
+			"auth:forbidden",
+			"resource:not_found",
+			"resource:conflict",
+			"server:internal_error"
+		]
 	},
 	adminScheduleBillingComponentEnd: {
 		path: "/admin/sites/{siteId}/billing/components/{componentId}/end",
@@ -6309,6 +6340,41 @@ const API_ENDPOINTS$1 = {
 		auth: "service",
 		responseKind: "json"
 	},
+	sdkCatalogTheme: {
+		path: "/sdk/{siteId}/catalog/theme",
+		method: "GET",
+		errors: ["server:internal_error"],
+		auth: "service",
+		responseKind: "json"
+	},
+	sdkCatalogBlocks: {
+		path: "/sdk/{siteId}/catalog/blocks",
+		method: "GET",
+		errors: ["server:internal_error"],
+		auth: "service",
+		responseKind: "json"
+	},
+	sdkCatalogContentTypes: {
+		path: "/sdk/{siteId}/catalog/content-types",
+		method: "GET",
+		errors: ["server:internal_error"],
+		auth: "service",
+		responseKind: "json"
+	},
+	sdkCapabilities: {
+		path: "/sdk/{siteId}/capabilities",
+		method: "GET",
+		errors: ["server:internal_error"],
+		auth: "service",
+		responseKind: "json"
+	},
+	sdkListDemoContent: {
+		path: "/sdk/{siteId}/demo-content",
+		method: "GET",
+		errors: ["server:internal_error"],
+		auth: "service",
+		responseKind: "json"
+	},
 	sdkPullPages: {
 		path: "/sdk/{siteId}/pull/pages",
 		method: "GET",
@@ -7726,7 +7792,7 @@ var SimpleCache = class {
 * 1. This constant
 * 2. The "version" field in package.json
 */
-const SDK_VERSION = "0.108.0";
+const SDK_VERSION = "0.111.0";
 //#endregion
 //#region src/client/error.ts
 let _Symbol$for;

package/dist/server/next/revalidate.mjs

@@ -12,7 +12,8 @@ z.enum([
 	"entry.path_changed",
 	"navigation.updated",
 	"theme.updated",
-	"site.settings_updated"
+	"site.settings_updated",
+	"events.updated"
 ]);
 function asRevalidationPath(path) {
 	return path;
@@ -84,6 +85,51 @@ const EntryPathChangedDataSchema = z.object({
 }).strict();
 const NavigationUpdatedDataSchema = z.object({ menuId: z.string().optional() }).strict();
 const EmptyWebhookDataSchema = z.object({}).strict();
+const EventSeriesPublicActionSchema = z.enum([
+	"created",
+	"updated",
+	"cancelled",
+	"archived",
+	"restored",
+	"deleted"
+]);
+const EventOccurrencePublicActionSchema = z.enum([
+	"created",
+	"updated",
+	"cancelled",
+	"deleted"
+]);
+const EventRegistrationCapacityActionSchema = z.enum([
+	"created",
+	"cancelled",
+	"hold_expired",
+	"waitlist_promoted"
+]);
+const EventsUpdatedDataSchema = z.discriminatedUnion("entity", [
+	z.object({
+		entity: z.literal("series"),
+		action: EventSeriesPublicActionSchema,
+		seriesId: z.string().min(1)
+	}).strict(),
+	z.object({
+		entity: z.literal("occurrence"),
+		action: EventOccurrencePublicActionSchema,
+		seriesId: z.string().min(1),
+		occurrenceId: z.string().min(1)
+	}).strict(),
+	z.object({
+		entity: z.literal("registration"),
+		action: EventRegistrationCapacityActionSchema,
+		seriesId: z.string().min(1),
+		occurrenceIds: z.tuple([z.string().min(1)]).rest(z.string().min(1))
+	}).strict()
+]).superRefine((data, ctx) => {
+	if (data.entity === "registration" && new Set(data.occurrenceIds).size !== data.occurrenceIds.length) ctx.addIssue({
+		code: "custom",
+		path: ["occurrenceIds"],
+		message: "Occurrence IDs must be unique"
+	});
+});
 const WebhookPayloadBaseSchema = z.object({
 	timestamp: z.string(),
 	dispatchId: z.string().optional(),
@@ -135,6 +181,12 @@ const WebhookPayloadSchema = z.discriminatedUnion("event", [
 	WebhookPayloadBaseSchema.extend({
 		event: z.literal("site.settings_updated"),
 		data: EmptyWebhookDataSchema
+	}),
+	WebhookPayloadBaseSchema.extend({
+		event: z.literal("events.updated"),
+		dispatchId: z.string().min(1),
+		tags: z.array(z.string()).min(1),
+		data: EventsUpdatedDataSchema
 	})
 ]);
 //#endregion