@setzkasten-cms/astro-admin 1.4.2 → 1.5.0

package/src/init/__tests__/page-list-coverage.test.ts

@@ -14,9 +14,9 @@
  *   6. Regression: real docs pages have no hardcoded <li> text after fix
  */
 
-import { describe, it, expect, beforeAll } from 'vitest'
 import { readFileSync } from 'node:fs'
 import { join, resolve } from 'node:path'
+import { beforeAll, describe, expect, it } from 'vitest'
 import { analyzeAstroSection } from '../astro-section-analyzer-v2'
 import { patchTemplateForFields } from '../template-patcher-v2'
 
@@ -30,7 +30,8 @@ const SECTIONS_DIR = resolve(import.meta.dirname!, '..', '..', '..', '..', '..',
 function findHardcodedListItems(source: string): RegExpMatchArray[] {
   // Match <span> that has direct text (no set:html, no {expr}), inside a <li>
   // We look for: <span> followed by a letter (not { or <), then text, then </span>
-  const pattern = /<li[\s\S]{0,300}?<span(?![^>]*set:html)(?![^>]*data-sk-field)[^>]*>([A-Za-zÄÖÜäöüß][^<{]*)<\/span>/g
+  const pattern =
+    /<li[\s\S]{0,300}?<span(?![^>]*set:html)(?![^>]*data-sk-field)[^>]*>([A-Za-zÄÖÜäöüß][^<{]*)<\/span>/g
   return [...source.matchAll(pattern)]
 }
 
@@ -58,15 +59,17 @@ describe('PageWithHardcodedList — analyzer detects list items', () => {
   })
 
   it('should detect the h2 headings as text fields', () => {
-    const keys = section.fields.map(f => f.key)
+    const keys = section.fields.map((f) => f.key)
     // The page has "Page Builder", "Section-Editor", "Collections" as <h2>
-    const hasHeadings = keys.some(k => k.includes('heading') || k.includes('pageBuild') || k.includes('section'))
+    const hasHeadings = keys.some(
+      (k) => k.includes('heading') || k.includes('pageBuild') || k.includes('section'),
+    )
     expect(hasHeadings, 'Should detect h2 headings').toBe(true)
   })
 
   it('should detect list item content as array fields', () => {
     // List items should appear either as array fields or individual text fields
-    const arrayFields = section.fields.filter(f => f.type === 'array')
+    const arrayFields = section.fields.filter((f) => f.type === 'array')
     const allFields = section.fields
 
     // Either the list items are grouped as arrays, or they appear as individual text fields
@@ -76,20 +79,19 @@ describe('PageWithHardcodedList — analyzer detects list items', () => {
   })
 
   it('should find list item default values', () => {
-    const allDefaultValues = section.fields
-      .flatMap(f => {
-        if (f.type === 'array' && Array.isArray(f.defaultValue)) return f.defaultValue as string[]
-        return typeof f.defaultValue === 'string' ? [f.defaultValue] : []
-      })
-
-    const hasListContent = allDefaultValues.some(v =>
-      typeof v === 'string' && (
-        v.includes('adoptieren') ||
-        v.includes('Textfelder') ||
-        v.includes('Eintraege')
-      ),
+    const allDefaultValues = section.fields.flatMap((f) => {
+      if (f.type === 'array' && Array.isArray(f.defaultValue)) return f.defaultValue as string[]
+      return typeof f.defaultValue === 'string' ? [f.defaultValue] : []
+    })
+
+    const hasListContent = allDefaultValues.some(
+      (v) =>
+        typeof v === 'string' &&
+        (v.includes('adoptieren') || v.includes('Textfelder') || v.includes('Eintraege')),
+    )
+    expect(hasListContent, 'List item text should appear in detected field default values').toBe(
+      true,
     )
-    expect(hasListContent, 'List item text should appear in detected field default values').toBe(true)
   })
 })
 
@@ -109,20 +111,16 @@ describe('PageWithHardcodedList — patcher eliminates hardcoded list items', ()
       { mode: 'page' },
     )
     const groups = (section as any)._analyzerResult?.repeatedGroups ?? []
-    patched = await patchTemplateForFields(
-      source,
-      '_page_docs_admin',
-      section.fields,
-      groups,
-      { mode: 'page' },
-    )
+    patched = await patchTemplateForFields(source, '_page_docs_admin', section.fields, groups, {
+      mode: 'page',
+    })
   })
 
   it('should not contain hardcoded <li> text after patching', () => {
     const hardcoded = findHardcodedListItems(patched)
     expect(
       hardcoded,
-      `Hardcoded list items found after patching:\n${hardcoded.map(m => `  "${m[1]}"`).join('\n')}`,
+      `Hardcoded list items found after patching:\n${hardcoded.map((m) => `  "${m[1]}"`).join('\n')}`,
     ).toHaveLength(0)
   })
 
@@ -160,21 +158,21 @@ describe('PagePartiallyAdoptedWithList — patcher fixes remaining static list',
       { mode: 'page' },
     )
     const groups = (section as any)._analyzerResult?.repeatedGroups ?? []
-    patched = await patchTemplateForFields(
-      source,
-      '_page_docs_partial',
-      section.fields,
-      groups,
-      { mode: 'page' },
-    )
+    patched = await patchTemplateForFields(source, '_page_docs_partial', section.fields, groups, {
+      mode: 'page',
+    })
   })
 
   it('should detect the static list as an array field', async () => {
     const source = readFileSync(join(SECTIONS_DIR, 'PagePartiallyAdoptedWithList.astro'), 'utf-8')
     const section = await analyzeAstroSection(
-      source, '_page_docs_partial', 'partialPage', 'src/pages/docs/partial.astro', { mode: 'page' },
+      source,
+      '_page_docs_partial',
+      'partialPage',
+      'src/pages/docs/partial.astro',
+      { mode: 'page' },
     )
-    const arrayFields = section.fields.filter(f => f.type === 'array')
+    const arrayFields = section.fields.filter((f) => f.type === 'array')
     expect(arrayFields.length, 'Should detect at least one array field').toBeGreaterThanOrEqual(1)
   })
 
