cms-renderer 0.0.0 → 0.1.1

package/dist/chunk-HVKFEZBT.js

@@ -0,0 +1,116 @@
+// lib/result.ts
+function ok(value) {
+  return { ok: true, value };
+}
+function err(error) {
+  return { ok: false, error };
+}
+function isOk(result) {
+  return result.ok === true;
+}
+function isErr(result) {
+  return result.ok === false;
+}
+function unwrap(result) {
+  if (isOk(result)) {
+    return result.value;
+  }
+  throw result.error;
+}
+function unwrapOr(result, defaultValue) {
+  if (isOk(result)) {
+    return result.value;
+  }
+  return defaultValue;
+}
+function unwrapOrElse(result, fn) {
+  if (isOk(result)) {
+    return result.value;
+  }
+  return fn(result.error);
+}
+function map(result, fn) {
+  if (isOk(result)) {
+    return ok(fn(result.value));
+  }
+  return result;
+}
+function mapErr(result, fn) {
+  if (isErr(result)) {
+    return err(fn(result.error));
+  }
+  return result;
+}
+function flatMap(result, fn) {
+  if (isOk(result)) {
+    return fn(result.value);
+  }
+  return result;
+}
+async function fromPromise(promise) {
+  try {
+    const value = await promise;
+    return ok(value);
+  } catch (error) {
+    return err(error instanceof Error ? error : new Error(String(error)));
+  }
+}
+function tryCatch(fn) {
+  try {
+    return ok(fn());
+  } catch (error) {
+    return err(error instanceof Error ? error : new Error(String(error)));
+  }
+}
+async function tryCatchAsync(fn) {
+  try {
+    const value = await fn();
+    return ok(value);
+  } catch (error) {
+    return err(error instanceof Error ? error : new Error(String(error)));
+  }
+}
+function toTuple(result) {
+  if (isOk(result)) {
+    return [void 0, result.value];
+  }
+  return [result.error, void 0];
+}
+async function handle(fn) {
+  try {
+    const value = await fn();
+    return [void 0, value];
+  } catch (error) {
+    const err2 = error instanceof Error ? error : new Error(String(error));
+    return [err2, void 0];
+  }
+}
+function handleSync(fn) {
+  try {
+    const value = fn();
+    return [void 0, value];
+  } catch (error) {
+    const err2 = error instanceof Error ? error : new Error(String(error));
+    return [err2, void 0];
+  }
+}
+
+export {
+  ok,
+  err,
+  isOk,
+  isErr,
+  unwrap,
+  unwrapOr,
+  unwrapOrElse,
+  map,
+  mapErr,
+  flatMap,
+  fromPromise,
+  tryCatch,
+  tryCatchAsync,
+  toTuple,
+  handle,
+  handleSync
+};
+//# sourceMappingURL=chunk-HVKFEZBT.js.map

