@jk2908/cxx 0.3.3 → 0.3.5

package/src/next/index.ts

@@ -1,154 +1,25 @@
-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, takeRebuildError, writeTypesForFile } from '../build.js'
-import { GENERATED_DIR } from '../config.js'
+import { collect, seedTypes, writeTypesForFile } from '../build.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')
 
-// keep the exact file inputs and their config so a single recursive watcher can filter events
-const watchedFiles = new Map<string, { pluginConfig: PluginConfig; logger: Logger }>()
-
-let subscription: AsyncSubscription | null = null
-let subscriptionPromise: Promise<void> | null = null
-let cleanupRegistered = false
-let watcherLogger: Logger | null = null
-
-// a single recursive watch avoids overlapping per-directory watchers; ignore the parts of the
-// tree that never contain source we transform
-const DEFAULT_IGNORE = [
-	'**/node_modules/**',
-	'**/.next/**',
-	`**/${GENERATED_DIR}/**`,
-	'**/.git/**',
-]
-
-async function onEvent(event: Event['type'], filePath: string) {
-	const watched = watchedFiles.get(filePath)
-	if (!watched) return
-
-	const { pluginConfig, logger } = watched
-
-	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
-	}
-
-	const tags = source.includes('cxx')
-		? collect(source, filePath, pluginConfig).tags
-		: new Map()
-
-	await writeTypesForFile(filePath, tags)
-	logger.info(`updated types from ${filePath}`)
-}
-
-/**
- * Start the watcher lazily, on the first file we actually process, so merely importing this module
- * has no side effects.
- */
-function ensureWatcher(pluginConfig: PluginConfig, logger: Logger) {
-	watcherLogger = 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
-		const { subscribe } = await import('@parcel/watcher')
-
-		subscription = await subscribe(
-			root,
-			(watchErr, events) => {
-				if (watchErr) {
-					watcherLogger?.error(`failed to watch ${root}`, watchErr)
-
-					return
-				}
-
-				for (const event of events) {
-					const filePath = path.resolve(event.path)
-					if (!watchedFiles.has(filePath)) continue
-
-					void onEvent(event.type, filePath).catch(err => {
-						watcherLogger?.error(`failed to update types from ${filePath}`, err)
-					})
-				}
-			},
-			{ ignore },
-		)
-
-		registerCleanup()
-	})().catch(err => {
-		watcherLogger?.error('failed to start cxx watcher', err)
-		subscriptionPromise = null
-	})
-}
-
-/**
- * Close all active Parcel subscriptions.
- */
-async function cleanup() {
-	const active = subscription
-
-	subscription = null
-	subscriptionPromise = null
-	watchedFiles.clear()
-
-	if (active) await active.unsubscribe()
-}
-
 /**
- * Restore the host process's default signal behaviour instead of forcing an exit from a library.
- */
-async function shutdown(signal: NodeJS.Signals) {
-	try {
-		await cleanup()
-	} finally {
-		// our `once` handlers have already been removed, so re-raising lets Node terminate as usual
-		process.kill(process.pid, signal)
-	}
-}
-
-function registerCleanup() {
-	if (cleanupRegistered) return
-
-	cleanupRegistered = true
-	process.once('SIGINT', () => void shutdown('SIGINT'))
-	process.once('SIGTERM', () => void shutdown('SIGTERM'))
-}
-
-/**
- * Transform one module and, in development, register it with the shared watcher state.
+ * Transform one module and persist its tag types. Deleted files are pruned from the types on the
+ * next rebuild, since `readPartials` drops any partial whose source is gone.
  */
 export function processFile(
 	source: string,
 	filePath: string,
 	pluginConfig: PluginConfig,
-	logger: Logger,
 ) {
 	const resolvedFilePath = path.resolve(filePath)
 
@@ -157,15 +28,6 @@ export function processFile(
 		return { template: source, tags: new Map(), map: null }
 	}
 
-	// surface a duplicate-tag error from a previous background rebuild
-	const priorError = takeRebuildError()
-	if (priorError) throw priorError
-
-	if (process.env['NODE_ENV'] !== 'production') {
-		watchedFiles.set(resolvedFilePath, { pluginConfig, logger })
-		ensureWatcher(pluginConfig, logger)
-	}
-
 	const result = collect(source, resolvedFilePath, pluginConfig)
 
 	void writeTypesForFile(resolvedFilePath, result.tags)
@@ -176,16 +38,20 @@ export function processFile(
 const TURBOPACK_GLOB = '*.{tsx,jsx,ts,js}'
 
 export function withCxx(nextConfig: NextConfig = {}, pluginConfig: PluginConfig = {}) {
-	const watchRoot =
-		pluginConfig.watch?.root ?? nextConfig.turbopack?.root ?? process.cwd()
+	// Seed on dev startup only, so a fresh checkout has types before any file is compiled. A
+	// production build is covered by the loader, and `next start` must not write at runtime.
+	if (process.env['NODE_ENV'] !== 'production') {
+		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: {
-			pluginConfig: {
-				...pluginConfig,
-				watch: { ...pluginConfig.watch, root: watchRoot },
-			},
+			pluginConfig,
 		},
 	}
 

package/src/types.ts

@@ -11,8 +11,6 @@ export type PluginConfig = {
 	watch?: {
 		/** 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[]
 	}
 }
 

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()