@jk2908/cxx 0.3.3 → 0.3.4

package/src/utils.ts

@@ -8,90 +8,3 @@ export function pascalise(str: string) {
 		.map(capitalise)
 		.join('')
 }
-
-export type Batcher<K, V> = {
-	/**
-	 * Queue a value for a key. Queueing the same key again replaces the previous value.
-	 */
-	add: (key: K, value: V) => void
-	/**
-	 * Run any waiting work now and resolve once it has finished.
-	 */
-	flush: () => Promise<void>
-}
-
-/**
- * Group bursts of work and run them together. Every key queued within `wait` is
- * included once, and a key queued while a batch is running is handled in the next
- * batch instead of replacing the one in progress.
- */
-export function createBatcher<K, V>(
-	wait: number,
-	flush: (batch: Map<K, V>) => void | Promise<void>,
-): Batcher<K, V> {
-	// work waiting to run, keyed so each key is only queued once
-	const pending = new Map<K, V>()
-	// waits for a burst of changes to settle before running
-	let timer: ReturnType<typeof setTimeout> | null = null
-	// the run in progress, so `flush` can wait for it and we never start a second
-	let current: Promise<void> | null = null
-
-	function drain() {
-		// a run is already going, so let it pick up the new work
-		if (current) return current
-
-		const run = (async () => {
-			// keep looping while there is work, including work added during a flush
-			while (pending.size > 0) {
-				// snapshot the queued work
-				const batch = new Map(pending)
-				// empty the queue right away, so anything added during flush waits for the next loop
-				pending.clear()
-
-				await flush(batch)
-			}
-		})()
-
-		current = run
-		run.then(
-			() => {
-				if (current === run) current = null
-			},
-			() => {
-				if (current === run) current = null
-			},
-		)
-
-		return run
-	}
-
-	function schedule() {
-		// cancel the previous wait, so the timer restarts from now
-		if (timer) clearTimeout(timer)
-
-		// run once the calls stop coming for `wait` ms
-		timer = setTimeout(() => {
-			// the timer has fired, so drop the stale handle
-			timer = null
-			// the flush callback handles its own errors, so just start the run
-			void drain().catch(() => {})
-		}, wait)
-	}
-
-	return {
-		add(key, value) {
-			// the newest value for this key wins
-			pending.set(key, value)
-			schedule()
-		},
-		flush() {
-			// run now instead of waiting out the timer
-			if (timer) {
-				clearTimeout(timer)
-				timer = null
-			}
-
-			return drain()
-		},
-	}
-}

package/src/vite/index.ts

@@ -1,5 +1,4 @@
 import { realpathSync } from 'node:fs'
-import fs from 'node:fs/promises'
 import path from 'node:path'
 
 import { type Plugin, type ResolvedConfig, type ViteDevServer } from 'vite'
@@ -8,15 +7,13 @@ import type { PluginConfig } from '../types.js'
 import {
 	collect,
 	flushTypes,
-	isENOENT,
-	takeRebuildError,
+	refreshFile,
+	seedTypes,
+	SOURCE_EXTENSIONS,
 	writeTypesForFile,
 } from '../build.js'
 import { GENERATED_DIR } from '../config.js'
 import { Logger } from '../logger.js'
-import { createBatcher } from '../utils.js'
-
-const ACCEPTED_EXTENSIONS = new Set(['.js', '.jsx', '.ts', '.tsx'])
 
 type WatchEvent = 'add' | 'change' | 'unlink'
 
