@nuasite/cms-marker 0.0.52 → 0.0.54

package/src/types.ts

@@ -27,14 +27,95 @@ export interface ComponentDefinition {
 	slots?: string[]
 }
 
+/** Context around an element for resilient matching when exact match fails */
+export interface SourceContext {
+	/** Text content of the preceding sibling element */
+	precedingText?: string
+	/** Text content of the following sibling element */
+	followingText?: string
+	/** Parent element's tag name */
+	parentTag?: string
+	/** Position among siblings (0-indexed) */
+	siblingIndex?: number
+	/** Parent element's class attribute */
+	parentClasses?: string
+}
+
+/** Image metadata for better tracking and integrity */
+export interface ImageMetadata {
+	/** Image source URL */
+	src: string
+	/** Alt text */
+	alt: string
+	/** SHA256 hash of image content (for integrity checking) */
+	hash?: string
+	/** Image dimensions */
+	dimensions?: { width: number; height: number }
+	/** Responsive image srcset */
+	srcSet?: string
+	/** Image sizes attribute */
+	sizes?: string
+}
+
+/** Content constraints for validation */
+export interface ContentConstraints {
+	/** Maximum content length */
+	maxLength?: number
+	/** Minimum content length */
+	minLength?: number
+	/** Regex pattern for validation */
+	pattern?: string
+	/** Allowed HTML tags for rich text content */
+	allowedTags?: string[]
+}
+
+/** Represents a single Tailwind color with its shades */
+export interface TailwindColor {
+	/** Color name (e.g., 'red', 'blue', 'primary') */
+	name: string
+	/** Available shades (e.g., ['50', '100', '200', ..., '900', '950']) */
+	shades: string[]
+	/** Whether this is a custom/theme color vs default Tailwind */
+	isCustom?: boolean
+}
+
+/** Color classes currently applied to an element */
+export interface ColorClasses {
+	/** Background color class (e.g., 'bg-blue-500') */
+	bg?: string
+	/** Text color class (e.g., 'text-white') */
+	text?: string
+	/** Border color class (e.g., 'border-blue-600') */
+	border?: string
+	/** Hover background color class (e.g., 'hover:bg-blue-600') */
+	hoverBg?: string
+	/** Hover text color class (e.g., 'hover:text-gray-100') */
+	hoverText?: string
+	/** All color-related classes as found in the element */
+	allColorClasses?: string[]
+}
+
+/** Available colors palette from Tailwind config */
+export interface AvailableColors {
+	/** All available colors with their shades */
+	colors: TailwindColor[]
+	/** Default Tailwind color names */
+	defaultColors: string[]
+	/** Custom/theme color names */
+	customColors: string[]
+}
+
 export interface ManifestEntry {
 	id: string
 	tag: string
+	/** Plain text content (for display/search) */
 	text: string
+	/** HTML content when element contains inline styling (strong, em, etc.) */
+	html?: string
 	sourcePath?: string
 	sourceLine?: number
 	sourceSnippet?: string
-	sourceType?: 'static' | 'variable' | 'prop' | 'computed' | 'collection'
+	sourceType?: 'static' | 'variable' | 'prop' | 'computed' | 'collection' | 'image'
 	variableName?: string
 	childCmsIds?: string[]
 	parentComponentId?: string
@@ -42,6 +123,27 @@ export interface ManifestEntry {
 	collectionName?: string
 	/** Entry slug for collection entries (e.g., '3d-tisk') */
 	collectionSlug?: string
+	/** Path to the markdown content file (e.g., 'src/content/blog/my-post.md') */
+	contentPath?: string
+	/** Image source URL (for image entries) - deprecated, use imageMetadata */
+	imageSrc?: string
+	/** Image alt text (for image entries) - deprecated, use imageMetadata */
+	imageAlt?: string
+
+	// === Robustness fields ===
+
+	/** Stable ID derived from content + context hash, survives rebuilds */
+	stableId?: string
+	/** SHA256 hash of sourceSnippet at generation time for conflict detection */
+	sourceHash?: string
+	/** Context around the element for resilient matching */
+	sourceContext?: SourceContext
+	/** Image metadata for img elements (replaces imageSrc/imageAlt) */
+	imageMetadata?: ImageMetadata
+	/** Content validation constraints */
+	constraints?: ContentConstraints
+	/** Color classes applied to this element (for buttons, etc.) */
+	colorClasses?: ColorClasses
 }
 
 export interface ComponentInstance {
@@ -73,10 +175,30 @@ export interface CollectionEntry {
 	wrapperId?: string
 }
 
+/** Manifest metadata for versioning and conflict detection */
+export interface ManifestMetadata {
+	/** Manifest schema version */
+	version: string
+	/** ISO timestamp when manifest was generated */
+	generatedAt: string
+	/** Build system that generated the manifest (e.g., 'astro', 'vite') */
+	generatedBy?: string
+	/** Build ID for correlation */
+	buildId?: string
+	/** SHA256 hash of all entry content for quick drift detection */
+	contentHash?: string
+	/** Per-source-file hashes for granular conflict detection */
+	sourceFileHashes?: Record<string, string>
+}
+
 export interface CmsManifest {
+	/** Manifest metadata for versioning and conflict detection */
+	metadata?: ManifestMetadata
 	entries: Record<string, ManifestEntry>
 	components: Record<string, ComponentInstance>
 	componentDefinitions: Record<string, ComponentDefinition>
 	/** Content collection entries indexed by "collectionName/slug" */
 	collections?: Record<string, CollectionEntry>
+	/** Available Tailwind colors from the project's config */
+	availableColors?: AvailableColors
 }

package/src/utils.ts

@@ -0,0 +1,99 @@
+import { createHash } from 'node:crypto'
+import type { ManifestEntry, SourceContext } from './types'
+
+/**
+ * Generate a SHA256 hash of the given content
+ */
+export function sha256(content: string): string {
+	return createHash('sha256').update(content, 'utf8').digest('hex')
+}
+
+/**
+ * Generate a short hash (first 12 characters of SHA256)
+ * Used for stableId to keep it reasonably short but still unique
+ */
+export function shortHash(content: string): string {
+	return sha256(content).substring(0, 12)
+}
+
+/**
+ * Generate a stable ID for an element based on its content and context.
+ * This ID survives rebuilds as long as the content and structure remain similar.
+ *
+ * Components:
+ * - tag name
+ * - first 50 chars of text content
+ * - source path (if available)
+ * - parent tag
+ * - sibling index
+ */
+export function generateStableId(
+	tag: string,
+	text: string,
+	sourcePath?: string,
+	context?: SourceContext,
+): string {
+	const components = [
+		tag,
+		text.substring(0, 50).trim(),
+		sourcePath || '',
+		context?.parentTag || '',
+		context?.siblingIndex?.toString() || '',
+	]
+
+	return shortHash(components.join('|'))
+}
+
+/**
+ * Generate a hash of the source snippet for conflict detection.
+ * If the source file changes, this hash will differ from what's stored in manifest.
+ */
+export function generateSourceHash(sourceSnippet: string): string {
+	return sha256(sourceSnippet)
+}
+
+/**
+ * Generate a content hash for the entire manifest (all entries).
+ * Used for quick drift detection without comparing individual entries.
+ */
+export function generateManifestContentHash(entries: Record<string, ManifestEntry>): string {
+	// Sort keys for deterministic hashing
+	const sortedKeys = Object.keys(entries).sort()
+	const content = sortedKeys.map(key => {
+		const entry = entries[key]!
+		// Hash only content-relevant fields, not generated IDs
+		return `${entry.tag}|${entry.text}|${entry.html || ''}|${entry.sourcePath || ''}`
+	}).join('\n')
+
+	return sha256(content)
+}
+
+/**
+ * Generate per-source-file hashes for granular conflict detection.
+ * Maps source file path -> hash of all entries from that file.
+ */
+export function generateSourceFileHashes(entries: Record<string, ManifestEntry>): Record<string, string> {
+	// Group entries by source file
+	const entriesByFile: Record<string, ManifestEntry[]> = {}
+
+	for (const entry of Object.values(entries)) {
+		const sourcePath = entry.sourcePath
+		if (sourcePath) {
+			if (!entriesByFile[sourcePath]) {
+				entriesByFile[sourcePath] = []
+			}
+			entriesByFile[sourcePath].push(entry)
+		}
+	}
+
+	// Generate hash for each file
+	const hashes: Record<string, string> = {}
+	for (const [filePath, fileEntries] of Object.entries(entriesByFile)) {
+		// Sort entries by line number for determinism
+		const sorted = fileEntries.sort((a, b) => (a.sourceLine || 0) - (b.sourceLine || 0))
+		const content = sorted.map(e => `${e.sourceLine || 0}|${e.text}|${e.sourceSnippet || ''}`).join('\n')
+		hashes[filePath] = sha256(content)
+	}
+
+	return hashes
+}