meno-core 1.0.39 → 1.0.41

package/lib/client/routing/Router.tsx

@@ -255,6 +255,12 @@ export function Router(props: RouterProps = {}): ReactElement {
     if (typeof window === 'undefined') return;
 
     const handleMessage = (event: MessageEvent) => {
+      if (event.data?.type === IFRAME_MESSAGE_TYPES.CSS_VARIABLE_UPDATE) {
+        const { name, value } = event.data as { name: string; value: string };
+        document.documentElement.style.setProperty(name, value);
+        return;
+      }
+
       if (event.data?.type === IFRAME_MESSAGE_TYPES.INTERACTIVE_CSS_UPDATE) {
         const css = event.data.css as string;
         const styleId = 'interactive-styles';

package/lib/client/templateEngine.test.ts

@@ -807,3 +807,181 @@ describe("Template Engine - normalizeStyle", () => {
     expect(result).toBeNull();
   });
 });
+
+// ==========================================================================
+// Targeted tests for `as any` code paths in processStructure
+// These exercise specific type-cast paths to ensure safety before refactoring
+// ==========================================================================
+
+describe("Template Engine - processStructure as-any paths", () => {
+  const baseContext: TemplateContext = {
+    props: { text: "Hello", size: "lg", variant: "primary" },
+    componentDef: {} as StructuredComponentDefinition,
+  };
+
+  describe("Boolean preservation (line 429)", () => {
+    test("should preserve false boolean values in structure", () => {
+      // processStructure should return false as-is, not convert to null
+      const result = processStructure(false as any, baseContext);
+      expect(result).toBe(false);
+    });
+
+    test("should preserve true boolean values in structure", () => {
+      const result = processStructure(true as any, baseContext);
+      expect(result).toBe(true);
+    });
+  });
+
+  describe("Object template evaluation returning objects (line 454)", () => {
+    test("should return object result from full template expression", () => {
+      const context: TemplateContext = {
+        props: { link: { href: "/about", target: "_blank" } },
+        componentDef: {} as StructuredComponentDefinition,
+      };
+      // Full template {{link}} should return the object as-is
+      const result = processStructure("{{link}}", context);
+      expect(result).toEqual({ href: "/about", target: "_blank" });
+    });
+  });
+
+  describe("Slot default content via 'default' property (lines 483-486, 516-517)", () => {
+    test("should render slot default array when no instance children", () => {
+      // Slot markers use type: "slot" (NODE_TYPE.SLOT)
+      const structure = [
+        { type: "node", tag: "div", children: [
+          { type: "slot", default: [{ type: "node", tag: "span", children: "fallback" }] }
+        ]}
+      ] as unknown as ComponentNode[];
+      const result = processStructure(structure, baseContext);
+      expect(Array.isArray(result)).toBe(true);
+      const root = (result as any[])[0];
+      expect(root.tag).toBe("div");
+      // The slot default should have been rendered
+      expect(root.children.length).toBe(1);
+      expect(root.children[0].tag).toBe("span");
+    });
+
+    test("should render slot default string when no instance children", () => {
+      const structure = [
+        { type: "node", tag: "div", children: [
+          { type: "slot", default: "Default text" }
+        ]}
+      ] as unknown as ComponentNode[];
+      const result = processStructure(structure, baseContext);
+      const root = (result as any[])[0];
+      expect(root.children[0]).toBe("Default text");
+    });
+
+    test("should use instance children over slot default", () => {
+      const structure = [
+        { type: "node", tag: "div", children: [
+          { type: "slot", default: [{ type: "node", tag: "span", children: "fallback" }] }
+        ]}
+      ] as unknown as ComponentNode[];
+      const instanceChildren = [
+        { type: "node", tag: "b", children: "override" }
+      ] as unknown as ComponentNode[];
+      const result = processStructure(structure, baseContext, undefined, instanceChildren);
+      const root = (result as any[])[0];
+      expect(root.children[0].tag).toBe("b");
+    });
+
+    test("should handle slot marker as standalone object with default", () => {
+      const slotMarker = {
+        type: "slot",
+        default: [{ type: "node", tag: "div", children: "content" }],
+      };
+      const result = processStructure(slotMarker as any, baseContext);
+      expect(result).toBeDefined();
+    });
+  });
+
+  describe("Plain object processing (lines 538, 543)", () => {
+    test("should process plain objects recursively and resolve templates", () => {
+      // An object without a valid node type gets treated as a plain props object
+      const structure = { label: "{{text}}", visible: true } as any;
+      const result = processStructure(structure, baseContext);
+      expect(result).toBeDefined();
+      expect((result as any).label).toBe("Hello");
+      expect((result as any).visible).toBe(true);
+    });
+
+    test("should strip null/undefined values from plain objects", () => {
+      const context: TemplateContext = {
+        props: { defined: "value" },
+        componentDef: {} as StructuredComponentDefinition,
+      };
+      const structure = { a: "{{defined}}", b: "{{missing}}" } as any;
+      const result = processStructure(structure, context);
+      expect((result as any).a).toBe("value");
+      // Missing props resolve to empty string, not null
+    });
+  });
+
+  describe("Embed node creation (line 562)", () => {
+    test("should process embed node with html content", () => {
+      const node: ComponentNode = {
+        type: "embed" as any,
+        html: "<script>alert('test')</script>",
+      } as any;
+      const result = processStructure(node, baseContext);
+      expect(result).toBeDefined();
+      expect((result as any).type).toBe("embed");
+      expect((result as any).html).toBe("<script>alert('test')</script>");
+    });
+  });
+
+  describe("Link node creation (line 569)", () => {
+    test("should process link node with href", () => {
+      const node = {
+        type: "link",
+        href: "/about",
+        children: ["About us"],
+      } as any;
+      const result = processStructure(node, baseContext);
+      expect(result).toBeDefined();
+      expect((result as any).type).toBe("link");
+    });
+
+    test("should process link node with template href", () => {
+      const context: TemplateContext = {
+        props: { url: "/contact" },
+        componentDef: {} as StructuredComponentDefinition,
+      };
+      const node = {
+        type: "link",
+        href: "{{url}}",
+        children: ["Contact"],
+      } as any;
+      const result = processStructure(node, context);
+      expect(result).toBeDefined();
+      expect((result as any).type).toBe("link");
+    });
+  });
+
+  describe("Locale-list node creation (line 574)", () => {
+    test("should process locale-list node", () => {
+      const node = {
+        type: "locale-list",
+        style: { display: "flex" },
+      } as any;
+      const result = processStructure(node, baseContext);
+      expect(result).toBeDefined();
+      expect((result as any).type).toBe("locale-list");
+    });
+  });
+
+  describe("List node with legacy cms-list type (line 575)", () => {
+    test("should process list node", () => {
+      const node = {
+        type: "list",
+        source: "items",
+        sourceType: "prop",
+        children: [{ type: "html" as const, tag: "div", children: [] }],
+      } as any;
+      const result = processStructure(node, baseContext);
+      expect(result).toBeDefined();
+      expect((result as any).type).toBe("list");
+    });
+  });
+});

package/lib/client/templateEngine.ts

@@ -814,8 +814,7 @@ export function processStructure(
         if (isResponsiveStyle(resolvedStyle)) {
           // Apply responsive styles directly to node.style or props.style
           if (isComponentNode(processed)) {
-            processed.props = processed.props || {};
-            processed.props.style = resolvedStyle as ResponsiveStyleObject;
+            (processed as any).style = resolvedStyle as ResponsiveStyleObject;
           } else if (isHtmlNode(processed) || isEmbedNode(processed) || isLocaleListNode(processed) || isLinkNode(processed) || isListNode(processed)) {
             processed.style = resolvedStyle as ResponsiveStyleObject;
           }

package/lib/server/astro/cmsPageEmitter.ts

@@ -0,0 +1,420 @@
+/**
+ * CMS Page File Generator
+ * Generates .astro page files for CMS template pages with getStaticPaths()
+ */
+
+import type { JSONPage, ComponentDefinition, CMSSchema, I18nConfig } from '../../shared/types';
+import type { BreakpointConfig } from '../../shared/breakpoints';
+import { DEFAULT_BREAKPOINTS } from '../../shared/breakpoints';
+import { nodeToAstro, type AstroEmitContext } from './nodeToAstro';
+import { transformCMSTemplate } from './templateTransformer';
+import type { ImageMetadataMap } from '../ssr/imageMetadata';
+import type { SlugMap } from '../../shared/slugTranslator';
+
+// ---------------------------------------------------------------------------
+// Types
+// ---------------------------------------------------------------------------
+
+export interface CMSPageEmitOptions {
+  /** Page data */
+  pageData: JSONPage;
+  /** All global components */
+  globalComponents: Record<string, ComponentDefinition>;
+  /** CMS collection schema */
+  cmsSchema: CMSSchema;
+  /** Page title (may contain {{cms.field}}) */
+  title: string;
+  /** Page meta HTML */
+  meta: string;
+  /** Locale */
+  locale: string;
+  /** Default theme */
+  theme: string;
+  /** Font preloads HTML */
+  fontPreloads: string;
+  /** Library tags */
+  libraryTags: { headCSS?: string; headJS?: string; bodyEndJS?: string };
+  /** Script paths */
+  scriptPaths: string[];
+  /** Import path to BaseLayout */
+  layoutImportPath: string;
+  /** File depth relative to src/pages */
+  fileDepth: number;
+  /** SSR HTML fallbacks: node path -> rendered HTML (for ListNode, LocaleListNode) */
+  ssrFallbacks: Map<string, string>;
+  /** Page name (without extension) */
+  pageName: string;
+  /** Breakpoint config for responsive Tailwind classes */
+  breakpoints?: BreakpointConfig;
+  /** Image metadata map for responsive image generation */
+  imageMetadataMap?: ImageMetadataMap;
+  /** Internationalization config */
+  i18nConfig: I18nConfig;
+  /** Whether site has multiple locales */
+  isMultiLocale: boolean;
+  /** Slug mappings for translating internal link hrefs */
+  slugMappings?: SlugMap[];
+  /** Image format: 'webp' uses plain <img>, 'avif' uses <picture> */
+  imageFormat?: 'webp' | 'avif';
+}
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function escapeTemplateLiteral(s: string): string {
+  return s.replace(/\\/g, '\\\\').replace(/`/g, '\\`').replace(/\$\{/g, '\\${');
+}
+
+function escapeJSX(s: string): string {
+  return s.replace(/&/g, '&amp;').replace(/"/g, '&quot;');
+}
+
+function componentImportPath(fileDepth: number, componentName: string): string {
+  const ups = '../'.repeat(fileDepth + 1);
+  return `${ups}components/${componentName}.astro`;
+}
+
+/**
+ * Collect rich-text field names from CMS schema
+ */
+function collectRichTextFields(schema: CMSSchema): Set<string> {
+  const richTextFields = new Set<string>();
+  for (const [fieldName, fieldDef] of Object.entries(schema.fields)) {
+    if (fieldDef.type === 'rich-text') {
+      richTextFields.add(fieldName);
+    }
+  }
+  return richTextFields;
+}
+
+/**
+ * Transform a title string that may contain {{cms.field}} to an Astro expression.
+ * Returns the transformed title suitable for use in a JSX attribute.
+ */
+function transformTitleExpression(
+  title: string,
+  binding: string,
+  richTextFields: Set<string>,
+  wrapFn?: string
+): string {
+  if (!/\{\{cms\./.test(title)) {
+    return `"${escapeJSX(title)}"`;
+  }
+
+  const w = (expr: string) => wrapFn ? `${wrapFn}(${expr})` : expr;
+
+  // Full match: entire title is a single {{cms.field}}
+  const fullMatch = title.match(/^\{\{cms\.([^}]+)\}\}$/);
+  if (fullMatch) {
+    return `{${w(`${binding}.data.${fullMatch[1].trim()}`)}}`;
+  }
+
+  // Mixed content: "Page - {{cms.title}}" -> {`Page - ${entry.data.title}`}
+  const replaced = title.replace(/\{\{cms\.([^}]+)\}\}/g, (_, fieldPath) => {
+    return `\${${w(`${binding}.data.${fieldPath.trim()}`)}}`;
+  });
+  return `{\`${replaced}\`}`;
+}
+
+/**
+ * Extract the path prefix from a URL pattern.
+ * E.g., "/blog/{{slug}}" -> "blog/"
+ * E.g., "/posts/{{slug}}" -> "posts/"
+ */
+function extractPathPrefix(urlPattern: string): string {
+  // Remove leading slash, then remove the slug placeholder and everything after
+  const withoutLeading = urlPattern.replace(/^\//, '');
+  const idx = withoutLeading.indexOf('{{');
+  if (idx <= 0) return '';
+  return withoutLeading.substring(0, idx);
+}
+
+// ---------------------------------------------------------------------------
+// getStaticPaths generator
+// ---------------------------------------------------------------------------
+
+function buildGetStaticPaths(
+  schema: CMSSchema,
+  isMultiLocale: boolean,
+  i18nConfig: I18nConfig,
+  locale?: string
+): string {
+  const collectionId = schema.id;
+  const slugField = schema.slugField || 'slug';
+  const pathPrefix = extractPathPrefix(schema.urlPattern);
+  const targetLocale = locale || i18nConfig.defaultLocale;
+
+  if (!isMultiLocale) {
+    // Single-locale version: resolve slug for this specific locale
+    // Route file is at blog/[slug].astro (or pl/blog/[slug].astro for non-default)
+    // If i18n values exist, resolve for the target locale
+    const slugExpr = i18nConfig.locales.length > 1
+      ? `entry.data.${slugField}?.${targetLocale} || entry.data.${slugField} || entry.id`
+      : `entry.data.${slugField} || entry.id`;
+
+    return [
+      `export async function getStaticPaths() {`,
+      `  const entries = await getCollection('${collectionId}');`,
+      `  return entries.map(entry => ({`,
+      `    params: { slug: ${slugExpr} },`,
+      `    props: { entry },`,
+      `  }));`,
+      `}`,
+      ``,
+      `const { entry } = Astro.props;`,
+    ].join('\n');
+  }
+
+  // Multi-locale version: enumerate items x locales
+  // Route file is at [...slug].astro (top level), so slug includes full path
+  const defaultLocale = i18nConfig.defaultLocale;
+  const locales = i18nConfig.locales;
+
+  const lines: string[] = [
+    `export async function getStaticPaths() {`,
+    `  const entries = await getCollection('${collectionId}');`,
+    `  const paths = [];`,
+    `  for (const entry of entries) {`,
+  ];
+
+  for (const locale of locales) {
+    const code = locale.code;
+    const slugExpr = `entry.data.${slugField}?.${code} || entry.data.${slugField} || entry.id`;
+
+    if (code === defaultLocale) {
+      // Default locale: include path prefix but no locale prefix
+      // e.g., /blog/{{slug}} → slug = "blog/hello"
+      if (pathPrefix) {
+        lines.push(
+          `    paths.push({`,
+          `      params: { slug: \`${pathPrefix}\${${slugExpr}}\` },`,
+          `      props: { entry, locale: '${code}' },`,
+          `    });`
+        );
+      } else {
+        lines.push(
+          `    paths.push({`,
+          `      params: { slug: ${slugExpr} },`,
+          `      props: { entry, locale: '${code}' },`,
+          `    });`
+        );
+      }
+    } else {
+      // Non-default locale: locale prefix + path prefix + slug
+      // e.g., slug = "pl/blog/witaj"
+      lines.push(
+        `    paths.push({`,
+        `      params: { slug: \`${code}/${pathPrefix}\${${slugExpr}}\` },`,
+        `      props: { entry, locale: '${code}' },`,
+        `    });`
+      );
+    }
+  }
+
+  lines.push(
+    `  }`,
+    `  return paths;`,
+    `}`,
+    ``,
+    `const { entry, locale = '${defaultLocale}' } = Astro.props;`
+  );
+
+  return lines.join('\n');
+}
+
+// ---------------------------------------------------------------------------
+// Main emitter
+// ---------------------------------------------------------------------------
+
+/**
+ * Generate a CMS template .astro page file with getStaticPaths()
+ */
+export function emitCMSPage(options: CMSPageEmitOptions): string {
+  const {
+    pageData,
+    globalComponents,
+    cmsSchema,
+    title,
+    meta,
+    locale,
+    theme,
+    fontPreloads,
+    libraryTags,
+    scriptPaths,
+    layoutImportPath,
+    fileDepth,
+    ssrFallbacks,
+    pageName,
+    breakpoints: breakpointsOpt,
+    imageMetadataMap,
+    i18nConfig,
+    isMultiLocale,
+    slugMappings,
+  } = options;
+
+  const breakpoints = breakpointsOpt ?? DEFAULT_BREAKPOINTS;
+  const binding = 'entry';
+  const richTextFields = collectRichTextFields(cmsSchema);
+  const wrapFn = 'r';
+
+  const root = pageData.root;
+  if (!root) {
+    return buildEmptyCMSPage(
+      layoutImportPath,
+      title,
+      meta,
+      locale,
+      theme,
+      fontPreloads,
+      libraryTags,
+      scriptPaths,
+      cmsSchema,
+      isMultiLocale,
+      i18nConfig,
+      binding,
+      richTextFields
+    );
+  }
+
+  // Build the Astro emit context with CMS mode enabled
+  const ctx: AstroEmitContext = {
+    imports: new Set<string>(),
+    isComponentDef: false,
+    componentProps: {},
+    globalComponents,
+    indent: 1, // inside BaseLayout
+    ssrFallbacks,
+    elementPath: [0],
+    fileType: 'page',
+    fileName: pageName,
+    breakpoints,
+    imageMetadataMap,
+    locale,
+    cmsMode: true,
+    cmsEntryBinding: binding,
+    cmsRichTextFields: richTextFields,
+    cmsWrapFn: wrapFn,
+    slugMappings,
+    i18nDefaultLocale: i18nConfig.defaultLocale,
+    imageFormat: options.imageFormat,
+  };
+
+  // Emit the template body
+  const templateBody = nodeToAstro(root, ctx);
+
+  // Build frontmatter with imports
+  const importLines: string[] = [];
+  importLines.push(`import { getCollection } from 'astro:content';`);
+  importLines.push(`import BaseLayout from '${layoutImportPath}';`);
+
+  // Sort component imports alphabetically
+  const componentImports = Array.from(ctx.imports).sort();
+  for (const comp of componentImports) {
+    const path = componentImportPath(fileDepth, comp);
+    importLines.push(`import ${comp} from '${path}';`);
+  }
+
+  // Build getStaticPaths
+  const staticPaths = buildGetStaticPaths(cmsSchema, isMultiLocale, i18nConfig, locale);
+
+  // Build script paths array
+  const scriptsArrayLiteral = scriptPaths.length > 0
+    ? `[${scriptPaths.map((s) => `"${s}"`).join(', ')}]`
+    : '[]';
+
+  // Build library tags literal
+  const libraryTagsLiteral = `{ headCSS: \`${escapeTemplateLiteral(libraryTags.headCSS || '')}\`, headJS: \`${escapeTemplateLiteral(libraryTags.headJS || '')}\`, bodyEndJS: \`${escapeTemplateLiteral(libraryTags.bodyEndJS || '')}\` }`;
+
+  // Escape meta first, then transform CMS templates ({{cms.X}} survives escaping intact)
+  const escapedMeta = escapeTemplateLiteral(meta).replace(
+    /\{\{cms\.([^}]+)\}\}/g,
+    (_, fieldPath) => `\${${wrapFn}(${binding}.data.${fieldPath.trim()})}`
+  );
+  const escapedFontPreloads = escapeTemplateLiteral(fontPreloads);
+
+  // Transform title for CMS entry data
+  const titleExpr = transformTitleExpression(title, binding, richTextFields, wrapFn);
+
+  // i18n resolver helper — resolves {_i18n: true, en: "...", pl: "..."} to the correct locale string
+  const resolverHelper = `function r(v) {
+  if (v && typeof v === 'object' && v._i18n) return v['${locale}'] ?? v['${i18nConfig.defaultLocale}'] ?? Object.values(v).find(x => x !== true && x !== undefined) ?? '';
+  return v ?? '';
+}`;
+
+  return `---
+${importLines.join('\n')}
+
+${staticPaths}
+
+${resolverHelper}
+---
+<BaseLayout
+  title=${titleExpr}
+  meta={\`${escapedMeta}\`}
+  scripts={${scriptsArrayLiteral}}
+  locale="${locale}"
+  theme="${theme}"
+  fontPreloads={\`${escapedFontPreloads}\`}
+  libraryTags={${libraryTagsLiteral}}
+>
+  <div id="root">
+${templateBody}  </div>
+</BaseLayout>
+`;
+}
+
+/**
+ * Build an empty CMS page with just the layout wrapper and getStaticPaths
+ */
+function buildEmptyCMSPage(
+  layoutImport: string,
+  title: string,
+  meta: string,
+  locale: string,
+  theme: string,
+  fontPreloads: string,
+  libraryTags: { headCSS?: string; headJS?: string; bodyEndJS?: string },
+  scriptPaths: string[],
+  cmsSchema: CMSSchema,
+  isMultiLocale: boolean,
+  i18nConfig: I18nConfig,
+  binding: string,
+  richTextFields: Set<string>
+): string {
+  const escapedMeta = escapeTemplateLiteral(meta);
+  const escapedFontPreloads = escapeTemplateLiteral(fontPreloads);
+  const scriptsArrayLiteral = scriptPaths.length > 0
+    ? `[${scriptPaths.map((s) => `"${s}"`).join(', ')}]`
+    : '[]';
+  const libraryTagsLiteral = `{ headCSS: \`${escapeTemplateLiteral(libraryTags.headCSS || '')}\`, headJS: \`${escapeTemplateLiteral(libraryTags.headJS || '')}\`, bodyEndJS: \`${escapeTemplateLiteral(libraryTags.bodyEndJS || '')}\` }`;
+
+  const wrapFn = 'r';
+  const staticPaths = buildGetStaticPaths(cmsSchema, isMultiLocale, i18nConfig, locale);
+  const titleExpr = transformTitleExpression(title, binding, richTextFields, wrapFn);
+
+  const resolverHelper = `function r(v) {
+  if (v && typeof v === 'object' && v._i18n) return v['${locale}'] ?? v['${i18nConfig.defaultLocale}'] ?? Object.values(v).find(x => x !== true && x !== undefined) ?? '';
+  return v ?? '';
+}`;
+
+  return `---
+import { getCollection } from 'astro:content';
+import BaseLayout from '${layoutImport}';
+
+${staticPaths}
+
+${resolverHelper}
+---
+<BaseLayout
+  title=${titleExpr}
+  meta={\`${escapedMeta}\`}
+  scripts={${scriptsArrayLiteral}}
+  locale="${locale}"
+  theme="${theme}"
+  fontPreloads={\`${escapedFontPreloads}\`}
+  libraryTags={${libraryTagsLiteral}}
+>
+</BaseLayout>
+`;
+}