@jk2908/cxx 0.2.6 → 0.3.3

package/src/vite/index.ts

@@ -2,42 +2,46 @@ import { realpathSync } from 'node:fs'
 import fs from 'node:fs/promises'
 import path from 'node:path'
 
-import { type Plugin, type ViteDevServer } from 'vite'
-
-import type { BuildContext, PluginConfig } from '../types.js'
-import { collect, flattenTags, isENOENT, writeTypes } from '../build.js'
+import { type Plugin, type ResolvedConfig, type ViteDevServer } from 'vite'
+
+import type { PluginConfig } from '../types.js'
+import {
+	collect,
+	flushTypes,
+	isENOENT,
+	takeRebuildError,
+	writeTypesForFile,
+} from '../build.js'
 import { GENERATED_DIR } from '../config.js'
 import { Logger } from '../logger.js'
-import { debounce } from '../utils.js'
+import { createBatcher } from '../utils.js'
 
 const ACCEPTED_EXTENSIONS = new Set(['.js', '.jsx', '.ts', '.tsx'])
 
+type WatchEvent = 'add' | 'change' | 'unlink'
+
 function normaliseWatchPath(p: string) {
 	return p.replace(/\\/g, '/')
 }
 
+/** Tiny glob matcher for the ignore patterns we support (`**`, `*`, `?`). */
+function globToRegExp(glob: string) {
+	const pattern = glob
+		.replace(/[.+^${}()|[\]\\]/g, '\\$&')
+		.replace(/\*\*(\/|$)/g, '.*$1')
+		.replace(/\*/g, '[^/]*')
+		.replace(/\?/g, '[^/]')
+
+	return new RegExp(`^${pattern}$`)
+}
+
 export default function cxx(pluginConfig: PluginConfig = {}) {
-	const buildContext = {
-		tagsByFile: new Map(),
-	} satisfies BuildContext
-
-	const logger = new Logger(
-		(pluginConfig?.logger?.level ?? process.env.NODE_ENV === 'production')
-			? 'error'
-			: 'debug',
-	)
-
-	// write generated files into a hidden folder at the project root
-	// keep the generated surface out of src
-	const watchRoot = normaliseWatchPath(realpathSync.native(process.cwd()))
-	const watchedRoots = [`${watchRoot}/`]
-
-	let rebuildRunning = false
-	let rebuildQueued = false
-
-	// watcher events can arrive through symlinked paths like /var while cwd has
-	// already resolved to /private/var, so canonicalise the parent dir once and
-	// reattach the file name for stable prefix checks
+	const logger = new Logger()
+
+	// resolved from Vite's root in `configResolved`, not from `process.cwd()`
+	let watchRoot = normaliseWatchPath(process.cwd())
+	const ignored = (pluginConfig.watch?.ignore ?? []).map(globToRegExp)
+
 	function resolveWatchFile(filePath: string) {
 		const absolutePath = path.resolve(watchRoot, filePath)
 		const parentPath = path.dirname(absolutePath)
@@ -53,104 +57,152 @@ export default function cxx(pluginConfig: PluginConfig = {}) {
 		}
 	}
 
-	function watchedFile(filePath: string) {
+	/** Returns the canonical, watchable path, or null when the file is irrelevant. */
+	function watchedFile(filePath: string): string | null {
 		const resolvedPath = resolveWatchFile(filePath)
 
-		return (
-			watchedRoots.some(root => resolvedPath.startsWith(root)) &&
+		if (
+			resolvedPath.startsWith(`${watchRoot}/`) &&
 			!resolvedPath.includes(`/${GENERATED_DIR}/`) &&
-			ACCEPTED_EXTENSIONS.has(path.extname(resolvedPath))
-		)
-	}
+			ACCEPTED_EXTENSIONS.has(path.extname(resolvedPath)) &&
+			!ignored.some(regexp => regexp.test(resolvedPath))
+		) {
+			return resolvedPath
+		}
 
-	const rebuild = debounce((event: 'add' | 'change' | 'unlink', filePath: string) => {
-		function queue() {
-			void (async () => {
-				// collapse bursts of file events into one active rebuild plus a single
-				// queued rerun when changes land mid-build
-				if (rebuildRunning) {
-					rebuildQueued = true
-					return
-				}
+		return null
+	}
 
-				rebuildRunning = true
+	async function recordFile(file: string) {
+		let source: string
 
-				do {
-					rebuildQueued = false
+		try {
+			source = await fs.readFile(file, 'utf-8')
+		} catch (err) {
+			if (!isENOENT(err)) throw err
+			await writeTypesForFile(file, new Map())
+			return
+		}
 
-					try {
-						const hadTags = buildContext.tagsByFile.has(file)
-						let hasTags = false
+		const tags = source.includes('cxx')
+			? collect(source, file, pluginConfig).tags
+			: new Map()
+		await writeTypesForFile(file, tags)
+	}
 
-						if (event === 'unlink') {
-							buildContext.tagsByFile.delete(file)
-						} else {
-							const source = await fs.readFile(file, 'utf-8')
-							const { tags } = collect(source, file, pluginConfig)
+	/**
+	 * Seed the type surface from the source tree, so a fresh checkout has types before any file is
+	 * transformed or edited.
+	 */
+	async function scan(dir: string) {
+		let entries
 
-							hasTags = tags.size > 0
+		try {
+			entries = await fs.readdir(dir, { withFileTypes: true })
+		} catch {
+			return
+		}
 
-							if (hasTags) {
-								buildContext.tagsByFile.set(file, tags)
-							} else {
-								buildContext.tagsByFile.delete(file)
-							}
-						}
+		await Promise.all(
+			entries.map(async entry => {
+				if (entry.name.startsWith('.') || entry.name === 'node_modules') return
 
-						if (!hadTags && !hasTags) continue
+				const full = path.join(dir, entry.name)
 
-						await writeTypes(flattenTags(buildContext.tagsByFile))
-						logger.info(`updated types from ${file}`)
-					} catch (err) {
-						if (isENOENT(err)) {
-							if (!buildContext.tagsByFile.has(file)) continue
+				if (entry.isDirectory()) {
+					await scan(full)
+					return
+				}
 
-							buildContext.tagsByFile.delete(file)
-							await writeTypes(flattenTags(buildContext.tagsByFile))
+				if (!ACCEPTED_EXTENSIONS.has(path.extname(entry.name))) return
 
-							logger.info(`updated types from ${file}`)
+				const resolved = resolveWatchFile(full)
+				if (ignored.some(regexp => regexp.test(resolved))) return
 
-							continue
-						}
+				await recordFile(resolved)
+			}),
+		)
+	}
 
-						logger.error(`failed to update types from ${file}`, err)
-					}
-				} while (rebuildQueued)
+	// collect change events that arrive close together and handle each file once.
+	// The file path is the key, so changes to different files are all kept, and a
+	// change that arrives during a rebuild runs after that rebuild finishes.
+	const queue = createBatcher<string, WatchEvent>(75, async batch => {
+		for (const [file, event] of batch) {
+			try {
+				if (event === 'unlink') {
+					await writeTypesForFile(file, new Map())
+				} else {
+					await recordFile(file)
+				}
 
-				rebuildRunning = false
-			})()
+				logger.info(`updated types from ${file}`)
+			} catch (err) {
+				logger.error(`failed to update types from ${file}`, err)
+			}
 		}
-
-		// ignore anything outside the watched content dirs
-		if (!watchedFile(filePath)) return
-
-		const file = resolveWatchFile(filePath)
-		queue()
-	}, 75)
+	})
 
 	return {
 		name: 'cxx',
 		enforce: 'pre',
+		configResolved(config: ResolvedConfig) {
+			const root = pluginConfig.watch?.root ?? config.root
+
+			try {
+				watchRoot = normaliseWatchPath(realpathSync.native(root))
+			} catch {
+				watchRoot = normaliseWatchPath(root)
+			}
+		},
 		transform(code, id) {
-			const { template, tags } = collect(code, id, pluginConfig)
+			if (id.startsWith('\0') || id.includes('/node_modules/')) return null
+
+			// cheap bail-out before running the regex/lightningcss on every module
+			if (!code.includes('cxx')) return null
+
+			const cleanId = id.split('?')[0]
+
+			if (!ACCEPTED_EXTENSIONS.has(path.extname(cleanId))) return null
+
+			const { template, tags, map } = collect(code, cleanId, pluginConfig)
+
+			if (template === code) return null
 
-			if (tags.size) buildContext.tagsByFile.set(id, tags)
+			void writeTypesForFile(resolveWatchFile(cleanId), tags)
 
 			return {
 				code: template,
-				map: null,
+				map,
 			}
 		},
 		configureServer(server: ViteDevServer) {
 			logger.info('Watching for changes...')
 
 			server.watcher
-				.on('add', (p: string) => rebuild('add', p))
-				.on('change', (p: string) => rebuild('change', p))
-				.on('unlink', (p: string) => rebuild('unlink', p))
+				.on('add', (p: string) => {
+					const file = watchedFile(p)
+					if (file) queue.add(file, 'add')
+				})
+				.on('change', (p: string) => {
+					const file = watchedFile(p)
+					if (file) queue.add(file, 'change')
+				})
+				.on('unlink', (p: string) => {
+					const file = watchedFile(p)
+					if (file) queue.add(file, 'unlink')
+				})
+
+			void scan(watchRoot)
+				.then(() => flushTypes())
+				.then(() => {
+					const err = takeRebuildError()
+					if (err) logger.error('failed to generate types', err)
+				})
+				.catch(err => logger.error('failed to scan for cxx templates', err))
 		},
 		async writeBundle() {
-			await writeTypes(flattenTags(buildContext.tagsByFile))
+			await flushTypes()
 		},
 	} satisfies Plugin
 }