@nuasite/cms 0.30.0 → 0.32.0

package/src/source-finder/snippet-utils.ts

@@ -16,7 +16,13 @@ import {
 } from './collection-finder'
 import { findAttributeSourceLocation, searchForExpressionProp, searchForPropInParents } from './cross-file-tracker'
 import { findImageElementNearLine, findImageSourceLocation } from './image-finder'
-import { initializeSearchIndex } from './search-index'
+import {
+	extractTranslationKeyFromSnippet,
+	findInTextIndex,
+	findTemplateElementUsingStringLiteral,
+	findTranslationByKeyAndText,
+	initializeSearchIndex,
+} from './search-index'
 import type { CachedParsedFile, ImageMatch, SourceLocation } from './types'
 
 // ============================================================================
@@ -287,7 +293,18 @@ export async function updateAttributeSources(
 				}
 			}
 
-			// Couldn't resolve - return without source info
+			// Prefer a template-level miss over falling back to the entry
+			// sourcePath, which may be an unrelated file (e.g. an i18n JSON).
+			if (sourceFilePath) {
+				const attrLine = findAttributeLineInSnippet(attrName, snippetLines, openingTagStartLine)
+				return [attrName, {
+					value,
+					sourcePath: sourceFilePath,
+					sourceLine: attrLine,
+					sourceSnippet: (attrLine && sourceLines) ? sourceLines[attrLine - 1] || '' : undefined,
+				}] as const
+			}
+
 			return [attrName, { value }] as const
 		}
 