@@ -182,7 +180,7 @@ describe('PagePartiallyAdoptedWithList — patcher fixes remaining static list',
     const hardcoded = findHardcodedListItems(patched)
     expect(
       hardcoded,
-      `Hardcoded list items remain after patching partially-adopted page:\n${hardcoded.map(m => `  "${m[1]}"`).join('\n')}`,
+      `Hardcoded list items remain after patching partially-adopted page:\n${hardcoded.map((m) => `  "${m[1]}"`).join('\n')}`,
     ).toHaveLength(0)
   })
 
@@ -207,7 +205,7 @@ describe('PageWithListItemsAdopted — already clean (regression baseline)', ()
     const hardcoded = findHardcodedListItems(source)
     expect(
       hardcoded,
-      `Adopted fixture should have no hardcoded list items, found:\n${hardcoded.map(m => `  "${m[1]}"`).join('\n')}`,
+      `Adopted fixture should have no hardcoded list items, found:\n${hardcoded.map((m) => `  "${m[1]}"`).join('\n')}`,
     ).toHaveLength(0)
   })
 
@@ -246,21 +244,21 @@ describe('PageWithFormattedList — analyzer detects formatting in list items',
   })
 
   it('should detect the list as an array field', () => {
-    const arrayFields = section.fields.filter(f => f.type === 'array')
+    const arrayFields = section.fields.filter((f) => f.type === 'array')
     expect(arrayFields.length).toBeGreaterThanOrEqual(1)
   })
 
   it('should set formatting: true on the array item type', () => {
-    const arrayField = section.fields.find(f => f.type === 'array')
+    const arrayField = section.fields.find((f) => f.type === 'array')
     expect(arrayField).toBeDefined()
     expect((arrayField?.options as any)?.arrayItem?.formatting).toBe(true)
   })
 
   it('should store innerHTML (with <strong>) as default values', () => {
-    const arrayField = section.fields.find(f => f.type === 'array')
+    const arrayField = section.fields.find((f) => f.type === 'array')
     const items = arrayField?.defaultValue as string[] | undefined
     expect(Array.isArray(items)).toBe(true)
-    const hasStrong = (items ?? []).some(v => typeof v === 'string' && v.includes('<strong'))
+    const hasStrong = (items ?? []).some((v) => typeof v === 'string' && v.includes('<strong'))
     expect(hasStrong, 'Default values should contain <strong> HTML').toBe(true)
   })
 })