@@ -24,48 +21,45 @@ 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 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)
+	let seeded = false
+
+	// realpath is synchronous, so cache it per directory to keep it off the transform hot path
+	const realpaths = new Map<string, string>()
 
 	function resolveWatchFile(filePath: string) {
 		const absolutePath = path.resolve(watchRoot, filePath)
 		const parentPath = path.dirname(absolutePath)
 
-		try {
-			const resolvedParentPath = normaliseWatchPath(realpathSync.native(parentPath))
+		let resolvedParentPath = realpaths.get(parentPath)
 
-			return normaliseWatchPath(
-				path.join(resolvedParentPath, path.basename(absolutePath)),
-			)
-		} catch {
-			return normaliseWatchPath(absolutePath)
+		if (resolvedParentPath === undefined) {
+			try {
+				resolvedParentPath = normaliseWatchPath(realpathSync.native(parentPath))
+			} catch {
+				resolvedParentPath = normaliseWatchPath(parentPath)
+			}
+
+			realpaths.set(parentPath, resolvedParentPath)
 		}
+
+		return normaliseWatchPath(path.join(resolvedParentPath, path.basename(absolutePath)))
 	}
 
-	/** Returns the canonical, watchable path, or null when the file is irrelevant. */
-	function watchedFile(filePath: string): string | null {
+	/**
+	 * Returns the canonical, watchable path, or null when the file is irrelevant.
+	 */
+	function watchedFile(filePath: string) {
 		const resolvedPath = resolveWatchFile(filePath)
 
 		if (
 			resolvedPath.startsWith(`${watchRoot}/`) &&
 			!resolvedPath.includes(`/${GENERATED_DIR}/`) &&
-			ACCEPTED_EXTENSIONS.has(path.extname(resolvedPath)) &&
-			!ignored.some(regexp => regexp.test(resolvedPath))
+			SOURCE_EXTENSIONS.has(path.extname(resolvedPath))
 		) {
 			return resolvedPath
 		}
@@ -73,76 +67,34 @@ export default function cxx(pluginConfig: PluginConfig = {}) {
 		return null
 	}
 
-	async function recordFile(file: string) {
-		let source: string
-
-		try {
-			source = await fs.readFile(file, 'utf-8')
-		} catch (err) {
-			if (!isENOENT(err)) throw err
+	async function handleEvent(event: WatchEvent, file: string) {
+		if (event === 'unlink') {
 			await writeTypesForFile(file, new Map())
-			return
+		} else {
+			await refreshFile(file, pluginConfig)
 		}
 
-		const tags = source.includes('cxx')
-			? collect(source, file, pluginConfig).tags
-			: new Map()
-		await writeTypesForFile(file, tags)
+		logger.info(`updated types from ${file}`)
 	}
 
-	/**
-	 * 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
+	function onWatch(event: WatchEvent) {
+		return (p: string) => {
+			const file = watchedFile(p)
+			if (!file) return
 
-		try {
-			entries = await fs.readdir(dir, { withFileTypes: true })
-		} catch {
-			return
+			void handleEvent(event, file).catch(err => {
+				logger.error(`failed to update types from ${file}`, err)
+			})
 		}
+	}
 
-		await Promise.all(
-			entries.map(async entry => {
-				if (entry.name.startsWith('.') || entry.name === 'node_modules') return
-
-				const full = path.join(dir, entry.name)
-
-				if (entry.isDirectory()) {
-					await scan(full)
-					return
-				}
-
-				if (!ACCEPTED_EXTENSIONS.has(path.extname(entry.name))) return
-
-				const resolved = resolveWatchFile(full)
-				if (ignored.some(regexp => regexp.test(resolved))) return
+	async function seed() {
+		if (seeded) return
+		seeded = true
 
-				await recordFile(resolved)
-			}),
-		)
+		await seedTypes(watchRoot, pluginConfig)
 	}
 
-	// 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)
-				}
-
-				logger.info(`updated types from ${file}`)
-			} catch (err) {
-				logger.error(`failed to update types from ${file}`, err)
-			}
-		}
-	})
-
 	return {
 		name: 'cxx',
 		enforce: 'pre',
@@ -154,16 +106,20 @@ export default function cxx(pluginConfig: PluginConfig = {}) {
 			} catch {
 				watchRoot = normaliseWatchPath(root)
 			}
+
+			realpaths.clear()
+		},
+		async buildStart() {
+			await seed()
 		},
 		transform(code, id) {
 			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
+			if (!SOURCE_EXTENSIONS.has(path.extname(cleanId))) return null
 
 			const { template, tags, map } = collect(code, cleanId, pluginConfig)
 
@@ -180,26 +136,9 @@ export default function cxx(pluginConfig: PluginConfig = {}) {
 			logger.info('Watching for changes...')
 
 			server.watcher
-				.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))
+				.on('add', onWatch('add'))
+				.on('change', onWatch('change'))
+				.on('unlink', onWatch('unlink'))
 		},
 		async writeBundle() {
 			await flushTypes()