meno-core 1.0.53 → 1.1.0

package/lib/server/astro/normalizeOrphanTemplateProps.test.ts

@@ -1,61 +1,59 @@
-import { test, expect, describe } from "bun:test";
-import { normalizeOrphanTemplateProps } from "./normalizeOrphanTemplateProps";
-import type { ComponentDefinition } from "../../shared/types";
+import { test, expect, describe } from 'bun:test';
+import { normalizeOrphanTemplateProps } from './normalizeOrphanTemplateProps';
+import type { ComponentDefinition } from '../../shared/types';
 
-describe("normalizeOrphanTemplateProps", () => {
+describe('normalizeOrphanTemplateProps', () => {
   test("lifts an orphan {{x}} onto the component's interface as a string default", () => {
     const components: Record<string, ComponentDefinition> = {
       ArrowLink: {
         component: {
           interface: {},
           structure: {
-            type: "node",
-            tag: "span",
-            children: ["{{ctaText}}"]
-          }
-        }
-      }
+            type: 'node',
+            tag: 'span',
+            children: ['{{ctaText}}'],
+          },
+        },
+      },
     };
 
     const out = normalizeOrphanTemplateProps(components);
-    const arrowIface = out.ArrowLink.component!.interface!;
+    const arrowIface = out.ArrowLink!.component!.interface!;
     expect(arrowIface.ctaText).toBeDefined();
-    expect((arrowIface.ctaText as any).type).toBe("string");
-    expect((arrowIface.ctaText as any).default).toBe("");
+    expect((arrowIface.ctaText as any).type).toBe('string');
+    expect((arrowIface.ctaText as any).default).toBe('');
   });
 
-  test("forwards lifted props on an instance ref when the host declares the prop", () => {
+  test('forwards lifted props on an instance ref when the host declares the prop', () => {
     const components: Record<string, ComponentDefinition> = {
       ArrowLink: {
         component: {
           interface: {},
           structure: {
-            type: "node",
-            tag: "span",
-            children: ["{{ctaText}}"]
-          }
-        }
+            type: 'node',
+            tag: 'span',
+            children: ['{{ctaText}}'],
+          },
+        },
       },
       Card: {
         component: {
           interface: {
-            ctaText: { type: "string", default: "Click" } as any
+            ctaText: { type: 'string', default: 'Click' } as any,
           },
           structure: {
-            type: "node",
-            tag: "div",
-            children: [
-              { type: "component", component: "ArrowLink" } as any
-            ]
-          }
-        }
-      }
+            type: 'node',
+            tag: 'div',
+            children: [{ type: 'component', component: 'ArrowLink' } as any],
+          },
+        },
+      },
     };
 
     const out = normalizeOrphanTemplateProps(components);
-    const cardChildren = (out.Card.component!.structure as any).children;
+    const cardChildren = (out.Card!.component!.structure as any).children;
     expect(cardChildren[0].props).toBeDefined();
-    expect(cardChildren[0].props.ctaText).toBe("{{ctaText}}");
+    expect(cardChildren[0].props.ctaText).toBe('{{ctaText}}');
   });
 
   test("does NOT forward when the host doesn't declare the same prop", () => {
@@ -63,202 +61,200 @@ describe("normalizeOrphanTemplateProps", () => {
       ArrowLink: {
         component: {
           interface: {},
-          structure: { type: "node", tag: "span", children: ["{{ctaText}}"] }
-        }
+          structure: { type: 'node', tag: 'span', children: ['{{ctaText}}'] },
+        },
       },
       // Page-level wrapper that doesn't know about ctaText.
       Wrapper: {
         component: {
           interface: {},
           structure: {
-            type: "node",
-            tag: "div",
-            children: [{ type: "component", component: "ArrowLink" } as any]
-          }
-        }
-      }
+            type: 'node',
+            tag: 'div',
+            children: [{ type: 'component', component: 'ArrowLink' } as any],
+          },
+        },
+      },
     };
 
     const out = normalizeOrphanTemplateProps(components);
