oxlint-plugin-vize 0.502.0 → 0.503.0

package/dist/cli.mjs

@@ -1,7 +1,7 @@
-import { m as loadBinding, n as prepareWorkaroundSource, p as isStandaloneHtmlFile, s as extractSfcBlocks, u as hasVueLikeExtension } from "./workaround-FRBXv1sV.mjs";
-import { spawn, spawnSync } from "node:child_process";
-import path from "node:path";
+import { m as loadBinding, n as prepareWorkaroundSource, p as isStandaloneHtmlFile, s as extractSfcBlocks, u as hasVueLikeExtension } from "./workaround-Byh3ja-i.mjs";
 import fs from "node:fs";
+import path from "node:path";
+import { spawn, spawnSync } from "node:child_process";
 import { createHash, randomUUID } from "node:crypto";
 import os from "node:os";
 import { fileURLToPath, pathToFileURL } from "node:url";

package/dist/{configs-CcanGVPM.mjs → configs-BjsIAx6F.mjs}

@@ -1,6 +1,8 @@
-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-FRBXv1sV.mjs";
+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-Byh3ja-i.mjs";
+import { createRequire } from "node:module";
 import { definePlugin, defineRule } from "@oxlint/plugins";
 import fs from "node:fs";
+import path from "node:path";
 //#region src/plugin-option-guards.ts
 function optionField(value) {
 	return value === void 0 || value === "always" || value === "never" || value === "any";
@@ -24,13 +26,18 @@ function getRuleOptions(ruleName, options) {
 	switch (ruleName) {
 		case "vue/component-name-in-template-casing":
 			if (isComponentNameInTemplateCasingOption(firstOption)) return { componentNameInTemplateCasing: firstOption };
+			if (isRecord(firstOption)) return cliRuleOptions(ruleName, firstOption);
 			break;
 		case "script/custom-event-name-casing":
 			if (isCustomEventNameCasingOption(firstOption)) return { customEventNameCasing: firstOption };
+			if (isRecord(firstOption)) return cliRuleOptions(ruleName, firstOption);
 			break;
 		case "vue/no-mutating-props":
 			if (isNoMutatingPropsOption(firstOption)) return { noMutatingProps: firstOption };
 			break;
+		case "script/define-macros-order":
+			if (isDefineMacrosOrderOption(firstOption)) return { defineMacrosOrder: firstOption };
+			break;
 		case "vue/sfc-element-order":
 			if (isSfcElementOrderOption(firstOption)) return { sfcElementOrder: firstOption };
 			break;
@@ -43,8 +50,27 @@ function getRuleOptions(ruleName, options) {
 		case "vue/attribute-hyphenation":
 			if (isHyphenationStyle(firstOption)) return { attributeHyphenation: firstOption };
 			break;
+		case "script/define-props-destructuring":
+		case "html/no-empty-palpable-content":
+		case "type/strict-boolean-expressions":
+		case "script/no-restricted-globals":
+		case "script/no-restricted-members":
+		case "vue/require-component-registration":
+		case "vue/valid-v-on":
+		case "vue/valid-v-slot":
+		case "musea/prefer-design-tokens":
+			if (isRecord(firstOption)) return cliRuleOptions(ruleName, firstOption);
+			break;
 	}
 }
+function isDefineMacrosOrderOption(value) {
+	if (!isRecord(value) || !hasOnlyKeys(value, ["order"])) return false;
+	const order = value.order;
+	return order === void 0 || Array.isArray(order) && order.every((name, index) => isString(name) && name.length > 0 && order.indexOf(name) === index);
+}
+function cliRuleOptions(ruleName, option) {
+	return { ruleOptions: { [ruleName]: structuredClone(option) } };
+}
 function isComponentNameInTemplateCasingOption(value) {
 	return value === "PascalCase" || value === "kebab-case";
 }
@@ -110,7 +136,7 @@ function parseRuleSelection(rules) {
 function createRuleSelection(optionsByRule) {
 	const names = [...optionsByRule.keys()].sort();
 	const options = {};
-	for (const name of names) Object.assign(options, optionsByRule.get(name));
+	for (const name of names) mergeRuleOptions(options, optionsByRule.get(name));
 	return {
 		names,
 		options,
@@ -118,6 +144,15 @@ function createRuleSelection(optionsByRule) {
 		cacheKey: JSON.stringify([names, ruleOptionsKey(options)])
 	};
 }
+function mergeRuleOptions(target, source) {
+	if (!source) return;
+	const { ruleOptions, ...direct } = source;
+	Object.assign(target, direct);
+	if (ruleOptions) target.ruleOptions = {
+		...target.ruleOptions,
+		...ruleOptions
+	};
+}
 function normalizeRuleName(name) {
 	return name.startsWith("vize/") ? name.slice(5) : name;
 }
@@ -190,8 +225,7 @@ function getActivePreset(settings) {
 function isIncrementalPreset(settings) {
 	return getActivePreset(settings) === "incremental";
 }
-function getCacheKey(filename, settings) {
-	const selection = parseRuleSelection(settings.rules);
+function getCacheKey(filename, settings, selection = parseRuleSelection(settings.rules)) {
 	return JSON.stringify([
 		filename,
 		settings.locale ?? "",
@@ -263,7 +297,10 @@ if (import.meta.vitest) {
 }
 //#endregion
 //#region src/binding.ts
+const VUE_ROUTER_COMPONENTS = ["RouterLink", "RouterView"];
+const COMPONENT_REGISTRATION_RULE = "vue/require-component-registration";
 function lintPatina(source, filename, settings, enabledRules, ruleOptions) {
+	const { ruleOptions: cliRuleOptions, ...directRuleOptions } = withVueRouterComponentGlobals(filename, ruleOptions) ?? {};
 	return loadBinding().lintPatinaSfc(source, {
 		filename,
 		locale: settings.locale,
@@ -272,9 +309,33 @@ function lintPatina(source, filename, settings, enabledRules, ruleOptions) {
 		enabledRules: enabledRules ? [...enabledRules] : void 0,
 		typeAware: settings.typeAware,
 		corsaPath: settings.corsaPath,
-		...ruleOptions
+		ruleOptionsJson: cliRuleOptions ? JSON.stringify(cliRuleOptions) : void 0,
+		...directRuleOptions
 	});
 }
+function withVueRouterComponentGlobals(filename, options) {
+	if (!isVueRouterResolvableFrom(filename)) return options;
+	const ruleOptions = options?.ruleOptions ?? {};
+	const registration = ruleOptions[COMPONENT_REGISTRATION_RULE] ?? {};
+	return {
+		...options,
+		ruleOptions: {
+			...ruleOptions,
+			[COMPONENT_REGISTRATION_RULE]: {
+				...registration,
+				globals: [...new Set([...registration.globals ?? [], ...VUE_ROUTER_COMPONENTS])]
+			}
+		}
+	};
+}
+function isVueRouterResolvableFrom(filename) {
+	try {
+		createRequire(path.resolve(filename)).resolve("vue-router");
+		return true;
+	} catch {
+		return false;
+	}
+}
 function getPatinaRules() {
 	return loadBinding().getPatinaRules();
 }
@@ -355,7 +416,8 @@ let fileStateCacheClock = 0;
 function getFileState(context) {
 	const settings = getVizeSettings(context);
 	const physicalSource = fs.readFileSync(context.physicalFilename, "utf8");
-	const cacheKey = getCacheKey(context.physicalFilename, settings);
+	const ruleSelection = parseRuleSelection(settings.rules);
+	const cacheKey = getCacheKey(context.physicalFilename, settings, ruleSelection);
 	const cached = fileStateCache.get(cacheKey);
 	if (cached && cached.state.revision.physicalSource === physicalSource) {
 		validateWorkaroundAuthority(cached.state, context.physicalFilename);
@@ -381,7 +443,7 @@ function getFileState(context) {
 		partialDiagnosticsByRule: /* @__PURE__ */ new Map(),
 		requestedRules: /* @__PURE__ */ new Set(),
 		reportedTypeAwareRuntimeDiagnostic: false,
-		ruleSelection: parseRuleSelection(settings.rules),
+		ruleSelection,
 		selectedDiagnosticsByRule: null
 	};
 	fileStateCache.set(cacheKey, {
@@ -461,25 +523,22 @@ function diagnosticsForRule(state, diagnosticsByRule, ruleName) {
 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,
+			state: getFileState(context),
+			physicalIdentity: physicalIdentity(context.physicalFilename),
+			runtimeSettings: getVizeSettings(context),
 			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) {
+	if (!hasCurrentProgramInputs(context, collection)) {
 		programs.delete(program);
 		throw new Error("Vize source or configuration changed before rule execution");
 	}
@@ -513,6 +572,24 @@ function getActiveRuleDiagnostics(context, program, ruleName) {
 		diagnostics
 	};
 }
+function physicalIdentity(filename) {
+	const stat = fs.statSync(filename, { bigint: true });
+	return {
+		dev: stat.dev,
+		ino: stat.ino,
+		size: stat.size,
+		mtimeNs: stat.mtimeNs,
+		ctimeNs: stat.ctimeNs
+	};
+}
+function hasCurrentProgramInputs(context, collection) {
+	const currentIdentity = physicalIdentity(context.physicalFilename);
+	const expectedIdentity = collection.physicalIdentity;
+	if (currentIdentity.dev !== expectedIdentity.dev || currentIdentity.ino !== expectedIdentity.ino || currentIdentity.size !== expectedIdentity.size || currentIdentity.mtimeNs !== expectedIdentity.mtimeNs || currentIdentity.ctimeNs !== expectedIdentity.ctimeNs || context.sourceCode.text !== collection.state.extractedScript) return false;
+	const current = getVizeSettings(context);
+	const expected = collection.runtimeSettings;
+	return current.locale === expected.locale && current.helpLevel === expected.helpLevel && current.preset === expected.preset && current.typeAware === expected.typeAware && current.corsaPath === expected.corsaPath;
+}
 //#endregion
 //#region src/format.ts
 const helpTextCache = /* @__PURE__ */ new Map();
@@ -652,16 +729,108 @@ function createPatinaRule(ruleMeta) {
 }
 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/component-name-in-template-casing": return [{ oneOf: [{ enum: ["PascalCase", "kebab-case"] }, objectSchema({
+			casing: { enum: ["PascalCase", "kebab-case"] },
+			registeredComponentsOnly: { type: "boolean" },
+			globals: stringArraySchema()
+		})] }];
+		case "script/custom-event-name-casing": return [{ oneOf: [{ enum: ["camelCase", "kebab-case"] }, objectSchema({ casing: { enum: ["camelCase", "kebab-case"] } })] }];
+		case "script/define-props-destructuring": return [objectSchema({ destructure: { enum: [
+			"only-when-assigned",
+			"always",
+			"never"
+		] } })];
+		case "html/no-empty-palpable-content": return [objectSchema({ contentDirectives: stringArraySchema() })];
+		case "type/strict-boolean-expressions": return [strictBooleanExpressionsSchema()];
+		case "script/no-restricted-globals": return [restrictedGlobalsSchema()];
+		case "script/no-restricted-members": return [restrictedMembersSchema()];
 		case "vue/no-mutating-props": return [noMutatingPropsSchema()];
+		case "script/define-macros-order": return [defineMacrosOrderSchema()];
 		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"] }];
+		case "vue/require-component-registration": return [objectSchema({ globals: stringArraySchema() })];
+		case "vue/valid-v-on": return [objectSchema({ modifiers: stringArraySchema() })];
+		case "vue/valid-v-slot": return [objectSchema({ allowModifiers: { type: "boolean" } })];
+		case "musea/prefer-design-tokens": return [designTokensSchema()];
 		default: return [];
 	}
 }
+function defineMacrosOrderSchema() {
+	return objectSchema({ order: {
+		type: "array",
+		items: {
+			type: "string",
+			minLength: 1
+		},
+		uniqueItems: true
+	} });
+}
+function objectSchema(properties) {
+	return {
+		type: "object",
+		properties,
+		additionalProperties: false
+	};
+}
+function stringArraySchema() {
+	return {
+		type: "array",
+		items: { type: "string" }
+	};
+}
+function strictBooleanExpressionsSchema() {
+	const boolean = { type: "boolean" };
+	return objectSchema({
+		allowString: boolean,
+		allowNumber: boolean,
+		allowNullableObject: boolean,
+		allowNullableBoolean: boolean,
+		allowNullableString: boolean,
+		allowNullableNumber: boolean,
+		allowNullableEnum: boolean,
+		allowAny: boolean
+	});
+}
+function restrictedGlobalsSchema() {
+	return objectSchema({ globals: {
+		type: "array",
+		items: {
+			...objectSchema({
+				name: { type: "string" },
+				message: { type: "string" }
+			}),
+			required: ["name"]
+		}
+	} });
+}
+function restrictedMembersSchema() {
+	return objectSchema({ members: {
+		type: "array",
+		items: {
+			...objectSchema({
+				object: { type: "string" },
+				property: { type: "string" },
+				message: { type: "string" }
+			}),
+			required: ["object", "property"]
+		}
+	} });
+}
+function designTokensSchema() {
+	return objectSchema({ tokens: {
+		type: "array",
+		items: {
+			...objectSchema({
+				path: { type: "string" },
+				value: { type: "string" },
+				tier: { type: "string" }
+			}),
+			required: ["path", "value"]
+		}
+	} });
+}
 function noMutatingPropsSchema() {
 	return {
 		type: "object",

package/dist/configs-U-ykt2bi.d.mts

@@ -0,0 +1,120 @@
+//#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>;
+}
+interface VizeRuleOptions {
+  "script/define-props-destructuring"?: {
+    destructure?: "only-when-assigned" | "always" | "never";
+  };
+  "html/no-empty-palpable-content"?: {
+    contentDirectives?: string[];
+  };
+  "type/strict-boolean-expressions"?: {
+    allowString?: boolean;
+    allowNumber?: boolean;
+    allowNullableObject?: boolean;
+    allowNullableBoolean?: boolean;
+    allowNullableString?: boolean;
+    allowNullableNumber?: boolean;
+    allowNullableEnum?: boolean;
+    allowAny?: boolean;
+  };
+  "script/no-restricted-globals"?: {
+    globals?: Array<{
+      name: string;
+      message?: string;
+    }>;
+  };
+  "script/no-restricted-members"?: {
+    members?: Array<{
+      object: string;
+      property: string;
+      message?: string;
+    }>;
+  };
+  "vue/component-name-in-template-casing"?: {
+    casing?: ComponentNameInTemplateCasingOption;
+    registeredComponentsOnly?: boolean;
+    globals?: string[];
+  };
+  "script/custom-event-name-casing"?: {
+    casing?: CustomEventNameCasingOption;
+  };
+  "vue/no-mutating-props"?: NoMutatingPropsOption;
+  "vue/require-component-registration"?: {
+    globals?: string[];
+  };
+  "vue/sfc-element-order"?: SfcElementOrderOption;
+  "vue/html-self-closing"?: HtmlSelfClosingOption;
+  "vue/v-on-event-hyphenation"?: HyphenationStyle;
+  "vue/attribute-hyphenation"?: HyphenationStyle;
+  "vue/valid-v-on"?: {
+    modifiers?: string[];
+  };
+  "vue/valid-v-slot"?: {
+    allowModifiers?: boolean;
+  };
+  "musea/prefer-design-tokens"?: {
+    tokens?: Array<{
+      path: string;
+      value: string;
+      tier?: string;
+    }>;
+  };
+}
+type ComponentNameInTemplateCasingOption = "PascalCase" | "kebab-case";
+type CustomEventNameCasingOption = "camelCase" | "kebab-case";
+interface NoMutatingPropsOption {
+  shallowOnly?: boolean;
+}
+type SfcElementOrderGroup = string | string[];
+interface SfcElementOrderOption {
+  order?: SfcElementOrderGroup[];
+}
+type HtmlSelfClosingStyle = "always" | "never" | "any";
+interface HtmlSelfClosingOption {
+  html?: {
+    void?: HtmlSelfClosingStyle;
+    normal?: HtmlSelfClosingStyle;
+    component?: HtmlSelfClosingStyle;
+  };
+  svg?: HtmlSelfClosingStyle;
+  math?: HtmlSelfClosingStyle;
+}
+type HyphenationStyle = "always" | "never";
+//#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, VizeRuleOptions as d, VizeRuleConfigOptions as i, PatinaPreset as l, OxlintRuleEntry as n, VizeRuleConfigPresetInput as o, OxlintRuleSeverity as r, configs as s, OxlintRuleConfig as t, PatinaSettings as u };

package/dist/eslint.d.mts

@@ -1,4 +1,4 @@
-import { c as createVizeRuleConfig, s as configs } from "./configs-BuOTHAnm.mjs";
+import { c as createVizeRuleConfig, s as configs } from "./configs-U-ykt2bi.mjs";
 
 //#region src/eslint.d.ts
 /** ESLint rules over the complete source supplied by the configured parser. */

package/dist/eslint.mjs

@@ -1,5 +1,5 @@
-import { a as getPatinaRules, c as isTypeAwareRuleName, d as getRuleOptions, i as formatPatinaMessage, l as createRuleSelection, n as createVizeRuleConfig, o as getActivePreset, r as plugin_default, s as getVizeSettings, t as configs } from "./configs-CcanGVPM.mjs";
-import { d as isPatinaFile, m as loadBinding } from "./workaround-FRBXv1sV.mjs";
+import { a as getPatinaRules, c as isTypeAwareRuleName, d as getRuleOptions, i as formatPatinaMessage, l as createRuleSelection, n as createVizeRuleConfig, o as getActivePreset, r as plugin_default, s as getVizeSettings, t as configs } from "./configs-BjsIAx6F.mjs";
+import { d as isPatinaFile, m as loadBinding } from "./workaround-Byh3ja-i.mjs";
 import { definePlugin, defineRule, eslintCompatPlugin } from "@oxlint/plugins";
 //#region src/eslint-source.ts
 /** Native UTF-8 text cannot preserve an unpaired UTF-16 surrogate. */

package/dist/index.d.mts

@@ -1,4 +1,4 @@
-import { a as VizeRuleConfigPreset, c as createVizeRuleConfig, i as VizeRuleConfigOptions, l as PatinaPreset, n as OxlintRuleEntry, o as VizeRuleConfigPresetInput, r as OxlintRuleSeverity, s as configs, t as OxlintRuleConfig, u as PatinaSettings } from "./configs-BuOTHAnm.mjs";
+import { a as VizeRuleConfigPreset, c as createVizeRuleConfig, d as VizeRuleOptions, i as VizeRuleConfigOptions, l as PatinaPreset, n as OxlintRuleEntry, o as VizeRuleConfigPresetInput, r as OxlintRuleSeverity, s as configs, t as OxlintRuleConfig, u as PatinaSettings } from "./configs-U-ykt2bi.mjs";
 
 //#region src/plugin.d.ts
 declare const _default: import("@oxlint/plugins").Plugin;
@@ -55,6 +55,11 @@ interface VizeLintConfigOptions {
    * bridge registers and, for a single gated preset, against the resolved preset.
    */
   rules?: OxlintRuleConfig;
+  /**
+   * CLI-compatible `vue.linter.ruleOptions`. Options are attached to rules
+   * already enabled by a preset or by `rules`; options never enable a rule.
+   */
+  ruleOptions?: VizeRuleOptions;
   /**
    * Patina runtime settings forwarded through `settings.vize`. `preset` and
    * `rules` are derived from the selected presets and final rule map,

package/dist/index.mjs

@@ -1,4 +1,4 @@
-import { a as getPatinaRules, n as createVizeRuleConfig, r as plugin_default, t as configs, u as selectVizeRuleConfig } from "./configs-CcanGVPM.mjs";
+import { a as getPatinaRules, n as createVizeRuleConfig, r as plugin_default, t as configs, u as selectVizeRuleConfig } from "./configs-BjsIAx6F.mjs";
 //#region src/vite-plus.ts
 /**
 * Bare specifier Oxlint uses to load this bridge as a JS plugin.
@@ -51,10 +51,10 @@ function buildVizeLintConfig(options, buildOptions) {
 	const runtimePreset = buildOptions.forceIncrementalRuntime ? "incremental" : toRuntimePreset(presets);
 	const extraRules = options.rules ?? {};
 	assertUsableVizeRules(extraRules, presets, runtimePreset);
-	const rules = {
+	const rules = applyRuleOptions({
 		...createPresetRules(presets, options.includeTypeAware),
 		...extraRules
-	};
+	}, options.ruleOptions);
 	return {
 		jsPlugins: [VIZE_JS_PLUGIN_SPECIFIER],
 		plugins: [...new Set(["vue", ...options.plugins ?? []])],
@@ -66,6 +66,17 @@ function buildVizeLintConfig(options, buildOptions) {
 		} }
 	};
 }
+function applyRuleOptions(rules, ruleOptions) {
+	if (!ruleOptions) return rules;
+	const resolved = { ...rules };
+	for (const [name, option] of Object.entries(ruleOptions)) {
+		const id = `${VIZE_RULE_PREFIX}${name}`;
+		const entry = resolved[id];
+		if (entry === void 0 || entry === "off") continue;
+		resolved[id] = [Array.isArray(entry) ? entry[0] : entry, option];
+	}
+	return resolved;
+}
 function createPresetRules(presets, includeTypeAware) {
 	const ruleConfigPresets = presets.filter(isRuleConfigPreset);
 	if (ruleConfigPresets.length === 0) return {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "oxlint-plugin-vize",
-  "version": "0.502.0",
+  "version": "0.503.0",
   "description": "Oxlint JS plugin bridge for Vize Patina",
   "keywords": [
     "lint",
@@ -48,21 +48,21 @@
   "devDependencies": {
     "@tsdown/css": "0.22.14",
     "@types/node": "25.9.2",
-    "@vizejs/native": "0.502.0",
+    "@vizejs/native": "0.503.0",
     "tsdown": "0.22.14",
     "typescript": "6.0.3",
     "vite": "npm:@voidzero-dev/vite-plus-core@0.1.24",
     "vite-plus": "0.1.24"
   },
   "optionalDependencies": {
-    "@vizejs/native-darwin-arm64": "0.502.0",
-    "@vizejs/native-darwin-x64": "0.502.0",
-    "@vizejs/native-linux-arm64-gnu": "0.502.0",
-    "@vizejs/native-linux-arm64-musl": "0.502.0",
-    "@vizejs/native-linux-x64-gnu": "0.502.0",
-    "@vizejs/native-linux-x64-musl": "0.502.0",
-    "@vizejs/native-win32-arm64-msvc": "0.502.0",
-    "@vizejs/native-win32-x64-msvc": "0.502.0"
+    "@vizejs/native-darwin-arm64": "0.503.0",
+    "@vizejs/native-darwin-x64": "0.503.0",
+    "@vizejs/native-linux-arm64-gnu": "0.503.0",
+    "@vizejs/native-linux-arm64-musl": "0.503.0",
+    "@vizejs/native-linux-x64-gnu": "0.503.0",
+    "@vizejs/native-linux-x64-musl": "0.503.0",
+    "@vizejs/native-win32-arm64-msvc": "0.503.0",
+    "@vizejs/native-win32-x64-msvc": "0.503.0"
   },
   "engines": {
     "node": "^22 || >= 24"
@@ -75,7 +75,7 @@
   },
   "scripts": {
     "build": "vp pack",
-    "test": "vp pack && vp test run src/file-state.test.ts src/batched-rules.test.ts src/script-safe-source.test.ts src/active-rule-collection.test.ts && node src/test.ts && node src/script-location.test.ts && node src/casing-options.test.ts && node src/template-style-fixes.test.mjs && node src/html-binding.test.mjs && node --test src/eslint-source.test.ts && node src/eslint-acceptance.test.mjs",
+    "test": "vp pack && vp test run src/file-state.test.ts src/batched-rules.test.ts src/script-safe-source.test.ts src/active-rule-collection.test.ts && node src/test.ts && node src/script-location.test.ts && node src/casing-options.test.ts && node src/router-globals.test.ts && node src/template-style-fixes.test.mjs && node src/html-binding.test.mjs && node --test src/eslint-source.test.ts && node src/eslint-acceptance.test.mjs",
     "check": "vp check src vite.config.ts",
     "check:fix": "vp check --fix src vite.config.ts",
     "fmt": "vp fmt --write src vite.config.ts"

package/dist/configs-BuOTHAnm.d.mts

@@ -1,40 +0,0 @@
-//#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 };

package/dist/{workaround-FRBXv1sV.mjs → workaround-Byh3ja-i.mjs}

@@ -1,7 +1,7 @@
 import { createRequire } from "node:module";
-import { spawnSync } from "node:child_process";
-import path from "node:path";
 import fs from "node:fs";
+import path from "node:path";
+import { spawnSync } from "node:child_process";
 import { isUtf8 } from "node:buffer";
 import { createHash } from "node:crypto";
 //#region src/native.ts