meno-core 1.0.53 → 1.1.0

package/lib/client/templateEngine.ts

@@ -5,19 +5,38 @@
  * Security: Uses jsep for safe expression parsing instead of eval/new Function()
  */
 
-import type { StyleMapping, HtmlMapping, ComponentDefinition, StructuredComponentDefinition, ComponentNode, HtmlNode, ComponentInstanceNode, EmbedNode, SlotMarker, StyleObject, ResponsiveStyleObject, StyleValue, TemplateContext } from '../shared/types';
+import type {
+  StyleMapping,
+  HtmlMapping,
+  ComponentNode,
+  HtmlNode,
+  ComponentInstanceNode,
+  SlotMarker,
+  StyleObject,
+  ResponsiveStyleObject,
+  StyleValue,
+  TemplateContext,
+} from '../shared/types';
 import { isResponsiveStyle } from '../shared/styleUtils';
-import { normalizeStyle as normalizeStyleShared, mergeResponsiveStyles } from '../shared/responsiveStyleUtils';
-import { DEFAULT_BREAKPOINTS } from '../shared/breakpoints';
+import { normalizeStyle as normalizeStyleShared } from '../shared/responsiveStyleUtils';
 import { NODE_TYPE } from '../shared/constants';
-import { isValidNodeType, isComponentNode, isHtmlNode, isSlotMarker, isEmbedNode, isLocaleListNode, isLinkNode, isCMSListNode, isListNode } from '../shared/nodeUtils';
+import {
+  isValidNodeType,
+  isComponentNode,
+  isHtmlNode,
+  isSlotMarker,
+  isEmbedNode,
+  isLocaleListNode,
+  isLinkNode,
+  isListNode,
+} from '../shared/nodeUtils';
 import { applyStylesToNode } from '../shared/styleNodeUtils';
 import { isRichTextMarker, richTextMarkerToHtml } from '../shared/propResolver';
-import { isTiptapDocument, tiptapToHtml } from '../shared/richtext';
 import { hasItemTemplates } from '../shared/itemTemplateUtils';
 import { safeEvaluate } from '../shared/expressionEvaluator';
 import { RAW_HTML_PREFIX } from '../shared/constants';
 import { getGlobalTemplateContext } from '../shared/globalTemplateContext';
+import { logRuntimeError } from '../shared/errorLogger';
 
 // Re-export for backward compatibility
 export { isResponsiveStyle };
