cms-renderer 0.6.6 → 0.6.7

package/dist/lib/parametric-route.js

@@ -0,0 +1,686 @@
+// ../../packages/cms-schema/src/blocks/article.ts
+function normalizeArticleContent(payload) {
+  if (!payload || typeof payload !== "object") {
+    return null;
+  }
+  const record = payload;
+  const headline = typeof record.headline === "string" ? record.headline : null;
+  const body = typeof record.body === "string" ? record.body : null;
+  if (!headline || !body) {
+    return null;
+  }
+  const author = typeof record.author === "string" ? record.author : void 0;
+  const publishedAt = typeof record.publishedAt === "string" ? record.publishedAt : void 0;
+  const tags = Array.isArray(record.tags) ? record.tags.map((tag) => String(tag)) : void 0;
+  const statusRaw = typeof record.status === "string" ? record.status.trim() : void 0;
+  return {
+    headline,
+    body,
+    author,
+    publishedAt,
+    tags,
+    status: statusRaw || void 0
+  };
+}
+function isArticlePublished(article) {
+  const now = /* @__PURE__ */ new Date();
+  const publishedAt = article.publishedAt ? new Date(article.publishedAt) : null;
+  return article.status === "published" && publishedAt !== null && !Number.isNaN(publishedAt.getTime()) && publishedAt <= now;
+}
+
+// ../../packages/cms-schema/src/validation/image.ts
+import { z } from "zod";
+var ALLOWED_MIME_TYPES = ["image/jpeg", "image/png", "image/webp"];
+var MAX_FILE_SIZE = 10 * 1024 * 1024;
+var MIN_FILE_SIZE = 1024;
+var MAX_DIMENSION = 8192;
+var MIN_DIMENSION = 10;
+var MimeTypeSchema = z.enum(ALLOWED_MIME_TYPES);
+var FileSizeSchema = z.number().int().min(MIN_FILE_SIZE, `File too small. Minimum: ${MIN_FILE_SIZE} bytes`).max(MAX_FILE_SIZE, `File too large. Maximum: ${MAX_FILE_SIZE / 1024 / 1024}MB`);
+var DimensionSchema = z.number().int().min(MIN_DIMENSION, `Dimension too small. Minimum: ${MIN_DIMENSION}px`).max(MAX_DIMENSION, `Dimension too large. Maximum: ${MAX_DIMENSION}px`);
+var UploadRequestSchema = z.object({
+  filename: z.string().min(1, "Filename is required").max(255, "Filename too long").regex(/^[^<>:"/\\|?*]+$/, "Filename contains invalid characters"),
+  mimeType: MimeTypeSchema,
+  fileSize: FileSizeSchema
+});
+var ConfirmUploadSchema = z.object({
+  assetId: z.uuid().optional(),
+  width: DimensionSchema,
+  height: DimensionSchema
+});
+
+// ../../packages/cms-schema/src/blocks/schemas/article-block.ts
+import { z as z2 } from "zod";
+var ArticleBlockContentSchema = z2.object({
+  headline: z2.string().min(1, "Article headline is required").max(300, "Headline too long").trim(),
+  author: z2.string().max(100, "Article author too long").trim().optional(),
+  publishedAt: z2.iso.datetime({ message: "Article publishedAt must be a valid ISO 8601 datetime string." }).optional(),
+  body: z2.string().min(1, "Article body content is required"),
+  tags: z2.array(z2.string()).optional(),
+  status: z2.enum(["draft", "review", "published"])
+});
+var ARTICLE_BLOCK_SCHEMA_NAME = "article";
+
+// ../../packages/cms-schema/src/blocks/schemas/cta-block.ts
+import { z as z3 } from "zod";
+var CTAButtonSchema = z3.object({
+  text: z3.string().min(1, "Button text is required").max(50, "Button text too long"),
+  url: z3.string().refine(
+    (val) => {
+      if (val.startsWith("http://") || val.startsWith("https://")) {
+        try {
+          new URL(val);
+          return true;
+        } catch {
+          return false;
+        }
+      }
+      if (val.startsWith("/")) {
+        return true;
+      }
+      if (val.startsWith("#")) {
+        return true;
+      }
+      return false;
+    },
+    {
+      message: "URL must be a valid full URL (http://... or https://...), relative path (/path), or anchor (#anchor)"
+    }
+  )
+});
+var CTABlockContentSchema = z3.object({
+  headline: z3.string().min(1, "Headline is required").max(100, "Headline too long"),
+  description: z3.string().max(500, "Description too long").optional(),
+  primaryButton: CTAButtonSchema,
+  secondaryButton: CTAButtonSchema.optional()
+});
+var CTA_BLOCK_SCHEMA_NAME = "cta-block";
+
+// ../../packages/cms-schema/src/blocks/schemas/features-block.ts
+import { z as z4 } from "zod";
+var FeaturesLayout = ["grid", "list", "carousel"];
+var FeatureItemSchema = z4.object({
+  icon: z4.string().max(50, "Icon name too long").optional(),
+  title: z4.string().min(1, "Title is required").max(100, "Title too long"),
+  description: z4.string().max(500, "Description too long").optional()
+});
+var FeaturesBlockContentSchema = z4.object({
+  title: z4.string().min(1, "Section title is required").max(100, "Title too long"),
+  subtitle: z4.string().max(200, "Subtitle too long").optional(),
+  features: z4.array(FeatureItemSchema).min(1, "At least one feature is required").max(6, "Maximum 6 features allowed"),
+  layout: z4.enum(FeaturesLayout).default("grid")
+});
+var FEATURES_BLOCK_SCHEMA_NAME = "features-block";
+
+// ../../packages/cms-schema/src/blocks/schemas/hero-block.ts
+import { z as z6 } from "zod";
+
+// ../../packages/cms-schema/src/fields/complex/media.ts
+import { z as z5 } from "zod";
+var ImageAssetSchema = z5.object({
+  /** UUID primary key */
+  id: z5.uuid(),
+  /** R2/S3 storage URL for the original file */
+  url: z5.url(),
+  /** Image width in pixels */
+  width: DimensionSchema,
+  /** Image height in pixels */
+  height: DimensionSchema,
+  /** Original filename from upload */
+  originalFilename: z5.string().min(1).max(255),
+  /** MIME type (only web-safe formats allowed) */
+  mimeType: MimeTypeSchema,
+  /** File size in bytes */
+  fileSize: FileSizeSchema,
+  /** Base64-encoded tiny preview for blur-up loading */
+  lqip: z5.string().optional()
+});
+var HotspotSchema = z5.object({
+  x: z5.number().min(0).max(1),
+  y: z5.number().min(0).max(1)
+});
+var CropSchema = z5.object({
+  /** X coordinate of top-left corner in pixels */
+  x: z5.number().int().nonnegative(),
+  /** Y coordinate of top-left corner in pixels */
+  y: z5.number().int().nonnegative(),
+  /** Width of crop region in pixels (must be > 0) */
+  width: z5.number().int().positive(),
+  /** Height of crop region in pixels (must be > 0) */
+  height: z5.number().int().positive()
+});
+var ImageReferenceSchema = z5.object({
+  // Alt text is REQUIRED for accessibility
+  alt: z5.string().min(1, "Alt text is required for accessibility"),
+  // Optional metadata
+  caption: z5.string().max(500).optional(),
+  attribution: z5.string().max(255).optional(),
+  // Reference to the ImageAsset with stored transformation
+  _asset: z5.object({
+    id: z5.uuid(),
+    transformation: z5.string().nullable().optional()
+  })
+});
+var fileSchema = z5.object({
+  url: z5.url(),
+  name: z5.string(),
+  size: z5.number().int().positive(),
+  type: z5.string()
+});
+
+// ../../packages/cms-schema/src/blocks/schemas/hero-block.ts
+var HeroAlignment = ["left", "center", "right"];
+var HeroBlockContentSchema = z6.object({
+  headline: z6.string().min(1, "Headline is required").max(100, "Headline too long"),
+  subheadline: z6.string().max(200, "Subheadline too long").optional(),
+  ctaText: z6.string().max(50, "CTA text too long").optional(),
+  ctaUrl: z6.string().refine(
+    (val) => {
+      if (val === "") return true;
+      if (val.startsWith("http://") || val.startsWith("https://")) {
+        try {
+          new URL(val);
+          return true;
+        } catch {
+          return false;
+        }
+      }
+      if (val.startsWith("/")) {
+        return true;
+      }
+      if (val.startsWith("#")) {
+        return true;
+      }
+      return false;
+    },
+    {
+      message: "URL must be a valid full URL (http://... or https://...), relative path (/path), anchor (#anchor), or empty string"
+    }
+  ).optional().or(z6.literal("")),
+  backgroundImage: ImageReferenceSchema.nullable().optional(),
+  alignment: z6.enum(HeroAlignment).default("center")
+});
+var HERO_BLOCK_SCHEMA_NAME = "hero-block";
+
+// ../../packages/cms-schema/src/blocks/schemas/logo-trust-block.ts
+import { z as z7 } from "zod";
+var LogoItemSchema = z7.object({
+  /** Unique ID for this logo item */
+  id: z7.uuid(),
+  /** Image reference (alt + _asset with transformation) */
+  image: ImageReferenceSchema,
+  /** Optional company/brand name to display */
+  name: z7.string().max(100, "Name too long").optional()
+});
+var LegacyLogoItemSchema = z7.object({
+  /** Direct URL to the logo image */
+  url: z7.string(),
+  /** Alt text for the image */
+  alt: z7.string(),
+  /** Optional company/brand name */
+  name: z7.string().optional()
+});
+var LogoTrustBlockContentSchema = z7.object({
+  title: z7.string().max(100, "Title too long").optional(),
+  logos: z7.array(LogoItemSchema).max(20, "Maximum 20 logos allowed")
+});
+var LOGO_TRUST_BLOCK_SCHEMA_NAME = "logo-trust-block";
+
+// ../../packages/cms-schema/src/blocks/registry.ts
+var BLOCK_SCHEMA_NAMES = [
+  ARTICLE_BLOCK_SCHEMA_NAME,
+  HERO_BLOCK_SCHEMA_NAME,
+  FEATURES_BLOCK_SCHEMA_NAME,
+  CTA_BLOCK_SCHEMA_NAME,
+  LOGO_TRUST_BLOCK_SCHEMA_NAME
+];
+function isValidBlockSchemaName(name) {
+  return BLOCK_SCHEMA_NAMES.includes(name);
+}
+
+// ../../packages/cms-schema/src/routing/normalize-path.ts
+function normalizePath(path) {
+  if (!path || path === "/") {
+    return "/";
+  }
+  let normalized = path.trim();
+  if (!normalized) {
+    return "/";
+  }
+  if (normalized === "/") {
+    return "/";
+  }
+  let end = normalized.length;
+  while (end > 1 && normalized.charCodeAt(end - 1) === 47) {
+    end--;
+  }
+  if (end < normalized.length) {
+    normalized = normalized.slice(0, end);
+  }
+  if (!normalized.startsWith("/")) {
+    normalized = `/${normalized}`;
+  }
+  const segments = normalized.split("/").filter((s) => s.length > 0);
+  if (segments.length === 0) {
+    return "/";
+  }
+  return `/${segments.join("/")}`;
+}
+
+// ../../packages/cms-schema/src/routing/path-validation.ts
+import { z as z8 } from "zod";
+var pathRegex = /^\/[\p{L}\p{N}\-_{}/:]*$/u;
+var placeholderSegmentRegex = /^(:[a-zA-Z0-9_]+|\{[a-zA-Z0-9_]+\})$/;
+function hasValidPlaceholderStructure(path) {
+  if (path === "/") {
+    return true;
+  }
+  const segments = path.split("/").filter(Boolean);
+  return segments.every((segment) => {
+    const hasPlaceholderSyntax = segment.includes(":") || segment.includes("{") || segment.includes("}");
+    if (!hasPlaceholderSyntax) {
+      return true;
+    }
+    return placeholderSegmentRegex.test(segment);
+  });
+}
+var pathSchema = z8.string().min(1, "Path is required").regex(
+  pathRegex,
+  "Path must start with / and contain only letters, numbers, hyphens, underscores, slashes, colons, and braces"
+).refine(
+  hasValidPlaceholderStructure,
+  "Path placeholders must be in the form :name or {name} with non-empty names"
+);
+
+// ../../packages/cms-schema/src/documents/schemas/language.ts
+import { z as z9 } from "zod";
+var LanguageSchema = z9.object({
+  /** 2-letter ISO 639-1 language code */
+  code: z9.string().length(2, "Language code must be 2 characters"),
+  /** English name of the language */
+  name: z9.string().min(1, "Language name required"),
+  /** Name in the language itself (optional but recommended) */
+  nativeName: z9.string().optional()
+});
+
+// lib/block-renderer.tsx
+import React from "react";
+import { ClientEditableBlock } from "./client-editable-block.js";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+function extractContentValues(content, basePath = []) {
+  const map = /* @__PURE__ */ new Map();
+  function walk(obj, path) {
+    if (typeof obj === "string" && obj.trim() !== "") {
+      const contentPath = path.join(".");
+      const existing = map.get(obj) || [];
+      existing.push({ contentPath, value: obj });
+      map.set(obj, existing);
+    } else if (Array.isArray(obj)) {
+      for (let index = 0; index < obj.length; index++) {
+        walk(obj[index], [...path, String(index)]);
+      }
+    } else if (obj && typeof obj === "object") {
+      for (const [key, value] of Object.entries(obj)) {
+        walk(value, [...path, key]);
+      }
+    }
+  }
+  walk(content, basePath);
+  return map;
+}
+function CmsEditableInit() {
+  return /* @__PURE__ */ jsxs(Fragment, { children: [
+    /* @__PURE__ */ jsx("style", { children: `
+        [data-cms-editable] {
+          cursor: pointer;
+          border-radius: 2px;
+        }
+        [data-cms-editable]:hover {
+          outline: 2px solid #3b82f6;
+          outline-offset: 2px;
+        }
+        .cms-block-toolbar {
+          position: fixed;
+          display: flex;
+          gap: 4px;
+          background: #1f2937;
+          border-radius: 6px;
+          padding: 4px;
+          box-shadow: 0 2px 8px rgba(0, 0, 0, 0.15);
+          transition: opacity 0.15s ease;
+          z-index: 99999;
+          pointer-events: auto;
+        }
+        .cms-block-toolbar button {
+          display: flex;
+          align-items: center;
+          justify-content: center;
+          width: 28px;
+          height: 28px;
+          border: none;
+          background: transparent;
+          color: #9ca3af;
+          border-radius: 4px;
+          cursor: pointer;
+          transition: background 0.15s ease, color 0.15s ease;
+        }
+        .cms-block-toolbar button:hover {
+          background: #374151;
+          color: #fff;
+        }
+        .cms-block-toolbar button.delete:hover {
+          background: #dc2626;
+          color: #fff;
+        }
+        .cms-block-toolbar button:disabled {
+          opacity: 0.4;
+          cursor: not-allowed;
+        }
+        .cms-block-toolbar button:disabled:hover {
+          background: transparent;
+          color: #9ca3af;
+        }
+        .cms-block-toolbar svg {
+          width: 16px;
+          height: 16px;
+        }
+      ` }),
+    /* @__PURE__ */ jsx(
+      "script",
+      {
+        dangerouslySetInnerHTML: {
+          __html: `
+            (function() {
+              if (!window.__cmsEditableInitialized) {
+                window.__cmsEditableInitialized = true;
+
+                document.addEventListener('click', function(e) {
+                  if (e.target.closest('.cms-block-toolbar')) return;
+
+                  var editableTarget = e.target.closest('[data-cms-editable]');
+                  if (editableTarget) {
+                    var message = {
+                      type: 'cms-editable-click',
+                      blockId: editableTarget.getAttribute('data-block-id'),
+                      blockType: editableTarget.getAttribute('data-block-type'),
+                      contentPath: editableTarget.getAttribute('data-content-path')
+                    };
+                    if (window.parent && window.parent !== window) {
+                      window.parent.postMessage(message, '*');
+                    }
+                    return;
+                  }
+
+                  var blockTarget = e.target.closest('[data-cms-block]');
+                  if (blockTarget) {
+                    var message = {
+                      type: 'cms-editable-click',
+                      blockId: blockTarget.getAttribute('data-block-id'),
+                      blockType: blockTarget.getAttribute('data-block-type'),
+                      contentPath: null
+                    };
+                    if (window.parent && window.parent !== window) {
+                      window.parent.postMessage(message, '*');
+                    }
+                  }
+                });
+              }
+            })();
+          `
+        }
+      }
+    )
+  ] });
+}
+function pathMatchesPattern(path, pattern) {
+  const pathSegs = path.split("/").filter(Boolean);
+  const patternSegs = pattern.split("/").filter(Boolean);
+  if (pathSegs.length !== patternSegs.length) return false;
+  for (let i = 0; i < patternSegs.length; i++) {
+    const seg = patternSegs[i];
+    if (!seg) return false;
+    if (seg.startsWith("{") && seg.endsWith("}") || seg.startsWith("(") && seg.endsWith(")")) {
+      continue;
+    }
+    if (seg !== pathSegs[i]) return false;
+  }
+  return true;
+}
+function resolveComponent(registry, blockType, path) {
+  if (path) {
+    for (const key of Object.keys(registry)) {
+      if (!key.startsWith("/")) continue;
+      const spaceIdx = key.indexOf(" ");
+      if (spaceIdx === -1) continue;
+      const pathPattern = key.slice(0, spaceIdx);
+      const registeredType = key.slice(spaceIdx + 1);
+      if (registeredType !== blockType) continue;
+      if (pathMatchesPattern(path, pathPattern)) {
+        return registry[key];
+      }
+    }
+  }
+  return registry[blockType];
+}
+function BlockRenderer({
+  block,
+  registry,
+  disableEditable,
+  routeParams,
+  path
+}) {
+  const Component = resolveComponent(registry, block.type, path);
+  if (!Component) {
+    if (process.env.NODE_ENV === "development") {
+      console.warn(`[BlockRenderer] Unknown block type: ${block.type}`);
+    }
+    return null;
+  }
+  const language = routeParams ? Object.values(routeParams).find((p) => p.schemaName === "language")?.value : void 0;
+  const component = /* @__PURE__ */ jsx(Component, { content: block.content, routeParams, language });
+  if (disableEditable) {
+    return component;
+  }
+  const contentValueMap = extractContentValues(block.content);
+  const contentEntries = Array.from(contentValueMap.entries()).map(([value, matches]) => ({ v: value, p: matches[0]?.contentPath })).filter((e) => !!e.p);
+  return /* @__PURE__ */ jsx(ClientEditableBlock, { blockId: block.id, blockType: block.type, contentEntries, children: component });
+}
+
+// lib/cms-api.ts
+import { createTRPCClient, httpBatchLink } from "@trpc/client";
+import superjson from "superjson";
+function getCmsApiUrl(cmsUrl) {
+  return new URL("/api/trpc", cmsUrl).toString();
+}
+function createFetchWithApiKey(apiKey, websiteId) {
+  return async (url, options) => {
+    let finalUrl = url;
+    const urlObj = new URL(url.toString());
+    if (apiKey) {
+      urlObj.searchParams.set("api_key", apiKey);
+    }
+    if (websiteId) {
+      urlObj.searchParams.set("website_id", websiteId);
+    }
+    if (apiKey || websiteId) {
+      finalUrl = urlObj.toString();
+    }
+    const response = await fetch(finalUrl, options);
+    return response;
+  };
+}
+function createCmsClient(options) {
+  const url = getCmsApiUrl(options.cmsUrl);
+  return createTRPCClient({
+    links: [
+      httpBatchLink({
+        url,
+        transformer: superjson,
+        fetch: createFetchWithApiKey(options.apiKey, options.websiteId)
+      })
+    ]
+  });
+}
+var clientCache = /* @__PURE__ */ new Map();
+function getClientCacheKey(options) {
+  return `${options.cmsUrl}|${options.apiKey ?? ""}|${options.websiteId ?? ""}`;
+}
+function getCmsClient(options) {
+  const cacheKey = getClientCacheKey(options);
+  let client = clientCache.get(cacheKey);
+  if (!client) {
+    client = createCmsClient(options);
+    clientCache.set(cacheKey, client);
+  }
+  return client;
+}
+
+// lib/parametric-route.tsx
+import { jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
+function getWebsiteId(providedWebsiteId) {
+  const websiteId = providedWebsiteId ?? process.env.NEXT_PUBLIC_WEBSITE_ID ?? process.env.WEBSITE_ID ?? process.env.CMS_WEBSITE_ID;
+  if (!websiteId) {
+    throw new Error(
+      "Missing websiteId for website renderer. Either pass websiteId prop or set NEXT_PUBLIC_WEBSITE_ID (or WEBSITE_ID/CMS_WEBSITE_ID) to a valid UUID."
+    );
+  }
+  const uuidRegex = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+  if (!uuidRegex.test(websiteId)) {
+    throw new Error(
+      `Invalid websiteId "${websiteId}". Provide a valid UUID via prop or set NEXT_PUBLIC_WEBSITE_ID (or WEBSITE_ID/CMS_WEBSITE_ID).`
+    );
+  }
+  return websiteId;
+}
+async function renderParametricRoute({
+  params,
+  searchParams,
+  registry,
+  apiKey,
+  cmsUrl,
+  websiteId: providedWebsiteId
+}) {
+  const websiteId = getWebsiteId(providedWebsiteId);
+  const { slug } = await params;
+  const resolvedSearchParams = await searchParams;
+  let aiPreviewIndex = null;
+  const aiPreviewParam = resolvedSearchParams?.ai_preview;
+  if (aiPreviewParam) {
+    const paramValue = Array.isArray(aiPreviewParam) ? aiPreviewParam[0] : aiPreviewParam;
+    if (paramValue) {
+      const parsed = parseInt(paramValue, 10);
+      if (!Number.isNaN(parsed)) {
+        aiPreviewIndex = parsed;
+      }
+    }
+  }
+  const editModeParam = resolvedSearchParams?.edit_mode;
+  const editMode = editModeParam === "true" || editModeParam === "1";
+  const rawPath = `/${slug.join("/")}`;
+  const path = normalizePath(rawPath);
+  if (/\.[a-zA-Z0-9]+$/.test(path)) {
+    return { status: "not_found" };
+  }
+  const client = getCmsClient({ apiKey, cmsUrl });
+  try {
+    const { route, resolvedParams } = await client.route.getByPath.query({
+      websiteId,
+      path
+    });
+    if (route.state !== "Live") {
+      return { status: "not_found" };
+    }
+    const blockResultsPromise = client.block.getByIds.query({ websiteId, ids: route.block_ids }).catch((error) => {
+      console.error("Failed to fetch blocks:", error);
+      return [];
+    });
+    const generatedBlocksPromise = aiPreviewIndex !== null ? client.block.getGeneratedByBlockIds.query({ websiteId, blockIds: route.block_ids }).catch((error) => {
+      console.error("Failed to fetch generated blocks:", error);
+      return { generatedBlocks: {} };
+    }) : Promise.resolve({ generatedBlocks: {} });
+    const [blockResults, { generatedBlocks }] = await Promise.all([
+      blockResultsPromise,
+      generatedBlocksPromise
+    ]);
+    const blocks = [];
+    for (const block of blockResults) {
+      if (!block || block.published_content === null) continue;
+      let content = null;
+      if (aiPreviewIndex !== null) {
+        const generatedBlock = generatedBlocks[block.id];
+        const variantIndex = aiPreviewIndex - 1;
+        const variants = generatedBlock?.generated_content;
+        if (variants && Array.isArray(variants) && variants[variantIndex]) {
+          content = variants[variantIndex].content;
+        }
+      }
+      content = content ?? block.published_content;
+      if (!content) continue;
+      if (block.schema_name === "article") {
+        const article = normalizeArticleContent(content);
+        const isPublished = article ? isArticlePublished(article) : null;
+        if (article && isPublished) {
+          blocks.push({ id: block.id, type: "article", content: article });
+        }
+        continue;
+      }
+      if (block.schema_id) {
+        blocks.push({ id: block.id, type: block.schema_name, content });
+        continue;
+      }
+      if (!isValidBlockSchemaName(block.schema_name)) {
+        continue;
+      }
+      blocks.push({
+        id: block.id,
+        type: block.schema_name,
+        content
+      });
+    }
+    const routeParams = resolvedParams ? Object.fromEntries(
+      Object.entries(resolvedParams).map(([key, param]) => [
+        key,
+        {
+          value: param.value,
+          schemaName: param.schemaName,
+          document: {
+            id: param.document.id,
+            title: param.document.title,
+            content: param.document.content,
+            schema_name: param.document.schema_name
+          }
+        }
+      ])
+    ) : void 0;
+    return {
+      status: "ok",
+      node: /* @__PURE__ */ jsxs2("main", { children: [
+        editMode && /* @__PURE__ */ jsx2(CmsEditableInit, {}),
+        blocks.map((block) => /* @__PURE__ */ jsx2(
+          BlockRenderer,
+          {
+            block,
+            registry: registry ?? {},
+            disableEditable: !editMode,
+            routeParams,
+            path
+          },
+          block.id
+        ))
+      ] })
+    };
+  } catch (error) {
+    console.error(`Route fetch error for path: ${path}`, error);
+    const errorCode = error instanceof Error && "data" in error ? error.data?.code : error instanceof Error && "code" in error ? error.code : void 0;
+    if (errorCode === "NOT_FOUND" || errorCode === "P0002" || errorCode === "BAD_REQUEST") {
+      return { status: "not_found" };
+    }
+    return { status: "error", error };
+  }
+}
+export {
+  getWebsiteId,
+  normalizePath,
+  renderParametricRoute
+};
+//# sourceMappingURL=parametric-route.js.map