package/dist/chunk-HVKFEZBT.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../lib/result.ts"],"sourcesContent":["/**\n * Result Type Utilities\n *\n * Go-style error handling with discriminated union types.\n * Provides type-safe success/error handling without exceptions.\n *\n * @example\n * ```ts\n * const [err, data] = await handle(async () => {\n *   const response = await fetch(url);\n *   if (!response.ok) throw new Error(`HTTP ${response.status}`);\n *   return response.json();\n * });\n *\n * if (err) {\n *   console.error('Failed:', err.message);\n *   return { error: err.message };\n * }\n * return { data };\n * ```\n */\n\n// -----------------------------------------------------------------------------\n// Result Type\n// -----------------------------------------------------------------------------\n\n/**\n * A discriminated union representing either success or failure.\n *\n * @template T - The success value type\n * @template E - The error type (defaults to Error)\n *\n * @example\n * ```ts\n * function divide(a: number, b: number): Result<number, string> {\n *   if (b === 0) return err('Division by zero');\n *   return ok(a / b);\n * }\n *\n * const result = divide(10, 2);\n * if (isOk(result)) {\n *   console.log('Result:', result.value); // 5\n * } else {\n *   console.error('Error:', result.error);\n * }\n * ```\n */\nexport type Result<T, E = Error> = { ok: true; value: T } | { ok: false; error: E };\n\n// -----------------------------------------------------------------------------\n// Constructors\n// -----------------------------------------------------------------------------\n\n/**\n * Creates a success Result.\n *\n * @param value - The success value\n * @returns A success Result containing the value\n *\n * @example\n * ```ts\n * const result = ok(42);\n * // { ok: true, value: 42 }\n * ```\n */\nexport function ok<T>(value: T): Result<T, never> {\n  return { ok: true, value };\n}\n\n/**\n * Creates a failure Result.\n *\n * @param error - The error value\n * @returns A failure Result containing the error\n *\n * @example\n * ```ts\n * const result = err(new Error('Something went wrong'));\n * // { ok: false, error: Error('Something went wrong') }\n * ```\n */\nexport function err<E>(error: E): Result<never, E> {\n  return { ok: false, error };\n}\n\n// -----------------------------------------------------------------------------\n// Type Guards\n// -----------------------------------------------------------------------------\n\n/**\n * Type guard to check if a Result is successful.\n *\n * @param result - The Result to check\n * @returns true if the Result is a success\n *\n * @example\n * ```ts\n * const result = fetchData();\n * if (isOk(result)) {\n *   // TypeScript knows result.value exists here\n *   console.log(result.value);\n * }\n * ```\n */\nexport function isOk<T, E>(result: Result<T, E>): result is { ok: true; value: T } {\n  return result.ok === true;\n}\n\n/**\n * Type guard to check if a Result is a failure.\n *\n * @param result - The Result to check\n * @returns true if the Result is a failure\n *\n * @example\n * ```ts\n * const result = fetchData();\n * if (isErr(result)) {\n *   // TypeScript knows result.error exists here\n *   console.error(result.error);\n * }\n * ```\n */\nexport function isErr<T, E>(result: Result<T, E>): result is { ok: false; error: E } {\n  return result.ok === false;\n}\n\n// -----------------------------------------------------------------------------\n// Extractors\n// -----------------------------------------------------------------------------\n\n/**\n * Extracts the value from a Result, throwing if it's an error.\n *\n * @param result - The Result to unwrap\n * @returns The success value\n * @throws The error if Result is a failure\n *\n * @example\n * ```ts\n * const result = ok(42);\n * const value = unwrap(result); // 42\n *\n * const errorResult = err(new Error('fail'));\n * const value2 = unwrap(errorResult); // throws Error('fail')\n * ```\n */\nexport function unwrap<T, E>(result: Result<T, E>): T {\n  if (isOk(result)) {\n    return result.value;\n  }\n  throw result.error;\n}\n\n/**\n * Extracts the value from a Result, returning a default on error.\n *\n * @param result - The Result to unwrap\n * @param defaultValue - The value to return if Result is an error\n * @returns The success value or the default value\n *\n * @example\n * ```ts\n * const result = err(new Error('fail'));\n * const value = unwrapOr(result, 0); // 0\n *\n * const okResult = ok(42);\n * const value2 = unwrapOr(okResult, 0); // 42\n * ```\n */\nexport function unwrapOr<T, E>(result: Result<T, E>, defaultValue: T): T {\n  if (isOk(result)) {\n    return result.value;\n  }\n  return defaultValue;\n}\n\n/**\n * Extracts the value from a Result, computing a default on error.\n *\n * @param result - The Result to unwrap\n * @param fn - Function to compute the default value from the error\n * @returns The success value or the computed default\n *\n * @example\n * ```ts\n * const result = err(new Error('not found'));\n * const value = unwrapOrElse(result, (e) => {\n *   console.error('Error:', e.message);\n *   return [];\n * });\n * ```\n */\nexport function unwrapOrElse<T, E>(result: Result<T, E>, fn: (error: E) => T): T {\n  if (isOk(result)) {\n    return result.value;\n  }\n  return fn(result.error);\n}\n\n// -----------------------------------------------------------------------------\n// Transformers\n// -----------------------------------------------------------------------------\n\n/**\n * Maps a successful Result's value.\n *\n * @param result - The Result to map\n * @param fn - Function to transform the value\n * @returns A new Result with the transformed value, or the original error\n *\n * @example\n * ```ts\n * const result = ok(5);\n * const doubled = map(result, (n) => n * 2); // ok(10)\n *\n * const errorResult = err('fail');\n * const still = map(errorResult, (n) => n * 2); // err('fail')\n * ```\n */\nexport function map<T, U, E>(result: Result<T, E>, fn: (value: T) => U): Result<U, E> {\n  if (isOk(result)) {\n    return ok(fn(result.value));\n  }\n  return result;\n}\n\n/**\n * Maps a failed Result's error.\n *\n * @param result - The Result to map\n * @param fn - Function to transform the error\n * @returns A new Result with the transformed error, or the original value\n *\n * @example\n * ```ts\n * const result = err('not found');\n * const mapped = mapErr(result, (e) => new Error(e)); // err(Error('not found'))\n * ```\n */\nexport function mapErr<T, E, F>(result: Result<T, E>, fn: (error: E) => F): Result<T, F> {\n  if (isErr(result)) {\n    return err(fn(result.error));\n  }\n  return result;\n}\n\n/**\n * Chains Result-returning operations.\n *\n * @param result - The Result to chain from\n * @param fn - Function that returns a new Result\n * @returns The chained Result\n *\n * @example\n * ```ts\n * function parse(input: string): Result<number, string> {\n *   const n = parseInt(input, 10);\n *   return isNaN(n) ? err('not a number') : ok(n);\n * }\n *\n * function double(n: number): Result<number, string> {\n *   return ok(n * 2);\n * }\n *\n * const result = flatMap(parse('5'), double); // ok(10)\n * const fail = flatMap(parse('abc'), double); // err('not a number')\n * ```\n */\nexport function flatMap<T, U, E>(\n  result: Result<T, E>,\n  fn: (value: T) => Result<U, E>\n): Result<U, E> {\n  if (isOk(result)) {\n    return fn(result.value);\n  }\n  return result;\n}\n\n// -----------------------------------------------------------------------------\n// Async Helpers\n// -----------------------------------------------------------------------------\n\n/**\n * Wraps a Promise in a Result type.\n *\n * @param promise - The Promise to wrap\n * @returns A Promise that resolves to a Result\n *\n * @example\n * ```ts\n * const result = await fromPromise(fetch('/api/data'));\n * if (isErr(result)) {\n *   console.error('Fetch failed:', result.error);\n *   return;\n * }\n * const response = result.value;\n * ```\n */\nexport async function fromPromise<T>(promise: Promise<T>): Promise<Result<T, Error>> {\n  try {\n    const value = await promise;\n    return ok(value);\n  } catch (error) {\n    return err(error instanceof Error ? error : new Error(String(error)));\n  }\n}\n\n/**\n * Wraps a throwing function in a Result type.\n *\n * @param fn - The function to wrap\n * @returns A Result containing the return value or the thrown error\n *\n * @example\n * ```ts\n * const result = tryCatch(() => JSON.parse(input));\n * if (isErr(result)) {\n *   console.error('Invalid JSON:', result.error);\n *   return null;\n * }\n * return result.value;\n * ```\n */\nexport function tryCatch<T>(fn: () => T): Result<T, Error> {\n  try {\n    return ok(fn());\n  } catch (error) {\n    return err(error instanceof Error ? error : new Error(String(error)));\n  }\n}\n\n/**\n * Wraps an async function in a Result type.\n *\n * @param fn - The async function to wrap\n * @returns A Promise that resolves to a Result\n *\n * @example\n * ```ts\n * const result = await tryCatchAsync(async () => {\n *   const response = await fetch('/api/data');\n *   if (!response.ok) throw new Error(`HTTP ${response.status}`);\n *   return response.json();\n * });\n * ```\n */\nexport async function tryCatchAsync<T>(fn: () => Promise<T>): Promise<Result<T, Error>> {\n  try {\n    const value = await fn();\n    return ok(value);\n  } catch (error) {\n    return err(error instanceof Error ? error : new Error(String(error)));\n  }\n}\n\n// -----------------------------------------------------------------------------\n// Tuple Helpers (Go-style)\n// -----------------------------------------------------------------------------\n\n/**\n * Go-style tuple for error handling: [error, value]\n *\n * @example\n * ```ts\n * const [err, data] = await handle(fetchData);\n * if (err) {\n *   console.error(err);\n *   return;\n * }\n * console.log(data);\n * ```\n */\nexport type GoTuple<T, E = Error> = [E, undefined] | [undefined, T];\n\n/**\n * Converts a Result to a Go-style tuple.\n *\n * @param result - The Result to convert\n * @returns A tuple of [error, value]\n *\n * @example\n * ```ts\n * const result = await fetchData();\n * const [err, data] = toTuple(result);\n * ```\n */\nexport function toTuple<T, E>(result: Result<T, E>): GoTuple<T, E> {\n  if (isOk(result)) {\n    return [undefined, result.value];\n  }\n  return [result.error, undefined];\n}\n\n/**\n * Wraps an async function and returns a Go-style tuple.\n *\n * @param fn - The async function to wrap\n * @returns A Promise that resolves to [error, value] tuple\n *\n * @example\n * ```ts\n * const [err, data] = await handle(async () => {\n *   const res = await fetch('/api/users');\n *   if (!res.ok) throw new Error(`HTTP ${res.status}`);\n *   return res.json();\n * });\n *\n * if (err) {\n *   console.error('Failed to fetch users:', err.message);\n *   return [];\n * }\n * return data;\n * ```\n */\nexport async function handle<T>(fn: () => Promise<T>): Promise<GoTuple<T, Error>> {\n  try {\n    const value = await fn();\n    return [undefined, value];\n  } catch (error) {\n    const err = error instanceof Error ? error : new Error(String(error));\n    return [err, undefined];\n  }\n}\n\n/**\n * Wraps a synchronous function and returns a Go-style tuple.\n *\n * @param fn - The function to wrap\n * @returns A tuple of [error, value]\n *\n * @example\n * ```ts\n * const [err, parsed] = handleSync(() => JSON.parse(input));\n * if (err) {\n *   console.error('Invalid JSON:', err.message);\n *   return null;\n * }\n * return parsed;\n * ```\n */\nexport function handleSync<T>(fn: () => T): GoTuple<T, Error> {\n  try {\n    const value = fn();\n    return [undefined, value];\n  } catch (error) {\n    const err = error instanceof Error ? error : new Error(String(error));\n    return [err, undefined];\n  }\n}\n"],"mappings":";AAiEO,SAAS,GAAM,OAA4B;AAChD,SAAO,EAAE,IAAI,MAAM,MAAM;AAC3B;AAcO,SAAS,IAAO,OAA4B;AACjD,SAAO,EAAE,IAAI,OAAO,MAAM;AAC5B;AAqBO,SAAS,KAAW,QAAwD;AACjF,SAAO,OAAO,OAAO;AACvB;AAiBO,SAAS,MAAY,QAAyD;AACnF,SAAO,OAAO,OAAO;AACvB;AAsBO,SAAS,OAAa,QAAyB;AACpD,MAAI,KAAK,MAAM,GAAG;AAChB,WAAO,OAAO;AAAA,EAChB;AACA,QAAM,OAAO;AACf;AAkBO,SAAS,SAAe,QAAsB,cAAoB;AACvE,MAAI,KAAK,MAAM,GAAG;AAChB,WAAO,OAAO;AAAA,EAChB;AACA,SAAO;AACT;AAkBO,SAAS,aAAmB,QAAsB,IAAwB;AAC/E,MAAI,KAAK,MAAM,GAAG;AAChB,WAAO,OAAO;AAAA,EAChB;AACA,SAAO,GAAG,OAAO,KAAK;AACxB;AAsBO,SAAS,IAAa,QAAsB,IAAmC;AACpF,MAAI,KAAK,MAAM,GAAG;AAChB,WAAO,GAAG,GAAG,OAAO,KAAK,CAAC;AAAA,EAC5B;AACA,SAAO;AACT;AAeO,SAAS,OAAgB,QAAsB,IAAmC;AACvF,MAAI,MAAM,MAAM,GAAG;AACjB,WAAO,IAAI,GAAG,OAAO,KAAK,CAAC;AAAA,EAC7B;AACA,SAAO;AACT;AAwBO,SAAS,QACd,QACA,IACc;AACd,MAAI,KAAK,MAAM,GAAG;AAChB,WAAO,GAAG,OAAO,KAAK;AAAA,EACxB;AACA,SAAO;AACT;AAsBA,eAAsB,YAAe,SAAgD;AACnF,MAAI;AACF,UAAM,QAAQ,MAAM;AACpB,WAAO,GAAG,KAAK;AAAA,EACjB,SAAS,OAAO;AACd,WAAO,IAAI,iBAAiB,QAAQ,QAAQ,IAAI,MAAM,OAAO,KAAK,CAAC,CAAC;AAAA,EACtE;AACF;AAkBO,SAAS,SAAY,IAA+B;AACzD,MAAI;AACF,WAAO,GAAG,GAAG,CAAC;AAAA,EAChB,SAAS,OAAO;AACd,WAAO,IAAI,iBAAiB,QAAQ,QAAQ,IAAI,MAAM,OAAO,KAAK,CAAC,CAAC;AAAA,EACtE;AACF;AAiBA,eAAsB,cAAiB,IAAiD;AACtF,MAAI;AACF,UAAM,QAAQ,MAAM,GAAG;AACvB,WAAO,GAAG,KAAK;AAAA,EACjB,SAAS,OAAO;AACd,WAAO,IAAI,iBAAiB,QAAQ,QAAQ,IAAI,MAAM,OAAO,KAAK,CAAC,CAAC;AAAA,EACtE;AACF;AAiCO,SAAS,QAAc,QAAqC;AACjE,MAAI,KAAK,MAAM,GAAG;AAChB,WAAO,CAAC,QAAW,OAAO,KAAK;AAAA,EACjC;AACA,SAAO,CAAC,OAAO,OAAO,MAAS;AACjC;AAuBA,eAAsB,OAAU,IAAkD;AAChF,MAAI;AACF,UAAM,QAAQ,MAAM,GAAG;AACvB,WAAO,CAAC,QAAW,KAAK;AAAA,EAC1B,SAAS,OAAO;AACd,UAAMA,OAAM,iBAAiB,QAAQ,QAAQ,IAAI,MAAM,OAAO,KAAK,CAAC;AACpE,WAAO,CAACA,MAAK,MAAS;AAAA,EACxB;AACF;AAkBO,SAAS,WAAc,IAAgC;AAC5D,MAAI;AACF,UAAM,QAAQ,GAAG;AACjB,WAAO,CAAC,QAAW,KAAK;AAAA,EAC1B,SAAS,OAAO;AACd,UAAMA,OAAM,iBAAiB,QAAQ,QAAQ,IAAI,MAAM,OAAO,KAAK,CAAC;AACpE,WAAO,CAACA,MAAK,MAAS;AAAA,EACxB;AACF;","names":["err"]}

