vite-plus 1.2.0 → 1.4.0

package/dist/{report-NhQk8VHb.js → report-DLHO30yZ.js}

@@ -1,4 +1,4 @@
-//#region src/migration/report.ts
+// src/migration/report.ts
 function createMigrationReport() {
 	return {
 		createdViteConfigCount: 0,
@@ -14,6 +14,7 @@ function createMigrationReport() {
 		rewrittenImportErrors: [],
 		eslintMigrated: false,
 		tsupMigrated: false,
+		tsxMigrated: false,
 		prettierMigrated: false,
 		nodeVersionFileMigrated: false,
 		setupVpVersionUpdatedFileCount: 0,
@@ -33,5 +34,4 @@ function addManualStep(report, step) {
 	if (!report || report.manualSteps.includes(step)) return;
 	report.manualSteps.push(step);
 }
-//#endregion
 export { addMigrationWarning as n, createMigrationReport as r, addManualStep as t };

package/dist/{resolve-vite-config-x47JetlI.js → resolve-vite-config-Dn5896A4.js}

@@ -1,8 +1,9 @@
-import { l as VITE_CONFIG_FILES } from "./constants-BW3g7VnD.js";
-import { u as withConfigMetadataResolution } from "./define-config-CIlk9scU.js";
+import { l as VITE_CONFIG_FILES } from "./constants-DRUnJ_Dz.js";
+import { u as withConfigMetadataResolution } from "./define-config-ChwJcu5e.js";
 import path from "node:path";
+import { findMonorepoRoot } from "../binding/index.js";
 import fs from "node:fs";
-//#region src/resolve-vite-config.ts
+// src/resolve-vite-config.ts
 /**
 * Find a vite config file by walking up from `startDir` to `stopDir`.
 * Returns the absolute path of the first config file found, or undefined.
@@ -10,13 +11,15 @@ import fs from "node:fs";
 function findViteConfigUp(startDir, stopDir) {
 	let dir = path.resolve(startDir);
 	const stop = path.resolve(stopDir);
+	const relative = path.relative(stop, dir);
+	if (relative === ".." || relative.startsWith(`..${path.sep}`) || path.isAbsolute(relative)) return;
 	while (true) {
 		for (const filename of VITE_CONFIG_FILES) {
 			const filePath = path.join(dir, filename);
 			if (fs.existsSync(filePath)) return filePath;
 		}
 		const parent = path.dirname(dir);
-		if (parent === dir || !parent.startsWith(stop)) break;
+		if (dir === stop || parent === dir) break;
 		dir = parent;
 	}
 }
@@ -33,31 +36,13 @@ function hasViteConfig(dir) {
 	return findViteConfig(dir) !== void 0;
 }
 /**
-* Find the workspace root by walking up from `startDir` looking for
-* monorepo indicators (pnpm-workspace.yaml, workspaces in package.json, lerna.json).
-*/
-function findWorkspaceRoot(startDir) {
-	let dir = path.resolve(startDir);
-	while (true) {
-		if (fs.existsSync(path.join(dir, "pnpm-workspace.yaml"))) return dir;
-		const pkgPath = path.join(dir, "package.json");
-		if (fs.existsSync(pkgPath)) try {
-			if (JSON.parse(fs.readFileSync(pkgPath, "utf-8")).workspaces) return dir;
-		} catch {}
-		if (fs.existsSync(path.join(dir, "lerna.json"))) return dir;
-		const parent = path.dirname(dir);
-		if (parent === dir) break;
-		dir = parent;
-	}
-}
-/**
 * Resolve vite.config.ts and return the config object.
 */
 async function resolveViteConfig(cwd, options) {
 	const { resolveConfig } = await import("./index.js");
 	return withConfigMetadataResolution(async () => {
 		if (options?.traverseUp && !hasViteConfig(cwd)) {
-			const workspaceRoot = findWorkspaceRoot(cwd);
+			const workspaceRoot = findMonorepoRoot(cwd);
 			if (workspaceRoot) {
 				const configFile = findViteConfigUp(path.dirname(cwd), workspaceRoot);
 				if (configFile) return resolveConfig({
@@ -86,5 +71,4 @@ async function resolveUniversalViteConfig(err, viteConfigCwd) {
 		throw resolveErr;
 	}
 }
-//#endregion
-export { resolveUniversalViteConfig as a, hasViteConfig as i, findViteConfigUp as n, resolveViteConfig as o, findWorkspaceRoot as r, findViteConfig as t };
+export { resolveViteConfig as a, resolveUniversalViteConfig as i, findViteConfigUp as n, hasViteConfig as r, findViteConfig as t };

package/dist/resolve-vite-config-QO6cC0SP.js

@@ -0,0 +1 @@
+export { i as resolveUniversalViteConfig } from "./resolve-vite-config-Dn5896A4.js";

package/dist/{rolldown-runtime-CMFfr-1z.js → rolldown-runtime-DegdyBIC.js}

@@ -1,12 +1,12 @@
 import { createRequire } from "node:module";
-//#region \0rolldown/runtime.js
+// \0rolldown/runtime.js
 var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __commonJSMin = (cb, mod) => () => (mod || (cb((mod = { exports: {} }).exports, mod), cb = null), mod.exports);
+var __commonJSMin = (cb, mod) => () => (mod || (cb((mod = { exports: {} }).exports, mod, mod.exports), cb = null), mod.exports);
 var __copyProps = (to, from, except, desc) => {
 	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
 		key = keys[i];
@@ -22,5 +22,4 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 	enumerable: true
 }) : target, mod));
 var __require = /* #__PURE__ */ (() => createRequire(import.meta.url))();
-//#endregion
 export { __require as n, __toESM as r, __commonJSMin as t };

package/dist/script-esm-hooks.d.ts

@@ -0,0 +1,8 @@
+import { InitializeHook, LoadHook, ResolveHook } from "node:module";
+import { MessagePort } from "node:worker_threads";
+/** Receives the port `script-register.ts` relays watch reports through. */
+export declare const initialize: InitializeHook<{
+  watchPort?: MessagePort;
+} | undefined>;
+export declare const resolve: ResolveHook;
+export declare const load: LoadHook;

package/dist/script-esm-hooks.js

@@ -0,0 +1,24 @@
+import { i as resolveWithOxcNode, r as loadOxcNode, s as withFlush, t as HELPER_MODULE_NAME } from "./script-hooks-9Fof5UMY.js";
+import { MessageChannel, isMainThread } from "node:worker_threads";
+// src/script-esm-hooks.ts
+const oxcNode = loadOxcNode();
+if (!isMainThread) new MessageChannel().port1.ref();
+const resolveHook = (specifier, context, nextResolve) => resolveWithOxcNode(oxcNode, specifier, context, nextResolve);
+const loadHook = (url, context, nextLoad) => oxcNode.load(url, context, nextLoad, HELPER_MODULE_NAME);
+/** Under watch mode, the hooks wrapped to report what each call read or looked for. */
+let watchHooks;
+/** Receives the port `script-register.ts` relays watch reports through. */
+const initialize = (data) => {
+	const port = data?.watchPort;
+	if (port) {
+		port.unref();
+		const sink = (message) => port.postMessage(message);
+		watchHooks = {
+			resolve: withFlush(resolveHook, sink, oxcNode.takeWatchDependencies),
+			load: withFlush(loadHook, sink, oxcNode.takeWatchDependencies)
+		};
+	}
+};
+const resolve = (specifier, context, nextResolve) => (watchHooks?.resolve ?? resolveHook)(specifier, context, nextResolve);
+const load = (url, context, nextLoad) => (watchHooks?.load ?? loadHook)(url, context, nextLoad);
+export { initialize, load, resolve };

package/dist/script-hooks-9Fof5UMY.js

@@ -0,0 +1,176 @@
+import { createRequire } from "node:module";
+import { MessageChannel, isMainThread, receiveMessageOnPort } from "node:worker_threads";
+// ../../oxc-node/packages/core/watch-report.mjs
+const WATCH_CHANNEL = "@oxc-node/core:watch-deps";
+/**
+* Where this thread sends its reports, or `null` when nobody is watching. With
+* `null` nothing is wrapped, opened or listened to.
+*
+* @returns {((message: { "watch:import": string[] }) => void) | null}
+*/
+function watchSink() {
+	if (!process.env.WATCH_REPORT_DEPENDENCIES) return null;
+	if (isMainThread) {
+		if (typeof process.send !== "function") return null;
+		const seen = /* @__PURE__ */ new Set();
+		const send = (message) => {
+			const url = message?.["watch:import"]?.[0];
+			if (typeof url !== "string" || seen.has(url) || !process.connected) return;
+			seen.add(url);
+			try {
+				process.send(message, () => {});
+			} catch {}
+		};
+		const channel = new BroadcastChannel(WATCH_CHANNEL);
+		channel.onmessage = (event) => send(event.data);
+		channel.unref();
+		return send;
+	}
+	const channel = new BroadcastChannel(WATCH_CHANNEL);
+	channel.unref();
+	return (message) => channel.postMessage(message);
+}
+/**
+* Send what the binding recorded, one URL per message: the watch parent reads a
+* whole array in one `try`, so one bad entry would drop the rest. `oxnode watch`
+* reads the `oxc-node` key to tell these from what Node.js reports (a tsconfig
+* in `node_modules` counts, an imported file there does not); Node.js ignores it.
+*
+* @param {(message: { "watch:import": string[], "oxc-node": true }) => void} sink
+* @param {() => string[]} take the binding's `takeWatchDependencies`
+*/
+function flush(sink, take) {
+	for (const url of take()) sink({
+		"watch:import": [url],
+		"oxc-node": true
+	});
+}
+/**
+* `fn`, flushing after each call whether it returns, throws or returns a promise.
+* A failed resolve records its candidates and then throws, which is exactly the
+* case that has to be reported. `sink` and `take` are as for `flush`.
+*/
+function withFlush(fn, sink, take) {
+	return function(...args) {
+		let result;
+		try {
+			result = fn.apply(this, args);
+		} catch (error) {
+			flush(sink, take);
+			throw error;
+		}
+		if (result && typeof result.then === "function") return result.then((value) => {
+			flush(sink, take);
+			return value;
+		}, (error) => {
+			flush(sink, take);
+			throw error;
+		});
+		flush(sink, take);
+		return result;
+	};
+}
+/**
+* For `module.register()`: the hooks run on a thread of their own with no
+* `process.send`, so they post into the returned port and the thread that
+* registered them forwards to `sink`. `take` is as for `flush`: what this thread's
+* binding recorded is drained here too, before the process ends.
+*/
+function createRelay(sink, take) {
+	const { port1, port2 } = new MessageChannel();
+	port1.on("message", sink);
+	port1.unref();
+	const drain = () => {
+		let received;
+		while (received = receiveMessageOnPort(port1)) sink(received.message);
+		flush(sink, take);
+	};
+	process.on("uncaughtExceptionMonitor", drain);
+	process.on("exit", drain);
+	return port2;
+}
+// src/script-hooks.ts
+/**
+* Shared pieces of the `vpx <script>` loader (see `script-preload.ts`).
+*/
+/**
+* The oxc-node hooks compiled into the Vite+ binding. Required, not imported: importing
+* `index.js` makes a `module.register()` hooks thread translate the whole CommonJS
+* binding for ESM, and `module.register()` waits for that (5-13 ms).
+*/
+function loadOxcNode() {
+	return createRequire(import.meta.url)("../binding/index.cjs").oxcNode;
+}
+const WATCH_SINK = Symbol.for("vite-plus:script-watch-sink");
+/**
+* Where this thread reports the files watch mode restarts on, or `null` when nobody is
+* watching (see oxc-node's `watchSink()`). It opens a channel, so it runs once per thread:
+* the preload and the `--import` entry are separate bundles and share it here.
+*/
+function threadWatchSink() {
+	const holder = globalThis;
+	if (holder[WATCH_SINK] === void 0) holder[WATCH_SINK] = watchSink();
+	return holder[WATCH_SINK];
+}
+/**
+* Whether to use the in-thread `module.registerHooks()` instead of the off-thread
+* `module.register()`, which needs a hooks thread (about twice the startup time) and
+* which Node.js deprecates from 25.9 (DEP0205).
+*
+* The in-thread hooks need two fixes: a sync resolve hook had its `conditions`
+* overridden (nodejs/node#59011, in 22.19 and 24.5), and a sync load hook could not
+* return a null source for CommonJS (nodejs/node#59929, in 22.22.3 and 24.11.1). tsx
+* switches at the same releases. Upstream oxc-node waits for 26.2 for a third fix,
+* nodejs/node#62920 (also in 24.18.0), which only matters when a load hook returns
+* CommonJS source. These hooks return it only for source another hook supplied, so
+* without that fix `require()` inside such a module can fail.
+*/
+function canRegisterSyncHooks(version) {
+	const [major = 0, minor = 0, patch = 0] = version.split(".").map(Number);
+	if (major === 22) return minor > 22 || minor === 22 && patch >= 3;
+	if (major === 24) return minor > 11 || minor === 11 && patch >= 1;
+	return major >= 26;
+}
+/**
+* The module name oxc-node gives the runtime helpers it injects, passed to its transformer
+* and load hook. Only these hooks emit it, so they redirect only their own helper imports,
+* not `@oxc-node/core/helpers/*` imports that another oxc-node copy produced.
+*/
+const HELPER_MODULE_NAME = "vite-plus:oxc-node";
+const OXC_NODE_HELPERS = `${HELPER_MODULE_NAME}/helpers/`;
+const RUNTIME_HELPERS = "@oxc-project/runtime/helpers/";
+/**
+* oxc-node lowers class fields, static blocks, `using`, and legacy decorators to
+* helper imports. The same helpers ship in `@oxc-project/runtime`, a dependency of
+* `vite-plus`; the hooks resolve them from here, because the user's project usually
+* does not have it.
+*/
+function runtimeHelperSpecifier(specifier) {
+	return specifier.startsWith(OXC_NODE_HELPERS) ? RUNTIME_HELPERS + specifier.slice(OXC_NODE_HELPERS.length) : void 0;
+}
+/** URL that runtime helper imports resolve from: this package. */
+const HELPERS_PARENT_URL = import.meta.url;
+/**
+* Whether this request comes from `require()`. Only `module.registerHooks()` shows
+* `require()` to the hooks; those requests stay on Node.js' CommonJS resolution and
+* the `pirates` hook. A CommonJS context never carries `importAttributes`.
+*/
+function isCommonJsRequire(context) {
+	return context?.importAttributes === void 0;
+}
+/**
+* The resolve hook for both hook paths: `require()` stays on Node.js' resolution, where
+* `routeHelperRequires` maps runtime helpers (it resolves from the requiring file and
+* ignores a `parentURL`), runtime helper imports resolve from this package, and
+* everything else goes through oxc-node.
+*/
+function resolveWithOxcNode(oxcNode, specifier, context, nextResolve) {
+	if (isCommonJsRequire(context)) return nextResolve(specifier, context);
+	const helper = runtimeHelperSpecifier(specifier);
+	if (helper) return nextResolve(helper, {
+		...context,
+		parentURL: HELPERS_PARENT_URL
+	});
+	return oxcNode.createResolve(specifier, context, nextResolve);
+}
+export { threadWatchSink as a, resolveWithOxcNode as i, canRegisterSyncHooks as n, createRelay as o, loadOxcNode as r, withFlush as s, HELPER_MODULE_NAME as t };