@@ -36,7 +55,7 @@ export function normalizeStyle(style: StyleValue | null | undefined): StyleObjec
  */
 function addProcessedItemToArray(
   item: ComponentNode | (ComponentNode | string)[] | string | number | Record<string, unknown> | null,
-  array: Array<ComponentNode | string>
+  array: Array<ComponentNode | string>,
 ): void {
   if (item === null) return;
 
@@ -66,7 +85,11 @@ export function isLinkMapping(value: unknown): value is LinkMapping {
   if (!value || typeof value !== 'object') return false;
   const obj = value as Record<string, unknown>;
   // values is optional - when empty/missing, acts as passthrough for link-type props
-  return obj._mapping === true && typeof obj.prop === 'string' && (obj.values === undefined || typeof obj.values === 'object');
+  return (
+    obj._mapping === true &&
+    typeof obj.prop === 'string' &&
+    (obj.values === undefined || typeof obj.values === 'object')
+  );
 }
 
 /**
@@ -95,7 +118,7 @@ export function isLinkMapping(value: unknown): value is LinkMapping {
  */
 export function resolveLinkMapping(
   mappingObj: unknown,
-  props: Record<string, unknown> | undefined
+  props: Record<string, unknown> | undefined,
 ): { href: string; target?: string } | undefined {
   if (!isLinkMapping(mappingObj)) {
     return undefined;
@@ -147,7 +170,7 @@ export function isHtmlMapping(value: unknown): value is HtmlMapping {
  */
 export function resolveHtmlMapping(
   mappingObj: unknown,
-  props: Record<string, unknown> | undefined
+  props: Record<string, unknown> | undefined,
 ): string | undefined {
   if (!isHtmlMapping(mappingObj)) {
     return undefined;
@@ -187,14 +210,14 @@ export function resolveHtmlMapping(
  */
 export function resolveStyleMapping(
   mappingObj: unknown,
-  props: Record<string, unknown> | undefined
+  props: Record<string, unknown> | undefined,
 ): string | number | undefined {
   if (!mappingObj || typeof mappingObj !== 'object') {
     return undefined;
   }
 
   const mapping = mappingObj as StyleMapping;
-  if (!mapping || !mapping._mapping) {
+  if (!mapping?._mapping) {
     return undefined;
   }
 
@@ -227,7 +250,7 @@ export function resolveStyleMapping(
  */
 function processStyleValue(
   styleValue: unknown,
-  props: Record<string, unknown> | undefined
+  props: Record<string, unknown> | undefined,
 ): string | number | undefined {
   // First try style mapping resolution
   const resolved = resolveStyleMapping(styleValue, props);
@@ -259,10 +282,7 @@ function processStyleValue(
  * @param includeItemContext - Whether to include itemContext from the context object
  * @returns A flat object suitable for template evaluation
  */
-function buildEvalContext(
-  context: TemplateContext,
-  includeItemContext: boolean = false
-): Record<string, unknown> {
+function buildEvalContext(context: TemplateContext, includeItemContext: boolean = false): Record<string, unknown> {
   // Layer order (lowest → highest precedence): global → parent component
   // props → this component's own props. The middle layer lets a `{{x}}` in
   // a child component's structure cascade to the host's `x` when the child
@@ -270,7 +290,7 @@ function buildEvalContext(
   const evalContext: Record<string, unknown> = {
     ...getGlobalTemplateContext(),
     ...(context.parentProps ?? {}),
-    ...context.props
+    ...context.props,
   };
 
   if (context.componentDef && typeof context.componentDef === 'object') {
@@ -306,30 +326,39 @@ const MAX_RECURSION_DEPTH = 100;
  * evaluateTemplate("{{count + 1}}", { count: 5 }) // 6
  * evaluateTemplate("{{undefinedVar}}", {}) // undefined (no error thrown)
  */
-export function evaluateTemplate(
-  template: string,
-  context: Record<string, unknown>
-): unknown {
+export function evaluateTemplate(template: string, context: Record<string, unknown>): unknown {
   if (typeof template !== 'string') return template;
 
   const templateMatch = template.match(/^\{\{(.+)\}\}$/);
   if (!templateMatch) return template;
 
-  const expression = templateMatch[1].trim();
+  const expression = (templateMatch[1] ?? '').trim();
 
   // Security: Expression length limit to prevent DoS
   if (expression.length > MAX_EXPRESSION_LENGTH) {
-    console.warn('Template expression too long:', expression.slice(0, 50) + '...');
+    console.warn('Template expression too long:', `${expression.slice(0, 50)}...`);
     return template;
   }
 
   try {
     // Use safe expression evaluator (jsep-based, no eval/new Function)
     const result = safeEvaluate(expression, context);
-    // If result is undefined, return template string for backward compatibility
-    return result === undefined ? template : result;
+    // undefined (unknown identifier) AND NaN (arithmetic over an identifier that isn't
+    // in context — e.g. a loop-var stagger like {{0.4+itemIndex*0.2}} evaluated by the
+    // props pass before the per-item pass) both mean "can't resolve here": return the
+    // template string so a later pass (item/CMS context) can still resolve it, and so
+    // React never receives a NaN attribute/prop ("Received NaN for the `fade` attribute").
+    if (result === undefined || (typeof result === 'number' && Number.isNaN(result))) {
+      return template;
+    }
+    return result;
   } catch (error) {
-    console.error('Template evaluation error:', error, 'Expression:', expression, 'Context:', context);
+    // Log the expression + context key names only — never the values, which
+    // carry props/CMS data. Dev-gated via logRuntimeError so production stays quiet.
+    logRuntimeError('templateEngine.evaluateTemplate', error, {
+      expression: expression.slice(0, 80),
+      contextKeys: context ? Object.keys(context) : [],
+    });
     // Return original template string on error for backward compatibility
     return template;
   }
@@ -346,18 +375,15 @@ export function hasTemplates(code: string): boolean {
 /**
  * Processes template strings in JavaScript or CSS code
  * Replaces {{propName}} or {{expression}} with evaluated values
- * 
+ *
  * @example
  * processCodeTemplates("console.log('{{name}}');", { name: "John" })
  * // "console.log('John');"
- * 
+ *
  * processCodeTemplates(".card { color: {{color}}; }", { color: "#ff0000" })
  * // ".card { color: #ff0000; }"
  */
-export function processCodeTemplates(
-  code: string,
-  context: Record<string, unknown> | undefined
-): string {
+export function processCodeTemplates(code: string, context: Record<string, unknown> | undefined): string {
   if (typeof code !== 'string') return code;
 
   // Guard against undefined context
@@ -371,7 +397,7 @@ export function processCodeTemplates(
 
     // Security: Expression length limit to prevent DoS
     if (trimmedExpr.length > MAX_EXPRESSION_LENGTH) {
-      console.warn('Code template expression too long:', trimmedExpr.slice(0, 50) + '...');
+      console.warn('Code template expression too long:', `${trimmedExpr.slice(0, 50)}...`);
       return match;
     }
 
@@ -396,7 +422,12 @@ export function processCodeTemplates(
       // For objects/arrays, stringify them
       return JSON.stringify(result);
     } catch (error) {
-      console.error('Code template evaluation error:', error, 'Expression:', trimmedExpr, 'Context:', context);
+      // Log the expression + context key names only — never the values, which
+      // carry props/CMS data. Dev-gated via logRuntimeError so production stays quiet.
+      logRuntimeError('templateEngine.processCodeTemplates', error, {
+        expression: trimmedExpr.slice(0, 80),
+        contextKeys: context ? Object.keys(context) : [],
+      });
       // Return original template if evaluation fails
       return match;
     }
@@ -417,12 +448,14 @@ export function processStructure(
   viewportWidth?: number,
   instanceChildren?: ComponentNode['children'],
   preserveResponsiveStyles: boolean = false,
-  depth: number = 0
+  depth: number = 0,
 ): ComponentNode | (ComponentNode | string)[] | string | number | Record<string, unknown> | null {
   try {
     // Guard against excessive recursion (circular references or very deep structures)
     if (depth > MAX_RECURSION_DEPTH) {
-      console.warn(`processStructure: Maximum recursion depth (${MAX_RECURSION_DEPTH}) exceeded. Possible circular reference.`);
+      console.warn(
+        `processStructure: Maximum recursion depth (${MAX_RECURSION_DEPTH}) exceeded. Possible circular reference.`,
+      );
       return null;
     }
 
@@ -472,7 +505,7 @@ export function processStructure(
       // No templates - return as-is
       return structure;
     }
-    
+
     if (Array.isArray(structure)) {
       const processed: Array<ComponentNode | string> = [];
       for (const item of structure) {
@@ -482,7 +515,14 @@ export function processStructure(
           if (instanceChildren) {
             const childrenArray = Array.isArray(instanceChildren) ? instanceChildren : [instanceChildren];
             for (const child of childrenArray) {
-              const processedChild = processStructure(child, context, viewportWidth, instanceChildren, preserveResponsiveStyles, depth + 1);
+              const processedChild = processStructure(
+                child,
+                context,
+                viewportWidth,
+                instanceChildren,
+                preserveResponsiveStyles,
+                depth + 1,
+              );
               addProcessedItemToArray(processedChild, processed);
             }
           } else if ('default' in item && (item as SlotMarker).default !== undefined) {
@@ -490,20 +530,34 @@ export function processStructure(
             const defaultContent = (item as SlotMarker).default;
             const defaultsArray = Array.isArray(defaultContent) ? defaultContent : [defaultContent];
             for (const defaultChild of defaultsArray) {
-              const processedChild = processStructure(defaultChild, context, viewportWidth, undefined, preserveResponsiveStyles, depth + 1);
+              const processedChild = processStructure(
+                defaultChild,
+                context,
+                viewportWidth,
+                undefined,
+                preserveResponsiveStyles,
+                depth + 1,
+              );
               addProcessedItemToArray(processedChild, processed);
             }
           }
           // If no instance children AND no default, marker renders nothing (skip it)
         } else {
           // Regular item - process normally
-          const processedItem = processStructure(item, context, viewportWidth, instanceChildren, preserveResponsiveStyles, depth + 1);
+          const processedItem = processStructure(
+            item,
+            context,
+            viewportWidth,
+            instanceChildren,
+            preserveResponsiveStyles,
+            depth + 1,
+          );
           addProcessedItemToArray(processedItem, processed);
         }
       }
       return processed;
     }
-    
+
     if (typeof structure === 'object' && !Array.isArray(structure) && structure !== null) {
       // Check if this is a slot marker (shouldn't happen here since we handle it in array processing, but guard anyway)
       if (isSlotMarker(structure)) {
@@ -512,10 +566,17 @@ export function processStructure(
           const processed: Array<ComponentNode | string> = [];
           const childrenArray = Array.isArray(instanceChildren) ? instanceChildren : [instanceChildren];
           for (const child of childrenArray) {
-            const processedChild = processStructure(child, context, viewportWidth, instanceChildren, preserveResponsiveStyles, depth + 1);
+            const processedChild = processStructure(
+              child,
+              context,
+              viewportWidth,
+              instanceChildren,
+              preserveResponsiveStyles,
+              depth + 1,
+            );
             addProcessedItemToArray(processedChild, processed);
           }
-          return processed.length === 1 ? processed[0] : processed;
+          return processed.length === 1 ? (processed[0] ?? processed) : processed;
         }
         // Fallback: use slot's default content
         if ('default' in structure && (structure as SlotMarker).default !== undefined) {
@@ -523,14 +584,21 @@ export function processStructure(
           const processed: Array<ComponentNode | string> = [];
           const defaultsArray = Array.isArray(defaultContent) ? defaultContent : [defaultContent];
           for (const defaultChild of defaultsArray) {
-            const processedChild = processStructure(defaultChild, context, viewportWidth, undefined, preserveResponsiveStyles, depth + 1);
+            const processedChild = processStructure(
+              defaultChild,
+              context,
+              viewportWidth,
+              undefined,
+              preserveResponsiveStyles,
+              depth + 1,
+            );
             addProcessedItemToArray(processedChild, processed);
           }
-          return processed.length === 1 ? processed[0] : processed;
+          return processed.length === 1 ? (processed[0] ?? processed) : processed;
         }
         return null;
       }
-      
+
       // Check if this is a valid node structure or a plain object (like props)
       const inputNode = structure as ComponentNode;
       const hasValidNodeType = inputNode.type && isValidNodeType(inputNode.type);
@@ -540,7 +608,14 @@ export function processStructure(
       if (!hasValidNodeType) {
         const result: Record<string, unknown> = {};
         for (const [key, value] of Object.entries(structure)) {
-          const processedValue = processStructure(value as ComponentNode | string | number | null, context, viewportWidth, instanceChildren, preserveResponsiveStyles, depth + 1);
+          const processedValue = processStructure(
+            value as ComponentNode | string | number | null,
+            context,
+            viewportWidth,
+            instanceChildren,
+            preserveResponsiveStyles,
+            depth + 1,
+          );
           if (processedValue !== null && processedValue !== undefined) {
             result[key] = processedValue;
           }
@@ -557,7 +632,7 @@ export function processStructure(
           type: NODE_TYPE.COMPONENT,
           component: '',
           props: {},
-          children: [] as Array<ComponentNode | string>
+          children: [] as Array<ComponentNode | string>,
         } as ComponentInstanceNode;
       } else if (preservedType === NODE_TYPE.EMBED) {
         // Handle embed nodes - they have html content, not children
@@ -570,7 +645,7 @@ export function processStructure(
         processed = {
           type: NODE_TYPE.LINK,
           href: '',
-          children: [] as Array<ComponentNode | string>
+          children: [] as Array<ComponentNode | string>,
         } as unknown as ComponentNode;
       } else if (preservedType === NODE_TYPE.LOCALE_LIST) {
         // Handle locale-list nodes - they have style, itemStyle, activeItemStyle properties
@@ -583,23 +658,30 @@ export function processStructure(
         processed = {
           type: NODE_TYPE.LIST,
           source: '',
-          children: [] as Array<ComponentNode | string>
+          children: [] as Array<ComponentNode | string>,
         } as unknown as ComponentNode;
       } else {
         processed = {
           type: NODE_TYPE.NODE,
           tag: 'div',
-          children: [] as Array<ComponentNode | string>
+          children: [] as Array<ComponentNode | string>,
         } as HtmlNode;
       }
-      
+
       // First pass: process all keys and resolve style mappings
       let resolvedStyle: StyleValue | null = null;
-      
+
       for (const [key, value] of Object.entries(structure)) {
         try {
           if (key === 'children') {
-            const processedChildren = processStructure(value as ComponentNode | ComponentNode[] | string | number | null | undefined, context, viewportWidth, instanceChildren, preserveResponsiveStyles, depth + 1);
+            const processedChildren = processStructure(
+              value as ComponentNode | ComponentNode[] | string | number | null | undefined,
+              context,
+              viewportWidth,
+              instanceChildren,
+              preserveResponsiveStyles,
+              depth + 1,
+            );
             if (Array.isArray(processedChildren)) {
               processed.children = processedChildren;
             } else if (processedChildren !== null && processedChildren !== undefined) {
@@ -648,7 +730,11 @@ export function processStructure(
                 } else {
                   processed.html = value;
                 }
-              } else if (typeof value === 'object' && value !== null && (value as Record<string, unknown>)._mapping === true) {
+              } else if (
+                typeof value === 'object' &&
+                value !== null &&
+                (value as Record<string, unknown>)._mapping === true
+              ) {
                 // HtmlMapping object that isHtmlMapping somehow missed — resolve it defensively
                 const resolved = resolveHtmlMapping(value, context.props);
                 processed.html = resolved ?? '';
@@ -668,7 +754,7 @@ export function processStructure(
                   component: '',
                   props: (p.props || {}) as ComponentInstanceNode['props'],
                   children: p.children as ComponentInstanceNode['children'],
-                  style: p.style as ComponentInstanceNode['style']
+                  style: p.style as ComponentInstanceNode['style'],
                 };
                 processed = newProcessed;
               } else if (value === NODE_TYPE.NODE && !isHtmlNode(processed)) {
@@ -678,7 +764,7 @@ export function processStructure(
                   type: NODE_TYPE.NODE,
                   tag: (p.component as string) || 'div',
                   children: p.children as HtmlNode['children'],
-                  style: p.style as HtmlNode['style']
+                  style: p.style as HtmlNode['style'],
                 };
                 processed = newProcessed;
               }
@@ -691,9 +777,9 @@ export function processStructure(
             if (processedStyle && typeof processedStyle === 'object' && !Array.isArray(processedStyle)) {
               // Check if it's a responsive style object
               const styleEvalContext = buildEvalContext(context, false);
-            if (isResponsiveStyle(processedStyle as StyleValue)) {
+              if (isResponsiveStyle(processedStyle as StyleValue)) {
                 // Preserve responsive styles (for both SSR and editor)
-                // responsiveStylesToClasses will generate prefixed classes (t-, mob-)
+                // responsiveStylesToClasses will generate prefixed classes (tablet:, mobile:)
                 // CSS media queries will handle displaying the correct styles based on viewport
                 const resolvedResponsive: ResponsiveStyleObject = {};
                 for (const [bkeyName, bkeyValue] of Object.entries(processedStyle)) {
@@ -721,9 +807,21 @@ export function processStructure(
             }
           } else if (key === 'props' && typeof value === 'object' && value !== null) {
             // Process non-style props (for instance props only)
-            const processedProps = processStructure(value as ComponentNode | ComponentNode[] | string | number | null | undefined, context, viewportWidth, instanceChildren, preserveResponsiveStyles, depth + 1);
+            const processedProps = processStructure(
+              value as ComponentNode | ComponentNode[] | string | number | null | undefined,
+              context,
+              viewportWidth,
+              instanceChildren,
+              preserveResponsiveStyles,
+              depth + 1,
+            );
             // Merge non-style props (style is handled separately at top level)
-            if (typeof processedProps === 'object' && !Array.isArray(processedProps) && processedProps !== null && processed.props) {
+            if (
+              typeof processedProps === 'object' &&
+              !Array.isArray(processedProps) &&
+              processedProps !== null &&
+              processed.props
+            ) {
               const propsObj = processedProps as unknown as Record<string, unknown>;
               Object.assign(processed.props, propsObj);
               // Remove style from props since we handle it at top level
@@ -744,7 +842,7 @@ export function processStructure(
                 if (resolved.target) {
                   pLink.attributes = {
                     ...((pLink.attributes as Record<string, unknown>) || {}),
-                    target: resolved.target
+                    target: resolved.target,
                   };
                 }
               } else {
@@ -752,13 +850,24 @@ export function processStructure(
               }
             } else {
               // Regular href value - process as template
-              const processedValue = processStructure(value as ComponentNode | ComponentNode[] | string | number | null | undefined, context, viewportWidth, instanceChildren, preserveResponsiveStyles, depth + 1);
+              const processedValue = processStructure(
+                value as ComponentNode | ComponentNode[] | string | number | null | undefined,
+                context,
+                viewportWidth,
+                instanceChildren,
+                preserveResponsiveStyles,
+                depth + 1,
+              );
               if (processedValue !== null && processedValue !== undefined) {
                 // Check if result is a link object (from link-type prop like {{link}})
                 if (typeof processedValue === 'object' && processedValue !== null && 'href' in processedValue) {
                   // Unwrap nested link objects (e.g., {href: {href: "/path"}} from double-wrapped list item templates)
                   let linkObj = processedValue as { href: unknown; target?: string };
-                  while (typeof linkObj.href === 'object' && linkObj.href !== null && 'href' in (linkObj.href as Record<string, unknown>)) {
+                  while (
+                    typeof linkObj.href === 'object' &&
+                    linkObj.href !== null &&
+                    'href' in (linkObj.href as Record<string, unknown>)
+                  ) {
                     const nested = linkObj.href as { href: unknown; target?: string };
                     if (!linkObj.target && nested.target) linkObj = { ...linkObj, target: nested.target };
                     linkObj = { ...linkObj, href: nested.href };
@@ -767,7 +876,7 @@ export function processStructure(
                   if (linkObj.target) {
                     pLink.attributes = {
                       ...((pLink.attributes as Record<string, unknown>) || {}),
-                      target: linkObj.target
+                      target: linkObj.target,
                     };
                   }
                 } else {
@@ -819,15 +928,31 @@ export function processStructure(
               context.props &&
               Array.isArray((context.props as Record<string, unknown>)[value])
             ) {
-              (processed as unknown as Record<string, unknown>).source = (context.props as Record<string, unknown>)[value];
+              (processed as unknown as Record<string, unknown>).source = (context.props as Record<string, unknown>)[
+                value
+              ];
             } else {
-              const processedValue = processStructure(value as ComponentNode | ComponentNode[] | string | number | null | undefined, context, viewportWidth, instanceChildren, preserveResponsiveStyles, depth + 1);
+              const processedValue = processStructure(
+                value as ComponentNode | ComponentNode[] | string | number | null | undefined,
+                context,
+                viewportWidth,
+                instanceChildren,
+                preserveResponsiveStyles,
+                depth + 1,
+              );
               if (processedValue !== null && processedValue !== undefined) {
                 (processed as unknown as Record<string, unknown>).source = processedValue;
               }
             }
           } else if (key !== 'type' && key !== 'children' && key !== 'style' && key !== 'props') {
-            const processedValue = processStructure(value as ComponentNode | ComponentNode[] | string | number | null | undefined, context, viewportWidth, instanceChildren, preserveResponsiveStyles, depth + 1);
+            const processedValue = processStructure(
+              value as ComponentNode | ComponentNode[] | string | number | null | undefined,
+              context,
+              viewportWidth,
+              instanceChildren,
+              preserveResponsiveStyles,
+              depth + 1,
+            );
             // Only assign if it's a valid value
             if (processedValue !== null && processedValue !== undefined) {
               // Store extra properties on the node object
@@ -839,7 +964,7 @@ export function processStructure(
           // Continue processing other keys
         }
       }
-      
+
       // Apply resolved styles to the processed node based on its type
       // Both SSR and Editor now preserve responsive styles for proper utility class generation
       if (resolvedStyle && Object.keys(resolvedStyle).length > 0) {
@@ -847,7 +972,13 @@ export function processStructure(
           // Apply responsive styles directly to node.style or props.style
           if (isComponentNode(processed)) {
             (processed as unknown as Record<string, unknown>).style = resolvedStyle as ResponsiveStyleObject;
-          } else if (isHtmlNode(processed) || isEmbedNode(processed) || isLocaleListNode(processed) || isLinkNode(processed) || isListNode(processed)) {
+          } else if (
+            isHtmlNode(processed) ||
+            isEmbedNode(processed) ||
+            isLocaleListNode(processed) ||
+            isLinkNode(processed) ||
+            isListNode(processed)
+          ) {
             processed.style = resolvedStyle as ResponsiveStyleObject;
           }
         } else {
@@ -855,14 +986,13 @@ export function processStructure(
           applyStylesToNode(processed, resolvedStyle);
         }
       }
-      
+
       return processed;
     }
-    
+
     return structure;
   } catch (error) {
     console.error('Error in processStructure:', error);
     throw error; // Re-throw so it can be caught by error boundary
   }
 }
-

package/lib/client/theme.test.ts

@@ -1,5 +1,5 @@
 import { describe, test, expect } from 'bun:test';
-import { getThemeColors, type Theme, type ThemeColors } from './theme';
+import { getThemeColors } from './theme';
 
 describe('theme', () => {
   describe('getThemeColors', () => {

package/lib/client/theme.ts

@@ -147,4 +147,3 @@ const darkThemeColors: ThemeColors = {
 export function getThemeColors(theme: Theme): ThemeColors {
   return theme === 'light' ? lightThemeColors : darkThemeColors;
 }
-

package/lib/client/utils/toast.ts

@@ -44,4 +44,3 @@ export function showApiErrorToast(error: Error, _duration?: number): void {
   const message = error.message || 'An unexpected error occurred';
   showErrorToast(message, _duration);
 }
-

package/lib/server/__integration__/api-routes.test.ts

@@ -15,10 +15,14 @@ beforeAll(async () => {
   ctx = await createTestServer({
     pages: {
       '/': TEST_PAGE_JSON,
-      '/about': JSON.stringify({
-        meta: { title: 'About', description: 'About page' },
-        root: { type: 'node', tag: 'div', children: 'About content' },
-      }, null, 2),
+      '/about': JSON.stringify(
+        {
+          meta: { title: 'About', description: 'About page' },
+          root: { type: 'node', tag: 'div', children: 'About content' },
+        },
+        null,
+        2,
+      ),
     },
     components,
   });

package/lib/server/__integration__/cms-integration.test.ts

@@ -40,10 +40,7 @@ beforeAll(async () => {
   setProjectRoot(tempProject.projectDir);
 
   // Create CMS provider and service with real file system
-  const cmsProvider = new FileSystemCMSProvider(
-    `${tempProject.projectDir}/templates`,
-    `${tempProject.projectDir}/cms`
-  );
+  const cmsProvider = new FileSystemCMSProvider(`${tempProject.projectDir}/templates`, `${tempProject.projectDir}/cms`);
   const cmsService = new CMSService(cmsProvider);
   await cmsService.initialize();