vite-plus 1.2.0 → 1.4.0

package/dist/script-preload.cjs

@@ -0,0 +1,468 @@
+// \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, 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];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule || !__hasOwnProp.call(mod, "default") ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+let node_module = require("node:module");
+node_module = __toESM(node_module, 1);
+let node_path = require("node:path");
+node_path = __toESM(node_path, 1);
+let node_worker_threads = require("node:worker_threads");
+let node_net = require("node:net");
+// ../../oxc-node/packages/core/signal-ack.mjs
+var import_lib = (/* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const BuiltinModule = require("module");
+	const path = require("path");
+	const nodeModulesRegex = /^(?:.*[\\/])?node_modules(?:[\\/].*)?$/;
+	const Module = module.constructor.length > 1 ? module.constructor : BuiltinModule;
+	const HOOK_RETURNED_NOTHING_ERROR_MESSAGE = "[Pirates] A hook returned a non-string, or nothing at all! This is a violation of intergalactic law!\n--------------------\nIf you have no idea what this means or what Pirates is, let me explain: Pirates is a module that makes it easy to implement require hooks. One of the require hooks you're using uses it. One of these require hooks didn't return anything from it's handler, so we don't know what to do. You might want to debug this.";
+	/**
+	* @param {string} filename The filename to check.
+	* @param {string[]} exts The extensions to hook. Should start with '.' (ex. ['.js']).
+	* @param {Matcher|null} matcher A matcher function, will be called with path to a file. Should return truthy if the file should be hooked, falsy otherwise.
+	* @param {boolean} ignoreNodeModules Auto-ignore node_modules. Independent of any matcher.
+	*/
+	function shouldCompile(filename, exts, matcher, ignoreNodeModules) {
+		if (typeof filename !== "string") return false;
+		if (exts.indexOf(path.extname(filename)) === -1) return false;
+		const resolvedFilename = path.resolve(filename);
+		if (ignoreNodeModules && nodeModulesRegex.test(resolvedFilename)) return false;
+		if (matcher && typeof matcher === "function") return !!matcher(resolvedFilename);
+		return true;
+	}
+	/**
+	* @callback Hook The hook. Accepts the code of the module and the filename.
+	* @param {string} code
+	* @param {string} filename
+	* @returns {string}
+	*/
+	/**
+	* @callback Matcher A matcher function, will be called with path to a file.
+	*
+	* Should return truthy if the file should be hooked, falsy otherwise.
+	* @param {string} path
+	* @returns {boolean}
+	*/
+	/**
+	* @callback RevertFunction Reverts the hook when called.
+	* @returns {void}
+	*/
+	/**
+	* @typedef {object} Options
+	* @property {Matcher|null} [matcher=null] A matcher function, will be called with path to a file.
+	*
+	* Should return truthy if the file should be hooked, falsy otherwise.
+	*
+	* @property {string[]} [extensions=['.js']] The extensions to hook. Should start with '.' (ex. ['.js']).
+	* @property {string[]} [exts=['.js']] The extensions to hook. Should start with '.' (ex. ['.js']).
+	*
+	* @property {string[]} [extension=['.js']] The extensions to hook. Should start with '.' (ex. ['.js']).
+	* @property {string[]} [ext=['.js']] The extensions to hook. Should start with '.' (ex. ['.js']).
+	*
+	* @property {boolean} [ignoreNodeModules=true] Auto-ignore node_modules. Independent of any matcher.
+	*/
+	/**
+	* Add a require hook.
+	*
+	* @param {Hook} hook The hook. Accepts the code of the module and the filename. Required.
+	* @param {Options} [opts] Options
+	* @returns {RevertFunction} The `revert` function. Reverts the hook when called.
+	*/
+	function addHook(hook, opts = {}) {
+		let reverted = false;
+		const loaders = [];
+		const oldLoaders = [];
+		let exts;
+		const originalJSLoader = Module._extensions[".js"];
+		const matcher = opts.matcher || null;
+		const ignoreNodeModules = opts.ignoreNodeModules !== false;
+		exts = opts.extensions || opts.exts || opts.extension || opts.ext || [".js"];
+		if (!Array.isArray(exts)) exts = [exts];
+		exts.forEach((ext) => {
+			if (typeof ext !== "string") throw new TypeError(`Invalid Extension: ${ext}`);
+			const oldLoader = Module._extensions[ext] || originalJSLoader;
+			oldLoaders[ext] = Module._extensions[ext];
+			loaders[ext] = Module._extensions[ext] = function newLoader(mod, filename) {
+				let compile;
+				if (!reverted) {
+					if (shouldCompile(filename, exts, matcher, ignoreNodeModules)) {
+						compile = mod._compile;
+						mod._compile = function _compile(code) {
+							mod._compile = compile;
+							const newCode = hook(code, filename);
+							if (typeof newCode !== "string") throw new Error(HOOK_RETURNED_NOTHING_ERROR_MESSAGE);
+							return mod._compile(newCode, filename);
+						};
+					}
+				}
+				oldLoader(mod, filename);
+			};
+		});
+		return function revert() {
+			if (reverted) return;
+			reverted = true;
+			exts.forEach((ext) => {
+				if (Module._extensions[ext] === loaders[ext]) {
+					if (!oldLoaders[ext]) delete Module._extensions[ext];
+					else Module._extensions[ext] = oldLoaders[ext];
+				}
+			});
+		};
+	}
+	exports.addHook = addHook;
+})))();
+/**
+* Ack every SIGINT this process gets, for as long as the app listens for SIGINT
+* itself. An app that does not keeps Node.js' default and dies on the signal,
+* so there is nothing to ack, and the extra listener must not keep it alive.
+*
+* A no-op unless OXNODE_SIGNAL_ACK is set. Call it on the main thread only.
+*/
+function installSignalAck() {
+	const path = process.env.OXNODE_SIGNAL_ACK;
+	delete process.env.OXNODE_SIGNAL_ACK;
+	if (!path) return;
+	let socket = null;
+	let installed = false;
+	const ack = () => {
+		socket?.write("I");
+	};
+	const getMaxListeners = process.getMaxListeners.bind(process);
+	const setMaxListeners = process.setMaxListeners.bind(process);
+	let raised = null;
+	const raise = () => {
+		const max = getMaxListeners();
+		raised = max > 0 && Number.isFinite(max) ? max + 1 : null;
+		if (raised !== null) setMaxListeners(raised);
+	};
+	const lower = () => {
+		if (raised !== null && getMaxListeners() === raised) setMaxListeners(raised - 1);
+		raised = null;
+	};
+	const install = () => {
+		installed = true;
+		raise();
+		if (!socket) {
+			socket = (0, node_net.connect)(path);
+			socket.on("error", () => {
+				socket = null;
+			});
+			socket.unref();
+		}
+		process.prependListener("SIGINT", ack);
+	};
+	const listeners = process.listeners.bind(process);
+	const rawListeners = process.rawListeners.bind(process);
+	const listenerCount = process.listenerCount.bind(process);
+	if (listenerCount("SIGINT") > 0) install();
+	process.on("newListener", (event, listener) => {
+		if (event === "SIGINT" && listener !== ack && !installed) install();
+	});
+	process.on("removeListener", (event, listener) => {
+		if (event !== "SIGINT") return;
+		if (listener === ack) {
+			installed = false;
+			lower();
+			return;
+		}
+		const left = rawListeners("SIGINT");
+		if (installed && left.length === 1 && left[0] === ack) process.removeListener("SIGINT", ack);
+	});
+	const visible = (list) => list.filter((listener) => listener !== ack);
+	process.listeners = (event) => {
+		const list = listeners(event);
+		return event === "SIGINT" ? visible(list) : list;
+	};
+	process.rawListeners = (event) => {
+		const list = rawListeners(event);
+		return event === "SIGINT" ? visible(list) : list;
+	};
+	process.listenerCount = (event, ...rest) => {
+		const count = listenerCount(event, ...rest);
+		if (event !== "SIGINT" || !installed || rest.length > 0) return count;
+		return count - 1;
+	};
+	process.getMaxListeners = () => {
+		const max = getMaxListeners();
+		return raised !== null && max === raised ? max - 1 : max;
+	};
+	process.setMaxListeners = (n) => {
+		setMaxListeners(n);
+		if (installed) raise();
+		return process;
+	};
+}
+// ../../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 (node_worker_threads.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;
+	};
+}
+// 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 (0, node_module.createRequire)(require("url").pathToFileURL(__filename).href)("../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];
+}
+/** Must match `engines.node` in package.json; `__tests__/vpx-script.spec.ts` checks it. */
+const SUPPORTED_NODE_RANGE = "^22.18.0 || ^24.11.0 || >=26.0.0";
+function isSupportedNodeVersion(version) {
+	const [major = 0, minor = 0] = version.split(".").map(Number);
+	if (major === 22) return minor >= 18;
+	if (major === 24) return minor >= 11;
+	return major >= 26;
+}
+/**
+* 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 = require("url").pathToFileURL(__filename).href;
+/**
+* CommonJS output (a file without `import`/`export`) loads helpers with `require()`,
+* which never reaches the `module.register()` hooks, while `registerHooks()` hands it
+* to Node.js' CommonJS resolution. Both go through `Module._resolveFilename`, so this
+* wraps it to resolve the helpers from this package, as upstream's `register.mjs` does.
+* The mapped specifier is not a helper specifier, so resolving it falls through.
+*/
+function routeHelperRequires(Module) {
+	const resolveFilename = Module._resolveFilename;
+	const requireFromHere = (0, node_module.createRequire)(HELPERS_PARENT_URL);
+	Module._resolveFilename = function(request, parent, isMain, options) {
+		const helper = runtimeHelperSpecifier(request);
+		return helper ? requireFromHere.resolve(helper) : resolveFilename.call(this, request, parent, isMain, options);
+	};
+}
+/**
+* The first line of oxc-node's error for `require()` of an ES module with top-level
+* await, worded as Node.js words it.
+*/
+const REQUIRE_ASYNC_MODULE_MESSAGE = "require() cannot be used on an ESM graph with top-level await. Use import() instead.";
+/**
+* Give oxc-node's `require()`-with-top-level-await error the code Node.js uses, which
+* code catches to fall back to `import()`; the binding can only report `GenericFailure`.
+* Mirrors upstream's `register.mjs` (oxc-project/oxc-node#842).
+*/
+function withRequireAsyncModuleCode(error) {
+	if (error instanceof Error && error.message.startsWith(REQUIRE_ASYNC_MODULE_MESSAGE)) error.code = "ERR_REQUIRE_ASYNC_MODULE";
+	return error;
+}
+/**
+* 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);
+}
+// src/script-preload.ts
+if (!isSupportedNodeVersion(process.versions.node)) {
+	process.stderr.write(`error: Running scripts with vpx requires Node.js ${SUPPORTED_NODE_RANGE} (current: ${process.version})\n`);
+	process.exit(1);
+}
+if (node_worker_threads.isMainThread) installSignalAck();
+const oxcNode = loadOxcNode();
+const watch = threadWatchSink();
+if (watch) oxcNode.enableWatchReport();
+oxcNode.setTsconfigPath(process.env.VP_SCRIPT_TSCONFIG);
+oxcNode.setTransformDeps("typescript");
+(0, node_module.setSourceMapsSupport)(true, {
+	nodeModules: true,
+	generatedCode: true
+});
+routeHelperRequires(node_module.default);
+const EXTENSIONS = [
+	".js",
+	".jsx",
+	".ts",
+	".tsx",
+	".mjs",
+	".mts",
+	".cjs",
+	".cts",
+	".es6",
+	".es"
+];
+const NODE_MODULES = `${node_path.default.sep}node_modules${node_path.default.sep}`;
+const SOURCEMAP_PREFIX = "\n//# sourceMappingURL=data:application/json;charset=utf-8;base64,";
+const transformer = new oxcNode.OxcTransformer(process.cwd(), HELPER_MODULE_NAME);
+(0, import_lib.addHook)((code, filename) => {
+	let output;
+	try {
+		output = transformer.transform(filename, code);
+	} catch (error) {
+		throw withRequireAsyncModuleCode(error);
+	} finally {
+		if (watch) flush(watch, oxcNode.takeWatchDependencies);
+	}
+	const source = output.source;
+	const sourceMap = output.sourceMap;
+	return sourceMap ? source + SOURCEMAP_PREFIX + Buffer.from(sourceMap, "utf8").toString("base64") : source;
+}, {
+	exts: EXTENSIONS,
+	ignoreNodeModules: false,
+	matcher: (filename) => !filename.includes(NODE_MODULES) || oxcNode.transformsDep(filename)
+});
+const resolve = (specifier, context, nextResolve) => resolveWithOxcNode(oxcNode, specifier, context, nextResolve);
+const load = (url, context, nextLoad) => {
+	if (isCommonJsRequire(context)) return nextLoad(url, context);
+	const result = oxcNode.load(url, context, nextLoad, HELPER_MODULE_NAME);
+	if (result.format === "commonjs" && result.source == null) return {
+		format: "commonjs",
+		source: null,
+		responseURL: result.responseURL ?? url
+	};
+	return result;
+};
+if (canRegisterSyncHooks(process.versions.node)) (0, node_module.registerHooks)(watch ? {
+	resolve: withFlush(resolve, watch, oxcNode.takeWatchDependencies),
+	load: withFlush(load, watch, oxcNode.takeWatchDependencies)
+} : {
+	resolve,
+	load
+});

package/dist/script-register.d.ts

@@ -0,0 +1 @@
+export {}

package/dist/script-register.js

@@ -0,0 +1,22 @@
+import { a as threadWatchSink, n as canRegisterSyncHooks, o as createRelay, r as loadOxcNode } from "./script-hooks-9Fof5UMY.js";
+import * as NodeModule from "node:module";
+// src/script-register.ts
+/**
+* `--import` entry for `vpx <script>`; `script-preload.ts` (the `--require` entry) runs
+* first and does the rest.
+*
+* Where `canRegisterSyncHooks` rules out the in-thread hooks, it registers the off-thread
+* ESM hooks through `module.register()`, which Node.js 22 cannot run from a `--require`.
+* On every version, an `--import` makes Node.js run the entry point through the ESM
+* loader, where the hooks decide each file's module format.
+*/
+const { register } = NodeModule;
+if (!canRegisterSyncHooks(process.versions.node)) {
+	const watch = threadWatchSink();
+	const watchPort = watch ? createRelay(watch, loadOxcNode().takeWatchDependencies) : void 0;
+	register(new URL("./script-esm-hooks.js", import.meta.url), {
+		data: { watchPort },
+		transferList: watchPort ? [watchPort] : []
+	});
+}
+export {};

package/dist/script-watch.d.ts

@@ -0,0 +1 @@
+export {}