@riverbankcms/sdk 0.151.0 → 0.153.0

package/dist/server/index.mjs

@@ -1713,6 +1713,32 @@ const SDK_PAGE_DESIGN_ENDPOINT_DEFINITIONS = defineEndpointDefinitions({
 		]
 	}
 });
+//#endregion
+//#region ../core/src/result.ts
+function ok(value) {
+	return {
+		ok: true,
+		value
+	};
+}
+function err(error) {
+	return {
+		ok: false,
+		error
+	};
+}
+//#endregion
+//#region ../core/src/branded.ts
+const UUID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+function parseUuidBrand(value, unsafeConstructor) {
+	if (typeof value !== "string") return err({ kind: "not_string" });
+	const normalized = value.trim().toLowerCase();
+	if (normalized.length === 0) return err({ kind: "empty_string" });
+	if (!UUID_PATTERN.test(normalized)) return err({ kind: "invalid_uuid" });
+	return ok(unsafeConstructor(normalized));
+}
+const unsafeAsMediaAssetId = (id) => id;
+const parseMediaAssetId = (value) => parseUuidBrand(value, unsafeAsMediaAssetId);
 const PUBLIC_CONTENT_FRESHNESS_SECONDS = 3600;
 function availability(transport) {
 	return {
@@ -8017,6 +8043,13 @@ const API_ENDPOINTS$1 = {
 		auth: "public",
 		responseKind: "json"
 	},
+	demoClaimReadiness: {
+		path: "/demo/claims/{claimId}/readiness",
+		method: "GET",
+		auth: "user",
+		responseKind: "json",
+		errors: []
+	},
 	demoClaimMagicLink: {
 		path: "/demo/auth/send-magic-link",
 		method: "POST",
@@ -8922,7 +8955,7 @@ var SimpleCache = class {
 * 1. This constant
 * 2. The "version" field in package.json
 */
-const SDK_VERSION = "0.151.0";
+const SDK_VERSION = "0.153.0";
 //#endregion
 //#region src/client/error.ts
 let _Symbol$for;
@@ -11751,4 +11784,203 @@ const SYSTEM_BLOCK_KINDS = [
 	"block.file-download"
 ];
 //#endregion
-export { API_ENDPOINTS, DEFAULT_PUBLISHED_RUNTIME_CACHE_PAYLOAD_SCHEMA_VERSION, PrebuildLoader, RiverbankApiError, SDK_CORRELATION_HEADER_NAMES, SYSTEM_BLOCK_KINDS, buildEndpointURL, canUsePrebuild, classifyPublishedRuntimeCacheFreshness, createPrebuildLoader, createRiverbankClient, derivePublishedRuntimeCacheKey, getResilienceStatusFromError, isPublishedRuntimeCacheKeyEndpoint, normalizeRuntimePublicPath, parsePublishedRuntimeCacheKey, parsePublishedRuntimeCacheKeyDetails, parsePublishedRuntimeCachePayloadSchemaVersion, prebuildCache, resolveRuntimeCachePolicy };
+//#region ../media-core/src/identifiers.ts
+function slugifyMediaIdentifier(value) {
+	return value.toLowerCase().trim().replace(/[^a-z0-9\s-]/g, "").replace(/\s+/g, "-").replace(/-+/g, "-");
+}
+function parseMediaIdentifier(value) {
+	if (typeof value !== "string") return err({ kind: "not_string" });
+	const trimmed = value.trim();
+	if (trimmed.length === 0) return err({ kind: "empty_identifier" });
+	const normalized = slugifyMediaIdentifier(trimmed);
+	if (normalized.length === 0) return err({
+		kind: "empty_after_normalization",
+		value
+	});
+	return ok(normalized);
+}
+/**
+* Admits identifiers read from trusted persistence without repairing dirty data in memory.
+* User input should use parseMediaIdentifier, which intentionally canonicalizes it.
+*/
+function parseCanonicalMediaIdentifier(value) {
+	if (typeof value !== "string") return err({ kind: "not_string" });
+	const parsed = parseMediaIdentifier(value);
+	if (!parsed.ok) return parsed;
+	if (value !== parsed.value) return err({
+		kind: "non_canonical_identifier",
+		value,
+		canonical: parsed.value
+	});
+	return parsed;
+}
+//#endregion
+//#region ../media-core/src/mediaIdentifierSchema.ts
+/** Strict stored-reference admission delegates the canonical identifier decision. */
+const mediaIdentifierSchema = z.string().transform((value, context) => {
+	const parsed = parseCanonicalMediaIdentifier(value);
+	if (parsed.ok) return parsed.value;
+	context.addIssue({
+		code: "custom",
+		message: "Expected a canonical media identifier"
+	});
+	return z.NEVER;
+});
+//#endregion
+//#region ../media-core/src/mediaKinds.ts
+const mediaTypeDiscriminants = [
+	"image",
+	"video",
+	"audio",
+	"document",
+	"spreadsheet",
+	"archive"
+];
+//#endregion
+//#region ../media-core/src/renderableMediaAsset.ts
+/** Shared identifier indexing for admitted site-scoped projections. */
+function buildMediaIdentifierIndex(assets) {
+	const index = new Map(assets.map((asset) => [asset.identifier, asset]));
+	if (index.size !== assets.length) throw new Error("Duplicate media identifier in a site asset list");
+	return index;
+}
+/** Index already admitted projections, including runtime registration updates. */
+function indexRenderableMediaAssets(assets) {
+	if (!assets.length) return void 0;
+	const byId = new Map(assets.map((asset) => [asset.id, asset]));
+	const byIdentifier = buildMediaIdentifierIndex(assets);
+	if (byId.size !== assets.length) throw new Error("Duplicate media asset identity in a site asset list");
+	return {
+		assets,
+		byId,
+		byIdentifier
+	};
+}
+/** A portable reference never uses an incidental UUID, URL or storage snapshot for identity. */
+function resolveManagedMediaReference(reference, index) {
+	const asset = index?.byIdentifier.get(reference.identifier);
+	return asset ? {
+		kind: "resolved",
+		reference,
+		asset
+	} : {
+		kind: "missing",
+		reference
+	};
+}
+//#endregion
+//#region ../media-core/src/renderableMediaAssetAdmission.ts
+const mediaAssetIdSchema = z.string().transform((value, context) => {
+	const parsed = parseMediaAssetId(value);
+	if (parsed.ok) return parsed.value;
+	context.addIssue({
+		code: "custom",
+		message: "Expected a media asset ID"
+	});
+	return z.NEVER;
+});
+const nonemptyStorageValue = z.string().refine((value) => value.trim().length > 0);
+const renderableMediaAssetSchema = z.object({
+	id: mediaAssetIdSchema,
+	identifier: mediaIdentifierSchema,
+	storageBucket: nonemptyStorageValue,
+	storagePath: nonemptyStorageValue,
+	mimeType: nonemptyStorageValue,
+	filename: z.string().optional(),
+	width: z.number().positive().nullable(),
+	height: z.number().positive().nullable()
+});
+/** Admission precedes the identifier-only runtime resolution decision. */
+function buildRenderableMediaAssetIndex(assets) {
+	if (!assets?.length) return void 0;
+	return indexRenderableMediaAssets(assets.map((asset) => renderableMediaAssetSchema.parse(asset)));
+}
+//#endregion
+//#region ../media-core/src/media.ts
+const hotspotSchema = z.object({
+	x: z.number().min(0).max(1),
+	y: z.number().min(0).max(1),
+	radius: z.number().optional()
+});
+const rotationSchema = z.union([
+	z.literal(0),
+	z.literal(90),
+	z.literal(180),
+	z.literal(270)
+]);
+const rectSchema = z.tuple([
+	z.number(),
+	z.number(),
+	z.number(),
+	z.number()
+]);
+const aspectCropSchema = z.object({
+	aspect: z.preprocess((value) => value == null ? void 0 : value, z.string().optional()),
+	rect: z.preprocess((value) => value == null ? void 0 : value, rectSchema.optional()),
+	hotspot: z.preprocess((value) => value == null ? void 0 : value, hotspotSchema.optional()),
+	rotation: z.preprocess((value) => value == null ? void 0 : value, rotationSchema.optional())
+});
+const transformSchema = z.object({
+	aspectCrops: z.preprocess((value) => {
+		if (!value || typeof value !== "object" || Array.isArray(value)) return;
+		return value;
+	}, z.record(z.string(), aspectCropSchema.catch({}))).optional(),
+	rect: rectSchema.optional(),
+	hotspot: hotspotSchema.optional(),
+	rotation: rotationSchema.optional()
+});
+const mediaPosterSchema = z.discriminatedUnion("tag", [z.object({
+	tag: z.literal("media"),
+	identifier: mediaIdentifierSchema
+}).strict(), z.object({
+	tag: z.literal("external-src"),
+	src: z.string().url()
+}).strict()]);
+const mediaUsageShape = {
+	purpose: z.string().optional(),
+	placeholder: z.boolean().default(true).optional(),
+	alt: z.string().optional(),
+	filename: z.string().optional(),
+	width: z.number().optional(),
+	height: z.number().optional(),
+	poster: mediaPosterSchema.optional(),
+	transform: transformSchema.optional()
+};
+const environmentExclusions = {
+	assetId: z.never().optional(),
+	id: z.never().optional(),
+	src: z.never().optional(),
+	storageBucket: z.never().optional(),
+	storagePath: z.never().optional(),
+	mimeType: z.never().optional()
+};
+const mediaBaseSchema = z.object({
+	...mediaUsageShape,
+	...environmentExclusions,
+	identifier: mediaIdentifierSchema
+}).strict();
+mediaBaseSchema.extend({ type: z.literal("image") });
+mediaBaseSchema.extend({ type: z.literal("video") });
+const mediaSchema = mediaBaseSchema.extend({ type: z.enum(mediaTypeDiscriminants) });
+const persistableMediaSchema = mediaSchema;
+const externalMediaSchema = z.object({
+	...mediaUsageShape,
+	...environmentExclusions,
+	type: z.enum(mediaTypeDiscriminants),
+	src: z.string().min(1),
+	identifier: z.never().optional()
+}).strict();
+const assetMediaSchema = z.object({
+	...mediaUsageShape,
+	...environmentExclusions,
+	type: z.enum(mediaTypeDiscriminants),
+	asset: renderableMediaAssetSchema,
+	identifier: z.never().optional()
+}).strict();
+const runtimeMediaSchema = z.union([
+	mediaSchema,
+	externalMediaSchema,
+	assetMediaSchema
+]);
+//#endregion
+export { API_ENDPOINTS, DEFAULT_PUBLISHED_RUNTIME_CACHE_PAYLOAD_SCHEMA_VERSION, PrebuildLoader, RiverbankApiError, SDK_CORRELATION_HEADER_NAMES, SYSTEM_BLOCK_KINDS, buildEndpointURL, buildRenderableMediaAssetIndex, canUsePrebuild, classifyPublishedRuntimeCacheFreshness, createPrebuildLoader, createRiverbankClient, derivePublishedRuntimeCacheKey, getResilienceStatusFromError, isPublishedRuntimeCacheKeyEndpoint, mediaIdentifierSchema, mediaSchema, normalizeRuntimePublicPath, parseCanonicalMediaIdentifier, parseMediaIdentifier, parsePublishedRuntimeCacheKey, parsePublishedRuntimeCacheKeyDetails, parsePublishedRuntimeCachePayloadSchemaVersion, persistableMediaSchema, prebuildCache, renderableMediaAssetSchema, resolveManagedMediaReference, resolveRuntimeCachePolicy, runtimeMediaSchema };