oxlint-plugin-vize 0.431.0 → 0.433.0

package/README.md

@@ -235,6 +235,8 @@ vp exec oxlint-vize -c .oxlintrc.json -f stylish src
 
 - Raw `oxlint` still misses files without `<script>` or `<script setup>`. It also anchors template diagnostics to an extracted script instead of the original template location. Use `oxlint-vize` when linting Vue and HTML files.
 - The wrapper's temporary files are not copied back when Oxlint fix flags are used; it warns when `--fix` or `--fix-suggestions` is passed.
+- With Oxlint 1.78 and an explicit complete JSON config containing `ignorePatterns` or `overrides`, the wrapper retains original file selection and ordered Vue overrides. This mode supports POSIX paths; inherited configs, import/type-aware project resolution, suppression state, ambiguous filenames, unsupported outside-root patterns and unknown option forms produce actionable errors.
+- Discovered, nested and dynamic configurations keep the existing wrapper path; the scoped JSON mode does not establish equivalent filtering for those configurations or other Oxlint versions.
 - Oxlint core rules that need JavaScript bindings extracted from Vue templates, such as template-aware unused-variable checks, still depend on upstream work in [Oxc's Better Vue Support](https://github.com/oxc-project/oxc/issues/15761).
 - Direct `oxlint` original-SFC ranges depend on the JS plugin reporting work tracked in [oxc-project/oxc#20465](https://github.com/oxc-project/oxc/issues/20465).
 - Type-aware Vize rules are experimental and excluded from the default exported configs. Opt into them explicitly with `configs.recommendedWithTypeAware`, `configs.opinionatedWithTypeAware`, or `createVizeRuleConfig({ includeTypeAware: true, preset: ... })`, and use `settings.vize.typeAware: true` when you want the shared full-file pass to run them eagerly.

package/dist/cli.mjs

@@ -2,6 +2,7 @@ import { i as hasVueLikeExtension, s as isStandaloneHtmlFile, t as appendScriptl
 import { spawn, spawnSync } from "node:child_process";
 import path from "node:path";
 import fs from "node:fs";
+import os from "node:os";
 //#region src/cli/args.ts
 const OPTION_NAMES_WITH_VALUES = new Set([
 	"-A",
@@ -9,27 +10,58 @@ const OPTION_NAMES_WITH_VALUES = new Set([
 	"-W",
 	"-c",
 	"-f",
+	"--allow",
 	"--config",
-	"--cwd",
+	"--debug",
 	"--deny",
 	"--format",
 	"--ignore-path",
 	"--ignore-pattern",
-	"--import-plugin",
-	"--jsx-a11y-plugin",
 	"--max-warnings",
-	"--nextjs-plugin",
-	"--node-plugin",
-	"--promise-plugin",
-	"--react-perf-plugin",
-	"--react-plugin",
+	"--report-unused-disable-directives-severity",
 	"--threads",
 	"--tsconfig",
-	"--typescript-plugin",
-	"--unicorn-plugin",
-	"--vitest-plugin",
 	"--warn"
 ]);
+const BOOLEAN_OPTIONS = new Set([
+	"-h",
+	"-V",
+	"--help",
+	"--version",
+	"--init",
+	"--fix",
+	"--fix-suggestions",
+	"--fix-dangerously",
+	"--quiet",
+	"--deny-warnings",
+	"--no-ignore",
+	"--silent",
+	"--no-error-on-unmatched-pattern",
+	"--print-config",
+	"--rules",
+	"--lsp",
+	"--disable-nested-config",
+	"--type-aware",
+	"--type-check",
+	"--type-check-only",
+	"--suppress-all",
+	"--prune-suppressions",
+	"--report-unused-disable-directives",
+	"--disable-unicorn-plugin",
+	"--disable-oxc-plugin",
+	"--disable-typescript-plugin",
+	"--import-plugin",
+	"--react-plugin",
+	"--jsdoc-plugin",
+	"--jest-plugin",
+	"--vitest-plugin",
+	"--jsx-a11y-plugin",
+	"--nextjs-plugin",
+	"--react-perf-plugin",
+	"--promise-plugin",
+	"--node-plugin",
+	"--vue-plugin"
+]);
 /**
 * Formats whose reports contain output even for a completely clean run.
 *
@@ -82,28 +114,51 @@ function getLintTargets(argv) {
 	}
 	return targets.length === 0 ? ["."] : targets;
 }
+/** Preserve original option/value pairs while replacing the selected target set. */
+function withoutLintTargets(argv) {
+	const options = [];
+	for (let index = 0; index < argv.length; index += 1) {
+		const arg = argv[index];
+		if (arg === "--") {
+			options.push(arg);
+			break;
+		}
+		if (OPTION_NAMES_WITH_VALUES.has(arg)) {
+			options.push(arg);
+			const value = argv[++index];
+			if (value == null || value === "--") throw new Error(`Scoped Vue transport requires a value for ${arg}.`);
+			options.push(value);
+		} else if (BOOLEAN_OPTIONS.has(arg) || arg.startsWith("--") && arg.includes("=") && OPTION_NAMES_WITH_VALUES.has(arg.slice(0, arg.indexOf("=")))) options.push(arg);
+		else if (arg.startsWith("-")) throw new Error(`Scoped Vue transport cannot preserve unsupported option form: ${arg}`);
+	}
+	return options;
+}
 //#endregion
 //#region src/cli/files.ts
 const GLOB_PATTERN = /[*?[\]{}]/u;
-function collectVueLikeFilesFromTargets(cwd, targets) {
+function collectVueLikeFilesFromTargets(cwd, targets, onCandidate) {
 	const files = /* @__PURE__ */ new Set();
-	for (const target of targets) for (const file of collectVueLikeFilesFromTarget(cwd, target)) files.add(file);
+	for (const target of targets) for (const file of collectVueLikeFilesFromTarget(cwd, target, onCandidate)) files.add(file);
 	return [...files].sort();
 }
-function collectVueLikeFilesFromTarget(cwd, target) {
+function collectVueLikeFilesFromTarget(cwd, target, onCandidate) {
+	const observe = (filename) => {
+		onCandidate?.(filename);
+		return filename;
+	};
+	const absoluteTarget = observe(path.resolve(cwd, target));
 	if (GLOB_PATTERN.test(target)) return fs.globSync(target, {
 		cwd,
 		withFileTypes: false,
 		exclude: ["**/node_modules/**", "**/.git/**"]
-	}).map((entry) => path.resolve(cwd, entry)).filter(isSupportedLintFile);
-	const absoluteTarget = path.resolve(cwd, target);
+	}).map((entry) => observe(path.resolve(cwd, entry))).filter(isSupportedLintFile);
 	if (!fs.existsSync(absoluteTarget)) return [];
 	const stat = fs.statSync(absoluteTarget);
 	if (stat.isDirectory()) return fs.globSync("**/*", {
 		cwd: absoluteTarget,
 		withFileTypes: false,
 		exclude: ["**/node_modules/**", "**/.git/**"]
-	}).map((entry) => path.resolve(absoluteTarget, entry)).filter(isSupportedLintFile);
+	}).map((entry) => observe(path.resolve(absoluteTarget, entry))).filter(isSupportedLintFile);
 	return stat.isFile() && hasVueLikeExtension(absoluteTarget) ? [absoluteTarget] : [];
 }
 function isSupportedLintFile(filename) {
@@ -211,7 +266,7 @@ function prepareScriptlessWorkaroundFiles(cwd, filenames) {
 		counter += 1;
 		fs.mkdirSync(path.dirname(tempFilename), { recursive: true });
 		fs.writeFileSync(tempFilename, appendScriptlessWorkaround(source, filename));
-		ignoreArgs.push("--ignore-pattern", toCliPath(relativeFilename));
+		ignoreArgs.push("--ignore-pattern", toCliPath$1(relativeFilename));
 		tempArgs.push(tempFilename);
 		registerPathReplacementVariants(pathReplacements, cwd, tempFilename, filename);
 	}
@@ -249,7 +304,7 @@ function removeEmptyDirectory(dirname) {
 function isIgnorableRemoveDirError(error) {
 	return error instanceof Error && "code" in error && (error.code === "ENOENT" || error.code === "ENOTDIR" || error.code === "ENOTEMPTY" || error.code === "EEXIST");
 }
-function toCliPath(filename) {
+function toCliPath$1(filename) {
 	return filename.split(path.sep).join("/");
 }
 function registerPathReplacementVariants(replacements, cwd, tempFilename, originalFilename) {
@@ -257,9 +312,9 @@ function registerPathReplacementVariants(replacements, cwd, tempFilename, origin
 	const relativeOriginalFilename = getReportedOriginalFilename(cwd, originalFilename);
 	const variants = new Set([
 		[tempFilename, relativeOriginalFilename],
-		[toCliPath(tempFilename), toCliPath(relativeOriginalFilename)],
+		[toCliPath$1(tempFilename), toCliPath$1(relativeOriginalFilename)],
 		[relativeTempFilename, relativeOriginalFilename],
-		[toCliPath(relativeTempFilename), toCliPath(relativeOriginalFilename)]
+		[toCliPath$1(relativeTempFilename), toCliPath$1(relativeOriginalFilename)]
 	]);
 	for (const [from, to] of variants) {
 		if (!from || !to) continue;
@@ -272,21 +327,234 @@ function getReportedOriginalFilename(cwd, filename) {
 	return filename;
 }
 //#endregion
+//#region src/cli/scoped-config.ts
+function readScopedConfig(cwd, args) {
+	let file;
+	for (let index = 0; index < args.length && args[index] !== "--"; index += 1) if (args[index] === "-c" || args[index] === "--config") file = args[++index];
+	else if (args[index].startsWith("--config=")) file = args[index].slice(9);
+	if (file == null || !file.endsWith(".json")) return void 0;
+	file = path.resolve(cwd, file);
+	const bytes = fs.readFileSync(file, "utf8");
+	let value;
+	try {
+		value = JSON.parse(bytes);
+	} catch {
+		return;
+	}
+	if (!isRecord(value) || value.ignorePatterns == null && value.overrides == null) return void 0;
+	if (!fs.lstatSync(file).isFile() || fs.lstatSync(file).isSymbolicLink()) throw new Error(`Scoped Vue transport requires a regular JSON config: ${file}`);
+	return {
+		file,
+		bytes,
+		value
+	};
+}
+function validateScopedConfig(config, args) {
+	const value = config.value;
+	if (path.parse(config.file).root !== "/") throw new Error("Scoped Vue transport cannot preserve non-POSIX filesystem roots.");
+	if (value.extends != null && (!Array.isArray(value.extends) || value.extends.length !== 0)) throw new Error("Scoped Vue transport cannot preserve inherited configs; use a complete JSON config.");
+	if (args.includes("--cwd") || args.some((arg) => arg.startsWith("--cwd="))) throw new Error("Scoped Vue transport requires the process cwd; remove --cwd.");
+	if (args.some((arg) => [
+		"--type-aware",
+		"--type-check",
+		"--type-check-only"
+	].includes(arg)) || isRecord(value.options) && (value.options.typeAware || value.options.typeCheck)) throw new Error("Scoped Vue transport cannot preserve Oxlint's type-aware project graph.");
+	if (args.some((arg) => ["--import-plugin", "--tsconfig"].includes(arg) || arg.startsWith("--import-plugin=") || arg.startsWith("--tsconfig=")) || Array.isArray(value.plugins) && value.plugins.includes("import") || Array.isArray(value.overrides) && value.overrides.some((row) => isRecord(row) && Array.isArray(row.plugins) && row.plugins.includes("import"))) throw new Error("Scoped Vue transport cannot preserve Oxlint's import/project resolution.");
+}
+function validateSelectionPaths(cwd, candidates) {
+	if (/[\r\n\\]/u.test(cwd) || [...candidates].some((file) => /[\r\n\\]/u.test(file))) throw new Error("Scoped Vue transport cannot preserve filenames containing CR, LF or backslash.");
+	if (fs.existsSync(path.join(cwd, "oxlint-suppressions.json"))) throw new Error("Scoped Vue transport cannot preserve path-sensitive suppression state.");
+}
+function createScopedMirror(cwd, config, files) {
+	const root = fs.mkdtempSync(path.join(os.tmpdir(), "oxlint-vize-"));
+	const configDir = path.dirname(config.file);
+	const sibling = path.join(configDir, `${path.basename(root)}.json`);
+	let ownsSibling = false;
+	const cleanup = () => {
+		try {
+			if (ownsSibling) fs.unlinkSync(sibling);
+		} finally {
+			fs.rmSync(root, {
+				recursive: true,
+				force: true
+			});
+		}
+	};
+	try {
+		if (contains(configDir, root) || contains(cwd, root)) throw new Error("Scoped Vue transport requires a temporary directory outside the lint/config roots.");
+		const originalsToCopies = /* @__PURE__ */ new Map();
+		const pathReplacements = /* @__PURE__ */ new Map();
+		for (const file of files) {
+			if (isStandaloneHtmlFile(file)) throw new Error("Scoped Vue transport requires .vue targets; HTML filtering is not equivalent.");
+			const relative = path.relative(configDir, file);
+			const copy = contains(configDir, file) ? path.join(root, "inside", relative) : path.join(root, "outside", file.slice(path.parse(file).root.length));
+			if (path.parse(file).root !== path.parse(configDir).root) throw new Error("Scoped Vue transport cannot preserve files on another filesystem root.");
+			const source = fs.readFileSync(file, "utf8");
+			fs.mkdirSync(path.dirname(copy), { recursive: true });
+			fs.writeFileSync(copy, appendScriptlessWorkaround(source, file), { flag: "wx" });
+			originalsToCopies.set(file, copy);
+			registerPathReplacementVariants(pathReplacements, cwd, copy, file);
+		}
+		const copyPatterns = [...originalsToCopies.values()].map(literalGlob);
+		const outside = [...originalsToCopies].filter(([file]) => !contains(configDir, file));
+		const insidePrefix = toCliPath(path.join(root, "inside"));
+		const outsidePrefix = toCliPath(path.join(root, "outside"));
+		const mapPatterns = (value) => {
+			if (!Array.isArray(value) || value.some((item) => typeof item !== "string")) throw new Error("Scoped Vue transport requires string-array override patterns.");
+			return value.flatMap((pattern) => {
+				if (pattern.startsWith("!")) throw new Error("Scoped Vue transport cannot preserve negated override patterns.");
+				if (path.isAbsolute(pattern)) return [`${literalGlob(outsidePrefix)}${toCliPath(pattern)}`];
+				const mapped = [`${literalGlob(insidePrefix)}/${pattern}`];
+				if (outside.length === 0) return mapped;
+				if (pattern === "**/*.vue") return [...mapped, ...outside.map(([, copy]) => literalGlob(copy))];
+				const first = pattern.split("/")[0];
+				if (first && !/[*?[\]{}\\]/u.test(first)) return mapped;
+				throw new Error(`Scoped Vue transport cannot preserve outside-root override pattern: ${pattern}`);
+			});
+		};
+		const overrides = config.value.overrides;
+		if (overrides != null && !Array.isArray(overrides)) throw new Error("Scoped Vue transport requires an override array.");
+		const borrowed = {
+			...config.value,
+			overrides: (overrides ?? []).flatMap((row) => {
+				if (!isRecord(row)) throw new Error("Scoped Vue transport requires object overrides.");
+				const files = mapPatterns(row.files);
+				const excludes = row.excludeFiles == null ? [] : mapPatterns(row.excludeFiles);
+				return [{
+					...row,
+					excludeFiles: [...strings(row.excludeFiles), ...copyPatterns]
+				}, {
+					...row,
+					files,
+					...excludes.length ? { excludeFiles: excludes } : { excludeFiles: [] }
+				}];
+			})
+		};
+		const descriptor = fs.openSync(sibling, "wx");
+		ownsSibling = true;
+		try {
+			fs.writeFileSync(descriptor, `${JSON.stringify(borrowed, null, 2)}\n`);
+		} finally {
+			fs.closeSync(descriptor);
+		}
+		if (fs.readFileSync(config.file, "utf8") !== config.bytes) throw new Error("Oxlint config changed while preparing its scoped Vue transport.");
+		return {
+			sibling,
+			originalsToCopies,
+			pathReplacements,
+			cleanup
+		};
+	} catch (error) {
+		cleanup();
+		throw error;
+	}
+}
+function isRecord(value) {
+	return typeof value === "object" && value != null && !Array.isArray(value);
+}
+function strings(value) {
+	if (value == null) return [];
+	if (!Array.isArray(value) || value.some((item) => typeof item !== "string")) throw new Error("Scoped Vue transport requires string-array override patterns.");
+	return value;
+}
+function contains(directory, file) {
+	const relative = path.relative(directory, file);
+	return relative !== ".." && !relative.startsWith(`..${path.sep}`) && !path.isAbsolute(relative);
+}
+function toCliPath(file) {
+	return file.split(path.sep).join("/");
+}
+function literalGlob(file) {
+	return toCliPath(file).replaceAll(/[\\*?[\]{}]/gu, String.raw`\$&`);
+}
+//#endregion
+//#region src/cli/scoped-selection.ts
+async function prepareScopedSelection(cwd, originalArgs, vueFiles, run, candidates) {
+	if (vueFiles.length === 0) return void 0;
+	const config = readScopedConfig(cwd, originalArgs);
+	if (config == null) return void 0;
+	const options = withoutLintTargets(originalArgs);
+	if (options.some((arg) => [
+		"--debug",
+		"--print-config",
+		"--rules",
+		"--lsp",
+		"--init",
+		"-h",
+		"--help",
+		"-V",
+		"--version",
+		"--suppress-all",
+		"--prune-suppressions"
+	].includes(arg) || arg.startsWith("--debug="))) throw new Error("Scoped Vue transport cannot combine linting with other Oxlint inspection modes.");
+	validateSelectionPaths(cwd, candidates);
+	const selection = await run([
+		"--debug",
+		"files",
+		...originalArgs
+	]);
+	if (selection.status !== 0) return { result: selection };
+	validateScopedConfig(config, originalArgs);
+	const selected = parseFiles(cwd, selection);
+	if (selected.some((file) => !candidates.has(file))) throw new Error("Scoped Vue transport cannot bind every selected file to an original candidate.");
+	const selectedVue = vueFiles.filter((file) => selected.includes(file));
+	if (selectedVue.length === 0) return { result: await run(originalArgs) };
+	const mirror = createScopedMirror(cwd, config, selectedVue);
+	try {
+		const args = [...options];
+		for (let index = 0; index < args.length && args[index] !== "--"; index += 1) if (args[index] === "-c" || args[index] === "--config") args[++index] = mirror.sibling;
+		else if (args[index].startsWith("--config=")) args[index] = `--config=${mirror.sibling}`;
+		const projected = selected.map((file) => mirror.originalsToCopies.get(file) ?? file).sort();
+		args.push(...projected);
+		const transported = await run([
+			"--debug",
+			"files",
+			...args
+		]);
+		if (transported.status !== 0 || transported.stderr !== "" || !equalFiles(projected, parseFiles(cwd, transported))) throw new Error("Scoped Vue transport changed Oxlint's selected files. The current ignore/config envelope cannot preserve original path ownership.\n" + transported.stdout + transported.stderr);
+		return {
+			args,
+			prepared: {
+				appendedArgs: [],
+				pathReplacements: mirror.pathReplacements,
+				usedScriptlessWorkaround: true,
+				cleanup: mirror.cleanup
+			}
+		};
+	} catch (error) {
+		mirror.cleanup();
+		throw error;
+	}
+}
+function parseFiles(cwd, result) {
+	if (result.stderr !== "") throw new Error(`Oxlint file selection emitted unexpected stderr: ${result.stderr}`);
+	const lines = result.stdout.split("\n");
+	if (lines.at(-1) === "") lines.pop();
+	if (lines.some((line) => line === "" || line.includes("\r"))) throw new Error("Oxlint file selection did not return a complete path per line.");
+	const files = lines.map((file) => path.resolve(cwd, file));
+	if (new Set(files).size !== files.length) throw new Error("Oxlint file selection returned duplicate paths.");
+	return files.sort();
+}
+function equalFiles(expected, actual) {
+	return expected.length === actual.length && expected.every((file, index) => file === actual[index]);
+}
+//#endregion
 //#region src/cli.ts
 async function main() {
 	const cwd = process.cwd();
 	const forwardedArgs = process.argv.slice(2);
-	const lintFiles = collectVueLikeFilesFromTargets(cwd, getLintTargets(forwardedArgs));
+	const targets = getLintTargets(forwardedArgs);
+	const candidates = /* @__PURE__ */ new Set();
+	const lintFiles = collectVueLikeFilesFromTargets(cwd, targets, (file) => candidates.add(file));
 	const oxlintEntrypoint = resolveOxlintCliEntrypoint(cwd);
 	verifyOxlintCliEntrypoint(process.execPath, oxlintEntrypoint);
-	const prepared = prepareScriptlessWorkaroundFiles(cwd, lintFiles);
-	const args = [
-		oxlintEntrypoint,
-		...forwardedArgs,
-		...prepared.appendedArgs
-	];
+	const scoped = await prepareScopedSelection(cwd, forwardedArgs, lintFiles, (args) => runOxlint(process.execPath, [oxlintEntrypoint, ...args], cwd), candidates);
+	const sourceResult = scoped && "result" in scoped ? scoped.result : void 0;
+	const transport = scoped && "prepared" in scoped ? scoped : void 0;
+	const prepared = sourceResult ? prepareScriptlessWorkaroundFiles(cwd, []) : transport?.prepared ?? prepareScriptlessWorkaroundFiles(cwd, lintFiles);
+	const args = [oxlintEntrypoint, ...transport?.args ?? [...forwardedArgs, ...prepared.appendedArgs]];
 	try {
-		const result = await runOxlint(process.execPath, args, cwd);
+		const result = sourceResult ?? await runOxlint(process.execPath, args, cwd);
 		const stdout = rewriteReportedPaths(result.stdout, prepared.pathReplacements);
 		const stderr = rewriteReportedPaths(result.stderr, prepared.pathReplacements);
 		if (stdout) await writeStream(process.stdout, stdout);

package/package.json

@@ -12,7 +12,7 @@
   "devDependencies": {
     "@tsdown/css": "0.22.14",
     "@types/node": "25.9.2",
-    "@vizejs/native": "0.431.0",
+    "@vizejs/native": "0.433.0",
     "tsdown": "0.22.14",
     "typescript": "6.0.3",
     "vite": "npm:@voidzero-dev/vite-plus-core@0.1.24",
@@ -49,14 +49,14 @@
   },
   "name": "oxlint-plugin-vize",
   "optionalDependencies": {
-    "@vizejs/native-darwin-arm64": "0.431.0",
-    "@vizejs/native-darwin-x64": "0.431.0",
-    "@vizejs/native-linux-arm64-gnu": "0.431.0",
-    "@vizejs/native-linux-arm64-musl": "0.431.0",
-    "@vizejs/native-linux-x64-gnu": "0.431.0",
-    "@vizejs/native-linux-x64-musl": "0.431.0",
-    "@vizejs/native-win32-arm64-msvc": "0.431.0",
-    "@vizejs/native-win32-x64-msvc": "0.431.0"
+    "@vizejs/native-darwin-arm64": "0.433.0",
+    "@vizejs/native-darwin-x64": "0.433.0",
+    "@vizejs/native-linux-arm64-gnu": "0.433.0",
+    "@vizejs/native-linux-arm64-musl": "0.433.0",
+    "@vizejs/native-linux-x64-gnu": "0.433.0",
+    "@vizejs/native-linux-x64-musl": "0.433.0",
+    "@vizejs/native-win32-arm64-msvc": "0.433.0",
+    "@vizejs/native-win32-x64-msvc": "0.433.0"
   },
   "publishConfig": {
     "access": "public"
@@ -68,7 +68,7 @@
   },
   "type": "module",
   "types": "./dist/index.d.mts",
-  "version": "0.431.0",
+  "version": "0.433.0",
   "scripts": {
     "build": "vp pack",
     "check": "vp check src vite.config.ts",