@jk2908/cxx 0.3.1 → 0.3.4

package/src/next/cxx-loader.js

@@ -5,7 +5,14 @@ const loader = function (source) {
 	const { pluginConfig } = this.getOptions()
 	const logger = new Logger()
 
-	const { template } = processFile(source, this.resourcePath, pluginConfig, logger)
+	const { template, map } = processFile(source, this.resourcePath, pluginConfig, logger)
+
+	// hand the transform's source map back to webpack/turbopack when they support it
+	if (map && typeof this.callback === 'function') {
+		this.callback(null, template, map)
+
+		return
+	}
 
 	return template
 }

package/src/next/index.ts

@@ -1,14 +1,15 @@
 import type { AsyncSubscription, Event } from '@parcel/watcher'
 import type { NextConfig } from 'next'
 
-import fs from 'node:fs/promises'
 import path from 'node:path'
 import { fileURLToPath } from 'node:url'
 
-import type { Logger } from '../logger.js'
 import type { PluginConfig } from '../types.js'
-import { collect, isENOENT, writeTypesForFile } from '../build.js'
+import { collect, refreshFile, seedTypes, writeTypesForFile } from '../build.js'
 import { GENERATED_DIR } from '../config.js'
+import { Logger } from '../logger.js'
+
+const typeLogger = new Logger('cxx')
 
 const nextDir = path.dirname(fileURLToPath(import.meta.url))
 const loader = path.join(nextDir, 'cxx-loader.cjs')
@@ -38,27 +39,10 @@ async function onEvent(event: Event['type'], filePath: string) {
 
 	if (event === 'delete') {
 		await writeTypesForFile(filePath, new Map())
-		logger.info(`updated types from ${filePath}`)
-
-		return
-	}
-
-	let source: string
-
-	try {
-		source = await fs.readFile(filePath, 'utf-8')
-	} catch (err) {
-		if (!isENOENT(err)) throw err
-
-		await writeTypesForFile(filePath, new Map())
-		logger.info(`updated types from ${filePath}`)
-
-		return
+	} else {
+		await refreshFile(filePath, pluginConfig)
 	}
 
-	const { tags } = collect(source, filePath, pluginConfig)
-
-	await writeTypesForFile(filePath, tags)
 	logger.info(`updated types from ${filePath}`)
 }
 
@@ -72,7 +56,6 @@ function ensureWatcher(pluginConfig: PluginConfig, logger: Logger) {
 	if (subscriptionPromise) return
 
 	const root = pluginConfig.watch?.root ?? process.cwd()
-	const ignore = [...DEFAULT_IGNORE, ...(pluginConfig.watch?.ignore ?? [])]
 
 	subscriptionPromise = (async () => {
 		// lazily imported so the native module is only loaded when watching is needed
@@ -96,7 +79,7 @@ function ensureWatcher(pluginConfig: PluginConfig, logger: Logger) {
 					})
 				}
 			},
-			{ ignore },
+			{ ignore: DEFAULT_IGNORE },
 		)
 
 		registerCleanup()