@@ -278,13 +276,9 @@ describe('PageWithFormattedList — patcher replaces content span with set:html'
       { mode: 'page' },
     )
     const groups = (section as any)._analyzerResult?.repeatedGroups ?? []
-    patched = await patchTemplateForFields(
-      source,
-      '_page_formatted',
-      section.fields,
-      groups,
-      { mode: 'page' },
-    )
+    patched = await patchTemplateForFields(source, '_page_formatted', section.fields, groups, {
+      mode: 'page',
+    })
   })
 
   it('should inject set:html={item} on the content span', () => {
@@ -298,7 +292,10 @@ describe('PageWithFormattedList — patcher replaces content span with set:html'
     const withoutTemplateLiterals = patched.replace(/`[^`]*`/g, '""')
     const withoutExpressions = withoutTemplateLiterals.replace(/\{[^}]*\}/g, '{}')
     const strongInMarkup = withoutExpressions.match(/<strong[^>]*>[^<{]+<\/strong>/g) ?? []
-    expect(strongInMarkup, `Hardcoded <strong> in template: ${strongInMarkup.join(', ')}`).toHaveLength(0)
+    expect(
+      strongInMarkup,
+      `Hardcoded <strong> in template: ${strongInMarkup.join(', ')}`,
+    ).toHaveLength(0)
   })
 
   it('should add data-sk-field to list items', () => {
@@ -334,23 +331,26 @@ describe('PageWithCalloutDiv — callout div with inline link detected as descri
     // The callout div must get the next available key: description4.
     // Bug: descCount started at 0, so key was 'description' → collision → skipped.
     // Fix: descCount is initialized from the count of already-used description* keys.
-    const calloutField = section.fields.find(f => f.key === 'description4')
-    expect(calloutField, 'description4 field must be detected from callout div (not dropped due to key collision)').toBeDefined()
+    const calloutField = section.fields.find((f) => f.key === 'description4')
+    expect(
+      calloutField,
+      'description4 field must be detected from callout div (not dropped due to key collision)',
+    ).toBeDefined()
   })
 
   it('sets formatting: true on the callout field (contains inline <a>)', () => {
-    const calloutField = section.fields.find(f => f.key === 'description4')
+    const calloutField = section.fields.find((f) => f.key === 'description4')
     expect((calloutField?.options as any)?.formatting).toBe(true)
   })
 
   it('extracts the text content as defaultValue', () => {
-    const calloutField = section.fields.find(f => f.key === 'description4')
+    const calloutField = section.fields.find((f) => f.key === 'description4')
     expect(typeof calloutField?.defaultValue).toBe('string')
-    expect((calloutField?.defaultValue as string)).toMatch(/kommerzielle Lizenzen/)
+    expect(calloutField?.defaultValue as string).toMatch(/kommerzielle Lizenzen/)
   })
 
   it('still detects heading from data-sk-field (Section 0)', () => {
-    const headingField = section.fields.find(f => f.key === 'heading')
+    const headingField = section.fields.find((f) => f.key === 'heading')
     expect(headingField, 'heading must be detected via Section 0').toBeDefined()
     expect(headingField?.defaultValue).toBe('Lizenz')
   })
@@ -381,41 +381,41 @@ describe('PageWithAdoptedArrays — analyzer detects arrays from ?? [...] fallba
   })
 
   it('detects items as type array (not text)', () => {
-    const itemsField = section.fields.find(f => f.key === 'items')
+    const itemsField = section.fields.find((f) => f.key === 'items')
     expect(itemsField, 'items field must exist').toBeDefined()
     expect(itemsField?.type).toBe('array')
   })
 
   it('extracts fallback items as defaultValue', () => {
-    const itemsField = section.fields.find(f => f.key === 'items')
+    const itemsField = section.fields.find((f) => f.key === 'items')
     expect(Array.isArray(itemsField?.defaultValue)).toBe(true)
     expect(itemsField?.defaultValue).toEqual(['Eintrag A', 'Eintrag B', 'Eintrag C'])
   })
 
   it('sets no formatting on plain-text array items', () => {
-    const itemsField = section.fields.find(f => f.key === 'items')
+    const itemsField = section.fields.find((f) => f.key === 'items')
     expect((itemsField?.options as any)?.arrayItem?.formatting).toBeFalsy()
   })
 
   it('detects items2 as type array', () => {
-    const items2Field = section.fields.find(f => f.key === 'items2')
+    const items2Field = section.fields.find((f) => f.key === 'items2')
     expect(items2Field?.type).toBe('array')
   })
 
   it('sets formatting: true on items2 because items contain HTML', () => {
-    const items2Field = section.fields.find(f => f.key === 'items2')
+    const items2Field = section.fields.find((f) => f.key === 'items2')
     expect((items2Field?.options as any)?.arrayItem?.formatting).toBe(true)
   })
 
   it('extracts HTML items as defaultValue for items2', () => {
-    const items2Field = section.fields.find(f => f.key === 'items2')
+    const items2Field = section.fields.find((f) => f.key === 'items2')
     const items = items2Field?.defaultValue as string[] | undefined
     expect(Array.isArray(items)).toBe(true)
-    expect(items?.some(v => v.includes('<strong'))).toBe(true)
+    expect(items?.some((v) => v.includes('<strong'))).toBe(true)
   })
 
   it('detects heading with fallback value', () => {
-    const headingField = section.fields.find(f => f.key === 'heading')
+    const headingField = section.fields.find((f) => f.key === 'heading')
     expect(headingField?.type).toBe('text')
     expect(headingField?.defaultValue).toBe('Lizenz')
   })
@@ -445,30 +445,30 @@ describe('PageWithHtmlFallback — Section 0 sets formatting:true for HTML fallb
   })
 
   it('detects heading without formatting (plain text fallback)', () => {
-    const f = section.fields.find(field => field.key === 'heading')
+    const f = section.fields.find((field) => field.key === 'heading')
     expect(f, 'heading must be detected').toBeDefined()
     expect((f?.options as any)?.formatting).toBeFalsy()
   })
 
   it('detects description with formatting:true (set:html attr with <code> in fallback)', () => {
-    const f = section.fields.find(field => field.key === 'description')
+    const f = section.fields.find((field) => field.key === 'description')
     expect(f, 'description must be detected').toBeDefined()
     expect((f?.options as any)?.formatting).toBe(true)
   })
 
   it('description defaultValue contains the HTML with <code>', () => {
-    const f = section.fields.find(field => field.key === 'description')
-    expect((f?.defaultValue as string)).toMatch(/<code>/)
+    const f = section.fields.find((field) => field.key === 'description')
+    expect(f?.defaultValue as string).toMatch(/<code>/)
   })
 
   it('detects note with formatting:true (expression fallback with <strong>)', () => {
-    const f = section.fields.find(field => field.key === 'note')
+    const f = section.fields.find((field) => field.key === 'note')
     expect(f, 'note must be detected').toBeDefined()
     expect((f?.options as any)?.formatting).toBe(true)
   })
 
   it('note defaultValue contains the HTML with <strong>', () => {
-    const f = section.fields.find(field => field.key === 'note')
-    expect((f?.defaultValue as string)).toMatch(/<strong>/)
+    const f = section.fields.find((field) => field.key === 'note')
+    expect(f?.defaultValue as string).toMatch(/<strong>/)
   })
 })

package/src/init/__tests__/patcher-child-component.test.ts

@@ -0,0 +1,126 @@
+/**
+ * Tests for patchChildComponentForFieldPrefix:
+ * Injects fieldPrefix prop + data-sk-field bindings into child components
+ * used by repeated-component sections (e.g. PricingCard).
+ */
+
+import { readFileSync } from 'fs'
+import { join } from 'path'
+import { describe, expect, it } from 'vitest'
+import { detectChildImports, patchChildComponentForFieldPrefix } from '../template-patcher-v2'
+
+const CHILD_DIR = join(
+  import.meta.dirname!,
+  '..',
+  '..',
+  '..',
+  '..',
+  '..',
+  'test-sections',
+  'child-components',
+)
+
+function readFixture(name: string): string {
+  return readFileSync(join(CHILD_DIR, name), 'utf-8')
+}
+
+// ---------------------------------------------------------------------------
+// Inner fields for PricingCard (mirrors what the analyzer produces)
+// ---------------------------------------------------------------------------
+const PRICING_INNER_FIELDS = [
+  { key: 'name', type: 'text' },
+  { key: 'price', type: 'text' },
+  { key: 'priceNote', type: 'text' },
+  { key: 'description', type: 'text' },
+  { key: 'features', type: 'array' },
+  { key: 'cta', type: 'text' },
+  { key: 'ctaHref', type: 'text' },
+]
+
+describe('patchChildComponentForFieldPrefix', () => {
+  it('adds fieldPrefix to Props interface', () => {
+    const source = readFixture('PricingCard.astro')
+    const patched = patchChildComponentForFieldPrefix(source, PRICING_INNER_FIELDS)
+    expect(patched).toContain('fieldPrefix?: string')
+  })
+
+  it('adds fieldPrefix to destructuring', () => {
+    const source = readFixture('PricingCard.astro')
+    const patched = patchChildComponentForFieldPrefix(source, PRICING_INNER_FIELDS)
+    expect(patched).toMatch(/fieldPrefix\s*[,}]/)
+  })
+
+  it('adds data-sk-field for scalar text props', () => {
+    const source = readFixture('PricingCard.astro')
+    const patched = patchChildComponentForFieldPrefix(source, PRICING_INNER_FIELDS)
+    expect(patched).toContain('fieldPrefix}.name')
+    expect(patched).toContain('fieldPrefix}.price')
+    expect(patched).toContain('fieldPrefix}.description')
+  })
+
+  it('adds data-sk-field for href prop on <a>', () => {
+    const source = readFixture('PricingCard.astro')
+    const patched = patchChildComponentForFieldPrefix(source, PRICING_INNER_FIELDS)
+    expect(patched).toContain('fieldPrefix}.ctaHref')
+    expect(patched).toContain('fieldPrefix}.cta')
+  })
+
+  it('adds indexed data-sk-field for array prop features', () => {
+    const source = readFixture('PricingCard.astro')
+    const patched = patchChildComponentForFieldPrefix(source, PRICING_INNER_FIELDS)
+    expect(patched).toMatch(/fieldPrefix\}\.features\._fi|fieldPrefix\}\.features\.\$\{_fi\}/)
+  })
+
+  it('is idempotent — second pass produces no changes', () => {
+    const source = readFixture('PricingCard.astro')
+    const patched = patchChildComponentForFieldPrefix(source, PRICING_INNER_FIELDS)
+    const patchedAgain = patchChildComponentForFieldPrefix(patched, PRICING_INNER_FIELDS)
+    expect(patchedAgain).toBe(patched)
+  })
+
+  it('does not modify source when fieldPrefix already present', () => {
+    const source = readFixture('PricingCard.astro')
+    const prePatched = source.replace(
+      'highlight?: boolean;',
+      'highlight?: boolean;\n  fieldPrefix?: string;',
+    )
+    const result = patchChildComponentForFieldPrefix(prePatched, PRICING_INNER_FIELDS)
+    expect(result).toContain('fieldPrefix?: string')
+    expect((result.match(/fieldPrefix\?\s*:\s*string/g) ?? []).length).toBe(1)
+  })
+})
+
+describe('detectChildImports', () => {
+  it('detects component imports from fields with sourceComponent', () => {
+    const sectionSource = `---
+import PricingCard from '../components/PricingCard.astro'
+interface Props { data: Record<string, any> | null }
+const { data: skData } = Astro.props
+---
+<section></section>`
+
+    const fields = [
+      {
+        key: 'pricingcards',
+        type: 'array',
+        defaultValue: [],
+        options: {
+          sourceComponent: 'PricingCard',
+          arrayItem: { type: 'object', fields: PRICING_INNER_FIELDS },
+        },
+      },
+    ]
+
+    const imports = detectChildImports(sectionSource, fields as any)
+    expect(imports).toHaveLength(1)
+    expect(imports[0]!.compName).toBe('PricingCard')
+    expect(imports[0]!.importPath).toBe('../components/PricingCard.astro')
+    expect(imports[0]!.innerFields).toEqual(PRICING_INNER_FIELDS)
+  })
+
+  it('returns empty array when no sourceComponent fields', () => {
+    const source = `---\nconst x = 1\n---\n<div></div>`
+    const fields = [{ key: 'heading', type: 'text' }]
+    expect(detectChildImports(source, fields as any)).toHaveLength(0)
+  })
+})

package/src/init/__tests__/patcher-edge-cases.test.ts

@@ -24,8 +24,12 @@
  *      still inject the getSection() call without throwing.
  */
 
-import { describe, it, expect } from 'vitest'
-import { patchTemplateForFields, stripTemplateFallbacks, convertToSetHtml } from '../../init/template-patcher-v2'
+import { describe, expect, it } from 'vitest'
+import {
+  convertToSetHtml,
+  patchTemplateForFields,
+  stripTemplateFallbacks,
+} from '../../init/template-patcher-v2'
 import type { PatchField } from '../../init/template-patcher-v2'
 
 // ---------------------------------------------------------------------------
@@ -89,22 +93,30 @@ import BaseLayout from '../layouts/BaseLayout.astro';
   ]
 
   it('should produce valid output containing skData references', async () => {
-    const patched = await patchTemplateForFields(source, '_page_about', fields, [], { mode: 'page' })
+    const patched = await patchTemplateForFields(source, '_page_about', fields, [], {
+      mode: 'page',
+    })
     expect(patched).toContain('skData')
   })
 
   it('should bind the heading field containing an umlaut', async () => {
-    const patched = await patchTemplateForFields(source, '_page_about', fields, [], { mode: 'page' })
+    const patched = await patchTemplateForFields(source, '_page_about', fields, [], {
+      mode: 'page',
+    })
     expect(patched).toContain('skData?.heading')
   })
 
   it('should bind the body field containing umlauts', async () => {
-    const patched = await patchTemplateForFields(source, '_page_about', fields, [], { mode: 'page' })
+    const patched = await patchTemplateForFields(source, '_page_about', fields, [], {
+      mode: 'page',
+    })
     expect(patched).toContain('skData?.body')
   })
 
   it('should not corrupt the surrounding markup', async () => {
-    const patched = await patchTemplateForFields(source, '_page_about', fields, [], { mode: 'page' })
+    const patched = await patchTemplateForFields(source, '_page_about', fields, [], {
+      mode: 'page',
+    })
     // The <section> tag must still be intact
     expect(patched).toMatch(/<section[^>]*>/)
     // Closing tags must still be present
@@ -113,7 +125,9 @@ import BaseLayout from '../layouts/BaseLayout.astro';
   })
 
   it('should add data-sk-field to the heading element', async () => {
-    const patched = await patchTemplateForFields(source, '_page_about', fields, [], { mode: 'page' })
+    const patched = await patchTemplateForFields(source, '_page_about', fields, [], {
+      mode: 'page',
+    })
     expect(patched).toMatch(/<h1[^>]*data-sk-field/)
   })
 })
@@ -151,25 +165,33 @@ const skData = getSection('_page_about')
   ]
 
   it('should not duplicate the getSection import', async () => {
-    const patched = await patchTemplateForFields(alreadyPatched, '_page_about', fields, [], { mode: 'page' })
+    const patched = await patchTemplateForFields(alreadyPatched, '_page_about', fields, [], {
+      mode: 'page',
+    })
     const importCount = (patched.match(/import \{ getSection \}/g) ?? []).length
     expect(importCount).toBe(1)
   })
 
   it('should not duplicate the skData declaration', async () => {
-    const patched = await patchTemplateForFields(alreadyPatched, '_page_about', fields, [], { mode: 'page' })
+    const patched = await patchTemplateForFields(alreadyPatched, '_page_about', fields, [], {
+      mode: 'page',
+    })
     const declCount = (patched.match(/const skData\s*=/g) ?? []).length
     expect(declCount).toBe(1)
   })
 
   it('should preserve existing data-sk-field attributes', async () => {
-    const patched = await patchTemplateForFields(alreadyPatched, '_page_about', fields, [], { mode: 'page' })
+    const patched = await patchTemplateForFields(alreadyPatched, '_page_about', fields, [], {
+      mode: 'page',
+    })
     expect(patched).toContain('data-sk-field="_page_about.heading"')
     expect(patched).toContain('data-sk-field="_page_about.body"')
   })
 
   it('should not add a second section id', async () => {
-    const patched = await patchTemplateForFields(alreadyPatched, '_page_about', fields, [], { mode: 'page' })
+    const patched = await patchTemplateForFields(alreadyPatched, '_page_about', fields, [], {
+      mode: 'page',
+    })
     const idCount = (patched.match(/id="section-_page_about"/g) ?? []).length
     expect(idCount).toBe(1)
   })
@@ -198,13 +220,11 @@ import BaseLayout from '../layouts/BaseLayout.astro';
   // Convert all LF to CRLF
   const crlf = lf.replace(/\n/g, '\r\n')
 
-  const fields: PatchField[] = [
-    { key: 'heading', type: 'text', defaultValue: 'Hello World' },
-  ]
+  const fields: PatchField[] = [{ key: 'heading', type: 'text', defaultValue: 'Hello World' }]
 
   it('should not throw on CRLF input', async () => {
     await expect(
-      patchTemplateForFields(crlf, '_page_test', fields, [], { mode: 'page' })
+      patchTemplateForFields(crlf, '_page_test', fields, [], { mode: 'page' }),
     ).resolves.toBeDefined()
   })
 
@@ -240,13 +260,11 @@ import BaseLayout from '../layouts/BaseLayout.astro';---
 </BaseLayout>
 `
 
-  const fields: PatchField[] = [
-    { key: 'heading', type: 'text', defaultValue: 'Tight Frontmatter' },
-  ]
+  const fields: PatchField[] = [{ key: 'heading', type: 'text', defaultValue: 'Tight Frontmatter' }]
 
   it('should not throw', async () => {
     await expect(
-      patchTemplateForFields(source, '_page_test', fields, [], { mode: 'page' })
+      patchTemplateForFields(source, '_page_test', fields, [], { mode: 'page' }),
     ).resolves.toBeDefined()
   })
 
@@ -285,7 +303,7 @@ import BaseLayout from '../layouts/BaseLayout.astro';
 
   it('should not throw', async () => {
     await expect(
-      patchTemplateForFields(source, '_page_test', fields, [], { mode: 'page' })
+      patchTemplateForFields(source, '_page_test', fields, [], { mode: 'page' }),
     ).resolves.toBeDefined()
   })
 
@@ -342,7 +360,7 @@ describe('stripTemplateFallbacks', () => {
   })
 
   it('strips array fallback with backtick HTML items', () => {
-    const source = "{(skData?.items ?? [`<strong>Label</strong> &mdash; Text.`]).map(("
+    const source = '{(skData?.items ?? [`<strong>Label</strong> &mdash; Text.`]).map(('
     const { source: result, fallbacks } = stripTemplateFallbacks(source)
     expect(result).toBe(`{(skData?.items ?? []).map((`)
     expect((fallbacks['items'] as string[])?.[0]).toContain('<strong>')
@@ -424,7 +442,12 @@ describe('HTML fallback wins over plain-text default in sectionData merge', () =
       const existing = result[key]
       const existingIsPlain = typeof existing === 'string' && !/<[a-z]/.test(existing)
       const newIsHtml = typeof value === 'string' && /<[a-z]/.test(value as string)
-      if (!(key in result) || existing === '' || existing === null || (existingIsPlain && newIsHtml)) {
+      if (
+        !(key in result) ||
+        existing === '' ||
+        existing === null ||
+        (existingIsPlain && newIsHtml)
+      ) {
         result[key] = value
       }
     }
@@ -436,7 +459,8 @@ describe('HTML fallback wins over plain-text default in sectionData merge', () =
       callout: 'Für kommerzielle Lizenzen: hello@example.com — text.',
     }
     const fallbacks = {
-      callout: 'Für kommerzielle Lizenzen: <a href="mailto:hello@example.com">hello@example.com</a> — text.',
+      callout:
+        'Für kommerzielle Lizenzen: <a href="mailto:hello@example.com">hello@example.com</a> — text.',
     }
     const result = mergeFallbacks(sectionData, fallbacks)
     expect(result['callout']).toMatch(/href="mailto:/)