meno-core 1.0.51 → 1.0.53

package/build-astro.ts

@@ -23,9 +23,12 @@ import { loadProjectConfig, generateFontCSS, generateFontPreloadTags } from "./l
 import { FileSystemCMSProvider } from "./lib/server/providers/fileSystemCMSProvider";
 import { CMSService } from "./lib/server/services/cmsService";
 import { isI18nValue, resolveI18nValue } from "./lib/shared/i18n";
+import { tiptapToHtml } from "./lib/shared/richtext/tiptapToHtml";
+import { isTiptapDocument } from "./lib/shared/richtext/types";
 import type { ComponentDefinition, JSONPage, CMSSchema, CMSItem, I18nConfig } from "./lib/shared/types";
 import type { CMSFieldDefinition } from "./lib/shared/types/cms";
 import { isItemDraftForLocale } from "./lib/shared/types";
+import { CMS_DRAFT_SUFFIX } from "./lib/shared/pathSecurity";
 import type { SlugMap } from "./lib/shared/slugTranslator";
 import { renderPageSSR } from "./lib/server/ssr/ssrRenderer";
 import { generateThemeColorVariablesCSS, generateVariablesCSS } from "./lib/server/cssGenerator";
@@ -38,7 +41,8 @@ import { collectComponentLibraries, filterLibrariesByContext, mergeLibraries, ge
 import { migrateTemplatesDirectory } from "./lib/server/migrateTemplates";
 import { emitAstroComponent } from "./lib/server/astro/componentEmitter";
 import { emitAstroPage } from "./lib/server/astro/pageEmitter";
-import { emitCMSPage } from './lib/server/astro/cmsPageEmitter';
+import { normalizeOrphanTemplateProps } from "./lib/server/astro/normalizeOrphanTemplateProps";
+import { emitCMSPage, CMS_SLUG_PLACEHOLDER } from './lib/server/astro/cmsPageEmitter';
 import { collectAllMappingClasses } from "./lib/server/astro/cssCollector";
 import { buildImageMetadataMap, RESPONSIVE_WIDTHS } from "./lib/server/ssr/imageMetadata";
 import { needsFormHandler, formHandlerScript } from "./lib/client/scripts/formHandler";
@@ -182,7 +186,9 @@ function cmsFieldToZod(field: CMSFieldDefinition): string {
     case 'string':
     case 'text':
     case 'rich-text':
-      // Support both plain strings and i18n objects { _i18n: true, en: "...", pl: "..." }
+      // Rich-text is serialized to an HTML string at item-copy time (see the
+      // CMS collection emission below), so by the time Astro validates it the
+      // value is a string (or an i18n object of strings). Support both.
       return 'z.union([z.string(), z.object({ _i18n: z.literal(true) }).passthrough()])';
     case 'number':
       return 'z.number()';
@@ -206,6 +212,99 @@ function cmsFieldToZod(field: CMSFieldDefinition): string {
   }
 }
 
+/**
+ * Serialize a single rich-text field value to an HTML string. Handles plain
+ * Tiptap doc objects, the `{ html: "..." }` marker shape, i18n-wrapped values
+ * ({ _i18n: true, en: <doc|string>, ... }), and already-serialized strings.
+ */
+function serializeRichTextValue(value: unknown): unknown {
+  const one = (v: unknown): unknown => {
+    if (v == null || typeof v === 'string') return v ?? '';
+    if (isTiptapDocument(v)) return tiptapToHtml(v);
+    if (typeof v === 'object' && v !== null && typeof (v as { html?: unknown }).html === 'string') {
+      return (v as { html: string }).html;
+    }
+    return v;
+  };
+
+  if (isI18nValue(value)) {
+    const out: Record<string, unknown> = { _i18n: true };
+    for (const [k, v] of Object.entries(value as Record<string, unknown>)) {
+      if (k === '_i18n') continue;
+      out[k] = one(v);
+    }
+    return out;
+  }
+  return one(value);
+}
+
+/**
+ * Walk a component structure and collect the names of every component instance
+ * it references (`{ type: 'component', component: 'X' }`).
+ */
+function collectComponentRefs(node: unknown, acc: Set<string>): void {
+  if (Array.isArray(node)) {
+    for (const child of node) collectComponentRefs(child, acc);
+    return;
+  }
+  if (!node || typeof node !== 'object') return;
+  const n = node as Record<string, unknown>;
+  if (n.type === 'component' && typeof n.component === 'string') {
+    acc.add(n.component);
+  }
+  for (const value of Object.values(n)) {
+    if (value && typeof value === 'object') collectComponentRefs(value, acc);
+  }
+}
+
+/**
+ * Compute the set of components that consume the CMS entry (`{{cms.*}}`),
+ * transitively including any component that renders a consumer in its own
+ * structure (it must forward the `cms` prop down). Astro components have
+ * isolated scopes, so each consumer needs the entry threaded in explicitly.
+ */
+function computeCmsConsumerComponents(
+  components: Record<string, ComponentDefinition>
+): Set<string> {
+  const consumers = new Set<string>();
+  const refsByComponent = new Map<string, Set<string>>();
+
+  for (const [name, def] of Object.entries(components)) {
+    const structure = def.component?.structure;
+    if (structure && JSON.stringify(structure).includes('{{cms.')) {
+      consumers.add(name);
+    }
+    const refs = new Set<string>();
+    collectComponentRefs(structure, refs);
+    refsByComponent.set(name, refs);
+  }
+
+  // Fixpoint: a component that renders a consumer is itself a consumer/forwarder.
+  let changed = true;
+  while (changed) {
+    changed = false;
+    for (const [name, refs] of refsByComponent) {
+      if (consumers.has(name)) continue;
+      for (const ref of refs) {
+        if (consumers.has(ref)) { consumers.add(name); changed = true; break; }
+      }
+    }
+  }
+  return consumers;
+}
+
+/**
+ * Build the `_url` expression (a JS template literal over the `e` collection
+ * entry) for a CMS collection, so flattened list items expose a usable link.
+ * E.g. urlPattern "/blog/{{slug}}" + slugField "slug" → `/blog/${e.data.slug ?? e.id}`.
+ */
+function buildCollectionUrlExpr(schema: CMSSchema): string {
+  const slugField = schema.slugField || 'slug';
+  const pattern = schema.urlPattern || `/${schema.id}/{{slug}}`;
+  const body = pattern.replace(/\{\{[^}]+\}\}/, '${e.data.' + slugField + ' ?? e.id}');
+  return '`' + body + '`';
+}
+
 // ---------------------------------------------------------------------------
 // Types
 // ---------------------------------------------------------------------------
