@nuasite/cms 0.38.0 → 0.39.1

package/src/index.ts

@@ -65,8 +65,16 @@ export interface NuaCmsOptions extends CmsMarkerOptions {
 	 * @default false
 	 */
 	usePolling?: boolean
+	/**
+	 * Maximum upload size in bytes. Applied to `/_nua/cms/media/upload` requests
+	 * (enforced on the server and pre-checked on the client).
+	 * @default 10 * 1024 * 1024 (10 MB)
+	 */
+	maxUploadSize?: number
 }
 
+const DEFAULT_MAX_UPLOAD_SIZE = 10 * 1024 * 1024
+
 const VIRTUAL_CMS_PATH = '/@nuasite/cms-editor.js'
 
 export default function nuaCms(options: NuaCmsOptions = {}): AstroIntegration {
@@ -89,16 +97,20 @@ export default function nuaCms(options: NuaCmsOptions = {}): AstroIntegration {
 		mdxComponentDirs,
 		usePolling = false,
 		seo = { trackSeo: true, markTitle: true, parseJsonLd: true },
+		maxUploadSize = DEFAULT_MAX_UPLOAD_SIZE,
 	} = options
 
 	// When no proxy, enable local CMS API with default media adapter
 	const enableCmsApi = !proxy
 	const mediaAdapter = media ?? (enableCmsApi ? createLocalStorageAdapter() : undefined)
 
-	// Default apiBase to local dev server when no proxy
-	const resolvedCmsConfig = enableCmsApi && !cmsConfig?.apiBase
-		? { ...cmsConfig, apiBase: '/_nua/cms' }
-		: cmsConfig
+	// Default apiBase to local dev server when no proxy; thread maxUploadSize through
+	// to the editor so the client can pre-check before sending the upload.
+	const resolvedCmsConfig = {
+		...(cmsConfig ?? {}),
+		...(enableCmsApi && !cmsConfig?.apiBase ? { apiBase: '/_nua/cms' } : {}),
+		maxUploadSize,
+	}
 
 	let componentDefinitions: Record<string, ComponentDefinition> = {}
 	let isPublicStaticFile: ((urlPath: string) => boolean) | undefined
@@ -203,9 +215,7 @@ export default function nuaCms(options: NuaCmsOptions = {}): AstroIntegration {
 				if (command === 'dev') {
 					const editorSrc = src ?? VIRTUAL_CMS_PATH
 
-					const configScript = resolvedCmsConfig
-						? `window.NuaCmsConfig = ${JSON.stringify(resolvedCmsConfig)};`
-						: ''
+					const configScript = `window.NuaCmsConfig = ${JSON.stringify(resolvedCmsConfig)};`
 
 					injectScript(
 						'page',
@@ -229,7 +239,8 @@ export default function nuaCms(options: NuaCmsOptions = {}): AstroIntegration {
 						if (hasPrebuiltBundle) {
 							// Pre-built bundle exists (npm install case):
 							// Serve it via a virtual module — no JSX pragma, Tailwind, or aliases needed.
-							const bundleContent = readFileSync(editorBundlePath!, 'utf-8')
+							// Read on every load() so rebuilds during dev pick up without restarting
+							// the host (Astro, pletivo, etc).
 							vitePlugins.push({
 								name: 'nuasite-cms-editor',
 								resolveId(id: string) {
@@ -239,7 +250,7 @@ export default function nuaCms(options: NuaCmsOptions = {}): AstroIntegration {
 								},
 								load(id: string) {
 									if (id === VIRTUAL_CMS_PATH) {
-										return bundleContent
+										return readFileSync(editorBundlePath!, 'utf-8')
 									}
 								},
 							})
@@ -319,7 +330,7 @@ export default function nuaCms(options: NuaCmsOptions = {}): AstroIntegration {
 					manifestWriter,
 					componentDefinitions,
 					idCounter,
-					{ enableCmsApi, mediaAdapter, isPublicStaticFile },
+					{ enableCmsApi, mediaAdapter, isPublicStaticFile, maxUploadSize },
 				)
 				logger.info('CMS dev middleware initialized')
 				if (enableCmsApi) {

package/src/source-finder/image-finder.ts

@@ -141,21 +141,28 @@ function parseSrcsetUrls(srcSet: string): string[] {
  * Also checks srcset URLs as fallback when src doesn't match (e.g., when src
  * is a local upload path but srcset contains CDN-transformed original URLs).
  * Uses pre-built search index for fast lookups.
+ *
+ * `pageFiles` disambiguates the same image URL across pages.
+ * `preferredLocation` disambiguates the same image URL within one page —
+ * pass the manifest entry's Astro attribution and the lookup will return the
+ * matching per-occurrence index entry when one exists.
  */
 export async function findImageSourceLocation(
 	imageSrc: string,
 	imageSrcSet?: string,
+	pageFiles?: readonly string[],
+	preferredLocation?: { file: string; line?: number; srcOccurrence?: number },
 ): Promise<SourceLocation | undefined> {
 	// Use index if available (much faster)
 	if (isSearchIndexInitialized()) {
-		const result = findInImageIndex(imageSrc)
+		const result = findInImageIndex(imageSrc, pageFiles, preferredLocation)
 		if (result) return result
 
 		// Fallback: try URLs extracted from srcset
 		if (imageSrcSet) {
 			const srcsetUrls = parseSrcsetUrls(imageSrcSet)
 			for (const url of srcsetUrls) {
-				const srcsetResult = findInImageIndex(url)
+				const srcsetResult = findInImageIndex(url, pageFiles, preferredLocation)
 				if (srcsetResult) return srcsetResult
 			}
 		}

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

@@ -1,4 +1,6 @@
 import type { ComponentNode, ElementNode, Node as AstroNode, TextNode } from '@astrojs/compiler/types'
+import { parse as parseBabel } from '@babel/parser'
+import type { Expression } from '@babel/types'
 import fs from 'node:fs/promises'
 import path from 'node:path'
 
@@ -22,7 +24,7 @@ import {
 	setSearchIndexInitialized,
 } from './cache'
 import { extractAstroImageOriginalUrl, extractImageSnippet, extractInnerHtmlFromSnippet, normalizeText } from './snippet-utils'
-import type { CachedParsedFile, SearchIndexEntry, SourceLocation } from './types'
+import type { CachedParsedFile, ImageIndexEntry, SearchIndexEntry, SourceLocation } from './types'
 
 /** Collection data files live under this path — used to prefer them over templates */
 const CONTENT_DIR_PREFIX = 'src/content/'
@@ -622,6 +624,42 @@ function parseMapInvocations(fullText: string): MapInvocation[] {
 	return maps
 }
 
+const BARE_IDENTIFIER = /^[A-Za-z_$][\w$]*$/
+
+function walkAccessor(node: Expression): { base: string; suffix: string } | null {
+	if (node.type === 'Identifier') {
+		return { base: node.name, suffix: '' }
+	}
+	if (node.type === 'MemberExpression' || node.type === 'OptionalMemberExpression') {
+		if (node.object.type === 'Super') return null
+		const inner = walkAccessor(node.object)
+		if (!inner) return null
+		const { property, computed } = node
+		let part: string
+		if (!computed && property.type === 'Identifier') {
+			part = `.${property.name}`
+		} else if (computed && property.type === 'NumericLiteral') {
+			part = `[${property.value}]`
+		} else {
+			return null
+		}
+		return { base: inner.base, suffix: inner.suffix + part }
+	}
+	return null
+}
+
+function parseAccessorChain(exprText: string): { base: string; suffix: string } | null {
+	if (BARE_IDENTIFIER.test(exprText)) return { base: exprText, suffix: '' }
+	try {
+		const file = parseBabel(exprText, { sourceType: 'module', plugins: ['typescript'] })
+		const stmt = file.program.body[0]
+		if (!stmt || stmt.type !== 'ExpressionStatement') return null
+		return walkAccessor(stmt.expression)
+	} catch {
+		return null
+	}
+}
+
 /**
  * Resolve a `.map()` callback parameter back to the source array path.
  *
@@ -632,6 +670,8 @@ function parseMapInvocations(fullText: string): MapInvocation[] {
  *     → `{ arrayPath: "categories[*].images", leafSuffix: "" }`
  *   `links.map(({ label, href }) => …)` looking for `label`
  *     → `{ arrayPath: "links", leafSuffix: ".label" }`
+ *   `services.map((service) => …)` looking for `service.image`
+ *     → `{ arrayPath: "services", leafSuffix: ".image" }`
  *
  * Returns null when the name doesn't appear as a parameter or destructured binding.
  */
@@ -639,13 +679,16 @@ export function resolveMapChain(exprTexts: string[], paramName: string): Resolve
 	const maps = parseMapInvocations(exprTexts.join(''))
 	if (maps.length === 0) return null
 
-	// Prefer simple-param match (most common); fall back to destructured.
-	const directMap = maps.find((m) => m.param === paramName)
-		?? maps.find((m) => m.destructured.includes(paramName))
+	const access = parseAccessorChain(paramName)
+	const baseName = access?.base ?? paramName
+	const memberSuffix = access?.suffix ?? ''
+
+	const directMap = maps.find((m) => m.param === baseName)
+		?? maps.find((m) => m.destructured.includes(baseName))
 	if (!directMap) return null
 
-	const isDestructured = directMap.param !== paramName
-	const leafSuffix = isDestructured ? `.${paramName}` : ''
+	const isDestructured = directMap.param !== baseName
+	const leafSuffix = (isDestructured ? `.${baseName}` : '') + memberSuffix
 
 	// Resolve the array expression by substituting outer .map() params (chained / nested loops).
 	let arrayPath = directMap.arrayExpr
@@ -1225,6 +1268,37 @@ function textEntryToLocation(entry: SearchIndexEntry): SourceLocation {
 	}
 }
 
+/** Helper to build SourceLocation from an image index entry */
+function imageEntryToLocation(entry: ImageIndexEntry): SourceLocation {
+	return {
+		file: entry.file,
+		line: entry.line,
+		snippet: entry.snippet,
+		type: 'static',
+	}
+}
+
+/**
+ * Classify a candidate result by file priority and stash it into the right
+ * bucket. Returns the result if it's a collection-file match (caller should
+ * return immediately — collection data files are always authoritative).
+ */
+interface RankedMatches {
+	page?: SourceLocation
+	other?: SourceLocation
+}
+function rankAndStash(
+	file: string,
+	result: SourceLocation,
+	pageFiles: readonly string[] | undefined,
+	matches: RankedMatches,
+): SourceLocation | undefined {
+	if (isCollectionFile(file)) return result
+	if (pageFiles?.includes(file)) matches.page ??= result
+	else matches.other ??= result
+	return undefined
+}
+
 /**
  * Look up an i18n dictionary entry by its literal key (e.g. `nav.prague4`),
  * preferring the match whose value equals `normalizedText` so the right locale
@@ -1282,55 +1356,56 @@ function toProjectRelativePath(file: string): string {
 }
 
 /**
- * Fast text lookup using pre-built index
+ * Fast text lookup using pre-built index.
+ *
+ * Priority order: collection data files > entries in `pageFiles` > anything
+ * else. Translation-tag (i18n dictionary) hits beat non-collection template
+ * matches — a dictionary entry is an authoritative translatable signal
+ * whereas a same-text template hit is often coincidental.
  */
-export function findInTextIndex(textContent: string, tag: string): SourceLocation | undefined {
+export function findInTextIndex(
+	textContent: string,
+	tag: string,
+	pageFiles?: readonly string[],
+): SourceLocation | undefined {
 	const normalizedSearch = normalizeText(textContent)
 	const tagLower = tag.toLowerCase()
 	const index = getTextSearchIndex()
-
-	// Single pass for exact matches: collect the best same-tag template hit
-	// *and* any i18n dictionary hit at once. A JSON dictionary entry is an
-	// authoritative translatable signal, so it beats a non-collection
-	// template match (which is often a coincidental same-text element).
-	let bestMatch: SourceLocation | undefined
+	const matches: RankedMatches = {}
 	let translationHit: SourceLocation | undefined
+
 	for (const entry of index) {
 		if (entry.normalizedText !== normalizedSearch) continue
 		if (entry.tag === tagLower) {
-			const result = textEntryToLocation(entry)
-			if (isCollectionFile(entry.file)) return result
-			bestMatch ??= result
+			const collectionHit = rankAndStash(entry.file, textEntryToLocation(entry), pageFiles, matches)
+			if (collectionHit) return collectionHit
 		} else if (entry.tag === TRANSLATION_TAG_MARKER) {
 			translationHit ??= textEntryToLocation(entry)
 		}
 	}
 	if (translationHit) return translationHit
-	if (bestMatch) return bestMatch
+	const sameTag = matches.page ?? matches.other
+	if (sameTag) return sameTag
 
-	// Then try partial match for longer text — prefer collection data files
 	if (normalizedSearch.length > 10) {
 		const textPreview = normalizedSearch.slice(0, Math.min(30, normalizedSearch.length))
 		for (const entry of index) {
-			if (entry.tag === tagLower && entry.normalizedText.includes(textPreview)) {
-				const result = textEntryToLocation(entry)
-				if (isCollectionFile(entry.file)) return result
-				bestMatch ??= result
-			}
+			if (entry.tag !== tagLower) continue
+			if (!entry.normalizedText.includes(textPreview)) continue
+			const collectionHit = rankAndStash(entry.file, textEntryToLocation(entry), pageFiles, matches)
+			if (collectionHit) return collectionHit
 		}
-		if (bestMatch) return bestMatch
+		const partial = matches.page ?? matches.other
+		if (partial) return partial
 	}
 
-	// Try any tag match — prefer collection data files
 	for (const entry of index) {
-		if (entry.normalizedText === normalizedSearch) {
-			const result = textEntryToLocation(entry)
-			if (isCollectionFile(entry.file)) return result
-			bestMatch ??= result
-		}
+		if (entry.normalizedText !== normalizedSearch) continue
+		const collectionHit = rankAndStash(entry.file, textEntryToLocation(entry), pageFiles, matches)
+		if (collectionHit) return collectionHit
 	}
 
-	return bestMatch
+	return matches.page ?? matches.other
 }
 
 /**
@@ -1345,34 +1420,57 @@ function extractPathname(src: string): string {
 }
 
 /**
- * Fast image lookup using pre-built index
+ * Fast image lookup using pre-built index.
+ *
+ * Priority order:
+ *   1. `preferredLocation` (file, srcOccurrence) — Nth index entry for
+ *      (src, file). Deterministic per-DOM-order; preferred over `line` because
+ *      Astro's `data-astro-source-loc` often points at a common ancestor and
+ *      collides for multiple imgs sharing the same src.
+ *   2. `preferredLocation` (file, line) exact match — used when occurrence
+ *      isn't provided (Astro's stamping happens to be precise enough).
+ *   3. Collection data files (always authoritative).
+ *   4. Entries in `pageFiles` — disambiguates same image across multiple pages.
+ *   5. Any other match.
  */
-export function findInImageIndex(imageSrc: string): SourceLocation | undefined {
+export function findInImageIndex(
+	imageSrc: string,
+	pageFiles?: readonly string[],
+	preferredLocation?: { file: string; line?: number; srcOccurrence?: number },
+): SourceLocation | undefined {
 	const index = getImageSearchIndex()
 
 	// Dev-mode optimized URLs (`/_image?href=...`, `/@image/...?f=...`) embed the source
 	// path; try both the raw URL and the decoded path so callers don't need to pre-decode.
 	const decoded = extractAstroImageOriginalUrl(imageSrc)
 	const candidates = decoded && decoded !== imageSrc ? [imageSrc, decoded] : [imageSrc]
-
-	// Exact match — prefer collection data files (src/content/) over templates.
-	// The same image URL can appear in both a collection data file and a template
-	// that statically renders the collection. The data file is the authoritative source.
-	let bestMatch: SourceLocation | undefined
+	// Astro stamps absolute paths in `data-astro-source-file`; the index uses
+	// project-relative paths. Normalize before comparing.
+	const preferredFile = preferredLocation ? toProjectRelativePath(preferredLocation.file) : undefined
+	const preferredLine = preferredLocation?.line
+	const preferredOccurrence = preferredLocation?.srcOccurrence
+
+	const matches: RankedMatches = {}
+	let occurrenceCounter = 0
+	let occurrenceMatch: SourceLocation | undefined
+	let lineMatch: SourceLocation | undefined
 	for (const entry of index) {
 		if (!candidates.includes(entry.src)) continue
-		const result: SourceLocation = {
-			file: entry.file,
-			line: entry.line,
-			snippet: entry.snippet,
-			type: 'static',
-		}
-		if (isCollectionFile(entry.file)) {
-			return result // Collection data file — always preferred
+		if (preferredFile && entry.file === preferredFile) {
+			if (preferredOccurrence !== undefined && occurrenceCounter++ === preferredOccurrence) {
+				occurrenceMatch ??= imageEntryToLocation(entry)
+			}
+			if (preferredLine !== undefined && entry.line === preferredLine) {
+				lineMatch ??= imageEntryToLocation(entry)
+			}
 		}
-		bestMatch ??= result // Keep first non-collection match as fallback
+		const collectionHit = rankAndStash(entry.file, imageEntryToLocation(entry), pageFiles, matches)
+		if (collectionHit) return collectionHit
 	}
-	if (bestMatch) return bestMatch
+	if (occurrenceMatch) return occurrenceMatch
+	if (lineMatch) return lineMatch
+	const exact = matches.page ?? matches.other
+	if (exact) return exact
 
 	// Fallback: path suffix matching for CDN-transformed URLs
 	// e.g., rendered src "/cdn-cgi/image/.../assets/photo.webp" should match
@@ -1380,19 +1478,11 @@ export function findInImageIndex(imageSrc: string): SourceLocation | undefined {
 	const targetPath = extractPathname(imageSrc)
 	for (const entry of index) {
 		const entryPath = extractPathname(entry.src)
-		if (entryPath.length > 5 && (targetPath.endsWith(entryPath) || entryPath.endsWith(targetPath))) {
-			const result: SourceLocation = {
-				file: entry.file,
-				line: entry.line,
-				snippet: entry.snippet,
-				type: 'static',
-			}
-			if (isCollectionFile(entry.file)) {
-				return result
-			}
-			bestMatch ??= result
-		}
+		if (entryPath.length <= 5) continue
+		if (!targetPath.endsWith(entryPath) && !entryPath.endsWith(targetPath)) continue
+		const collectionHit = rankAndStash(entry.file, imageEntryToLocation(entry), pageFiles, matches)
+		if (collectionHit) return collectionHit
 	}
 
-	return bestMatch
+	return matches.page ?? matches.other
 }

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

@@ -629,6 +629,7 @@ function resolveTranslationKeyFromSnippet(
 export async function enhanceManifestWithSourceSnippets(
 	entries: Record<string, ManifestEntry>,
 	collectionDefinitions?: Record<string, CollectionDefinition>,
+	pageFiles?: readonly string[],
 ): Promise<Record<string, ManifestEntry>> {
 	// Ensure the search index is ready (returns immediately if already built,
 	// otherwise waits for the in-flight initialization or triggers a new one).
@@ -750,7 +751,19 @@ export async function enhanceManifestWithSourceSnippets(
 			}
 
 			// ── Non-collection images: find via search index / AST ──
-			const imageLocation = await findImageSourceLocation(entry.imageMetadata.src, entry.imageMetadata.srcSet)
+			const preferredLocation = entry.sourcePath
+				? {
+					file: entry.sourcePath,
+					line: entry.sourceLine,
+					srcOccurrence: entry.imageMetadata.srcOccurrence,
+				}
+				: undefined
+			const imageLocation = await findImageSourceLocation(
+				entry.imageMetadata.src,
+				entry.imageMetadata.srcSet,
+				pageFiles,
+				preferredLocation,
+			)
 			if (imageLocation) {
 				const sourceHash = generateSourceHash(imageLocation.snippet || entry.imageMetadata.src)
 				const updated: ManifestEntry = {
@@ -862,7 +875,7 @@ export async function enhanceManifestWithSourceSnippets(
 				? findVariableHitInFile(trimmedEntryText, entry.tag, entry.sourcePath)
 				: undefined
 			const noCoords = !entry.sourcePath || !entry.sourceLine
-			const winner = sameFileHit ?? (noCoords ? findInTextIndex(trimmedEntryText, entry.tag) : undefined)
+			const winner = sameFileHit ?? (noCoords ? findInTextIndex(trimmedEntryText, entry.tag, pageFiles) : undefined)
 
 			if (winner) {
 				if (isTranslationFilePath(winner.file)) {
@@ -1059,7 +1072,7 @@ export async function enhanceManifestWithSourceSnippets(
 
 					// 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)
+					const indexHit = findInTextIndex(trimmedText, entry.tag, pageFiles)
 					if (indexHit && indexHit.file !== entry.sourcePath) {
 						const resolved = await applyTranslationSource(entry, indexHit, attributes, colorClasses)
 						return [id, resolved] as const

package/src/source-finder/source-lookup.ts

@@ -17,14 +17,18 @@ import type { SourceLocation } from './types'
 /**
  * Find source file and line number for text content.
  * Uses pre-built search index for fast lookups.
+ *
+ * `pageFiles` disambiguates when the same text appears on multiple pages —
+ * the lookup prefers index entries whose file is one of the candidates.
  */
 export async function findSourceLocation(
 	textContent: string,
 	tag: string,
+	pageFiles?: readonly string[],
 ): Promise<SourceLocation | undefined> {
 	// Use index if available (much faster)
 	if (isSearchIndexInitialized()) {
-		const indexHit = findInTextIndex(textContent, tag)
+		const indexHit = findInTextIndex(textContent, tag, pageFiles)
 		if (indexHit) return indexHit
 		// Fall through to slow search on miss — covers cases the per-file
 		// indexer can't pre-emit, like a child component's `.map()` over a

package/src/types.ts

@@ -70,6 +70,10 @@ export interface ImageMetadata {
 	srcSet?: string
 	/** Image sizes attribute */
 	sizes?: string
+	/** 0-based DOM-order index of this `<img>` among same-(src, sourceFile)
+	 *  occurrences on the page. Disambiguates source location when the same
+	 *  image URL appears multiple times in the same source file. */
+	srcOccurrence?: number
 }
 
 /** Identifies the (collection, entry, field) destination for an editor upload. */