oxlint-plugin-vize 0.442.0 → 0.454.0

package/README.md

@@ -47,6 +47,36 @@ vp install -D oxlint oxlint-plugin-vize
 
 ## Usage
 
+### With ESLint
+
+Use the independent `oxlint-plugin-vize/eslint` entry with the project's Vue parser:
+
+```js
+import vize from "oxlint-plugin-vize/eslint";
+import vueParser from "vue-eslint-parser";
+
+export default [
+  {
+    files: ["**/*.vue"],
+    languageOptions: { parser: vueParser },
+    plugins: { vize },
+    settings: { vize: { preset: "incremental" } },
+    rules: { "vize/vue/require-v-for-key": "error" },
+  },
+];
+```
+
+This entry lints the parser's complete source, including an editor's unsaved text.
+It reports original template, script, and style locations and batches the enabled
+Vize rules once per file. Native text edits support ESLint's `--fix`; suggestions
+are not invented from help text. Install ESLint and
+`vue-eslint-parser` in the project, and keep the plugin and native binding versions
+together. The default package entry remains the Oxlint bridge.
+Unpaired UTF-16 surrogates are refused before native conversion. Invalid native
+ranges and inconsistent locations are errors. Files containing
+lone CR or Unicode line separators currently require a matching native location
+convention; the entry refuses mismatched positions rather than moving reports.
+
 Which file you configure depends on which command you run.
 
 | Command                 | Reads                                |
@@ -231,8 +261,13 @@ vp exec oxlint-vize -c .oxlintrc.json -f stylish src
 
 `oxlint-vize` appends a temporary `<script setup>` location bridge for Vue and HTML files, including files with existing scripts. This lets Patina report the original SFC line and column through Oxlint's JS plugin pipeline. The wrapper rewrites temporary paths back to the original files; `-f json` retains those original positions for machine-readable diagnostics.
 
+### Oxlint type-aware rules in Vue files
+
+Oxlint's own type-aware rules (`typescript/no-floating-promises`, `typescript/no-misused-promises` and the rest of the tsgolint set) do not look inside `.vue` files. When you run `oxlint-vize --type-aware`, or your `.oxlintrc.json` sets `options.typeAware: true`, the wrapper runs those rules on each SFC's `<script>` and `<script setup>` blocks too, with the severities from your resolved configuration, and reports them at the original `.vue` lines and columns. Imports between `.vue` and `.ts` files resolve as they do for TypeScript. Template expressions are not part of this pass; Vize's `vize/type/*` rules cover them.
+
 ## Limitations
 
+- The type-aware pass for Vue script blocks uses your root configuration's resolved rules; per-file `overrides` and nested configs do not change which type-aware rules run on Vue files. Your `tsconfig.json` must include the `.vue` files' directories with a `**/*.ts` pattern, because each SFC is checked through a temporary `Component.vue.ts` sibling that is removed after the run.
 - 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, complete explicit/discovered JSON configs containing `ignorePatterns` or `overrides`, and root TS/MTS configs with object `extends`, the wrapper retains original file selection and ordered Vue overrides. This mode supports POSIX paths; inherited JSON configs, import/type-aware project resolution, suppression state, ambiguous filenames, unsupported outside-root patterns and unknown option forms produce actionable errors.

package/dist/cli.mjs

@@ -1,4 +1,4 @@
-import { m as loadBinding, n as prepareWorkaroundSource, p as isStandaloneHtmlFile, u as hasVueLikeExtension } from "./workaround-CiQUFJw0.mjs";
+import { m as loadBinding, n as prepareWorkaroundSource, p as isStandaloneHtmlFile, s as extractSfcBlocks, u as hasVueLikeExtension } from "./workaround-CiQUFJw0.mjs";
 import { spawn, spawnSync } from "node:child_process";
 import path from "node:path";
 import fs from "node:fs";
@@ -1119,7 +1119,11 @@ const digest = (bytes) => createHash("sha256").update(bytes).digest("hex");
 function prepareHtmlContext(cwd, args, entrypoint, version, candidates) {
 	const context = { environment: presentationContext() };
 	try {
-		if (!["1.78.0", "1.86.0"].includes(version)) throw new Error("original HTML requires a qualified Oxlint 1.78.0 or 1.86.0 host");
+		if (![
+			"1.78.0",
+			"1.81.0",
+			"1.86.0"
+		].includes(version)) throw new Error("original HTML requires a qualified Oxlint 1.78.0, 1.81.0 or 1.86.0 host");
 		const targets = getLintTargets(args);
 		if (targets.length !== 1) throw new Error("original HTML requires one literal original target");
 		const config = readScopedConfig(cwd, args);
@@ -1394,6 +1398,229 @@ function runOxlint(executable, args, cwd) {
 	});
 }
 //#endregion