@@ -484,7 +583,12 @@ export async function buildAstroProject(
         // Compute URL path
         let slug: string;
         if (slugs && slugs[locale]) {
-          slug = slugs[locale];
+          // Slugs may be authored with a leading slash (e.g. "/blog" from the
+          // page-rename flow). Normalize to the bare form the rest of the
+          // pipeline expects — matches buildPageUrlForLocale(). A leading slash
+          // here would otherwise inflate fileDepth (".../blog.astro".split('/'))
+          // and produce a wrong "../../layouts" import.
+          slug = slugs[locale].replace(/^\/+/, '');
         } else if (basePath === '/') {
           slug = '';
         } else {
@@ -584,6 +688,30 @@ export async function buildAstroProject(
   const templateSchemas: CMSSchema[] = [];
   let cmsPageCount = 0;
 
+  // Pre-pass: components that consume the CMS entry (so the page/component
+  // emitters know which instances to thread `cms={...}` into), plus per-
+  // collection `_url` expressions (for flattened collection lists). Built
+  // before the template loop so the very first emitted CMS page sees the
+  // full picture even when it lists items from another collection.
+  const cmsConsumerComponents = computeCmsConsumerComponents(globalComponents);
+  const collectionUrlExpr = new Map<string, string>();
+  const mergedRichTextFields = new Set<string>();
+  if (existsSync(templatesDir)) {
+    for (const file of readdirSync(templatesDir).filter((f) => f.endsWith('.json'))) {
+      const tc = await loadJSONFile(join(templatesDir, file));
+      if (!tc) continue;
+      try {
+        const pd = parseJSON<JSONPage>(tc);
+        const schema = pd.meta?.cms as CMSSchema | undefined;
+        if (!schema?.id) continue;
+        collectionUrlExpr.set(schema.id, buildCollectionUrlExpr(schema));
+        for (const [fn, fd] of Object.entries(schema.fields || {})) {
+          if (fd.type === 'rich-text') mergedRichTextFields.add(fn);
+        }
+      } catch { /* ignore parse errors; handled in main loop */ }
+    }
+  }
+
   if (existsSync(templatesDir)) {
     const templateFiles = readdirSync(templatesDir).filter(f => f.endsWith('.json'));
 
@@ -613,7 +741,7 @@ export async function buildAstroProject(
 
         // Render SSR once for metadata collection (interactive styles, component CSS, JS)
         const defaultLocale = i18nConfig.defaultLocale;
-        const dummyPath = cmsSchema.urlPattern.replace('{{slug}}', '__placeholder__');
+        const dummyPath = cmsSchema.urlPattern.replace('{{slug}}', CMS_SLUG_PLACEHOLDER);
 
         const metaResult = await renderPageSSR(
           pageData,
@@ -699,6 +827,8 @@ export async function buildAstroProject(
             imageFormat: configService.getImageFormat(),
             processedRawHtml: metaResult.processedRawHtmlCollector,
             remConfig: remConversionConfig,
+            cmsConsumers: cmsConsumerComponents,
+            collectionUrlExpr,
           });
 
           const astroFileFull = join(pagesOutDir, astroFilePath);
@@ -815,10 +945,20 @@ const { title, meta = '', scripts = [], locale = 'en', theme = '${themeConfig.de
   // ----------------------------------------------------------
   // 7.5. Generate component .astro files
   // ----------------------------------------------------------
+  // SSR/Next.js resolve orphan `{{x}}` refs in a component's structure via
+  // the parentProps cascade in templateEngine. Astro can't fall back at
+  // runtime (each .astro file is its own scope), so we lift orphan refs
+  // onto each component's interface and forward them from hosts that
+  // declare the same prop. See `normalizeOrphanTemplateProps` for details.
+  const emittableComponents = normalizeOrphanTemplateProps(globalComponents);
   let componentFileCount = 0;
-  for (const [compName, compDef] of Object.entries(globalComponents)) {
+  for (const [compName, compDef] of Object.entries(emittableComponents)) {
     try {
-      const astroContent = emitAstroComponent(compName, compDef, globalComponents, breakpoints, i18nConfig.defaultLocale, responsiveScales, remConversionConfig);
+      const astroContent = emitAstroComponent(compName, compDef, emittableComponents, breakpoints, i18nConfig.defaultLocale, responsiveScales, remConversionConfig, {
+        cmsConsumers: cmsConsumerComponents,
+        cmsRichTextFields: mergedRichTextFields,
+        collectionUrlExpr,
+      });
       await writeFile(join(componentsOutDir, `${compName}.astro`), astroContent, 'utf-8');
       componentFileCount++;
     } catch (error: any) {
@@ -852,7 +992,7 @@ const { title, meta = '', scripts = [], locale = 'en', theme = '${themeConfig.de
         // because each .astro component already has its own inline <script>
         astroContent = emitAstroPage({
           pageData: result.pageData,
-          globalComponents,
+          globalComponents: emittableComponents,
           title: result.title,
           meta: result.meta,
           locale: result.locale,
@@ -931,10 +1071,22 @@ export const GET: APIRoute = () => {
       const collectionDir = join(contentDir, schema.id);
       mkdirSync(collectionDir, { recursive: true });
 
+      // Rich-text fields are stored as Tiptap doc objects; Astro's content
+      // schema (and `<Fragment set:html>`) expects HTML strings. Mirror the
+      // live SSR (cmsSSRProcessor) by serializing them to HTML at copy time.
+      const richTextFieldNames = Object.entries(schema.fields || {})
+        .filter(([, fd]) => fd.type === 'rich-text')
+        .map(([fn]) => fn);
+
       // Copy CMS item JSON files, resolving i18n values to default locale
       const cmsItemsDir = join(projectPaths.cms(), schema.id);
       if (existsSync(cmsItemsDir)) {
-        const itemFiles = readdirSync(cmsItemsDir).filter(f => f.endsWith('.json'));
+        // Skip `*.draft.json` siblings in production builds — they mirror the
+        // published item-list filter and may hold partial/invalid WIP data.
+        const isDevBuild = process.env.MENO_DEV_BUILD === 'true';
+        const itemFiles = readdirSync(cmsItemsDir).filter(f =>
+          f.endsWith('.json') && (isDevBuild || !f.endsWith(`${CMS_DRAFT_SUFFIX}.json`))
+        );
 
         for (const itemFile of itemFiles) {
           try {
@@ -944,6 +1096,12 @@ export const GET: APIRoute = () => {
             // Keep i18n values as-is so getStaticPaths() can resolve per-locale
             const resolved: Record<string, unknown> = { ...item };
 
+            // Serialize rich-text fields (Tiptap doc → HTML string), handling
+            // i18n-wrapped values ({ _i18n: true, en: <doc>, ... }) per-locale.
+            for (const fieldName of richTextFieldNames) {
+              resolved[fieldName] = serializeRichTextValue(resolved[fieldName]);
+            }
+
             await writeFile(
               join(collectionDir, itemFile),
               JSON.stringify(resolved, null, 2),
@@ -1052,15 +1210,13 @@ export { collections };
       preview: 'astro preview',
     },
     dependencies: {
-      'astro': '^6.0.0',
+      // Astro 5 (stable Vite), NOT 6 — Astro 6's rolldown-vite breaks
+      // @tailwindcss/vite at build time ("Missing field `tsconfigPaths`").
+      'astro': '^5.0.0',
       '@astrojs/sitemap': '^3.0.0',
       '@tailwindcss/vite': '^4.0.0',
       'tailwindcss': '^4.0.0',
     },
-    // Astro 6 expects Vite 7; pin it so npm doesn't pull Vite 8+ and warn.
-    overrides: {
-      'vite': '^7.0.0',
-    },
   };
 
   await writeFile(join(outDir, 'package.json'), JSON.stringify(packageJson, null, 2), 'utf-8');
@@ -1092,6 +1248,20 @@ export default defineConfig({${siteUrl ? `\n  site: '${siteUrl}',` : ''}${i18nBl
 
   await writeFile(join(outDir, 'tsconfig.json'), JSON.stringify(tsConfig, null, 2), 'utf-8');
 
+  // netlify.toml — makes the exported project deployable on Netlify out of the
+  // box. `astro` is a real dependency here (see package.json above), so once
+  // Netlify runs `npm install`, `astro build` is on PATH and writes to dist/.
+  // Harmless on other hosts (Cloudflare Pages / Vercel ignore this file).
+  const netlifyToml = `# Generated by Meno's Astro build.
+[build]
+  command = "npm run build"
+  publish = "dist"
+
+[build.environment]
+  NODE_VERSION = "22"
+`;
+  await writeFile(join(outDir, 'netlify.toml'), netlifyToml, 'utf-8');
+
   // src/env.d.ts — resolves astro:assets and other virtual module types in IDE
   await writeFile(join(outDir, 'src', 'env.d.ts'), '/// <reference path="../.astro/types.d.ts" />\n', 'utf-8');