@decocms/start 1.1.0 → 1.2.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@decocms/start",
-  "version": "1.1.0",
+  "version": "1.2.1",
   "type": "module",
   "description": "Deco framework for TanStack Start - CMS bridge, admin protocol, hooks, schema generation",
   "main": "./src/index.ts",
@@ -17,6 +17,7 @@
     "./sdk/useScript": "./src/sdk/useScript.ts",
     "./sdk/signal": "./src/sdk/signal.ts",
     "./sdk/clx": "./src/sdk/clx.ts",
+    "./sdk/retry": "./src/sdk/retry.ts",
     "./sdk/useId": "./src/sdk/useId.ts",
     "./sdk/cookie": "./src/sdk/cookie.ts",
     "./sdk/cookiePassthrough": "./src/sdk/cookiePassthrough.ts",

package/src/cms/applySectionConventions.ts

@@ -77,7 +77,7 @@ export function applySectionConventions(input: ApplySectionConventionsInput): vo
   }
 
   if (eagerSections.length > 0) {
-    const existing = getAsyncRenderingConfig();
+    const existing = getAsyncRenderingConfig() ?? {};
     setAsyncRenderingConfig({
       ...existing,
       alwaysEager: [...(existing.alwaysEager ?? []), ...eagerSections],

package/src/hooks/PreviewProviders.tsx

@@ -0,0 +1,23 @@
+import {
+  createMemoryHistory,
+  createRootRoute,
+  createRouter,
+  RouterContextProvider,
+} from "@tanstack/react-router";
+import type { ReactNode } from "react";
+
+const rootRoute = createRootRoute();
+
+const previewRouter = createRouter({
+  routeTree: rootRoute,
+  history: createMemoryHistory({ initialEntries: ["/"] }),
+});
+
+/**
+ * Default preview wrapper for admin iframe rendering.
+ * Provides a TanStack Router context with memory history so components
+ * that depend on router hooks (Link, useNavigate, etc.) work in previews.
+ */
+export default function PreviewProviders({ children }: { children: ReactNode }) {
+  return <RouterContextProvider router={previewRouter as any}>{children}</RouterContextProvider>;
+}

package/src/hooks/RenderSection.tsx

@@ -0,0 +1,73 @@
+import { lazy, Suspense, type ComponentType } from "react";
+import { getSection } from "../cms/registry";
+
+const componentCache = new Map<string, ComponentType<any>>();
+
+function getOrCreateLazy(resolveType: string): ComponentType<any> | null {
+  if (componentCache.has(resolveType)) {
+    return componentCache.get(resolveType)!;
+  }
+
+  const loader = getSection(resolveType);
+  if (!loader) return null;
+
+  const LazyComponent = lazy(async () => {
+    const mod = await loader();
+    return { default: mod.default };
+  });
+
+  componentCache.set(resolveType, LazyComponent);
+  return LazyComponent;
+}
+
+interface SectionLike {
+  __resolveType?: string;
+  Component?: ComponentType<any>;
+  props?: Record<string, unknown>;
+  [key: string]: unknown;
+}
+
+/**
+ * Renders a Section-type prop from the CMS.
+ *
+ * Handles both the old Deco format ({ Component, props }) and
+ * the new @decocms/start format ({ __resolveType, ...props }).
+ */
+export default function RenderSection({
+  section,
+  fallback,
+}: {
+  section: SectionLike | null | undefined;
+  fallback?: React.ReactNode;
+}) {
+  if (!section) return null;
+
+  if (section.Component) {
+    const { Component, props = {}, ...overrides } = section;
+    const mergedProps = { ...(props as Record<string, unknown>), ...overrides };
+    if (typeof Component === "string") {
+      const Comp = getOrCreateLazy(Component);
+      if (!Comp) return <>{fallback ?? null}</>;
+      return (
+        <Suspense fallback={fallback ?? null}>
+          <Comp {...mergedProps} />
+        </Suspense>
+      );
+    }
+    return <Component {...mergedProps} />;
+  }
+
+  if (section.__resolveType) {
+    const Comp = getOrCreateLazy(section.__resolveType);
+    if (!Comp) return <>{fallback ?? null}</>;
+
+    const { __resolveType: _, ...props } = section;
+    return (
+      <Suspense fallback={fallback ?? null}>
+        <Comp {...props} />
+      </Suspense>
+    );
+  }
+
+  return null;
+}

package/src/hooks/index.ts

@@ -9,3 +9,5 @@ export { SectionErrorBoundary } from "./SectionErrorFallback";
 export { NavigationProgress } from "./NavigationProgress";
 export { StableOutlet } from "./StableOutlet";
 export { DecoRootLayout, type DecoRootLayoutProps } from "./DecoRootLayout";
+export { default as RenderSection } from "./RenderSection";
+export { default as PreviewProviders } from "./PreviewProviders";

package/src/sdk/retry.ts

@@ -0,0 +1,45 @@
+export const CONNECTION_CLOSED_MESSAGE = "connection closed before message completed";
+
+function sleep(ms: number): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+/**
+ * Simple retry utility — replaces cockatiel to avoid module-level AbortController
+ * (cockatiel's abort.js creates new AbortController() at module scope, which is
+ * forbidden in Cloudflare Workers global scope).
+ *
+ * Retries up to maxAttempts when the error matches the predicate.
+ * Uses exponential backoff: delay = min(initialDelay * exponent^attempt, maxDelay).
+ */
+export function retryExceptionOr500() {
+  return {
+    execute: async <T>(fn: () => Promise<T>): Promise<T> => {
+      const maxAttempts = 3;
+      const initialDelay = 100;
+      const maxDelay = 5000;
+      const exponent = 2;
+
+      let lastErr: unknown;
+      for (let attempt = 0; attempt < maxAttempts; attempt++) {
+        try {
+          return await fn();
+        } catch (err) {
+          const message = err instanceof Error ? err.message : String(err);
+          if (!message.includes(CONNECTION_CLOSED_MESSAGE)) {
+            throw err;
+          }
+          lastErr = err;
+          try {
+            console.error("retrying...", err);
+          } catch (_) {}
+          if (attempt < maxAttempts - 1) {
+            const delay = Math.min(initialDelay * Math.pow(exponent, attempt), maxDelay);
+            await sleep(delay);
+          }
+        }
+      }
+      throw lastErr;
+    },
+  };
+}