cms-renderer 0.6.5 → 0.6.7

package/dist/lib/renderer.js

@@ -1,3 +1,75 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// lib/cms-api.ts
+var cms_api_exports = {};
+__export(cms_api_exports, {
+  getCmsClient: () => getCmsClient
+});
+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)
+      })
+    ]
+  });
+}
+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;
+}
+var clientCache;
+var init_cms_api = __esm({
+  "lib/cms-api.ts"() {
+    "use strict";
+    clientCache = /* @__PURE__ */ new Map();
+  }
+});
+
+// lib/renderer.tsx
+import { notFound } from "next/navigation";
+
 // ../../packages/cms-schema/src/blocks/article.ts
 function normalizeArticleContent(payload) {
   if (!payload || typeof payload !== "object") {
@@ -238,8 +310,70 @@ function isValidBlockSchemaName(name) {
   return BLOCK_SCHEMA_NAMES.includes(name);
 }
 
-// lib/renderer.tsx
-import { notFound } from "next/navigation";
+// ../../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";
@@ -424,46 +558,8 @@ function BlockRenderer({
   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)
-      })
-    ]
-  });
-}
-function getCmsClient(options) {
-  return createCmsClient(options);
-}
-
-// lib/renderer.tsx
+// lib/parametric-route.tsx
+init_cms_api();
 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;
@@ -480,7 +576,7 @@ function getWebsiteId(providedWebsiteId) {
   }
   return websiteId;
 }
-async function ParametricRoutePage({
+async function renderParametricRoute({
   params,
   searchParams,
   registry,
@@ -507,7 +603,7 @@ async function ParametricRoutePage({
   const rawPath = `/${slug.join("/")}`;
   const path = normalizePath(rawPath);
   if (/\.[a-zA-Z0-9]+$/.test(path)) {
-    notFound();
+    return { status: "not_found" };
   }
   const client = getCmsClient({ apiKey, cmsUrl });
   try {
@@ -516,23 +612,18 @@ async function ParametricRoutePage({
       path
     });
     if (route.state !== "Live") {
-      notFound();
+      return { status: "not_found" };
     }
-    const blockPromises = route.block_ids.map(async (blockId) => {
-      try {
-        const result = await client.block.getById.query({ websiteId, id: blockId });
-        return result.block;
-      } catch (error) {
-        console.error(`Failed to fetch block ${blockId}:`, error);
-        return null;
-      }
+    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([
-      Promise.all(blockPromises),
+      blockResultsPromise,
       generatedBlocksPromise
     ]);
     const blocks = [];
@@ -585,29 +676,44 @@ async function ParametricRoutePage({
         }
       ])
     ) : void 0;
-    return /* @__PURE__ */ jsxs2("main", { children: [
-      editMode && /* @__PURE__ */ jsx2(CmsEditableInit, {}),
-      blocks.map((block) => /* @__PURE__ */ jsx2(
-        BlockRenderer,
-        {
-          block,
-          registry: registry ?? {},
-          disableEditable: !editMode,
-          routeParams,
-          path
-        },
-        block.id
-      ))
-    ] });
+    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") {
-      notFound();
+      return { status: "not_found" };
     }
-    throw error;
+    return { status: "error", error };
   }
 }
+
+// lib/renderer.tsx
+async function ParametricRoutePage(props) {
+  const result = await renderParametricRoute(props);
+  if (result.status === "not_found") {
+    notFound();
+  }
+  if (result.status === "error") {
+    throw result.error;
+  }
+  return result.node;
+}
 async function generateMetadata({
   params,
   apiKey,
@@ -618,7 +724,8 @@ async function generateMetadata({
   const { slug } = await params;
   const rawPath = `/${slug.join("/")}`;
   const path = normalizePath(rawPath);
-  const client = getCmsClient({ apiKey, cmsUrl });
+  const { getCmsClient: getCmsClient2 } = await Promise.resolve().then(() => (init_cms_api(), cms_api_exports));
+  const client = getCmsClient2({ apiKey, cmsUrl });
   try {
     const { route } = await client.route.getByPath.query({ websiteId, path });
     return {
@@ -632,21 +739,8 @@ async function generateMetadata({
     };
   }
 }
-function normalizePath(path) {
-  if (!path || path === "/") {
-    return "/";
-  }
-  let normalized = path.trim();
-  normalized = normalized.replace(/\/+$/, "");
-  if (!normalized.startsWith("/")) {
-    normalized = `/${normalized}`;
-  }
-  normalized = normalized.replace(/\/+/g, "/");
-  return normalized;
-}
 export {
   ParametricRoutePage as default,
-  generateMetadata,
-  normalizePath
+  generateMetadata
 };
 //# sourceMappingURL=renderer.js.map