@nuasite/cms-marker 0.0.82 → 0.0.83

package/src/index.ts

@@ -128,46 +128,33 @@ export type { CollectionInfo, MarkdownContent, SourceLocation, VariableReference
 // Re-export types for consumers
 export { findCollectionSource, parseMarkdownContent } from './source-finder'
 export type {
-	AriaAttributes,
+	Attribute,
 	AvailableColors,
 	AvailableTextStyles,
-	ButtonAttributes,
 	CanonicalUrl,
 	CmsManifest,
 	CmsMarkerOptions,
 	CollectionDefinition,
 	CollectionEntry,
-	ColorClasses,
 	ComponentDefinition,
 	ComponentInstance,
 	ComponentProp,
 	ContentConstraints,
-	DataAttributes,
 	FieldDefinition,
 	FieldType,
-	FormAttributes,
-	GradientClasses,
-	IframeAttributes,
 	ImageMetadata,
-	InputAttributes,
 	JsonLdEntry,
-	LinkAttributes,
 	ManifestEntry,
 	ManifestMetadata,
-	MediaAttributes,
-	OpacityClasses,
 	OpenGraphData,
 	PageEntry,
 	PageSeoData,
-	SelectAttributes,
 	SeoKeywords,
 	SeoMetaTag,
 	SeoOptions,
 	SeoSourceInfo,
 	SeoTitle,
-	SourceContext,
 	TailwindColor,
-	TextareaAttributes,
 	TextStyleValue,
 	TwitterCardData,
 } from './types'

package/src/source-finder/ast-extractors.ts

@@ -25,6 +25,16 @@ export function getStringValue(node: BabelNode): string | null {
 // Object and Array Extraction
 // ============================================================================
 
+/**
+ * Extract property name from an object key node.
+ * Handles both `{ name: value }` (Identifier) and `{ "name": value }` (StringLiteral).
+ */
+function getKeyName(key: BabelNode): string | null {
+	if (key.type === 'Identifier') return key.name as string
+	if (key.type === 'StringLiteral') return key.value as string
+	return null
+}
+
 /**
  * Recursively extract properties from an object expression
  * @param objNode - The ObjectExpression node
@@ -43,9 +53,9 @@ export function extractObjectProperties(
 		if (prop.type !== 'ObjectProperty') continue
 		const key = prop.key as BabelNode | undefined
 		const value = prop.value as BabelNode | undefined
-		if (!key || key.type !== 'Identifier' || !value) continue
-
-		const propName = key.name as string
+		if (!key || !value) continue
+		const propName = getKeyName(key)
+		if (!propName) continue
 		const fullPath = `${parentPath}.${propName}`
 		const propLoc = prop.loc as { start: { line: number } } | undefined
 		const propLine = lineTransformer(propLoc?.start.line ?? 1)
@@ -107,16 +117,16 @@ export function extractArrayElements(
 			})
 		}
 
-		// Handle array of objects: [{ text: 'Home' }]
+		// Handle array of objects: [{ text: 'Home' }] or [{ "text": 'Home' }]
 		if (elem.type === 'ObjectExpression') {
 			const objProperties = elem.properties as BabelNode[] | undefined
 			for (const prop of objProperties ?? []) {
 				if (prop.type !== 'ObjectProperty') continue
 				const key = prop.key as BabelNode | undefined
 				const value = prop.value as BabelNode | undefined
-				if (!key || key.type !== 'Identifier' || !value) continue
-
-				const propName = key.name as string
+				if (!key || !value) continue
+				const propName = getKeyName(key)
+				if (!propName) continue
 				const propLoc = prop.loc as { start: { line: number } } | undefined
 				const propLine = propLoc ? lineTransformer(propLoc.start.line) : elemLine
 

package/src/source-finder/cross-file-tracker.ts

@@ -2,11 +2,11 @@ import fs from 'node:fs/promises'
 import path from 'node:path'
 
 import { getProjectRoot } from '../config'
-import { buildDefinitionPath } from './ast-extractors'
+import { buildDefinitionPath, parseExpressionPath } from './ast-extractors'
 import { getCachedParsedFile } from './ast-parser'
 import { findComponentProp, findExpressionProp, findSpreadProp } from './element-finder'
 import { normalizeText } from './snippet-utils'
-import type { ImportInfo, SourceLocation } from './types'
+import type { ImportInfo, SourceLocation, VariableDefinition } from './types'
 import { getExportedDefinitions, resolveImportPath } from './variable-extraction'
 
 // ============================================================================
@@ -335,3 +335,406 @@ export async function searchForPropInParents(dir: string, textContent: string):
 
 	return undefined
 }
+
+// ============================================================================
+// Attribute Source Location Finding
+// ============================================================================
+
+/**
+ * Find the actual source location for a dynamic attribute value.
+ * Uses the resolved VALUE to search for where it's defined (handles loop variables, etc.)
+ *
+ * @param expression - The source expression (e.g., "component.githubUrl")
+ * @param resolvedValue - The actual resolved value from the rendered HTML
+ * @param sourceFilePath - The source file path where the attribute is used (relative to project root)
+ * @returns Source location with file, line, and snippet for the actual value definition
+ */
+export async function findAttributeSourceLocation(
+	expression: string,
+	resolvedValue: string,
+	sourceFilePath: string,
+): Promise<SourceLocation | undefined> {
+	// Parse the expression to get property name (e.g., "githubUrl" from "component.githubUrl")
+	const exprPath = parseExpressionPath(expression)
+	if (!exprPath) return undefined
+
+	// Get the property name (last part of the expression)
+	const propName = exprPath.includes('.') ? exprPath.split('.').pop()! : exprPath
+
+	const filePath = path.isAbsolute(sourceFilePath)
+		? sourceFilePath
+		: path.join(getProjectRoot(), sourceFilePath)
+
+	const cached = await getCachedParsedFile(filePath)
+	if (!cached) return undefined
+
+	// 1. Search local variable definitions by VALUE (handles loop variables)
+	// Look for definitions where: the property name matches AND the value matches
+	for (const def of cached.variableDefinitions) {
+		if (def.name === propName && def.value === resolvedValue) {
+			return {
+				file: path.relative(getProjectRoot(), filePath),
+				line: def.line,
+				snippet: cached.lines[def.line - 1] || '',
+				type: 'variable',
+				variableName: buildDefinitionPath(def),
+				definitionLine: def.line,
+			}
+		}
+	}
+
+	// 2. Search by exact expression path match
+	const baseVar = exprPath.match(/^(\w+)/)?.[1]
+	if (baseVar) {
+		for (const def of cached.variableDefinitions) {
+			const defPath = buildDefinitionPath(def)
+			if (defPath === exprPath && def.value === resolvedValue) {
+				return {
+					file: path.relative(getProjectRoot(), filePath),
+					line: def.line,
+					snippet: cached.lines[def.line - 1] || '',
+					type: 'variable',
+					variableName: defPath,
+					definitionLine: def.line,
+				}
+			}
+		}
+
+		// 3. Check if the base variable comes from props
+		const actualPropName = cached.propAliases.get(baseVar)
+		if (actualPropName) {
+			const componentFileName = path.basename(filePath)
+			const result = await searchForExpressionPropAttributeByValue(
+				componentFileName,
+				propName,
+				resolvedValue,
+			)
+			if (result) return result
+		}
+
+		// 4. Check if the base variable comes from an import
+		const importInfo = cached.imports.find((imp) => imp.localName === baseVar)
+		if (importInfo) {
+			const result = await searchForImportedAttributeByValue(
+				filePath,
+				importInfo,
+				propName,
+				resolvedValue,
+			)
+			if (result) return result
+		}
+	}
+
+	// 5. Fallback: search all variable definitions by value only
+	for (const def of cached.variableDefinitions) {
+		if (def.value === resolvedValue) {
+			return {
+				file: path.relative(getProjectRoot(), filePath),
+				line: def.line,
+				snippet: cached.lines[def.line - 1] || '',
+				type: 'variable',
+				variableName: buildDefinitionPath(def),
+				definitionLine: def.line,
+			}
+		}
+	}
+
+	return undefined
+}
+
+/**
+ * Search for attribute value in parent components by matching the resolved value.
+ */
+async function searchForExpressionPropAttributeByValue(
+	componentFileName: string,
+	propName: string,
+	resolvedValue: string,
+	depth: number = 0,
+): Promise<SourceLocation | undefined> {
+	if (depth > 5) return undefined
+
+	const srcDir = path.join(getProjectRoot(), 'src')
+	const searchDirs = [
+		path.join(srcDir, 'pages'),
+		path.join(srcDir, 'components'),
+		path.join(srcDir, 'layouts'),
+	]
+
+	for (const dir of searchDirs) {
+		try {
+			const result = await searchDirForAttributeByValue(dir, propName, resolvedValue, depth)
+			if (result) return result
+		} catch {
+			// Directory doesn't exist
+		}
+	}
+
+	return undefined
+}
+
+async function searchDirForAttributeByValue(
+	dir: string,
+	propName: string,
+	resolvedValue: string,
+	depth: number,
+): Promise<SourceLocation | undefined> {
+	try {
+		const entries = await fs.readdir(dir, { withFileTypes: true })
+
+		for (const entry of entries) {
+			const fullPath = path.join(dir, entry.name)
+
+			if (entry.isDirectory()) {
+				const result = await searchDirForAttributeByValue(fullPath, propName, resolvedValue, depth)
+				if (result) return result
+			} else if (entry.isFile() && entry.name.endsWith('.astro')) {
+				const cached = await getCachedParsedFile(fullPath)
+				if (!cached) continue
+
+				// Search for variable definitions matching propName and value
+				for (const def of cached.variableDefinitions) {
+					if (def.name === propName && def.value === resolvedValue) {
+						return {
+							file: path.relative(getProjectRoot(), fullPath),
+							line: def.line,
+							snippet: cached.lines[def.line - 1] || '',
+							type: 'variable',
+							variableName: buildDefinitionPath(def),
+							definitionLine: def.line,
+						}
+					}
+				}
+			}
+		}
+	} catch {
+		// Error reading directory
+	}
+
+	return undefined
+}
+
+/**
+ * Search for attribute value in imported files by matching the resolved value.
+ */
+async function searchForImportedAttributeByValue(
+	fromFile: string,
+	importInfo: ImportInfo,
+	propName: string,
+	resolvedValue: string,
+): Promise<SourceLocation | undefined> {
+	const importedFilePath = await resolveImportPath(importInfo.source, fromFile)
+	if (!importedFilePath) return undefined
+
+	const exportedDefs = await getExportedDefinitions(importedFilePath)
+	if (exportedDefs.length === 0) return undefined
+
+	// Search for definitions matching propName and value
+	for (const def of exportedDefs) {
+		if (def.name === propName && def.value === resolvedValue) {
+			const importedFileContent = await fs.readFile(importedFilePath, 'utf-8')
+			const importedLines = importedFileContent.split('\n')
+
+			return {
+				file: path.relative(getProjectRoot(), importedFilePath),
+				line: def.line,
+				snippet: importedLines[def.line - 1] || '',
+				type: 'variable',
+				variableName: buildDefinitionPath(def),
+				definitionLine: def.line,
+			}
+		}
+	}
+
+	// Also try matching by value only as fallback
+	for (const def of exportedDefs) {
+		if (def.value === resolvedValue) {
+			const importedFileContent = await fs.readFile(importedFilePath, 'utf-8')
+			const importedLines = importedFileContent.split('\n')
+
+			return {
+				file: path.relative(getProjectRoot(), importedFilePath),
+				line: def.line,
+				snippet: importedLines[def.line - 1] || '',
+				type: 'variable',
+				variableName: buildDefinitionPath(def),
+				definitionLine: def.line,
+			}
+		}
+	}
+
+	return undefined
+}
+
+/**
+ * Search for attribute value in parent components via expression props.
+ * @deprecated Use searchForExpressionPropAttributeByValue instead
+ */
+async function searchForExpressionPropAttribute(
+	componentFileName: string,
+	propName: string,
+	expressionPath: string,
+	depth: number = 0,
+): Promise<SourceLocation | undefined> {
+	if (depth > 5) return undefined
+
+	const srcDir = path.join(getProjectRoot(), 'src')
+	const searchDirs = [
+		path.join(srcDir, 'pages'),
+		path.join(srcDir, 'components'),
+		path.join(srcDir, 'layouts'),
+	]
+
+	const componentName = path.basename(componentFileName, '.astro')
+
+	for (const dir of searchDirs) {
+		try {
+			const result = await searchDirForAttributeProp(
+				dir,
+				componentName,
+				propName,
+				expressionPath,
+				depth,
+			)
+			if (result) return result
+		} catch {
+			// Directory doesn't exist
+		}
+	}
+
+	return undefined
+}
+
+async function searchDirForAttributeProp(
+	dir: string,
+	componentName: string,
+	propName: string,
+	expressionPath: string,
+	depth: number,
+): Promise<SourceLocation | undefined> {
+	try {
+		const entries = await fs.readdir(dir, { withFileTypes: true })
+
+		for (const entry of entries) {
+			const fullPath = path.join(dir, entry.name)
+
+			if (entry.isDirectory()) {
+				const result = await searchDirForAttributeProp(
+					fullPath,
+					componentName,
+					propName,
+					expressionPath,
+					depth,
+				)
+				if (result) return result
+			} else if (entry.isFile() && entry.name.endsWith('.astro')) {
+				const cached = await getCachedParsedFile(fullPath)
+				if (!cached) continue
+
+				// Find expression prop usage: <Component prop={variable} />
+				const exprPropMatch = findExpressionProp(cached.ast, componentName, propName)
+
+				if (exprPropMatch) {
+					const exprText = exprPropMatch.expressionText
+					// Build the path in the parent's context
+					const parentPath = expressionPath.replace(/^[^.[]+/, exprText)
+
+					// Check local variable definitions
+					for (const def of cached.variableDefinitions) {
+						const defPath = buildDefinitionPath(def)
+						if (defPath === parentPath) {
+							return {
+								file: path.relative(getProjectRoot(), fullPath),
+								line: def.line,
+								snippet: cached.lines[def.line - 1] || '',
+								type: 'variable',
+								variableName: defPath,
+								definitionLine: def.line,
+							}
+						}
+					}
+
+					// Check if exprText is from props (multi-level drilling)
+					const baseVar = exprText.match(/^(\w+)/)?.[1]
+					if (baseVar && cached.propAliases.has(baseVar)) {
+						const actualPropName = cached.propAliases.get(baseVar)!
+						const result = await searchForExpressionPropAttribute(
+							entry.name,
+							actualPropName,
+							parentPath,
+							depth + 1,
+						)
+						if (result) return result
+					}
+				}
+
+				// Try spread prop usage
+				const spreadMatch = findSpreadProp(cached.ast, componentName)
+				if (spreadMatch) {
+					const spreadPropPath = `${spreadMatch.spreadVarName}.${propName}`
+					for (const def of cached.variableDefinitions) {
+						const defPath = buildDefinitionPath(def)
+						if (defPath === spreadPropPath) {
+							return {
+								file: path.relative(getProjectRoot(), fullPath),
+								line: def.line,
+								snippet: cached.lines[def.line - 1] || '',
+								type: 'variable',
+								variableName: defPath,
+								definitionLine: def.line,
+							}
+						}
+					}
+				}
+			}
+		}
+	} catch {
+		// Error reading directory
+	}
+
+	return undefined
+}
+
+/**
+ * Search for attribute value in an imported file.
+ */
+async function searchForImportedAttribute(
+	fromFile: string,
+	importInfo: ImportInfo,
+	expressionPath: string,
+): Promise<SourceLocation | undefined> {
+	const importedFilePath = await resolveImportPath(importInfo.source, fromFile)
+	if (!importedFilePath) return undefined
+
+	const exportedDefs = await getExportedDefinitions(importedFilePath)
+	if (exportedDefs.length === 0) return undefined
+
+	// Build the target path in the imported file
+	let targetPath: string
+	if (importInfo.importedName === 'default' || importInfo.importedName === importInfo.localName) {
+		targetPath = expressionPath
+	} else {
+		targetPath = expressionPath.replace(
+			new RegExp(`^${importInfo.localName}`),
+			importInfo.importedName,
+		)
+	}
+
+	for (const def of exportedDefs) {
+		const defPath = buildDefinitionPath(def)
+		if (defPath === targetPath) {
+			const importedFileContent = await fs.readFile(importedFilePath, 'utf-8')
+			const importedLines = importedFileContent.split('\n')
+
+			return {
+				file: path.relative(getProjectRoot(), importedFilePath),
+				line: def.line,
+				snippet: importedLines[def.line - 1] || '',
+				type: 'variable',
+				variableName: defPath,
+				definitionLine: def.line,
+			}
+		}
+	}
+
+	return undefined
+}

package/src/source-finder/index.ts

@@ -16,6 +16,9 @@ export { initializeSearchIndex } from './search-index'
 // Source location finding
 export { findSourceLocation } from './source-lookup'
 
+// Attribute source finding
+export { findAttributeSourceLocation } from './cross-file-tracker'
+
 // Image finding
 export { findImageSourceLocation } from './image-finder'
 
@@ -23,4 +26,12 @@ export { findImageSourceLocation } from './image-finder'
 export { findCollectionSource, findMarkdownSourceLocation, parseMarkdownContent } from './collection-finder'
 
 // Snippet utilities (used by html-processor)
-export { enhanceManifestWithSourceSnippets, extractCompleteTagSnippet, extractInnerHtmlFromSnippet, extractSourceSnippet } from './snippet-utils'
+export {
+	enhanceManifestWithSourceSnippets,
+	extractCompleteTagSnippet,
+	extractInnerHtmlFromSnippet,
+	extractOpeningTagWithLine,
+	extractSourceSnippet,
+	updateAttributeSources,
+	updateColorClassSources,
+} from './snippet-utils'

package/src/source-finder/search-index.ts

@@ -193,6 +193,53 @@ function extractCompleteTagSnippet(lines: string[], startLine: number, tag: stri
 	return snippetLines.join('\n')
 }
 
+/**
+ * Extract the opening tag from source lines with its start line number.
+ * Local version for indexing (to avoid circular dependency)
+ */
+function extractOpeningTagWithLine(
+	lines: string[],
+	startLine: number,
+	tag: string,
+): { snippet: string; startLine: number } | undefined {
+	const openTagPattern = new RegExp(`<${tag}(?:[\\s>]|$)`, 'gi')
+
+	let actualStartLine = startLine
+	const startLineContent = lines[startLine] || ''
+	if (!openTagPattern.test(startLineContent)) {
+		for (let i = startLine - 1; i >= Math.max(0, startLine - 20); i--) {
+			const line = lines[i]
+			if (!line) continue
+			openTagPattern.lastIndex = 0
+			if (openTagPattern.test(line)) {
+				actualStartLine = i
+				break
+			}
+		}
+	}
+
+	const snippetLines: string[] = []
+	for (let i = actualStartLine; i < Math.min(actualStartLine + 10, lines.length); i++) {
+		const line = lines[i]
+		if (!line) continue
+
+		snippetLines.push(line)
+		const combined = snippetLines.join('\n')
+
+		const openTagMatch = combined.match(new RegExp(`<${tag}[^>]*>`, 'i'))
+		if (openTagMatch) {
+			return { snippet: openTagMatch[0], startLine: actualStartLine }
+		}
+
+		const selfClosingMatch = combined.match(new RegExp(`<${tag}[^>]*/\\s*>`, 'i'))
+		if (selfClosingMatch) {
+			return { snippet: selfClosingMatch[0], startLine: actualStartLine }
+		}
+	}
+
+	return undefined
+}
+
 /**
  * Index all searchable text content from a parsed file
  */
@@ -241,11 +288,13 @@ export function indexFileContent(cached: CachedParsedFile, relFile: string): voi
 				// Index static text content
 				const completeSnippet = extractCompleteTagSnippet(cached.lines, line - 1, tag)
 				const snippet = extractInnerHtmlFromSnippet(completeSnippet, tag) ?? completeSnippet
+				const openingTagInfo = extractOpeningTagWithLine(cached.lines, line - 1, tag)
 
 				addToTextSearchIndex({
 					file: relFile,
 					line,
 					snippet,
+					openingTagSnippet: openingTagInfo?.snippet,
 					type: 'static',
 					normalizedText,
 					tag,
@@ -358,6 +407,7 @@ export function findInTextIndex(textContent: string, tag: string): SourceLocatio
 				file: entry.file,
 				line: entry.line,
 				snippet: entry.snippet,
+				openingTagSnippet: entry.openingTagSnippet,
 				type: entry.type,
 				variableName: entry.variableName,
 				definitionLine: entry.definitionLine,
@@ -374,6 +424,7 @@ export function findInTextIndex(textContent: string, tag: string): SourceLocatio
 					file: entry.file,
 					line: entry.line,
 					snippet: entry.snippet,
+					openingTagSnippet: entry.openingTagSnippet,
 					type: entry.type,
 					variableName: entry.variableName,
 					definitionLine: entry.definitionLine,
@@ -389,6 +440,7 @@ export function findInTextIndex(textContent: string, tag: string): SourceLocatio
 				file: entry.file,
 				line: entry.line,
 				snippet: entry.snippet,
+				openingTagSnippet: entry.openingTagSnippet,
 				type: entry.type,
 				variableName: entry.variableName,
 				definitionLine: entry.definitionLine,