-    const wrapperChildren = (out.Wrapper.component!.structure as any).children;
+    const wrapperChildren = (out.Wrapper!.component!.structure as any).children;
     // No forward — would have made Wrapper produce a new orphan ref.
     expect(wrapperChildren[0].props).toBeUndefined();
   });
 
-  test("does not override an instance prop the host already passes", () => {
+  test('does not override an instance prop the host already passes', () => {
     const components: Record<string, ComponentDefinition> = {
       ArrowLink: {
         component: {
           interface: {},
-          structure: { type: "node", tag: "span", children: ["{{ctaText}}"] }
-        }
+          structure: { type: 'node', tag: 'span', children: ['{{ctaText}}'] },
+        },
       },
       Card: {
         component: {
           interface: {
-            ctaText: { type: "string", default: "Click" } as any
+            ctaText: { type: 'string', default: 'Click' } as any,
           },
           structure: {
-            type: "node",
-            tag: "div",
+            type: 'node',
+            tag: 'div',
             children: [
               {
-                type: "component",
-                component: "ArrowLink",
-                props: { ctaText: "Explicit value" }
-              } as any
-            ]
-          }
-        }
-      }
+                type: 'component',
+                component: 'ArrowLink',
+                props: { ctaText: 'Explicit value' },
+              } as any,
+            ],
+          },
+        },
+      },
     };
 
     const out = normalizeOrphanTemplateProps(components);
-    const cardChildren = (out.Card.component!.structure as any).children;
-    expect(cardChildren[0].props.ctaText).toBe("Explicit value");
+    const cardChildren = (out.Card!.component!.structure as any).children;
+    expect(cardChildren[0].props.ctaText).toBe('Explicit value');
   });
 
-  test("ignores cms.*, item.*, page.* refs (already namespaced)", () => {
+  test('ignores cms.*, item.*, page.* refs (already namespaced)', () => {
     const components: Record<string, ComponentDefinition> = {
       Title: {
         component: {
           interface: {},
           structure: {
-            type: "node",
-            tag: "h1",
-            children: ["{{cms.title}} - {{page.slug}}"]
-          }
-        }
-      }
+            type: 'node',
+            tag: 'h1',
+            children: ['{{cms.title}} - {{page.slug}}'],
+          },
+        },
+      },
     };
 
     const out = normalizeOrphanTemplateProps(components);
-    expect(Object.keys(out.Title.component!.interface!)).toHaveLength(0);
+    expect(Object.keys(out.Title!.component!.interface!)).toHaveLength(0);
   });
 
-  test("ignores list loop variables", () => {
+  test('ignores list loop variables', () => {
     const components: Record<string, ComponentDefinition> = {
       List: {
         component: {
           interface: {
-            items: { type: "list", default: [], itemSchema: {} } as any
+            items: { type: 'list', default: [], itemSchema: {} } as any,
           },
           structure: {
-            type: "list",
-            sourceType: "prop",
-            source: "items",
-            itemAs: "row",
-            children: [
-              { type: "node", tag: "div", children: ["{{row.label}}"] }
-            ]
-          }
-        }
-      }
+            type: 'list',
+            sourceType: 'prop',
+            source: 'items',
+            itemAs: 'row',
+            children: [{ type: 'node', tag: 'div', children: ['{{row.label}}'] }],
+          },
+        },
+      },
     };
 
     const out = normalizeOrphanTemplateProps(components);
     // `row` is the loop var — must NOT be auto-lifted as a string prop.
-    expect((out.List.component!.interface as any).row).toBeUndefined();
+    expect((out.List!.component!.interface as any).row).toBeUndefined();
   });
 