+//#region src/cli/type-aware-vue.ts
+/**
+* Runs oxlint's type-aware rules on Vue SFC script blocks (#8937).
+*
+* oxlint's type-aware engine (tsgolint) never sees `.vue` files, so rules such
+* as `typescript/no-floating-promises` stay silent inside `<script setup>`.
+* After the normal run, this pass writes one position-preserving script shim
+* next to each SFC (`Foo.vue.ts`: every character outside the script blocks
+* is blanked, newlines are kept), lints only those shims with a configuration
+* that enables nothing but the user's type-aware rules, and rewrites the shim
+* paths back to the `.vue` files. Lines and columns already match the SFC, and
+* `import Foo from "./Foo.vue"` resolves to the shim the way TypeScript
+* resolves any extensionless sibling, so imported types flow between files.
+* Template expressions stay with Vize's own `type/*` rules.
+*/
+const CATEGORIES = [
+	"correctness",
+	"suspicious",
+	"pedantic",
+	"perf",
+	"style",
+	"restriction",
+	"nursery"
+];
+/** Options that would re-enable or re-select rules, or change what is linted. */
+const DROPPED_WITH_VALUE = new Set([
+	"-A",
+	"-D",
+	"-W",
+	"-c",
+	"--allow",
+	"--deny",
+	"--warn",
+	"--config",
+	"--ignore-path",
+	"--ignore-pattern",
+	"--max-warnings"
+]);
+const DROPPED_FLAGS = new Set([
+	"--fix",
+	"--fix-suggestions",
+	"--fix-dangerously",
+	"--print-config",
+	"--rules",
+	"--type-aware",
+	"--type-check",
+	"--type-check-only",
+	"--suppress-all",
+	"--prune-suppressions"
+]);
+/** Whether the run asks oxlint for type-aware linting (flag or `options.typeAware`). */
+function requestsTypeAware(args, cwd) {
+	const end = args.includes("--") ? args.indexOf("--") : args.length;
+	const options = args.slice(0, end);
+	if (options.includes("--type-aware")) return true;
+	let configPath = path.join(cwd, ".oxlintrc.json");
+	for (let index = 0; index < options.length; index += 1) if (options[index] === "-c" || options[index] === "--config") configPath = path.resolve(cwd, options[index + 1] ?? "");
+	else if (options[index].startsWith("--config=")) configPath = path.resolve(cwd, options[index].slice(9));
+	if (!configPath.endsWith(".json") || !fs.existsSync(configPath)) return false;
+	try {
+		return JSON.parse(stripJsonComments(fs.readFileSync(configPath, "utf8"))).options?.typeAware === true;
+	} catch {
+		return false;
+	}
+}
+/** Blank everything outside the script blocks, keeping every offset in place. */
+function buildScriptShim(source) {
+	const lineStarts = [0];
+	for (let index = 0; index < source.length; index += 1) if (source.charCodeAt(index) === 10) lineStarts.push(index + 1);
+	const chars = source.replace(/[^\r\n]/gu, " ").split("");
+	let lang = "";
+	let found = false;
+	for (const block of extractSfcBlocks(source)) {
+		if (block.kind !== "script" && block.kind !== "script-setup") continue;
+		const start = lineStarts[block.contentStart.line - 1] + block.contentStart.column - 1;
+		const openTag = source.slice(source.lastIndexOf("<script", start), start);
+		if (/\bsrc\s*=/u.test(openTag)) continue;
+		const blockLang = /\blang\s*=\s*["']?([a-z]+)/iu.exec(openTag)?.[1]?.toLowerCase() ?? "js";
+		if (lang === "" || blockLang.startsWith("t")) lang = blockLang;
+		for (let offset = 0; offset < block.content.length; offset += 1) chars[start + offset] = block.content[offset];
+		found = true;
+	}
+	if (!found) return null;
+	const extension = lang === "tsx" ? ".tsx" : lang === "ts" ? ".ts" : lang === "jsx" ? ".jsx" : ".js";
+	return {
+		text: chars.join(""),
+		extension
+	};
+}
+/** The user's resolved config, reduced to its enabled type-aware rules. */
+function typeAwareOnlyConfig(printed, typeAwareRules) {
+	const rules = {};
+	for (const [name, value] of Object.entries(printed.rules ?? {})) {
+		const severity = Array.isArray(value) ? value[0] : value;
+		if (!typeAwareRules.has(name) || severity === "off" || severity === "allow" || severity === 0) continue;
+		rules[name] = value;
+	}
+	if (Object.keys(rules).length === 0) return null;
+	return {
+		plugins: printed.plugins ?? [],
+		categories: Object.fromEntries(CATEGORIES.map((category) => [category, "off"])),
+		rules,
+		settings: printed.settings ?? {},
+		env: printed.env ?? {},
+		globals: printed.globals ?? {}
+	};
+}
+/** Lint the SFC script shims with the user's type-aware rules; undefined when nothing applies. */
+async function runVueTypeAwarePass(cwd, entrypoint, forwardedArgs, vueFiles, run) {
+	const sfcFiles = vueFiles.filter((file) => file.endsWith(".vue") && !isStandaloneHtmlFile(file));
+	if (sfcFiles.length === 0) return void 0;
+	const options = withoutLintTargets(forwardedArgs);
+	const configOptions = keepConfigSelection(options);
+	const ruleList = await run([
+		entrypoint,
+		"--rules",
+		"--format",
+		"json"
+	]);
+	const printed = await run([
+		entrypoint,
+		...configOptions,
+		"--print-config"
+	]);
+	if (ruleList.status !== 0 || printed.status !== 0) throw new Error(`oxlint could not list its rules or print the config: ${printed.stderr}`);
+	const typeAwareRules = new Set(JSON.parse(ruleList.stdout).filter((rule) => rule.type_aware === true).map((rule) => `${rule.scope}/${rule.value}`));
+	const config = typeAwareOnlyConfig(JSON.parse(printed.stdout), typeAwareRules);
+	if (config == null) return void 0;
+	const created = [];
+	const replacements = /* @__PURE__ */ new Map();
+	const configDir = fs.mkdtempSync(path.join(os.tmpdir(), "oxlint-vize-type-aware-"));
+	const cleanup = () => {
+		for (const file of created) fs.rmSync(file, { force: true });
+		fs.rmSync(configDir, {
+			force: true,
+			recursive: true
+		});
+	};
+	process.once("exit", cleanup);
+	try {
+		for (const file of sfcFiles) {
+			const shim = buildScriptShim(fs.readFileSync(file, "utf8"));
+			if (shim == null) continue;
+			const shimPath = `${file}${shim.extension}`;
+			if (fs.existsSync(shimPath)) continue;
+			fs.writeFileSync(shimPath, shim.text, { flag: "wx" });
+			created.push(shimPath);
+			registerPathReplacementVariants(replacements, cwd, shimPath, file);
+		}
+		if (created.length === 0) return void 0;
+		const configPath = path.join(configDir, ".oxlintrc.json");
+		fs.writeFileSync(configPath, JSON.stringify(config));
+		const result = await run([
+			entrypoint,
+			...passOptions(options),
+			"-c",
+			configPath,
+			"--type-aware",
+			...created
+		]);
+		const stdout = rewriteReportedPaths(result.stdout, replacements);
+		const stderr = rewriteReportedPaths(result.stderr, replacements);
+		return {
+			...result,
+			stdout,
+			stderr,
+			rawStdout: void 0,
+			rawStderr: void 0
+		};
+	} finally {
+		cleanup();
+		process.removeListener("exit", cleanup);
+	}
+}
+function keepConfigSelection(options) {
+	const kept = [];
+	for (let index = 0; index < options.length; index += 1) {
+		const option = options[index];
+		if (option === "-c" || option === "--config" || option === "--tsconfig") kept.push(option, options[++index]);
+		else if (option.startsWith("--config=") || option.startsWith("--tsconfig=")) kept.push(option);
+		else if (option === "--disable-nested-config") kept.push(option);
+	}
+	return kept;
+}
+function passOptions(options) {
+	const kept = [];
+	for (let index = 0; index < options.length; index += 1) {
+		const option = options[index];
+		if (option === "--") break;
+		const name = option.includes("=") ? option.slice(0, option.indexOf("=")) : option;
+		if (DROPPED_WITH_VALUE.has(name)) {
+			if (!option.includes("=")) index += 1;
+			continue;
+		}
+		if (DROPPED_FLAGS.has(name)) continue;
+		kept.push(option);
+	}
+	return kept;
+}
+function stripJsonComments(text) {
+	let result = "";
+	let inString = false;
+	for (let index = 0; index < text.length; index += 1) {
+		const char = text[index];
+		if (inString) {
+			result += char;
+			if (char === "\\") result += text[++index] ?? "";
+			else if (char === "\"") inString = false;
+		} else if (char === "\"") {
+			inString = true;
+			result += char;
+		} else if (char === "/" && text[index + 1] === "/") {
+			while (index < text.length && text[index] !== "\n") index += 1;
+			result += "\n";
+		} else if (char === "/" && text[index + 1] === "*") {
+			index = text.indexOf("*/", index + 2);
+			if (index === -1) break;
+			index += 1;
+		} else result += char;
+	}
+	return result;
+}
+//#endregion
 //#region src/cli.ts
 async function main() {
 	const cwd = process.cwd();
@@ -1440,6 +1667,7 @@ async function main() {
 			} catch (error) {
 				merged = unavailableHtml(merged, error);
 			}
+			if (requestsTypeAware(forwardedArgs, cwd)) merged = await withVueTypeAwarePass(merged, cwd, oxlintEntrypoint, forwardedArgs, vueFiles);
 		} catch (error) {
 			if (transport?.originalResult) {
 				process.exitCode = Math.max(transport.originalResult.status ?? 1, result?.status ?? 1, 1);
@@ -1471,6 +1699,21 @@ main().catch((error) => {
 	process.stderr.write(`${error instanceof Error ? error.stack ?? error.message : String(error)}\n`);
 	process.exitCode = Math.max(Number(process.exitCode) || 1, 1);
 });
+/** Adds oxlint's type-aware rules on Vue script blocks; a failure is reported, never hidden. */
+async function withVueTypeAwarePass(merged, cwd, entrypoint, forwardedArgs, vueFiles) {
+	try {
+		const pass = await runVueTypeAwarePass(cwd, entrypoint, forwardedArgs, vueFiles, (args) => runOxlint(process.execPath, args, cwd));
+		return pass ? mergeProjectOutput(merged, pass, forwardedArgs) : merged;
+	} catch (error) {
+		const notice = `\n[oxlint-plugin-vize] Type-aware rules could not run on Vue script blocks: ${error instanceof Error ? error.message : String(error)}\n`;
+		return {
+			...merged,
+			stderr: merged.stderr + notice,
+			rawStderr: void 0,
+			status: Math.max(merged.status ?? 1, 1)
+		};
+	}
+}
 function writeStream(stream, text) {
 	return new Promise((resolve, reject) => {
 		stream.write(text, (error) => {

package/dist/configs-BuOTHAnm.d.mts

@@ -0,0 +1,40 @@
+//#region src/model.d.ts
+type HelpLevel = "none" | "short" | "full";
+type PatinaPreset = "general-recommended" | "essential" | "ecosystem" | "incremental" | "opinionated" | "nuxt";
+interface PatinaSettings {
+  locale?: string;
+  helpLevel?: HelpLevel;
+  preset?: PatinaPreset;
+  typeAware?: boolean;
+  corsaPath?: string;
+  /** Rules to evaluate together. Oxlint's own rules still control reporting. */
+  rules?: readonly string[] | Record<string, unknown>;
+}
+//#endregion
+//#region src/configs.d.ts
+type OxlintRuleSeverity = "error" | "warn" | "off";
+type OxlintRuleEntry = OxlintRuleSeverity | [OxlintRuleSeverity, ...unknown[]];
+type OxlintRuleConfig = Record<string, OxlintRuleEntry>;
+type VizeRuleConfigPreset = Exclude<PatinaPreset, "incremental"> | "happy-path" | "all";
+type VizeRuleConfigPresetInput = VizeRuleConfigPreset | readonly VizeRuleConfigPreset[];
+interface VizeRuleConfigOptions {
+  includeTypeAware?: boolean;
+  preset?: VizeRuleConfigPresetInput;
+  presets?: readonly VizeRuleConfigPreset[];
+}
+declare function createVizeRuleConfig(options?: VizeRuleConfigOptions): OxlintRuleConfig;
+declare const configs: {
+  readonly all: OxlintRuleConfig;
+  readonly ecosystem: OxlintRuleConfig;
+  readonly ecosystemWithTypeAware: OxlintRuleConfig;
+  readonly essential: OxlintRuleConfig;
+  readonly happyPath: OxlintRuleConfig;
+  readonly happyPathWithTypeAware: OxlintRuleConfig;
+  readonly nuxt: OxlintRuleConfig;
+  readonly opinionated: OxlintRuleConfig;
+  readonly opinionatedWithTypeAware: OxlintRuleConfig;
+  readonly recommended: OxlintRuleConfig;
+  readonly recommendedWithTypeAware: OxlintRuleConfig;
+};
+//#endregion
+export { VizeRuleConfigPreset as a, createVizeRuleConfig as c, VizeRuleConfigOptions as i, PatinaPreset as l, OxlintRuleEntry as n, VizeRuleConfigPresetInput as o, OxlintRuleSeverity as r, configs as s, OxlintRuleConfig as t, PatinaSettings as u };