@@ -466,6 +483,138 @@ export async function extractSourceSnippet(
 // Manifest Enhancement
 // ============================================================================
 
+/**
+ * Build the manifest entry produced when rendered text resolved to a
+ * translation-dictionary file (e.g. `src/i18n/cs.json`).
+ *
+ * Text edits target the JSON entry (`sourcePath`/`sourceLine`/`sourceSnippet`),
+ * while `attributes.*` and `colorClasses.*` keep pointing at the template's
+ * `<tag>` — those edits belong on the element, not the dictionary.
+ */
+async function applyTranslationSource(
+	entry: ManifestEntry,
+	indexHit: SourceLocation,
+	attributes: ManifestEntry['attributes'],
+	colorClasses: ManifestEntry['colorClasses'],
+): Promise<ManifestEntry> {
+	const hitSnippet = indexHit.snippet ?? ''
+	let resolvedAttributes = attributes
+	let resolvedColorClasses = colorClasses
+
+	// When the hit comes from a JSON dictionary, look up the template element
+	// that references the translation key so attr/class edits can target it.
+	const needsTemplateLookup = indexHit.file.endsWith('.json')
+		&& ((attributes && !hasAnySourcePath(attributes)) || (colorClasses && !hasAnySourcePath(colorClasses)))
+
+	if (needsTemplateLookup && entry.tag) {
+		const translationKey = extractTranslationKeyFromSnippet(hitSnippet)
+		if (translationKey) {
+			const templateLoc = await findTemplateElementUsingStringLiteral(translationKey, entry.tag)
+			if (templateLoc) {
+				const openingTagInfo = extractOpeningTagWithLine(templateLoc.lines, templateLoc.line - 1, entry.tag)
+				if (openingTagInfo) {
+					const openingStartLine = openingTagInfo.startLine + 1
+					if (attributes) {
+						resolvedAttributes = await updateAttributeSources(
+							openingTagInfo.snippet,
+							attributes,
+							templateLoc.file,
+							openingStartLine,
+							templateLoc.lines,
+						)
+					}
+					if (colorClasses) {
+						resolvedColorClasses = updateColorClassSources(
+							openingTagInfo.snippet,
+							colorClasses,
+							templateLoc.file,
+							openingStartLine,
+							templateLoc.lines,
+						)
+					}
+				}
+			}
+		}
+	}
+
+	return {
+		...entry,
+		sourcePath: indexHit.file,
+		sourceLine: indexHit.line,
+		sourceSnippet: hitSnippet,
+		variableName: indexHit.variableName,
+		allowStyling: false,
+		attributes: resolvedAttributes,
+		colorClasses: resolvedColorClasses,
+		sourceHash: generateSourceHash(hitSnippet || entry.text || ''),
+	}
+}
+
+/** True when any of the attribute/colorClass values already carries a sourcePath. */
+function hasAnySourcePath(bag: Record<string, { sourcePath?: string }>): boolean {
+	for (const key in bag) {
+		if (bag[key]?.sourcePath) return true
+	}
+	return false
+}
+
+/**
+ * Extract string literals from every `{…}` expression in an Astro snippet.
+ * Intended to recover translation keys from patterns like:
+ *   {t(locale, 'nav.prague4')}
+ *   {cs['nav.prague4']}
+ *   {dict.nav['prague4']}
+ *
+ * Nested braces inside template strings can fool the naive brace tracker but
+ * not in ways that matter here — we only care about literal string arguments.
+ */
+export function extractStringLiteralsFromExpressions(snippet: string): string[] {
+	const literals: string[] = []
+	let depth = 0
+	let exprStart = -1
+	for (let i = 0; i < snippet.length; i++) {
+		const ch = snippet[i]
+		if (ch === '{') {
+			if (depth === 0) exprStart = i + 1
+			depth++
+		} else if (ch === '}') {
+			depth--
+			if (depth === 0 && exprStart >= 0) {
+				const expr = snippet.slice(exprStart, i)
+				const pattern = /'((?:[^'\\]|\\.)+)'|"((?:[^"\\]|\\.)+)"|`((?:[^`\\$]|\\.)+)`/g
+				let m: RegExpExecArray | null
+				while ((m = pattern.exec(expr)) !== null) {
+					const s = m[1] ?? m[2] ?? m[3]
+					if (s) literals.push(s)
+				}
+				exprStart = -1
+			}
+		}
+	}
+	return literals
+}
+
+/**
+ * When the template expression references a literal translation key (e.g.
+ * `{t(locale, 'nav.prague4')}`), look the key up directly in the i18n index
+ * and return the JSON location. Falls back to value-based heuristics only via
+ * the caller's other branches — this path is only taken when the key match
+ * is unambiguous, which is the authoritative signal from the template.
+ */
+function resolveTranslationKeyFromSnippet(
+	snippet: string,
+	entryText: string,
+): SourceLocation | undefined {
+	const literals = extractStringLiteralsFromExpressions(snippet)
+	if (literals.length === 0) return undefined
+	const normalizedText = normalizeText(entryText)
+	for (const literal of literals) {
+		const hit = findTranslationByKeyAndText(literal, normalizedText)
+		if (hit) return hit
+	}
+	return undefined
+}
+
 /**
  * Enhance manifest entries with actual source snippets from source files.
  * This reads the source files and extracts the innerHTML at the specified locations.
@@ -674,6 +823,18 @@ export async function enhanceManifestWithSourceSnippets(
 			}
 		}
 
+		// Missing source info — try the text search index as a last resort.
+		// Templates that render text through helpers (e.g. `{t(locale, 'key')}`)
+		// don't get resolved to the originating i18n JSON in the marking phase,
+		// so the entry arrives here without a sourcePath/sourceLine.
+		if (!entry.sourceSnippet && entry.text?.trim() && entry.tag && (!entry.sourcePath || !entry.sourceLine)) {
+			const indexHit = findInTextIndex(entry.text.trim(), entry.tag)
+			if (indexHit) {
+				const resolved = await applyTranslationSource(entry, indexHit, entry.attributes, entry.colorClasses)
+				return [id, resolved] as const
+			}
+		}
+
 		// Skip if already has sourceSnippet or missing source info
 		if (entry.sourceSnippet || !entry.sourcePath || !entry.sourceLine || !entry.tag) {
 			return [id, entry] as const
@@ -828,6 +989,14 @@ export async function enhanceManifestWithSourceSnippets(
 						}
 					}
 
+					// An explicit `{t(locale, 'key')}`-style reference is a stronger
+					// signal than value-based collection/text-index matches below.
+					const i18nKeySource = resolveTranslationKeyFromSnippet(sourceSnippet, trimmedText)
+					if (i18nKeySource) {
+						const resolved = await applyTranslationSource(entry, i18nKeySource, attributes, colorClasses)
+						return [id, resolved] as const
+					}
+
 					// Search collection frontmatter — text rendered on listing pages
 					// from collection entries (e.g. {post.data.title}) won't be found
 					// through AST or prop lookups since the value lives in a .md file
@@ -844,6 +1013,14 @@ export async function enhanceManifestWithSourceSnippets(
 							] as const
 						}
 					}
+
+					// Last resort — consult the text index (covers i18n JSON dictionaries
+					// and any other indexed text that shares no tag with the rendered element).
+					const indexHit = findInTextIndex(trimmedText, entry.tag)
+					if (indexHit && indexHit.file !== entry.sourcePath) {
+						const resolved = await applyTranslationSource(entry, indexHit, attributes, colorClasses)
+						return [id, resolved] as const
+					}
 				}
 
 				// Original static content path

package/src/source-finder/types.ts

@@ -56,6 +56,9 @@ export interface SearchIndexEntry {
 	definitionLine?: number
 	normalizedText: string
 	tag: string
+	/** For i18n JSON entries: the dictionary key (e.g., `nav.prague4`). Enables
+	 *  direct lookups when a template expression references the key by literal. */
+	translationKey?: string
 }
 
 export interface ImageIndexEntry {

package/src/source-finder/variable-extraction.ts

@@ -2,7 +2,7 @@ import { parse as parseBabel } from '@babel/parser'
 import fs from 'node:fs/promises'
 import path from 'node:path'
 
-import { extractArrayElements, extractObjectProperties, getStringValue } from './ast-extractors'
+import { extractArrayElements, extractObjectProperties, extractPossibleStringValues, getStringValue } from './ast-extractors'
 import type { BabelFile, BabelNode, ImportInfo, VariableDefinition } from './types'
 import { createFrontmatterLineTransformer, identityLine } from './types'
 
@@ -37,6 +37,13 @@ export function extractVariableDefinitions(ast: BabelFile, frontmatterStartLine:
 					const stringValue = getStringValue(init)
 					if (stringValue !== null) {
 						definitions.push({ name: varName, value: stringValue, line })
+					} else if (init.type === 'ConditionalExpression' || init.type === 'LogicalExpression') {
+						// One definition per reachable branch — each carries its own
+						// literal's line so edits route to the matching branch.
+						const branches = extractPossibleStringValues(init, lineTransformer)
+						for (const branch of branches) {
+							definitions.push({ name: varName, value: branch.value, line: branch.line })
+						}
 					}
 
 					// Object expression - extract properties recursively