-  test("ignores expressions with operators (not a bare ident)", () => {
+  test('ignores expressions with operators (not a bare ident)', () => {
     const components: Record<string, ComponentDefinition> = {
       Cmp: {
         component: {
           interface: {},
           structure: {
-            type: "node",
-            tag: "div",
-            children: ["{{a + b}} {{x ? y : z}}"]
-          }
-        }
-      }
+            type: 'node',
+            tag: 'div',
+            children: ['{{a + b}} {{x ? y : z}}'],
+          },
+        },
+      },
     };
 
     const out = normalizeOrphanTemplateProps(components);
     // Don't lift `a`, `b`, `x`, `y`, `z` from compound expressions — too
     // risky to guess types or what's actually intended.
-    expect(Object.keys(out.Cmp.component!.interface!)).toHaveLength(0);
+    expect(Object.keys(out.Cmp!.component!.interface!)).toHaveLength(0);
   });
 
-  test("does not mutate the input component definitions", () => {
+  test('does not mutate the input component definitions', () => {
     const components: Record<string, ComponentDefinition> = {
       ArrowLink: {
         component: {
           interface: {},
-          structure: { type: "node", tag: "span", children: ["{{ctaText}}"] }
-        }
-      }
+          structure: { type: 'node', tag: 'span', children: ['{{ctaText}}'] },
+        },
+      },
     };
     const before = JSON.stringify(components);
     normalizeOrphanTemplateProps(components);
     expect(JSON.stringify(components)).toBe(before);
   });
 
-  test("lifts a prop ref from a style _mapping object", () => {
+  test('lifts a prop ref from a style _mapping object', () => {
     const components: Record<string, ComponentDefinition> = {
       Cmp: {
         component: {
           interface: {},
           structure: {
-            type: "node",
-            tag: "div",
+            type: 'node',
+            tag: 'div',
             style: {
               base: {
                 color: {
                   _mapping: true,
-                  prop: "variant",
-                  values: { default: "black", featured: "white" }
-                }
-              }
-            }
-          } as any
-        }
-      }
+                  prop: 'variant',
+                  values: { default: 'black', featured: 'white' },
+                },
+              },
+            },
+          } as any,
+        },
+      },
     };
 
     const out = normalizeOrphanTemplateProps(components);
-    expect((out.Cmp.component!.interface as any).variant).toBeDefined();
-    expect((out.Cmp.component!.interface as any).variant.type).toBe("string");
+    expect((out.Cmp!.component!.interface as any).variant).toBeDefined();
+    expect((out.Cmp!.component!.interface as any).variant.type).toBe('string');
   });
 
-  test("lifts a prop ref from an if boolean mapping", () => {
+  test('lifts a prop ref from an if boolean mapping', () => {
     const components: Record<string, ComponentDefinition> = {
       Cmp: {
         component: {
           interface: {},
           structure: {
-            type: "node",
-            tag: "span",
+            type: 'node',
+            tag: 'span',
             if: {
               _mapping: true,
-              prop: "showBadge",
-              values: { true: true, false: false }
-            }
-          } as any
-        }
-      }
+              prop: 'showBadge',
+              values: { true: true, false: false },
+            },
+          } as any,
+        },
+      },
     };
 
     const out = normalizeOrphanTemplateProps(components);
-    expect((out.Cmp.component!.interface as any).showBadge).toBeDefined();
+    expect((out.Cmp!.component!.interface as any).showBadge).toBeDefined();
   });
 
-  test("dotted ref {{link.href}} lifts the base name", () => {
+  test('dotted ref {{link.href}} lifts the base name', () => {
     const components: Record<string, ComponentDefinition> = {
       Anchor: {
         component: {
           interface: {},
           structure: {
-            type: "node",
-            tag: "a",
-            attributes: { href: "{{link.href}}" }
-          }
-        }
-      }
+            type: 'node',
+            tag: 'a',
+            attributes: { href: '{{link.href}}' },
+          },
+        },
+      },
     };
 
     const out = normalizeOrphanTemplateProps(components);
-    expect((out.Anchor.component!.interface as any).link).toBeDefined();
+    expect((out.Anchor!.component!.interface as any).link).toBeDefined();
   });
 });

package/lib/server/astro/normalizeOrphanTemplateProps.ts