package/dist/chunk-JHKDRASN.js

@@ -0,0 +1,39 @@
+// lib/cms-api.ts
+import { createTRPCClient, httpBatchLink } from "@trpc/client";
+import superjson from "superjson";
+function getCmsApiUrl(cmsUrl) {
+  return `${cmsUrl}/api/trpc`;
+}
+function createFetchWithApiKey(apiKey) {
+  return async (url, options) => {
+    let finalUrl = url;
+    if (apiKey) {
+      const urlObj = new URL(url.toString());
+      urlObj.searchParams.set("api_key", apiKey);
+      finalUrl = urlObj.toString();
+    }
+    const response = await fetch(finalUrl, options);
+    return response;
+  };
+}
+function createCmsClient(options) {
+  const url = getCmsApiUrl(options.cmsUrl);
+  console.log("[CMS API] Creating client with URL:", url);
+  return createTRPCClient({
+    links: [
+      httpBatchLink({
+        url,
+        transformer: superjson,
+        fetch: createFetchWithApiKey(options.apiKey)
+      })
+    ]
+  });
+}
+function getCmsClient(options) {
+  return createCmsClient(options);
+}
+
+export {
+  getCmsClient
+};
+//# sourceMappingURL=chunk-JHKDRASN.js.map

package/dist/chunk-JHKDRASN.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../lib/cms-api.ts"],"sourcesContent":["/**\n * CMS API Client\n *\n * Creates an HTTP-based tRPC client for calling the CMS API.\n * Used in Server Components to fetch routes and blocks from the CMS.\n */\n\nimport type { AppRouter } from '@repo/cms-schema/trpc';\nimport { type CreateTRPCClient, createTRPCClient, httpBatchLink } from '@trpc/client';\nimport superjson from 'superjson';\n\n/** Type alias for the CMS API client */\ntype CmsClient = CreateTRPCClient<AppRouter>;\n\n/**\n * Get the CMS API URL from the provided base URL.\n */\nfunction getCmsApiUrl(cmsUrl: string): string {\n  return `${cmsUrl}/api/trpc`;\n}\n\n/** Options for creating a CMS client */\nexport interface CmsClientOptions {\n  /** CMS API base URL (e.g., 'http://localhost:3000') */\n  cmsUrl: string;\n  /** API key for authentication (passed as query parameter) */\n  apiKey?: string;\n}\n\n/**\n * Create a custom fetch function that appends API key as query parameter.\n */\nfunction createFetchWithApiKey(apiKey?: string) {\n  return async (url: URL | RequestInfo, options?: RequestInit): Promise<Response> => {\n    let finalUrl = url;\n\n    // Append api_key to URL if provided\n    if (apiKey) {\n      const urlObj = new URL(url.toString());\n      urlObj.searchParams.set('api_key', apiKey);\n      finalUrl = urlObj.toString();\n    }\n\n    const response = await fetch(finalUrl, options);\n\n    return response;\n  };\n}\n\n/**\n * Create a tRPC client for the CMS API.\n */\nfunction createCmsClient(options: CmsClientOptions): CmsClient {\n  const url = getCmsApiUrl(options.cmsUrl);\n  console.log('[CMS API] Creating client with URL:', url);\n\n  return createTRPCClient<AppRouter>({\n    links: [\n      httpBatchLink({\n        url,\n        transformer: superjson,\n        fetch: createFetchWithApiKey(options.apiKey),\n      }),\n    ],\n  });\n}\n\n/**\n * Get a CMS client for the specified CMS URL.\n */\nexport function getCmsClient(options: CmsClientOptions): CmsClient {\n  return createCmsClient(options);\n}\n"],"mappings":";AAQA,SAAgC,kBAAkB,qBAAqB;AACvE,OAAO,eAAe;AAQtB,SAAS,aAAa,QAAwB;AAC5C,SAAO,GAAG,MAAM;AAClB;AAaA,SAAS,sBAAsB,QAAiB;AAC9C,SAAO,OAAO,KAAwB,YAA6C;AACjF,QAAI,WAAW;AAGf,QAAI,QAAQ;AACV,YAAM,SAAS,IAAI,IAAI,IAAI,SAAS,CAAC;AACrC,aAAO,aAAa,IAAI,WAAW,MAAM;AACzC,iBAAW,OAAO,SAAS;AAAA,IAC7B;AAEA,UAAM,WAAW,MAAM,MAAM,UAAU,OAAO;AAE9C,WAAO;AAAA,EACT;AACF;AAKA,SAAS,gBAAgB,SAAsC;AAC7D,QAAM,MAAM,aAAa,QAAQ,MAAM;AACvC,UAAQ,IAAI,uCAAuC,GAAG;AAEtD,SAAO,iBAA4B;AAAA,IACjC,OAAO;AAAA,MACL,cAAc;AAAA,QACZ;AAAA,QACA,aAAa;AAAA,QACb,OAAO,sBAAsB,QAAQ,MAAM;AAAA,MAC7C,CAAC;AAAA,IACH;AAAA,EACF,CAAC;AACH;AAKO,SAAS,aAAa,SAAsC;AACjE,SAAO,gBAAgB,OAAO;AAChC;","names":[]}

package/dist/chunk-RPM73PQZ.js

@@ -0,0 +1,17 @@
+// lib/block-renderer.tsx
+import { jsx } from "react/jsx-runtime";
+function BlockRenderer({ block, registry }) {
+  const Component = registry[block.type];
+  if (!Component) {
+    if (process.env.NODE_ENV === "development") {
+      console.warn(`[BlockRenderer] Unknown block type: ${block.type}`);
+    }
+    return null;
+  }
+  return /* @__PURE__ */ jsx(Component, { content: block.content });
+}
+
+export {
+  BlockRenderer
+};
+//# sourceMappingURL=chunk-RPM73PQZ.js.map

package/dist/chunk-RPM73PQZ.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../lib/block-renderer.tsx"],"sourcesContent":["/**\n * Block Renderer Component\n *\n * Dispatches block data to the appropriate component using the ComponentMap pattern.\n * This is the main entry point for rendering blocks from the CMS.\n */\n\nimport type { BlockComponentRegistry, BlockData } from './types';\n\n// -----------------------------------------------------------------------------\n// Props\n// -----------------------------------------------------------------------------\n\ninterface BlockRendererProps {\n  /**\n   * The block data to render.\n   * Must have a `type` field that maps to a registered component.\n   */\n  block: BlockData;\n  registry: Partial<BlockComponentRegistry>;\n}\n\n// -----------------------------------------------------------------------------\n// Component\n// -----------------------------------------------------------------------------\n\n/**\n * Renders a single block by dispatching to the appropriate component.\n *\n * Uses the ComponentMap pattern: the block's `type` field determines which\n * component renders the block's `content`.\n *\n * @example\n * ```tsx\n * // Render a single block\n * <BlockRenderer block={{ type: 'header', content: { headline: 'Hello' } }} />\n *\n * // Render an array of blocks\n * {page.blocks.map((block, index) => (\n *   <BlockRenderer key={index} block={block} />\n * ))}\n * ```\n */\nexport function BlockRenderer({ block, registry }: BlockRendererProps) {\n  const Component = registry[block.type];\n\n  if (!Component) {\n    // Log warning in development, render nothing in production\n    if (process.env.NODE_ENV === 'development') {\n      console.warn(`[BlockRenderer] Unknown block type: ${block.type}`);\n    }\n    return null;\n  }\n\n  // TypeScript cannot narrow the content type through the component lookup,\n  // so we use a type assertion here. Runtime safety is guaranteed by the\n  // discriminated union and the blockComponents registry.\n  // biome-ignore lint/suspicious/noExplicitAny: Type safety ensured by BlockData discriminated union\n  return <Component content={block.content as any} />;\n}\n"],"mappings":";AA0DS;AAfF,SAAS,cAAc,EAAE,OAAO,SAAS,GAAuB;AACrE,QAAM,YAAY,SAAS,MAAM,IAAI;AAErC,MAAI,CAAC,WAAW;AAEd,QAAI,QAAQ,IAAI,aAAa,eAAe;AAC1C,cAAQ,KAAK,uCAAuC,MAAM,IAAI,EAAE;AAAA,IAClE;AACA,WAAO;AAAA,EACT;AAMA,SAAO,oBAAC,aAAU,SAAS,MAAM,SAAgB;AACnD;","names":[]}

package/dist/lib/block-renderer.d.ts

@@ -0,0 +1,32 @@
+import * as react from 'react';
+import { BlockData, BlockComponentRegistry } from './types.js';
+import '@repo/cms-schema/blocks';
+
+interface BlockRendererProps {
+    /**
+     * The block data to render.
+     * Must have a `type` field that maps to a registered component.
+     */
+    block: BlockData;
+    registry: Partial<BlockComponentRegistry>;
+}
+/**
+ * Renders a single block by dispatching to the appropriate component.
+ *
+ * Uses the ComponentMap pattern: the block's `type` field determines which
+ * component renders the block's `content`.
+ *
+ * @example
+ * ```tsx
+ * // Render a single block
+ * <BlockRenderer block={{ type: 'header', content: { headline: 'Hello' } }} />
+ *
+ * // Render an array of blocks
+ * {page.blocks.map((block, index) => (
+ *   <BlockRenderer key={index} block={block} />
+ * ))}
+ * ```
+ */
+declare function BlockRenderer({ block, registry }: BlockRendererProps): react.JSX.Element | null;
+
+export { BlockRenderer };

package/dist/lib/block-renderer.js

@@ -0,0 +1,7 @@
+import {
+  BlockRenderer
+} from "../chunk-RPM73PQZ.js";
+export {
+  BlockRenderer
+};
+//# sourceMappingURL=block-renderer.js.map

package/dist/lib/block-renderer.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/lib/cms-api.d.ts

@@ -0,0 +1,25 @@
+import { AppRouter } from '@repo/cms-schema/trpc';
+import { CreateTRPCClient } from '@trpc/client';
+
+/**
+ * CMS API Client
+ *
+ * Creates an HTTP-based tRPC client for calling the CMS API.
+ * Used in Server Components to fetch routes and blocks from the CMS.
+ */
+
+/** Type alias for the CMS API client */
+type CmsClient = CreateTRPCClient<AppRouter>;
+/** Options for creating a CMS client */
+interface CmsClientOptions {
+    /** CMS API base URL (e.g., 'http://localhost:3000') */
+    cmsUrl: string;
+    /** API key for authentication (passed as query parameter) */
+    apiKey?: string;
+}
+/**
+ * Get a CMS client for the specified CMS URL.
+ */
+declare function getCmsClient(options: CmsClientOptions): CmsClient;
+
+export { type CmsClientOptions, getCmsClient };

package/dist/lib/cms-api.js

@@ -0,0 +1,7 @@
+import {
+  getCmsClient
+} from "../chunk-JHKDRASN.js";
+export {
+  getCmsClient
+};
+//# sourceMappingURL=cms-api.js.map

package/dist/lib/cms-api.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/lib/data-utils.d.ts

@@ -0,0 +1,218 @@
+import { Result } from './result.js';
+import { BlockData } from './types.js';
+import '@repo/cms-schema/blocks';
+import 'react';
+
+/**
+ * Data Fetching Utilities
+ *
+ * Three implementations showing the progression from naive to production-ready:
+ * - v1 (Naive): Direct await, crashes on any error
+ * - v2 (Defensive): Try-catch with null fallback
+ * - v3 (Robust): Result type, retry logic, timeout support
+ *
+ * The robust version (v3) is exported as the default `fetchPage`.
+ */
+
+/**
+ * Page structure returned by the tRPC API.
+ */
+interface Page {
+    slug: string;
+    title: string;
+    blocks: BlockData[];
+}
+/**
+ * Error codes for data fetching failures.
+ */
+declare const FetchErrorCode: {
+    readonly INVALID_SLUG: "INVALID_SLUG";
+    readonly NOT_FOUND: "NOT_FOUND";
+    readonly NETWORK_ERROR: "NETWORK_ERROR";
+    readonly TIMEOUT: "TIMEOUT";
+    readonly PARSE_ERROR: "PARSE_ERROR";
+    readonly SERVER_ERROR: "SERVER_ERROR";
+    readonly RETRY_EXHAUSTED: "RETRY_EXHAUSTED";
+};
+type FetchErrorCode = (typeof FetchErrorCode)[keyof typeof FetchErrorCode];
+/**
+ * Structured error for data fetching failures.
+ */
+interface FetchError {
+    code: FetchErrorCode;
+    message: string;
+    cause?: Error;
+    retryCount?: number;
+}
+/**
+ * Options for robust data fetching.
+ */
+interface FetchOptions {
+    /**
+     * Timeout in milliseconds.
+     * @default 10000 (10 seconds)
+     */
+    timeout?: number;
+    /**
+     * Number of retry attempts for transient failures.
+     * @default 3
+     */
+    retries?: number;
+    /**
+     * Base delay between retries in milliseconds.
+     * Uses exponential backoff: delay * 2^attempt
+     * @default 1000 (1 second)
+     */
+    retryDelay?: number;
+    /**
+     * AbortSignal for cancellation support.
+     */
+    signal?: AbortSignal;
+}
+/**
+ * Naive data fetcher - crashes on any error.
+ *
+ * DO NOT USE IN PRODUCTION. This is for demonstration only.
+ *
+ * Problems:
+ * - No input validation
+ * - No error handling
+ * - Will crash the entire app on network failure
+ * - No timeout protection
+ * - No retry logic for transient failures
+ *
+ * @example
+ * ```ts
+ * // This throws if slug is invalid or network fails
+ * const page = await fetchPageV1('demo');
+ * ```
+ */
+declare function fetchPageV1(slug: string): Promise<Page>;
+/**
+ * Defensive data fetcher - catches errors but loses context.
+ *
+ * Better than v1 but still problematic:
+ * - Returns null on any error (loses error details)
+ * - Caller can't distinguish between 404 and network failure
+ * - No retry logic for transient failures
+ * - No timeout protection
+ *
+ * @example
+ * ```ts
+ * const page = await fetchPageV2(slug);
+ * if (!page) {
+ *   // What went wrong? 404? Network? Timeout? We don't know.
+ *   return <NotFound />;
+ * }
+ * ```
+ */
+declare function fetchPageV2(slug: string): Promise<Page | null>;
+/**
+ * Robust data fetcher - production-ready with full error context.
+ *
+ * Features:
+ * - Input validation with specific error codes
+ * - Result type for explicit error handling
+ * - Automatic retry with exponential backoff
+ * - Timeout support via AbortController
+ * - Distinguishes between error types (404 vs network vs timeout)
+ * - Preserves error context for debugging
+ *
+ * @param slug - Page slug to fetch
+ * @param options - Fetch options (timeout, retries, etc.)
+ * @returns Result containing the page data or a structured error
+ *
+ * @example
+ * ```ts
+ * const result = await fetchPageV3('demo', {
+ *   timeout: 5000,
+ *   retries: 3,
+ * });
+ *
+ * if (!result.ok) {
+ *   switch (result.error.code) {
+ *     case 'NOT_FOUND':
+ *       return <NotFoundPage slug={slug} />;
+ *     case 'TIMEOUT':
+ *       return <TimeoutError onRetry={handleRetry} />;
+ *     case 'NETWORK_ERROR':
+ *       return <NetworkError message={result.error.message} />;
+ *     case 'RETRY_EXHAUSTED':
+ *       return <RetryExhausted attempts={result.error.retryCount} />;
+ *     default:
+ *       return <GenericError />;
+ *   }
+ * }
+ *
+ * return <PageRenderer page={result.value} />;
+ * ```
+ */
+declare function fetchPageV3(slug: string, options?: FetchOptions): Promise<Result<Page, FetchError>>;
+/**
+ * Production-ready page fetcher.
+ *
+ * This is an alias for `fetchPageV3` - the robust implementation
+ * with validation, retry logic, and Result-based error handling.
+ *
+ * @example
+ * ```ts
+ * import { fetchPage } from '@/lib/data-utils';
+ *
+ * const result = await fetchPage('demo');
+ * if (!result.ok) {
+ *   // Handle error with full context
+ *   console.error(`[${result.error.code}] ${result.error.message}`);
+ *   return null;
+ * }
+ * return result.value;
+ * ```
+ */
+declare const fetchPage: typeof fetchPageV3;
+/**
+ * Validates a page slug format.
+ *
+ * @param slug - Slug to validate
+ * @returns true if slug is valid format
+ */
+declare function isValidSlug(slug: string): boolean;
+/**
+ * Normalizes a slug (lowercase, trim, replace spaces with hyphens).
+ *
+ * @param input - Raw input to normalize
+ * @returns Normalized slug
+ */
+declare function normalizeSlug(input: string): string;
+/**
+ * Prefetches multiple pages in parallel with Result types.
+ *
+ * @param slugs - Array of page slugs to fetch
+ * @param options - Fetch options applied to all requests
+ * @returns Array of Results for each page
+ *
+ * @example
+ * ```ts
+ * const results = await prefetchPages(['home', 'about', 'blog']);
+ * const errors = results.filter(r => !r.ok);
+ * if (errors.length > 0) {
+ *   console.warn(`${errors.length} pages failed to load`);
+ * }
+ * ```
+ */
+declare function prefetchPages(slugs: string[], options?: FetchOptions): Promise<Result<Page, FetchError>[]>;
+/**
+ * Fetches a page with stale-while-revalidate semantics.
+ * Returns cached data immediately if available, then updates in background.
+ *
+ * @param slug - Page slug to fetch
+ * @param cache - Cache storage (e.g., Map, localStorage wrapper)
+ * @param options - Fetch options
+ * @returns Cached data or fresh fetch result
+ */
+declare function fetchPageWithSWR(slug: string, cache: Map<string, {
+    data: Page;
+    timestamp: number;
+}>, options?: FetchOptions & {
+    maxAge?: number;
+}): Promise<Result<Page, FetchError>>;
+
+export { type FetchError, FetchErrorCode, type FetchOptions, type Page, fetchPage, fetchPageV1, fetchPageV2, fetchPageV3, fetchPageWithSWR, isValidSlug, normalizeSlug, prefetchPages };