oxlint-plugin-vize 0.443.0 → 0.454.0

package/dist/configs-DY0BrbH2.mjs

@@ -0,0 +1,853 @@
+import { a as validateWorkaroundAuthority, c as formatBlockLabel, d as isPatinaFile, f as isScriptLikeFile, i as resolveWorkaroundSource, l as getDiagnosticBlock, m as loadBinding, o as compareLineColumn, r as readOriginalWorkaroundSource, s as extractSfcBlocks, t as isLocationBridgeProgram } from "./workaround-CiQUFJw0.mjs";
+import { definePlugin, defineRule } from "@oxlint/plugins";
+import fs from "node:fs";
+//#region src/plugin-option-guards.ts
+function optionField(value) {
+	return value === void 0 || value === "always" || value === "never" || value === "any";
+}
+function optionalBooleanField(value) {
+	return value === void 0 || typeof value === "boolean";
+}
+function isString(value) {
+	return typeof value === "string";
+}
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function hasOnlyKeys(value, keys) {
+	return Object.keys(value).every((key) => keys.includes(key));
+}
+//#endregion
+//#region src/rule-options.ts
+function getRuleOptions(ruleName, options) {
+	const firstOption = options[0];
+	switch (ruleName) {
+		case "vue/component-name-in-template-casing":
+			if (isComponentNameInTemplateCasingOption(firstOption)) return { componentNameInTemplateCasing: firstOption };
+			break;
+		case "script/custom-event-name-casing":
+			if (isCustomEventNameCasingOption(firstOption)) return { customEventNameCasing: firstOption };
+			break;
+		case "vue/no-mutating-props":
+			if (isNoMutatingPropsOption(firstOption)) return { noMutatingProps: firstOption };
+			break;
+		case "vue/sfc-element-order":
+			if (isSfcElementOrderOption(firstOption)) return { sfcElementOrder: firstOption };
+			break;
+		case "vue/html-self-closing":
+			if (isHtmlSelfClosingOption(firstOption)) return { htmlSelfClosing: firstOption };
+			break;
+		case "vue/v-on-event-hyphenation":
+			if (isHyphenationStyle(firstOption)) return { vOnEventHyphenation: firstOption };
+			break;
+		case "vue/attribute-hyphenation":
+			if (isHyphenationStyle(firstOption)) return { attributeHyphenation: firstOption };
+			break;
+	}
+}
+function isComponentNameInTemplateCasingOption(value) {
+	return value === "PascalCase" || value === "kebab-case";
+}
+function isCustomEventNameCasingOption(value) {
+	return value === "camelCase" || value === "kebab-case";
+}
+function isNoMutatingPropsOption(value) {
+	if (!isRecord(value)) return false;
+	return hasOnlyKeys(value, ["shallowOnly"]) && optionalBooleanField(value.shallowOnly);
+}
+function isSfcElementOrderOption(value) {
+	if (!isRecord(value)) return false;
+	return hasOnlyKeys(value, ["order"]) && (value.order === void 0 || Array.isArray(value.order) && value.order.every(isSfcElementOrderGroup));
+}
+function isSfcElementOrderGroup(value) {
+	return typeof value === "string" || Array.isArray(value) && value.every(isString);
+}
+function isHtmlSelfClosingOption(value) {
+	if (!isRecord(value)) return false;
+	return hasOnlyKeys(value, [
+		"html",
+		"svg",
+		"math"
+	]) && optionField(value.svg) && optionField(value.math) && (value.html === void 0 || isRecord(value.html) && hasOnlyKeys(value.html, [
+		"void",
+		"normal",
+		"component"
+	]) && optionField(value.html.void) && optionField(value.html.normal) && optionField(value.html.component));
+}
+function isHyphenationStyle(value) {
+	return value === "always" || value === "never";
+}
+//#endregion
+//#region src/rule-selection.ts
+const selectionCache = /* @__PURE__ */ new WeakMap();
+/** A selection is a batching hint, never a second reporting/severity gate. */
+function parseRuleSelection(rules) {
+	if (rules === void 0) return;
+	const revision = JSON.stringify(rules);
+	const cached = selectionCache.get(rules);
+	if (cached?.revision === revision) return cached.selection;
+	const optionsByRule = /* @__PURE__ */ new Map();
+	if (Array.isArray(rules)) {
+		for (const name of rules) if (typeof name === "string" && name.length > 0) optionsByRule.set(normalizeRuleName(name), void 0);
+	} else if (typeof rules === "object" && rules !== null) {
+		const usesPluginIds = Object.keys(rules).some((id) => id.startsWith("vize/"));
+		for (const [id, entry] of Object.entries(rules)) {
+			if (!id.startsWith("vize/") && (usesPluginIds || !/^(vue|script|style|css|type|nuxt|ecosystem)\//u.test(id))) continue;
+			const severity = Array.isArray(entry) ? entry[0] : entry;
+			if (severity !== "error" && severity !== "warn" && severity !== 1 && severity !== 2) continue;
+			const name = normalizeRuleName(id);
+			const options = Array.isArray(entry) ? getRuleOptions(name, entry.slice(1)) : void 0;
+			optionsByRule.set(name, options);
+		}
+	} else return;
+	const selection = createRuleSelection(optionsByRule);
+	selectionCache.set(rules, {
+		revision,
+		selection
+	});
+	return selection;
+}
+function createRuleSelection(optionsByRule) {
+	const names = [...optionsByRule.keys()].sort();
+	const options = {};
+	for (const name of names) Object.assign(options, optionsByRule.get(name));
+	return {
+		names,
+		options,
+		optionsByRule,
+		cacheKey: JSON.stringify([names, ruleOptionsKey(options)])
+	};
+}
+function normalizeRuleName(name) {
+	return name.startsWith("vize/") ? name.slice(5) : name;
+}
+function ruleOptionsKey(options) {
+	if (options === void 0) return "{}";
+	return JSON.stringify(options ?? {}, (_key, value) => {
+		if (typeof value !== "object" || value === null || Array.isArray(value)) return value;
+		return Object.fromEntries(Object.entries(value).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0));
+	});
+}
+function selectVizeRuleConfig(rules) {
+	return Object.fromEntries(Object.entries(rules).filter(([id]) => id.startsWith("vize/")));
+}
+//#endregion
+//#region src/settings.ts
+const HELP_LEVELS = new Set([
+	"none",
+	"short",
+	"full"
+]);
+const TYPE_AWARE_RULE_PREFIX$1 = "type/";
+const PRESET_ALIASES = new Map([
+	["generalrecommended", "general-recommended"],
+	["happypath", "general-recommended"],
+	["happy", "general-recommended"],
+	["default", "general-recommended"],
+	["recommended", "general-recommended"],
+	["essential", "essential"],
+	["ecosystem", "ecosystem"],
+	["eco", "ecosystem"],
+	["incremental", "incremental"],
+	["all", "incremental"],
+	["opinionated", "opinionated"],
+	["opnionated", "opinionated"],
+	["strict", "opinionated"],
+	["nuxt", "nuxt"]
+]);
+function getVizeSettings(context) {
+	const settings = context.settings;
+	return parseVizeSettings(settings.vize ?? settings.patina);
+}
+function parseVizeSettings(vize) {
+	if (typeof vize !== "object" || vize === null || Array.isArray(vize)) return {};
+	const vizeRecord = vize;
+	const locale = vizeRecord.locale;
+	const helpLevel = vizeRecord.helpLevel;
+	const preset = vizeRecord.preset;
+	const showHelp = vizeRecord.showHelp;
+	const typeAware = vizeRecord.typeAware;
+	const corsaPath = vizeRecord.corsaPath;
+	const resolved = {};
+	if (Array.isArray(vizeRecord.rules) || typeof vizeRecord.rules === "object" && vizeRecord.rules !== null) resolved.rules = vizeRecord.rules;
+	if (typeof locale === "string") resolved.locale = locale;
+	if (typeof preset === "string") {
+		const normalizedPreset = normalizePreset(preset);
+		if (normalizedPreset) resolved.preset = normalizedPreset;
+	}
+	if (typeof typeAware === "boolean") resolved.typeAware = typeAware;
+	if (typeof corsaPath === "string") resolved.corsaPath = corsaPath;
+	if (typeof helpLevel === "string" && HELP_LEVELS.has(helpLevel)) {
+		resolved.helpLevel = helpLevel;
+		return resolved;
+	}
+	if (typeof showHelp === "boolean") resolved.helpLevel = showHelp ? "full" : "none";
+	return resolved;
+}
+function getActivePreset(settings) {
+	return settings.preset ?? "incremental";
+}
+function isIncrementalPreset(settings) {
+	return getActivePreset(settings) === "incremental";
+}
+function getCacheKey(filename, settings) {
+	const selection = parseRuleSelection(settings.rules);
+	return JSON.stringify([
+		filename,
+		settings.locale ?? "",
+		settings.helpLevel ?? "",
+		getActivePreset(settings),
+		settings.typeAware ? "type-aware" : "",
+		settings.corsaPath ?? "",
+		selection?.cacheKey
+	]);
+}
+function isTypeAwareRuleName(ruleName) {
+	return ruleName.startsWith(TYPE_AWARE_RULE_PREFIX$1);
+}
+function normalizePreset(value) {
+	return PRESET_ALIASES.get(value.replaceAll(/[-_\s]/gu, "").toLowerCase());
+}
+if (import.meta.vitest) {
+	const { describe, expect, it } = import.meta.vitest;
+	describe("parseVizeSettings", () => {
+		it("reads locale, help level, preset, and type-aware settings", () => {
+			expect(parseVizeSettings({
+				locale: "ja",
+				helpLevel: "short",
+				preset: "essential",
+				typeAware: true,
+				corsaPath: "./node_modules/@typescript/typescript-linux-x64/lib/tsc"
+			})).toEqual({
+				locale: "ja",
+				helpLevel: "short",
+				preset: "essential",
+				typeAware: true,
+				corsaPath: "./node_modules/@typescript/typescript-linux-x64/lib/tsc"
+			});
+		});
+		it("normalizes preset aliases", () => {
+			expect(parseVizeSettings({ preset: "recommended" })).toEqual({ preset: "general-recommended" });
+			expect(parseVizeSettings({ preset: "incremental" })).toEqual({ preset: "incremental" });
+			expect(parseVizeSettings({ preset: "all" })).toEqual({ preset: "incremental" });
+			expect(parseVizeSettings({ preset: "ecosystem" })).toEqual({ preset: "ecosystem" });
+			expect(parseVizeSettings({ preset: "strict" })).toEqual({ preset: "opinionated" });
+			expect(parseVizeSettings({ preset: "Opnionated" })).toEqual({ preset: "opinionated" });
+		});
+		it("falls back to showHelp for compatibility", () => {
+			expect(parseVizeSettings({
+				locale: "ja",
+				showHelp: false,
+				preset: "Nuxt"
+			})).toEqual({
+				locale: "ja",
+				helpLevel: "none",
+				preset: "nuxt"
+			});
+		});
+		it("ignores invalid values", () => {
+			expect(parseVizeSettings({
+				locale: 1,
+				showHelp: "no",
+				helpLevel: "verbose",
+				preset: "wide",
+				typeAware: "yes",
+				corsaPath: false
+			})).toEqual({});
+		});
+		it("ignores non-object vize settings", () => {
+			expect(parseVizeSettings(null)).toEqual({});
+			expect(parseVizeSettings("ja")).toEqual({});
+		});
+	});
+}
+//#endregion
+//#region src/binding.ts
+function lintPatina(source, filename, settings, enabledRules, ruleOptions) {
+	return loadBinding().lintPatinaSfc(source, {
+		filename,
+		locale: settings.locale,
+		helpLevel: settings.helpLevel,
+		preset: getActivePreset(settings),
+		enabledRules: enabledRules ? [...enabledRules] : void 0,
+		typeAware: settings.typeAware,
+		corsaPath: settings.corsaPath,
+		...ruleOptions
+	});
+}
+function getPatinaRules() {
+	return loadBinding().getPatinaRules();
+}
+//#endregion
+//#region src/script-map.ts
+function createSingleScriptMap(source, extractedScript, sfcBlocks = extractSfcBlocks(source)) {
+	if (!extractedScript) return null;
+	const blocks = sfcBlocks.filter((block) => block.kind === "script" || block.kind === "script-setup");
+	let match = null;
+	for (const block of blocks) {
+		const skipped = countSkippedPrefix(block.content, extractedScript);
+		if (skipped === null) continue;
+		if (match !== null) return null;
+		match = {
+			block,
+			scriptStart: advancePosition(block.contentStart, block.content.slice(0, skipped))
+		};
+	}
+	return match;
+}
+/**
+* Oxlint trims the leading newline (and any indentation on that line) from a
+* `.vue` script block before handing the program to JS plugins, so the
+* extracted text starts partway into `block.content`. Returns how many
+* characters were dropped, or `null` when the extracted text is not this
+* block's body.
+*/
+function countSkippedPrefix(content, extractedScript) {
+	const skipped = content.length - extractedScript.length;
+	if (skipped < 0 || !content.endsWith(extractedScript)) return null;
+	return /^\s*$/u.test(content.slice(0, skipped)) ? skipped : null;
+}
+function advancePosition(from, text) {
+	let { line, column } = from;
+	for (const character of text) {
+		if (character === "\n") {
+			line += 1;
+			column = 1;
+			continue;
+		}
+		if (character !== "\r") column += 1;
+	}
+	return {
+		line,
+		column
+	};
+}
+function mapToScriptLoc(diagnostic, scriptMap) {
+	if (!scriptMap) return null;
+	const { block, scriptStart } = scriptMap;
+	if (compareLineColumn(diagnostic.location.start, scriptStart) < 0 || compareLineColumn(diagnostic.location.end, block.contentEnd) > 0) return null;
+	return {
+		start: toScriptPosition(diagnostic.location.start, scriptStart),
+		end: toScriptPosition(diagnostic.location.end, scriptStart)
+	};
+}
+/**
+* Patina reports 1-based SFC line/column; Oxlint expects 1-based lines and
+* 0-based columns relative to the extracted program.
+*/
+function toScriptPosition(position, scriptStart) {
+	if (position.line === scriptStart.line) return {
+		line: 1,
+		column: position.column - scriptStart.column
+	};
+	return {
+		line: position.line - scriptStart.line + 1,
+		column: position.column - 1
+	};
+}
+//#endregion
+//#region src/file-state.ts
+const FILE_STATE_CACHE_CAPACITY = 128;
+const fileStateCache = /* @__PURE__ */ new Map();
+const EMPTY_DIAGNOSTICS = [];
+const TYPE_AWARE_RUNTIME_RULE = "type/corsa-runtime";
+let fileStateCacheClock = 0;
+function getFileState(context) {
+	const settings = getVizeSettings(context);
+	const physicalSource = fs.readFileSync(context.physicalFilename, "utf8");
+	const cacheKey = getCacheKey(context.physicalFilename, settings);
+	const cached = fileStateCache.get(cacheKey);
+	if (cached && cached.state.revision.physicalSource === physicalSource) {
+		validateWorkaroundAuthority(cached.state, context.physicalFilename);
+		if (cached.state.extractedScript !== context.sourceCode.text) {
+			cached.state.extractedScript = context.sourceCode.text;
+			cached.state.scriptMap = void 0;
+		}
+		cached.lastUsed = nextFileStateCacheClock();
+		return cached.state;
+	}
+	const resolvedSource = resolveWorkaroundSource(physicalSource, context.physicalFilename, readOriginalWorkaroundSource);
+	const state = {
+		revision: { physicalSource },
+		filename: resolvedSource.filename,
+		source: resolvedSource.source,
+		extractedScript: context.sourceCode.text,
+		usesOriginalLocations: resolvedSource.usesOriginalLocations || isScriptLikeFile(resolvedSource.filename),
+		reportedDiagnostics: /* @__PURE__ */ new Set(),
+		sfcBlocks: void 0,
+		scriptMap: void 0,
+		allDiagnosticsByRule: null,
+		allDiagnosticsIncludesTypeAware: false,
+		partialDiagnosticsByRule: /* @__PURE__ */ new Map(),
+		requestedRules: /* @__PURE__ */ new Set(),
+		reportedTypeAwareRuntimeDiagnostic: false,
+		ruleSelection: parseRuleSelection(settings.rules),
+		selectedDiagnosticsByRule: null
+	};
+	fileStateCache.set(cacheKey, {
+		state,
+		lastUsed: nextFileStateCacheClock()
+	});
+	evictLeastRecentlyUsedFileState();
+	return state;
+}
+function getScriptMap(state) {
+	if (state.scriptMap !== void 0) return state.scriptMap;
+	state.scriptMap = createSingleScriptMap(state.source, state.extractedScript, getSfcBlocks(state));
+	return state.scriptMap;
+}
+function getSfcBlocks(state) {
+	if (state.sfcBlocks !== void 0) return state.sfcBlocks;
+	state.sfcBlocks = extractSfcBlocks(state.source);
+	return state.sfcBlocks;
+}
+function markDiagnosticAsReported(state, diagnostic) {
+	const key = diagnosticIdentity(diagnostic);
+	if (state.reportedDiagnostics.has(key)) return false;
+	state.reportedDiagnostics.add(key);
+	return true;
+}
+function diagnosticIdentity(diagnostic) {
+	const { start, end } = diagnostic.location;
+	return [
+		diagnostic.rule,
+		diagnostic.severity,
+		diagnostic.message,
+		start.line,
+		start.column,
+		start.offset,
+		end.line,
+		end.column,
+		end.offset
+	].join("\0");
+}
+function nextFileStateCacheClock() {
+	fileStateCacheClock += 1;
+	return fileStateCacheClock;
+}
+function evictLeastRecentlyUsedFileState() {
+	if (fileStateCache.size <= FILE_STATE_CACHE_CAPACITY) return;
+	let oldestKey;
+	let oldestUse = Number.POSITIVE_INFINITY;
+	for (const [key, cached] of fileStateCache) if (cached.lastUsed < oldestUse) {
+		oldestKey = key;
+		oldestUse = cached.lastUsed;
+	}
+	if (oldestKey !== void 0) fileStateCache.delete(oldestKey);
+}
+function indexDiagnosticsByRule(diagnostics) {
+	const grouped = /* @__PURE__ */ new Map();
+	for (const diagnostic of diagnostics) {
+		const existing = grouped.get(diagnostic.rule);
+		if (existing) {
+			existing.push(diagnostic);
+			continue;
+		}
+		grouped.set(diagnostic.rule, [diagnostic]);
+	}
+	return grouped;
+}
+function diagnosticsForRule(state, diagnosticsByRule, ruleName) {
+	const directDiagnostics = diagnosticsByRule.get(ruleName);
+	if (directDiagnostics && directDiagnostics.length > 0) return directDiagnostics;
+	if (!isTypeAwareRuleName(ruleName) || state.reportedTypeAwareRuntimeDiagnostic) return EMPTY_DIAGNOSTICS;
+	const runtimeDiagnostics = diagnosticsByRule.get(TYPE_AWARE_RUNTIME_RULE);
+	if (!runtimeDiagnostics || runtimeDiagnostics.length === 0) return EMPTY_DIAGNOSTICS;
+	state.reportedTypeAwareRuntimeDiagnostic = true;
+	return runtimeDiagnostics;
+}
+//#endregion
+//#region src/active-rule-collection.ts
+const programs = /* @__PURE__ */ new WeakMap();
+const results = /* @__PURE__ */ new WeakMap();
+function collectActiveRule(context, program, ruleName, options) {
+	const state = getFileState(context);
+	let collection = programs.get(program);
+	if (!collection || collection.selection) {
+		collection = {
+			state,
+			optionsByRule: /* @__PURE__ */ new Map()
+		};
+		programs.set(program, collection);
+	}
+	if (collection.state !== state) {
+		programs.delete(program);
+		throw new Error("Vize source or configuration changed during rule collection");
+	}
+	collection.optionsByRule.set(ruleName, options === void 0 ? void 0 : structuredClone(options));
+}
+function getActiveRuleDiagnostics(context, program, ruleName) {
+	const collection = programs.get(program);
+	if (!collection?.optionsByRule.has(ruleName)) return void 0;
+	if (getFileState(context) !== collection.state) {
+		programs.delete(program);
+		throw new Error("Vize source or configuration changed before rule execution");
+	}
+	if (!collection.selection) {
+		collection.selection = createRuleSelection(collection.optionsByRule);
+		collection.remaining = new Set(collection.selection.names);
+	}
+	const { state, selection } = collection;
+	let cached = results.get(state);
+	if (cached?.key !== selection.cacheKey) {
+		const settings = getVizeSettings(context);
+		const diagnostics = indexDiagnosticsByRule(lintPatina(state.source, state.filename, {
+			...settings,
+			typeAware: settings.typeAware === true || selection.names.some(isTypeAwareRuleName)
+		}, selection.names, selection.options).diagnostics);
+		if (cached) {
+			state.reportedDiagnostics.clear();
+			state.reportedTypeAwareRuntimeDiagnostic = false;
+		}
+		cached = {
+			key: selection.cacheKey,
+			diagnostics
+		};
+		results.set(state, cached);
+	}
+	const diagnostics = diagnosticsForRule(state, cached.diagnostics, ruleName);
+	collection.remaining.delete(ruleName);
+	if (collection.remaining.size === 0) programs.delete(program);
+	return {
+		state,
+		diagnostics
+	};
+}
+//#endregion
+//#region src/format.ts
+const helpTextCache = /* @__PURE__ */ new Map();
+function formatPatinaMessage(diagnostic, options) {
+	const sections = [];
+	const summaryLine = createSummaryLine(diagnostic.message);
+	const details = createDetailsBody(diagnostic.message, summaryLine);
+	const summary = options.hasMappedLocation ? summaryLine : `${summaryLine} (${formatInlineLocation(options.blockLabel, diagnostic)})`;
+	if (details) sections.push(formatSection("Details", details));
+	const helpText = resolveHelpText(diagnostic.help, options.helpLevel);
+	if (helpText) sections.push(formatSection("Help", helpText));
+	if (sections.length === 0) return summary;
+	return `${summary}\n${sections.join("\n")}`;
+}
+function createDetailsBody(message, summary) {
+	if (message === summary) return null;
+	if (message.startsWith(summary)) return message.slice(summary.length).trim() || null;
+	return message;
+}
+function formatSection(title, body) {
+	return `    ${title}:\n${indentBlock(body, "      ")}`;
+}
+function formatInlineLocation(blockLabel, diagnostic) {
+	const { line, column } = diagnostic.location.start;
+	return `at ${blockLabel}:${line}:${column}`;
+}
+function resolveHelpText(help, helpLevel) {
+	if (help == null || helpLevel === "none") return null;
+	const plainText = formatHelpText(help);
+	if (helpLevel === "short") return firstMeaningfulLine(plainText);
+	return plainText;
+}
+function formatHelpText(help) {
+	const cached = helpTextCache.get(help);
+	if (cached) return cached;
+	const plainText = help.replace(/\r\n?/gu, "\n").replace(/^\s*```[^\n]*$/gmu, "").replace(/\*\*(.*?)\*\*/gu, "$1").replace(/__(.*?)__/gu, "$1").replace(/`([^`\n]+)`/gu, "$1").replace(/^\s*[-*]\s+/gmu, "- ").replace(/\n{3,}/gu, "\n\n").trim();
+	helpTextCache.set(help, plainText);
+	return plainText;
+}
+function firstMeaningfulLine(text) {
+	for (const line of text.split("\n")) {
+		const trimmed = line.trim();
+		if (trimmed) return trimmed;
+	}
+	return null;
+}
+function indentBlock(text, indent) {
+	return text.split("\n").map((line) => `${indent}${line}`).join("\n");
+}
+function createSummaryLine(message) {
+	const firstSentenceEnd = message.indexOf(". ");
+	if (firstSentenceEnd === -1) return message;
+	return message.slice(0, firstSentenceEnd + 1);
+}
+//#endregion
+//#region src/plugin.ts
+function createOxlintDiagnostic(diagnostic, state, scriptMap, helpLevel, program) {
+	const loc = state.usesOriginalLocations ? createOriginalSfcLoc(diagnostic) : mapToScriptLoc(diagnostic, scriptMap);
+	const block = loc === null ? getDiagnosticBlock(diagnostic, getSfcBlocks(state)) : null;
+	const message = formatPatinaMessage(diagnostic, {
+		hasMappedLocation: loc !== null,
+		blockLabel: formatBlockLabel(block),
+		helpLevel
+	});
+	if (loc == null && state.extractedScript.length === 0) return {
+		node: program,
+		message
+	};
+	const fallbackColumn = state.extractedScript.length === 0 ? 0 : 1;
+	return {
+		loc: loc ?? {
+			start: {
+				line: 1,
+				column: fallbackColumn
+			},
+			end: {
+				line: 1,
+				column: fallbackColumn
+			}
+		},
+		message
+	};
+}
+function shouldReportForCurrentProgram(diagnostic, state, scriptMap) {
+	if (state.usesOriginalLocations) return isScriptLikeFile(state.filename) || isLocationBridgeProgram(state.extractedScript);
+	if (scriptMap == null) return true;
+	const block = getDiagnosticBlock(diagnostic, getSfcBlocks(state));
+	return !isScriptBlock(block) || block === scriptMap.block;
+}
+function isScriptBlock(block) {
+	return block?.kind === "script" || block?.kind === "script-setup";
+}
+function createOriginalSfcLoc(diagnostic) {
+	return {
+		start: {
+			line: diagnostic.location.start.line,
+			column: Math.max(0, diagnostic.location.start.column - 1)
+		},
+		end: {
+			line: diagnostic.location.end.line,
+			column: Math.max(0, diagnostic.location.end.column - 1)
+		}
+	};
+}
+function createPatinaRule(ruleMeta) {
+	return defineRule({
+		meta: {
+			type: ruleMeta.defaultSeverity === "error" ? "problem" : "suggestion",
+			docs: { description: ruleMeta.description },
+			schema: ruleOptionsSchema(ruleMeta.name)
+		},
+		createOnce(context) {
+			return {
+				Program(program) {
+					if (!isPatinaFile(context.filename)) return;
+					const settings = getVizeSettings(context);
+					const activePreset = getActivePreset(settings);
+					if (ruleMeta.presets.length > 0 && !isIncrementalPreset(settings) && !ruleMeta.presets.includes(activePreset)) return;
+					collectActiveRule(context, program, ruleMeta.name, getRuleOptions(ruleMeta.name, contextOptions(context)));
+				},
+				"Program:exit"(program) {
+					const collected = getActiveRuleDiagnostics(context, program, ruleMeta.name);
+					if (!collected) return;
+					const { state } = collected;
+					const helpLevel = getVizeSettings(context).helpLevel ?? "full";
+					const scriptMap = getScriptMap(state);
+					const diagnostics = collected.diagnostics.filter((diagnostic) => shouldReportForCurrentProgram(diagnostic, state, scriptMap));
+					if (diagnostics.length === 0) return;
+					for (const diagnostic of diagnostics) {
+						if (!markDiagnosticAsReported(state, diagnostic)) continue;
+						context.report(createOxlintDiagnostic(diagnostic, state, scriptMap, helpLevel, program));
+					}
+				}
+			};
+		}
+	});
+}
+function ruleOptionsSchema(ruleName) {
+	switch (ruleName) {
+		case "vue/component-name-in-template-casing": return [{ enum: ["PascalCase", "kebab-case"] }];
+		case "script/custom-event-name-casing": return [{ enum: ["camelCase", "kebab-case"] }];
+		case "vue/no-mutating-props": return [noMutatingPropsSchema()];
+		case "vue/sfc-element-order": return [sfcElementOrderSchema()];
+		case "vue/html-self-closing": return [htmlSelfClosingSchema()];
+		case "vue/v-on-event-hyphenation":
+		case "vue/attribute-hyphenation": return [{ enum: ["always", "never"] }];
+		default: return [];
+	}
+}
+function noMutatingPropsSchema() {
+	return {
+		type: "object",
+		properties: { shallowOnly: { type: "boolean" } },
+		additionalProperties: false
+	};
+}
+function sfcElementOrderSchema() {
+	const selector = { type: "string" };
+	return {
+		type: "object",
+		properties: { order: {
+			type: "array",
+			items: { oneOf: [selector, {
+				type: "array",
+				items: selector
+			}] }
+		} },
+		additionalProperties: false
+	};
+}
+function htmlSelfClosingSchema() {
+	const style = { enum: [
+		"always",
+		"never",
+		"any"
+	] };
+	return {
+		type: "object",
+		properties: {
+			html: {
+				type: "object",
+				properties: {
+					void: style,
+					normal: style,
+					component: style
+				},
+				additionalProperties: false
+			},
+			svg: style,
+			math: style
+		},
+		additionalProperties: false
+	};
+}
+function contextOptions(context) {
+	const options = context.options;
+	return Array.isArray(options) ? options : [];
+}
+var plugin_default = definePlugin({
+	meta: { name: "vize" },
+	rules: Object.fromEntries(getPatinaRules().map((ruleMeta) => [ruleMeta.name, createPatinaRule(ruleMeta)]))
+});
+//#endregion
+//#region src/configs.ts
+const TYPE_AWARE_RULE_PREFIX = "type/";
+function createVizeRuleConfig(options = {}) {
+	const presets = resolveRuleConfigPresets(options);
+	const includeTypeAware = options.includeTypeAware ?? false;
+	const rules = {};
+	for (const ruleMeta of getPatinaRules()) {
+		if (!matchesPresets(ruleMeta, presets)) continue;
+		if (!includeTypeAware && isTypeAwareRule(ruleMeta)) continue;
+		rules[`vize/${ruleMeta.name}`] = toOxlintSeverity(ruleMeta.defaultSeverity);
+	}
+	return rules;
+}
+const configs = {
+	all: createVizeRuleConfig({ preset: "all" }),
+	ecosystem: createVizeRuleConfig({ preset: "ecosystem" }),
+	ecosystemWithTypeAware: createVizeRuleConfig({
+		includeTypeAware: true,
+		preset: "ecosystem"
+	}),
+	essential: createVizeRuleConfig({ preset: "essential" }),
+	happyPath: createVizeRuleConfig({ preset: "happy-path" }),
+	happyPathWithTypeAware: createVizeRuleConfig({
+		includeTypeAware: true,
+		preset: "happy-path"
+	}),
+	nuxt: createVizeRuleConfig({ preset: "nuxt" }),
+	opinionated: createVizeRuleConfig({ preset: "opinionated" }),
+	opinionatedWithTypeAware: createVizeRuleConfig({
+		includeTypeAware: true,
+		preset: "opinionated"
+	}),
+	recommended: createVizeRuleConfig({ preset: "general-recommended" }),
+	recommendedWithTypeAware: createVizeRuleConfig({
+		includeTypeAware: true,
+		preset: "general-recommended"
+	})
+};
+function normalizeRuleConfigPreset(preset) {
+	return preset === "happy-path" ? "general-recommended" : preset;
+}
+function resolveRuleConfigPresets(options) {
+	const requestedPresets = [...toPresetArray((options.preset === void 0 && options.presets === void 0 ? "general-recommended" : options.preset) ?? []), ...options.presets ?? []].map(normalizeRuleConfigPreset);
+	return [...new Set(requestedPresets)];
+}
+function toPresetArray(preset) {
+	return Array.isArray(preset) ? preset : [preset];
+}
+function matchesPresets(ruleMeta, presets) {
+	return presets.includes("all") || presets.some((preset) => preset !== "all" && ruleMeta.presets.includes(preset));
+}
+function isTypeAwareRule(ruleMeta) {
+	return ruleMeta.name.startsWith(TYPE_AWARE_RULE_PREFIX);
+}
+function toOxlintSeverity(severity) {
+	return severity === "warning" ? "warn" : severity;
+}
+if (import.meta.vitest) {
+	const { describe, expect, it } = import.meta.vitest;
+	describe("createVizeRuleConfig", () => {
+		it("normalizes Vize warning severity to Oxlint's warn", () => {
+			expect(configs.recommended["vize/vue/no-multi-spaces"]).toBe("warn");
+		});
+		it("accepts the CLI happy-path preset alias", () => {
+			expect(createVizeRuleConfig({ preset: "happy-path" })).toEqual(configs.recommended);
+			expect(configs.happyPath).toEqual(configs.recommended);
+		});
+		it("unions multiple presets", () => {
+			const config = createVizeRuleConfig({ presets: ["happy-path", "ecosystem"] });
+			expect(config["vize/script/valid-define-props"]).toBe("error");
+			expect(config["vize/ecosystem/router-link-require-to"]).toBe("error");
+			expect(config["vize/script/no-options-api"]).toBeUndefined();
+		});
+		it("accepts multiple presets through the preset option", () => {
+			expect(createVizeRuleConfig({ preset: ["happy-path", "ecosystem"] })).toEqual(createVizeRuleConfig({ presets: ["happy-path", "ecosystem"] }));
+		});
+		it("filters rules by preset", () => {
+			expect(configs.essential["vize/vue/require-v-for-key"]).toBe("error");
+			expect(configs.essential["vize/vue/require-scoped-style"]).toBeUndefined();
+		});
+		it("enables script correctness rules in essential and happy-path", () => {
+			expect(configs.essential["vize/script/valid-define-props"]).toBe("error");
+			expect(configs.essential["vize/script/no-import-compiler-macros"]).toBe("error");
+			expect(configs.recommended["vize/script/valid-define-props"]).toBe("error");
+			expect(configs.recommended["vize/script/no-import-compiler-macros"]).toBe("error");
+		});
+		it("keeps low-noise happy-path script warnings out of essential", () => {
+			expect(configs.recommended["vize/script/no-duplicate-attr-inheritance"]).toBe("warn");
+			expect(configs.recommended["vize/script/no-reactive-destructure"]).toBeUndefined();
+			expect(configs.essential["vize/script/no-duplicate-attr-inheritance"]).toBeUndefined();
+			expect(configs.recommended["vize/script/no-unused-emit-declarations"]).toBeUndefined();
+			expect(configs.essential["vize/script/no-unused-emit-declarations"]).toBeUndefined();
+		});
+		it("keeps opinionated script style out of happy-path", () => {
+			expect(configs.recommended["vize/script/no-options-api"]).toBeUndefined();
+			expect(configs.recommended["vize/script/define-props-declaration"]).toBeUndefined();
+			expect(configs.opinionated["vize/script/no-options-api"]).toBe("error");
+		});
+		it("skips unstable type-aware rules by default", () => {
+			expect(configs.opinionated["vize/type/require-typed-props"]).toBeUndefined();
+			expect(configs.opinionatedWithTypeAware["vize/type/require-typed-props"]).toBe("warn");
+		});
+		it("keeps Options API allowed in the Nuxt preset", () => {
+			expect(configs.nuxt["vize/script/no-options-api"]).toBeUndefined();
+			expect(configs.opinionated["vize/script/no-options-api"]).toBe("error");
+		});
+		it("enables Nuxt framework rules only in the Nuxt and all presets", () => {
+			for (const ruleName of [
+				"prefer-import-meta",
+				"no-page-meta-runtime-values",
+				"no-nuxt-config-test-key",
+				"nuxt-config-keys-order"
+			]) {
+				const ruleId = `vize/nuxt/${ruleName}`;
+				expect(configs.nuxt[ruleId]).toBe("error");
+				expect(configs.all[ruleId]).toBe("error");
+				expect(configs.ecosystem[ruleId]).toBeUndefined();
+				expect(configs.opinionated[ruleId]).toBeUndefined();
+				expect(configs.recommended[ruleId]).toBeUndefined();
+			}
+		});
+		it("keeps ecosystem rules out of non-ecosystem presets until explicitly selected", () => {
+			expect(configs.recommended["vize/ecosystem/router-link-require-to"]).toBeUndefined();
+			expect(configs.nuxt["vize/ecosystem/nuxt-prefer-nuxt-link"]).toBe("warn");
+			expect(configs.ecosystem["vize/ecosystem/nuxt-prefer-nuxt-link"]).toBeUndefined();
+			expect(configs.all["vize/ecosystem/nuxt-prefer-nuxt-link"]).toBe("warn");
+			expect(configs.ecosystem["vize/ecosystem/router-link-require-to"]).toBe("error");
+			expect(configs.ecosystem["vize/ecosystem/vue-i18n-no-missing-key"]).toBe("warn");
+			expect(configs.ecosystem["vize/ecosystem/void-link-require-href"]).toBe("error");
+			expect(configs.all["vize/ecosystem/router-link-require-to"]).toBe("error");
+		});
+	});
+}
+//#endregion
+export { getPatinaRules as a, isTypeAwareRuleName as c, getRuleOptions as d, formatPatinaMessage as i, createRuleSelection as l, createVizeRuleConfig as n, getActivePreset as o, plugin_default as r, getVizeSettings as s, configs as t, selectVizeRuleConfig as u };