@@ -35,17 +35,9 @@ import type { ComponentDefinition, PropDefinition } from '../../shared/types';
 const BARE_IDENT_BODY = /^\s*([a-zA-Z_$][a-zA-Z0-9_$]*)(?:\s*\.\s*[a-zA-Z_$][a-zA-Z0-9_$]*)*\s*$/;
 
 // Namespaces and meta-vars that are never component-instance props.
-const RESERVED_BASES = new Set([
-  'cms', 'item', 'page',
-  'itemIndex', 'itemFirst', 'itemLast',
-]);
+const RESERVED_BASES = new Set(['cms', 'item', 'page', 'itemIndex', 'itemFirst', 'itemLast']);
 
-function recordRef(
-  base: string,
-  declared: Set<string>,
-  listVars: Set<string>,
-  out: Set<string>
-): void {
+function recordRef(base: string, declared: Set<string>, listVars: Set<string>, out: Set<string>): void {
   if (RESERVED_BASES.has(base)) return;
   if (listVars.has(base)) return;
   if (declared.has(base)) return;
@@ -56,12 +48,13 @@ function findOrphanRefs(value: unknown, declared: Set<string>, listVars: Set<str
   if (value == null) return;
   if (typeof value === 'string') {
     const re = /\{\{([^}]+)\}\}/g;
-    let m: RegExpExecArray | null;
-    while ((m = re.exec(value)) !== null) {
-      const body = m[1];
+    let m: RegExpExecArray | null = re.exec(value);
+    while (m !== null) {
+      const body = m[1] ?? '';
+      m = re.exec(value);
       const idMatch = body.match(BARE_IDENT_BODY);
       if (!idMatch) continue; // expressions, operators, calls — skip
-      recordRef(idMatch[1], declared, listVars, out);
+      recordRef(idMatch[1] ?? '', declared, listVars, out);
     }
     return;
   }
@@ -111,7 +104,7 @@ function findOrphanRefs(value: unknown, declared: Set<string>, listVars: Set<str
 function forwardLiftedPropsOnInstances(
   structure: unknown,
   hostProps: Set<string>,
-  liftedByComp: ReadonlyMap<string, ReadonlySet<string>>
+  liftedByComp: ReadonlyMap<string, ReadonlySet<string>>,
 ): void {
   if (structure == null || typeof structure !== 'object') return;
   if (Array.isArray(structure)) {
@@ -143,7 +136,7 @@ function forwardLiftedPropsOnInstances(
  * The input map is not mutated.
  */
 export function normalizeOrphanTemplateProps(
-  components: Record<string, ComponentDefinition>
+  components: Record<string, ComponentDefinition>,
 ): Record<string, ComponentDefinition> {
   const next: Record<string, ComponentDefinition> = {};
   const liftedByComp = new Map<string, Set<string>>();
@@ -156,7 +149,7 @@ export function normalizeOrphanTemplateProps(
     next[name] = cloned;
 
     const comp = cloned.component;
-    if (!comp || !comp.structure) continue;
+    if (!comp?.structure) continue;
     const iface = (comp.interface ?? {}) as Record<string, PropDefinition>;
     const declared = new Set(Object.keys(iface));
     const orphans = new Set<string>();
@@ -175,7 +168,7 @@ export function normalizeOrphanTemplateProps(
   // same prop. Mutates the cloned structures in `next`.
   for (const [, hostDef] of Object.entries(next)) {
     const comp = hostDef.component;
-    if (!comp || !comp.structure) continue;
+    if (!comp?.structure) continue;
     const hostProps = new Set(Object.keys(comp.interface ?? {}));
     forwardLiftedPropsOnInstances(comp.structure, hostProps, liftedByComp);
   }

package/lib/server/astro/pageEmitter.ts

@@ -198,9 +198,7 @@ export function emitAstroPage(options: PageEmitOptions): string {
   }
 
   // Build script paths array
-  const scriptsArrayLiteral = scriptPaths.length > 0
-    ? `[${scriptPaths.map((s) => `"${s}"`).join(', ')}]`
-    : '[]';
+  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 || '')}\` }`;
@@ -209,14 +207,14 @@ export function emitAstroPage(options: PageEmitOptions): string {
   const escapedFontPreloads = escapeTemplateLiteral(fontPreloads);
 
   // Collect frontmatter lines from list emission (e.g., getCollection calls)
-  const extraFrontmatter = ctx.frontmatterLines && ctx.frontmatterLines.length > 0
-    ? '\n' + ctx.frontmatterLines.join('\n')
-    : '';
+  const extraFrontmatter =
+    ctx.frontmatterLines && ctx.frontmatterLines.length > 0 ? `\n${ctx.frontmatterLines.join('\n')}` : '';
 
   // Generate interactive style block for page-level interactive styles
-  const interactiveStyleSection = ctx.collectedInteractiveStyles!.size > 0
-    ? `\n<style is:global>\n${generateAllInteractiveCSS(ctx.collectedInteractiveStyles!, breakpoints, remConfig, responsiveScales)}\n</style>\n`
-    : '';
+  const interactiveStyleSection =
+    ctx.collectedInteractiveStyles!.size > 0
+      ? `\n<style is:global>\n${generateAllInteractiveCSS(ctx.collectedInteractiveStyles!, breakpoints, remConfig, responsiveScales)}\n</style>\n`
+      : '';
 
   return `---
 ${importLines.join('\n')}${extraFrontmatter}
@@ -247,13 +245,11 @@ function buildEmptyPage(
   theme: string,
   fontPreloads: string,
   libraryTags: { headCSS?: string; headJS?: string; bodyEndJS?: string },
-  scriptPaths: string[]
+  scriptPaths: string[],
 ): string {
   const escapedMeta = escapeTemplateLiteral(meta);
   const escapedFontPreloads = escapeTemplateLiteral(fontPreloads);
-  const scriptsArrayLiteral = scriptPaths.length > 0
-    ? `[${scriptPaths.map((s) => `"${s}"`).join(', ')}]`
-    : '[]';
+  const scriptsArrayLiteral = scriptPaths.length > 0 ? `[${scriptPaths.map((s) => `"${s}"`).join(', ')}]` : '[]';
   const libraryTagsLiteral = `{ headCSS: \`${escapeTemplateLiteral(libraryTags.headCSS || '')}\`, headJS: \`${escapeTemplateLiteral(libraryTags.headJS || '')}\`, bodyEndJS: \`${escapeTemplateLiteral(libraryTags.bodyEndJS || '')}\` }`;
 
   return `---

package/lib/server/astro/tailwindMapper.test.ts

@@ -23,24 +23,16 @@ const scalesDisabled: ResponsiveScales = {
 
 describe('responsiveStylesToTailwind — auto-responsive scaling', () => {
   test('emits scaled max-[Npx]: variants for base scalable property', () => {
-    const { classes } = responsiveStylesToTailwind(
-      { base: { padding: '40px' } },
-      DEFAULT_BREAKPOINTS,
-      scalesEnabled
-    );
+    const { classes } = responsiveStylesToTailwind({ base: { padding: '40px' } }, DEFAULT_BREAKPOINTS, scalesEnabled);
     // base: 40px; tablet: 40 + (40-16)*(0.75-1) = 34px; mobile: 40 + (40-16)*(0.5-1) = 28px
-    expect(classes).toEqual([
-      'p-[40px]',
-      'max-[1024px]:p-[34px]',
-      'max-[540px]:p-[28px]',
-    ]);
+    expect(classes).toEqual(['p-[40px]', 'max-[1024px]:p-[34px]', 'max-[540px]:p-[28px]']);
   });
 
   test('explicit breakpoint override wins — no auto-scaled variant for that breakpoint/property pair', () => {
     const { classes } = responsiveStylesToTailwind(
       { base: { padding: '40px' }, tablet: { padding: '30px' } },
       DEFAULT_BREAKPOINTS,
-      scalesEnabled
+      scalesEnabled,
     );
     expect(classes).toContain('p-[40px]');
     expect(classes).toContain('max-[1024px]:p-[30px]');
@@ -51,15 +43,8 @@ describe('responsiveStylesToTailwind — auto-responsive scaling', () => {
   });
 
   test('scaling disabled → output identical to no-scaling path', () => {
-    const withScales = responsiveStylesToTailwind(
-      { base: { padding: '40px' } },
-      DEFAULT_BREAKPOINTS,
-      scalesDisabled
-    );
-    const withoutScales = responsiveStylesToTailwind(
-      { base: { padding: '40px' } },
-      DEFAULT_BREAKPOINTS
-    );
+    const withScales = responsiveStylesToTailwind({ base: { padding: '40px' } }, DEFAULT_BREAKPOINTS, scalesDisabled);
+    const withoutScales = responsiveStylesToTailwind({ base: { padding: '40px' } }, DEFAULT_BREAKPOINTS);
     expect(withScales.classes).toEqual(withoutScales.classes);
     expect(withScales.classes).toEqual(['p-[40px]']);
   });
@@ -68,17 +53,13 @@ describe('responsiveStylesToTailwind — auto-responsive scaling', () => {
     const { classes } = responsiveStylesToTailwind(
       { base: { padding: '8px' } }, // 8 < 16 → stays unchanged → skipped
       DEFAULT_BREAKPOINTS,
-      scalesEnabled
+      scalesEnabled,
     );
     expect(classes).toEqual(['p-[8px]']);
   });
 
   test('non-scalable property (e.g. color) is left untouched', () => {
-    const { classes } = responsiveStylesToTailwind(
-      { base: { color: '#abc' } },
-      DEFAULT_BREAKPOINTS,
-      scalesEnabled
-    );
+    const { classes } = responsiveStylesToTailwind({ base: { color: '#abc' } }, DEFAULT_BREAKPOINTS, scalesEnabled);
     // Just the base color class — no max-[Npx] prefix because color isn't in any scale category
     expect(classes.filter((c) => c.startsWith('max-['))).toEqual([]);
   });
@@ -87,7 +68,7 @@ describe('responsiveStylesToTailwind — auto-responsive scaling', () => {
     const { classes } = responsiveStylesToTailwind(
       { base: { padding: '40px 80px' } },
       DEFAULT_BREAKPOINTS,
-      scalesEnabled
+      scalesEnabled,
     );
     // tablet: 40→34, 80→64; mobile: 40→28, 80→48
     expect(classes).toContain('max-[1024px]:p-[34px_64px]');
@@ -95,22 +76,14 @@ describe('responsiveStylesToTailwind — auto-responsive scaling', () => {
   });
 
   test('flat style object (no `base`) gets no auto-scaling', () => {
-    const { classes } = responsiveStylesToTailwind(
-      { padding: '40px' },
-      DEFAULT_BREAKPOINTS,
-      scalesEnabled
-    );
+    const { classes } = responsiveStylesToTailwind({ padding: '40px' }, DEFAULT_BREAKPOINTS, scalesEnabled);
     // A flat style is treated as base with no breakpoints — nothing to
     // auto-scale *into*. The scaling pass only runs on the responsive branch.
     expect(classes.filter((c) => c.startsWith('max-['))).toEqual([]);
   });
 
   test('fontSize scales using the fontSize category', () => {
-    const { classes } = responsiveStylesToTailwind(
-      { base: { fontSize: '100px' } },
-      DEFAULT_BREAKPOINTS,
-      scalesEnabled
-    );
+    const { classes } = responsiveStylesToTailwind({ base: { fontSize: '100px' } }, DEFAULT_BREAKPOINTS, scalesEnabled);
     // tablet: 100 + (100-16)*(0.88-1) = 100 - 10.08 = round(89.92) = 90
     // mobile: 100 + (100-16)*(0.75-1) = 100 - 21 = 79
     expect(classes).toContain('max-[1024px]:text-[length:90px]');