@@ -150,6 +133,11 @@ export function processFile(
 ) {
 	const resolvedFilePath = path.resolve(filePath)
 
+	// skip files that cannot contain a template, including node_modules
+	if (!source.includes('cxx') || /[\\/]node_modules[\\/]/.test(resolvedFilePath)) {
+		return { template: source, tags: new Map(), map: null }
+	}
+
 	if (process.env['NODE_ENV'] !== 'production') {
 		watchedFiles.set(resolvedFilePath, { pluginConfig, logger })
 		ensureWatcher(pluginConfig, logger)
@@ -157,9 +145,7 @@ export function processFile(
 
 	const result = collect(source, resolvedFilePath, pluginConfig)
 
-	void writeTypesForFile(resolvedFilePath, result.tags).catch(err => {
-		logger.error(`failed to write types for ${resolvedFilePath}`, err)
-	})
+	void writeTypesForFile(resolvedFilePath, result.tags)
 
 	return result
 }
@@ -170,6 +156,18 @@ export function withCxx(nextConfig: NextConfig = {}, pluginConfig: PluginConfig
 	const watchRoot =
 		pluginConfig.watch?.root ?? nextConfig.turbopack?.root ?? process.cwd()
 
+	// Seed on dev startup only, matching Vite. A production build is covered by the loader, and
+	// `next start` must not scan or write at runtime.
+	if (process.env['NODE_ENV'] !== 'production') {
+		// the app directory, not the whole Turbopack root, so sibling apps in a monorepo do not
+		// leak into this app's types
+		const seedRoot = pluginConfig.watch?.root ?? process.cwd()
+
+		void seedTypes(seedRoot, pluginConfig).catch(err =>
+			typeLogger.error('failed to seed cxx types', err),
+		)
+	}
+
 	const loaderItem = {
 		loader,
 		options: {

package/src/types.ts

@@ -9,17 +9,11 @@ export type Tags = Map<string, string[]>
 export type PluginConfig = {
 	typeSuffix?: string | false
 	watch?: {
-		// root used for type-regeneration watching; defaults to the Vite root / Next turbopack root
+		/** Root used for type-regeneration watching. Defaults to the Vite root or Next Turbopack root. */
 		root?: string
-		// extra globs to ignore on top of the defaults
-		ignore?: string[]
 	}
 }
 
-export type BuildContext = {
-	tagsByFile: Map<string, Tags>
-}
-
 export type Tag = <ClassName extends string = string>(
 	name: string,
 ) => (_: TemplateStringsArray) => Result<ClassName>

package/src/utils.ts

@@ -8,82 +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
-	// true while a batch is running, so we never start a second one
-	let running = false
-
-	async function drain() {
-		// a run is already going, so let it pick up the new work
-		if (running) return
-		running = true
-
-		try {
-			// 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)
-			}
-		} finally {
-			// always allow the next run, even if flush threw
-			running = false
-		}
-	}
-
-	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
-			// start the run without waiting for it (this is a timer callback)
-			void drain()
-		}, 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,16 +1,19 @@
 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'
 
-import type { BuildContext, PluginConfig } from '../types.js'
-import { collect, flattenTags, isENOENT, writeTypes } from '../build.js'
+import type { PluginConfig } from '../types.js'
+import {
+	collect,
+	flushTypes,
+	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'
 
@@ -19,38 +22,44 @@ function normaliseWatchPath(p: string) {
 }
 
 export default function cxx(pluginConfig: PluginConfig = {}) {
-	const buildContext = {
-		tagsByFile: new Map(),
-	} satisfies BuildContext
-
 	const logger = new Logger()
 
 	// resolved from Vite's root in `configResolved`, not from `process.cwd()`
 	let watchRoot = normaliseWatchPath(process.cwd())
+	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)
+
+		if (resolvedParentPath === undefined) {
+			try {
+				resolvedParentPath = normaliseWatchPath(realpathSync.native(parentPath))
+			} catch {
+				resolvedParentPath = normaliseWatchPath(parentPath)
+			}
 
-			return normaliseWatchPath(
-				path.join(resolvedParentPath, path.basename(absolutePath)),
-			)
-		} catch {
-			return normaliseWatchPath(absolutePath)
+			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))
+			SOURCE_EXTENSIONS.has(path.extname(resolvedPath))
 		) {
 			return resolvedPath
 		}
@@ -58,78 +67,37 @@ export default function cxx(pluginConfig: PluginConfig = {}) {
 		return null
 	}
 
-	async function onEvent(event: WatchEvent, file: string) {
-		const hadTags = buildContext.tagsByFile.has(file)
-
+	async function handleEvent(event: WatchEvent, file: string) {
 		if (event === 'unlink') {
-			if (!hadTags) return
-
-			buildContext.tagsByFile.delete(file)
-			await writeTypes(flattenTags(buildContext.tagsByFile))
-			logger.info(`updated types from ${file}`)
-
-			return
-		}
-
-		let source: string
-
-		try {
-			source = await fs.readFile(file, 'utf-8')
-		} catch (err) {
-			if (!isENOENT(err)) throw err
-			if (!hadTags) return
-
-			buildContext.tagsByFile.delete(file)
-			await writeTypes(flattenTags(buildContext.tagsByFile))
-			logger.info(`updated types from ${file}`)
-
-			return
-		}
-
-		const { tags } = collect(source, file, pluginConfig)
-		const hasTags = tags.size > 0
-
-		if (hasTags) {
-			buildContext.tagsByFile.set(file, tags)
+			await writeTypesForFile(file, new Map())
 		} else {
-			buildContext.tagsByFile.delete(file)
+			await refreshFile(file, pluginConfig)
 		}
 
-		if (!hadTags && !hasTags) return
-
-		await writeTypes(flattenTags(buildContext.tagsByFile))
 		logger.info(`updated types from ${file}`)
 	}
 
-	// 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 {
-				await onEvent(event, file)
-			} catch (err) {
+	function onWatch(event: WatchEvent) {
+		return (p: string) => {
+			const file = watchedFile(p)
+			if (!file) return
+
+			void handleEvent(event, file).catch(err => {
 				logger.error(`failed to update types from ${file}`, err)
-			}
+			})
 		}
-	})
+	}
+
+	async function seed() {
+		if (seeded) return
+		seeded = true
+
+		await seedTypes(watchRoot, pluginConfig)
+	}
 
 	return {
 		name: 'cxx',
 		enforce: 'pre',
-		config() {
-			const ignore = pluginConfig.watch?.ignore
-			if (!ignore?.length) return null
-
-			// Vite concatenates `server.watch.ignored`, so only return the additions
-			return {
-				server: {
-					watch: {
-						ignored: ignore,
-					},
-				},
-			}
-		},
 		configResolved(config: ResolvedConfig) {
 			const root = pluginConfig.watch?.root ?? config.root
 
@@ -138,6 +106,11 @@ 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
@@ -145,18 +118,14 @@ export default function cxx(pluginConfig: PluginConfig = {}) {
 			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)
-			if (template === code) return null
 
-			const resolved = resolveWatchFile(cleanId)
+			if (template === code) return null
 
-			if (tags.size) {
-				buildContext.tagsByFile.set(resolved, tags)
-			} else {
-				buildContext.tagsByFile.delete(resolved)
-			}
+			void writeTypesForFile(resolveWatchFile(cleanId), tags)
 
 			return {
 				code: template,
@@ -167,21 +136,12 @@ 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')
-				})
+				.on('add', onWatch('add'))
+				.on('change', onWatch('change'))
+				.on('unlink', onWatch('unlink'))
 		},
 		async writeBundle() {
-			await writeTypes(flattenTags(buildContext.tagsByFile))
+			await flushTypes()
 		},
 	} satisfies Plugin
 }