@jasonshimmy/vite-plugin-cer-app 0.20.3 → 0.20.4

package/src/plugin/content/index.ts

@@ -24,14 +24,14 @@ export function resolveContentDir(root: string, contentConfig?: CerContentConfig
 
 /**
  * Loads all content files from `contentDir`, parses them concurrently, and
- * returns the full `ContentItem[]`. Excludes drafts in production unless
- * `drafts: true`. Uses async I/O + `Promise.all` for concurrent disk reads,
- * which is significantly faster than sequential `readFileSync` at 10k+ pages.
+ * returns the full `ContentItem[]`. Excludes drafts unless `includeDrafts: true`
+ * is set in the content config. Uses async I/O + `Promise.all` for concurrent
+ * disk reads, which is significantly faster than sequential `readFileSync` at
+ * 10k+ pages.
  */
 export async function loadContentStore(
   contentDir: string,
   isDraft: boolean,
-  isProduction: boolean,
 ): Promise<ContentItem[]> {
   if (!existsSync(contentDir)) return []
 
@@ -41,8 +41,8 @@ export async function loadContentStore(
     files.map(async (file) => {
       try {
         const item = await parseContentFileAsync(file, contentDir)
-        // Skip drafts in production (unless drafts flag is set)
-        if (isProduction && !isDraft && item.draft === true) return null
+        // Skip drafts unless the user explicitly opted in via drafts: true
+        if (!isDraft && item.draft === true) return null
         return item
       } catch (err) {
         // Warn and skip unparseable / invalid files so one bad file does not
@@ -175,8 +175,7 @@ export function cerContent(
     },
 
     async buildStart() {
-      const isProduction = this.meta.watchMode === false
-      const items = await loadContentStore(_resolvedContentDir, includeDrafts, isProduction)
+      const items = await loadContentStore(_resolvedContentDir, includeDrafts)
       const g = globalThis as Record<string, unknown>
       g[CONTENT_STORE_KEY] = items
     },
@@ -225,9 +224,7 @@ export function cerContent(
 }
 
 async function refreshStore(contentDir: string, includeDrafts: boolean): Promise<void> {
-  // HMR runs in dev (watchMode=true) — use isProduction=false so draft items
-  // remain visible, matching the initial buildStart behaviour in dev mode.
-  const items = await loadContentStore(contentDir, includeDrafts, false)
+  const items = await loadContentStore(contentDir, includeDrafts)
   const g = globalThis as Record<string, unknown>
   g[CONTENT_STORE_KEY] = items
   // Invalidate the dev middleware caches so the next request rebuilds manifest

package/src/plugin/dev-server.ts

@@ -1,5 +1,7 @@
 import type { ViteDevServer } from 'vite'
 import type { IncomingMessage, ServerResponse } from 'node:http'
+import { existsSync, readFileSync } from 'node:fs'
+import { resolve } from 'node:path'
 import { join } from 'pathe'
 import { getGeneratedDir } from './generated-dir.js'
 
@@ -246,7 +248,7 @@ export function configureCerDevServer(
       const acceptsHtml =
         (req.headers['accept'] ?? '').includes('text/html') ||
         url === '/' ||
-        (!url.includes('.') && !url.startsWith('/api/'))
+        (!url.includes('.') && !url.startsWith('/api/') && !url.startsWith('/@'))
 
       if (acceptsHtml) {
         // Check per-route render mode — skip SSR for 'spa' routes.
@@ -257,6 +259,20 @@ export function configureCerDevServer(
           for (const route of pageRoutes) {
             if (_matchDevRoute(route.path, urlPathOnly)) {
               if (route.meta?.render === 'spa') {
+                // In SSR/SSG dev mode, a route with render:'spa' should be served as
+                // the SPA shell (no server rendering). Serve .cer/index.html so the
+                // client bundle boots and handles the route client-side.
+                const _userHtml = resolve(config.root, 'index.html')
+                const _cerHtml = join(getGeneratedDir(config.root), 'index.html')
+                const _spaSrcPath = existsSync(_userHtml) ? _userHtml : _cerHtml
+                if (existsSync(_spaSrcPath)) {
+                  const rawHtml = readFileSync(_spaSrcPath, 'utf-8')
+                  const transformed = await server.transformIndexHtml(url, rawHtml)
+                  res.setHeader('Content-Type', 'text/html; charset=utf-8')
+                  res.statusCode = 200
+                  res.end(transformed)
+                  return
+                }
                 next()
                 return
               }
@@ -276,7 +292,26 @@ export function configureCerDevServer(
             ssrEntry.handler ?? ssrEntry.default?.handler
 
           if (typeof handler === 'function') {
-            await handler(req, res)
+            // In dev mode _clientTemplate inside entry-server.ts is null because
+            // the dist/client/index.html path doesn't exist. Set the global that
+            // the handler reads per-request so the SSR response includes the
+            // Vite client scripts (/@vite/client, HMR, module imports for app.ts).
+            const _userIndexPath = resolve(config.root, 'index.html')
+            const _genIndexPath = join(getGeneratedDir(config.root), 'index.html')
+            const _rawHtml = existsSync(_userIndexPath)
+              ? readFileSync(_userIndexPath, 'utf-8')
+              : existsSync(_genIndexPath)
+                ? readFileSync(_genIndexPath, 'utf-8')
+                : null
+            if (_rawHtml) {
+              ;(globalThis as Record<string, unknown>).__CER_CLIENT_TEMPLATE__ =
+                await server.transformIndexHtml(url, _rawHtml)
+            }
+            try {
+              await handler(req, res)
+            } finally {
+              ;(globalThis as Record<string, unknown>).__CER_CLIENT_TEMPLATE__ = undefined
+            }
             return
           }
 

package/src/plugin/dts-generator.ts

@@ -40,7 +40,13 @@ export function writeTsconfigPaths(root: string, srcDir: string): void {
   }
 
   const content = JSON.stringify(tsconfig, null, 2) + '\n'
-  writeFileSync(join(cerDir, 'tsconfig.json'), content, 'utf-8')
+  const tsconfigPath = join(cerDir, 'tsconfig.json')
+  // Skip write when content is unchanged to avoid triggering Vite's tsconfig
+  // watcher, which would cause an unnecessary server restart on every dev start.
+  try {
+    if (existsSync(tsconfigPath) && readFileSync(tsconfigPath, 'utf-8') === content) return
+  } catch { /* proceed to write */ }
+  writeFileSync(tsconfigPath, content, 'utf-8')
 }
 
 const RUNTIME_GLOBALS = [

package/src/plugin/index.ts

@@ -365,6 +365,13 @@ export function cerApp(userConfig: CerAppConfig = {}): Plugin[] {
       if (!existsSync(userHtml)) {
         const cerHtmlPath = join(getGeneratedDir(config.root), 'index.html')
         server.middlewares.use(async (req, res, next) => {
+          // In SSR/SSG mode, HTML requests must fall through to configureCerDevServer
+          // so the SSR handler can run loaders and inject __CER_DATA__ into the response.
+          // Only SPA mode (no server rendering) should serve the raw SPA shell here.
+          if (config.mode === 'ssr' || config.mode === 'ssg') {
+            next()
+            return
+          }
           const url = (req as { url?: string }).url ?? '/'
           const isHtmlRequest =
             url === '/' ||

package/src/runtime/entry-server-template.ts

@@ -394,8 +394,14 @@ export const handler = async (req, res) => {
       // (loader data script, useHead() tags, JIT styles). No polyfill in body yet.
       const ssrHtml = \`<!DOCTYPE html><html><head>\${headContent}</head><body>\${firstChunk}</body></html>\`
 
-      const merged = _clientTemplate
-        ? _mergeWithClientTemplate(ssrHtml, _clientTemplate)
+      // In dev mode the module-level _clientTemplate is null (only the
+      // production dist/client/index.html path is searched at init time).
+      // The dev server sets (globalThis).__CER_CLIENT_TEMPLATE__ per-request
+      // after running server.transformIndexHtml so the Vite client scripts
+      // (/@vite/client, HMR) are included in every SSR response.
+      const _resolvedClientTemplate = (globalThis).__CER_CLIENT_TEMPLATE__ ?? _clientTemplate
+      const merged = _resolvedClientTemplate
+        ? _mergeWithClientTemplate(ssrHtml, _resolvedClientTemplate)
         : ssrHtml
 
       // Split at </body> so async swap scripts and the DSD polyfill can be streamed