oxlint-plugin-vize 0.390.0 → 0.391.0

package/README.md

@@ -12,8 +12,8 @@ This package lets Oxlint execute Patina through Vize's native binding while stil
 
 - Runs Vize Patina rules inside Oxlint as `vize/*` diagnostics, so Vue-specific findings can live beside Oxlint core rules in one command.
 - Keeps Oxlint's existing rules and built-in `vue` plugin active. The bridge adds Vize rules; it does not replace `eqeqeq`, `no-console`, or your existing `vue/*` setup.
-- Ships preset rule maps for JS/TS Oxlint configs: `configs.recommended`, `configs.essential`, `configs.ecosystem`, `configs.opinionated`, `configs.nuxt`, `configs.all`, and type-aware opt-in variants.
-- Ships `createVizeLintConfig()` for the Vite+ `lint` block in `vite.config.ts`, which is the only Oxlint configuration `vp lint` and `vp check` read.
+- Ships preset rule maps for JS/TS Oxlint configs: `configs.recommended`, `configs.happyPath`, `configs.essential`, `configs.ecosystem`, `configs.opinionated`, `configs.nuxt`, `configs.all`, and type-aware opt-in variants.
+- Ships `createVizeLintConfig()`, `flatConfigs`, and `defineVizeLintConfig()` for the Vite+ `lint` block in `vite.config.ts`, which is the only Oxlint configuration `vp lint` and `vp check` read.
 - Supports runtime settings through `settings.vize`, including `locale`, `preset`, and `helpLevel`.
 - Provides the `oxlint-vize` CLI wrapper, which runs Oxlint with a scriptless-SFC workaround and rewrites temporary paths back to the original `.vue` files.
 - Resolves Vize native bindings through platform-specific optional dependencies, so published installs do not need a separate `@vizejs/native` package.
@@ -63,7 +63,7 @@ Which file you configure depends on which command you run.
 
 ### With `vp lint` (Vite+)
 
-`createVizeLintConfig()` returns the whole `lint` block, so the `jsPlugins` entry cannot go missing:
+`createVizeLintConfig()` returns a complete `lint` block, so the `jsPlugins` entry cannot go missing. The default preset is `"happy-path"`/`"general-recommended"`: use it when you want a safe Vue baseline without taking a position on stronger style or framework choices.
 
 ```ts
 // vite.config.ts
@@ -72,7 +72,7 @@ import { createVizeLintConfig } from "oxlint-plugin-vize";
 
 export default defineConfig({
   lint: createVizeLintConfig({
-    preset: "essential",
+    preset: "happy-path",
     rules: {
       "no-console": "warn",
     },
@@ -83,12 +83,18 @@ export default defineConfig({
 });
 ```
 
-`preset` drives both the emitted rule map and `settings.vize.preset`, so the two can never disagree.
-That matters because the bridge silently drops any `vize/*` rule outside the active preset: listing
-`vize/ecosystem/router-link-require-to` while the active preset is `general-recommended` reports
-nothing at all. `createVizeLintConfig` throws for that case, and for unknown `vize/*` ids, instead of
-leaving you with a config that looks enabled and reports nothing. Use `preset: "incremental"` when
-you want only the rules you list, and `preset: "all"` for every bundle at once.
+`preset` drives both the emitted rule map and `settings.vize.preset` when a single bundle is
+selected, so the two can never disagree. That matters because the bridge silently drops any `vize/*`
+rule outside the active preset: listing `vize/ecosystem/router-link-require-to` while the active
+preset is `general-recommended` reports nothing at all. `createVizeLintConfig` throws for that case,
+and for unknown `vize/*` ids, instead of leaving you with a config that looks enabled and reports
+nothing.
+
+Use `preset: "incremental"` when you want only the rules you list, `preset: "all"` for every bundle
+at once, and `preset: ["happy-path", "ecosystem"]` or `presets: ["happy-path", "ecosystem"]` when
+you want several bundles without taking on all of them. Multiple-bundle configs emit
+`settings.vize.preset: "incremental"` so the runtime gate cannot suppress one selected bundle's
+rules while another bundle is active.
 
 The emitted block always enables Oxlint's built-in `vue` plugin. Pass `plugins` to keep the rest of
 your project's plugin list; they are merged with `vue`, never replaced, because narrowing the list
@@ -106,6 +112,27 @@ export default defineConfig({
 });
 ```
 
+For Flat Config-style composition in `vite.config.ts`, use spreadable fragments and collapse them
+back to Vite+'s object-shaped `lint` config:
+
+```ts
+import { defineConfig } from "vite-plus";
+import { defineVizeLintConfig, flatConfigs } from "oxlint-plugin-vize";
+
+export default defineConfig({
+  lint: defineVizeLintConfig(...flatConfigs.recommended, ...flatConfigs.ecosystem, {
+    ignorePatterns: ["dist/**"],
+    rules: {
+      "no-console": "warn",
+    },
+  }),
+});
+```
+
+The exported fragments include `flatConfigs.recommended`, `flatConfigs.happyPath`,
+`flatConfigs.essential`, `flatConfigs.ecosystem`, `flatConfigs.nuxt`, `flatConfigs.opinionated`,
+and `flatConfigs.all`, plus the same `*WithTypeAware` variants as `configs`.
+
 ### With `oxlint` or `oxlint-vize`
 
 Enable Oxlint's built-in `vue` plugin as well as this JS plugin:
@@ -144,7 +171,7 @@ export default {
 };
 ```
 
-`configs.recommended`, `configs.essential`, `configs.ecosystem`, `configs.opinionated`, `configs.nuxt`, and `configs.all` intentionally skip Vize's unstable type-aware rules for now. If you explicitly want those experimental rules too, use `configs.recommendedWithTypeAware`, `configs.ecosystemWithTypeAware`, `configs.opinionatedWithTypeAware`, or `createVizeRuleConfig({ includeTypeAware: true, preset: ... })`. Set `settings.vize.typeAware: true` to run the shared full-file Patina pass with Corsa enabled; explicitly configured `vize/type/*` rules also opt in when they are queried one by one.
+`configs.recommended`, `configs.happyPath`, `configs.essential`, `configs.ecosystem`, `configs.opinionated`, `configs.nuxt`, and `configs.all` intentionally skip Vize's unstable type-aware rules for now. If you explicitly want those experimental rules too, use `configs.recommendedWithTypeAware`, `configs.happyPathWithTypeAware`, `configs.ecosystemWithTypeAware`, `configs.opinionatedWithTypeAware`, or `createVizeRuleConfig({ includeTypeAware: true, preset: ... })`. Set `settings.vize.typeAware: true` to run the shared full-file Patina pass with Corsa enabled; explicitly configured `vize/type/*` rules also opt in when they are queried one by one.
 
 You can pass Patina settings through `settings.vize`:
 
@@ -161,11 +188,12 @@ You can pass Patina settings through `settings.vize`:
 }
 ```
 
-- `preset` accepts `"general-recommended"`, `"essential"`, `"ecosystem"`, `"incremental"`, `"opinionated"`, or `"nuxt"`.
+- `preset` accepts `"general-recommended"`/`"happy-path"`, `"essential"`, `"ecosystem"`, `"incremental"`, `"opinionated"`, `"nuxt"`, or `"all"`.
 - `preset` defaults to `"general-recommended"`.
 - Bundle presets keep out-of-bundle rules quiet even if they are still listed in `rules`.
 - `"incremental"` skips bundle gating and runs only the Vize rules you explicitly configure in Oxlint.
-- `"ecosystem"` enables Vize's Vue Router, Vue I18n, Pinia, Vue Test Utils, Nuxt, and Void Vue rules without taking on the full opinionated preset.
+- `"all"` is accepted as a settings alias for `"incremental"`; use `configs.all` or `createVizeLintConfig({ preset: "all" })` when you also want every rule emitted.
+- `"ecosystem"` enables Vize's Vue Router, Vue I18n, Pinia, Vue Test Utils, and Void Vue rules without taking on the full opinionated preset.
 - `"opinionated"` is the preset that enables Vize's built-in script rules such as `vize/script/no-options-api`.
 - Legacy aliases such as `"GeneralRecommended"`, `"Essential"`, `"Ecosystem"`, `"Incremental"`, `"Opinionated"`, `"Nuxt"`, and `"happy-path"` are still accepted for compatibility.
 - `helpLevel` accepts `"full"`, `"short"`, or `"none"`. Short help keeps one actionable sentence and removes inline examples and trailing rationale.

package/dist/index.d.mts

@@ -16,10 +16,12 @@ interface PatinaSettings {
 type OxlintRuleSeverity = "error" | "warn" | "off";
 type OxlintRuleEntry = OxlintRuleSeverity | [OxlintRuleSeverity, ...unknown[]];
 type OxlintRuleConfig = Record<string, OxlintRuleEntry>;
-type VizeRuleConfigPreset = Exclude<PatinaPreset, "incremental"> | "all";
+type VizeRuleConfigPreset = Exclude<PatinaPreset, "incremental"> | "happy-path" | "all";
+type VizeRuleConfigPresetInput = VizeRuleConfigPreset | readonly VizeRuleConfigPreset[];
 interface VizeRuleConfigOptions {
   includeTypeAware?: boolean;
-  preset?: VizeRuleConfigPreset;
+  preset?: VizeRuleConfigPresetInput;
+  presets?: readonly VizeRuleConfigPreset[];
 }
 declare function createVizeRuleConfig(options?: VizeRuleConfigOptions): OxlintRuleConfig;
 declare const configs: {
@@ -27,6 +29,8 @@ declare const configs: {
   readonly ecosystem: OxlintRuleConfig;
   readonly ecosystemWithTypeAware: OxlintRuleConfig;
   readonly essential: OxlintRuleConfig;
+  readonly happyPath: OxlintRuleConfig;
+  readonly happyPathWithTypeAware: OxlintRuleConfig;
   readonly nuxt: OxlintRuleConfig;
   readonly opinionated: OxlintRuleConfig;
   readonly opinionatedWithTypeAware: OxlintRuleConfig;
@@ -47,11 +51,12 @@ type VitePlusLintPlugin = "eslint" | "import" | "jest" | "jsdoc" | "jsx-a11y" |
 /**
  * Rule bundles `createVizeLintConfig` accepts.
  *
- * `"all"` and `"incremental"` both disable preset gating in the bridge, which is
- * what makes them usable: `"all"` needs every bundle's rules to run at once, and
- * `"incremental"` needs only the rules the caller lists to run.
+ * `"all"`, `"incremental"`, and multiple-preset selections disable preset
+ * gating in the bridge. That is what makes them usable: the runtime only accepts
+ * one preset, while those shapes need exactly the emitted rule map to run.
  */
-type VizeLintPreset = PatinaPreset | "all";
+type VizeLintPreset = PatinaPreset | "happy-path" | "all";
+type VizeLintPresetInput = VizeLintPreset | readonly VizeLintPreset[];
 interface VizeLintConfigOptions {
   /**
    * Include Vize's unstable `vize/type/*` rules in the preset rule map. Off by
@@ -68,30 +73,38 @@ interface VizeLintConfigOptions {
    */
   plugins?: readonly VitePlusLintPlugin[];
   /**
-   * Rule bundle to enable. Defaults to `"general-recommended"`, the bridge's own
-   * default. `"incremental"` emits no preset rules, so only `rules` run.
+   * Rule bundle or bundles to enable. Defaults to `"general-recommended"`, the
+   * bridge's own default. `"incremental"` emits no preset rules, so only `rules`
+   * run.
    */
-  preset?: VizeLintPreset;
+  preset?: VizeLintPresetInput;
+  /**
+   * Additional rule bundles to enable alongside `preset`. This is equivalent to
+   * passing an array to `preset`, but reads better when the base preset is kept
+   * separate from project-specific add-ons.
+   */
+  presets?: readonly VizeLintPreset[];
   /**
    * Extra Oxlint rules merged after the preset rules. Core Oxlint rule ids pass
    * through untouched; `vize/*` ids are validated against the rules the native
-   * bridge registers and against the resolved preset.
+   * bridge registers and, for a single gated preset, against the resolved preset.
    */
   rules?: OxlintRuleConfig;
   /**
    * Patina runtime settings forwarded through `settings.vize`. `preset` is
-   * intentionally absent: it is derived from `options.preset` so the rule map and
-   * the bridge's runtime gate can never disagree.
+   * intentionally absent: it is derived from `options.preset`/`options.presets`
+   * so the rule map and the bridge's runtime gate can never disagree.
    */
   settings?: Omit<PatinaSettings, "preset">;
 }
-interface VizeLintConfig {
+interface VizeLintConfigSettings extends Record<string, unknown> {
+  vize: PatinaSettings;
+}
+interface VizeLintConfig extends Record<string, unknown> {
   jsPlugins: string[];
   plugins: VitePlusLintPlugin[];
   rules: OxlintRuleConfig;
-  settings: {
-    vize: PatinaSettings;
-  };
+  settings: VizeLintConfigSettings;
 }
 /**
  * Builds the Oxlint configuration block that runs Patina through this bridge.
@@ -119,14 +132,57 @@ interface VizeLintConfig {
  * - An unknown `vize/*` id only produces Oxlint's
  *   `Rule '...' not found in plugin 'vize'` error when Oxlint actually reads the
  *   config. A typo in a config Oxlint never reads reports nothing at all.
- * - A `vize/*` id that is outside the active preset is dropped by the bridge's
- *   runtime preset gate (`plugin.ts`), so it stays listed in `rules` and reports
- *   nothing. `preset: "incremental"` is the supported way to run an arbitrary
- *   subset.
+ * - A `vize/*` id that is outside a single active preset is dropped by the
+ *   bridge's runtime preset gate (`plugin.ts`), so it stays listed in `rules` and
+ *   reports nothing. `preset: "incremental"` is the supported way to run an
+ *   arbitrary subset.
  *
  * @throws {Error} When `options.rules` names a `vize/*` id the native bridge does
- *   not register, or one the resolved preset would silently suppress.
+ *   not register, or one a single resolved preset would silently suppress.
  */
 declare function createVizeLintConfig(options?: VizeLintConfigOptions): VizeLintConfig;
 //#endregion
-export { type OxlintRuleConfig, type OxlintRuleEntry, type OxlintRuleSeverity, VIZE_JS_PLUGIN_SPECIFIER, type VitePlusLintPlugin, type VizeLintConfig, type VizeLintConfigOptions, type VizeLintPreset, type VizeRuleConfigOptions, configs, createVizeLintConfig, createVizeRuleConfig, _default as default };
+//#region src/vite-plus-flat-config.d.ts
+interface VizeLintConfigFragment extends Record<string, unknown> {
+  extends?: readonly (VizeLintConfigFragment | VizeLintFlatConfig)[];
+  ignorePatterns?: readonly string[];
+  jsPlugins?: readonly string[];
+  overrides?: readonly unknown[];
+  plugins?: readonly VitePlusLintPlugin[];
+  rules?: VizeLintConfig["rules"];
+  settings?: Record<string, unknown> & {
+    vize?: PatinaSettings | Record<string, unknown>;
+  };
+}
+type VizeLintFlatConfig = readonly VizeLintConfigFragment[];
+/**
+ * Returns spreadable Oxlint/Vite+ config fragments for Flat Config style use.
+ *
+ * The fragments intentionally set `settings.vize.preset` to `"incremental"` so
+ * multiple fragments can be composed without one preset's runtime gate
+ * suppressing rules emitted by another fragment.
+ */
+declare function createVizeLintFlatConfig(options?: VizeLintConfigOptions): VizeLintFlatConfig;
+declare const flatConfigs: {
+  all: VizeLintFlatConfig;
+  ecosystem: VizeLintFlatConfig;
+  ecosystemWithTypeAware: VizeLintFlatConfig;
+  essential: VizeLintFlatConfig;
+  happyPath: VizeLintFlatConfig;
+  happyPathWithTypeAware: VizeLintFlatConfig;
+  nuxt: VizeLintFlatConfig;
+  opinionated: VizeLintFlatConfig;
+  opinionatedWithTypeAware: VizeLintFlatConfig;
+  recommended: VizeLintFlatConfig;
+  recommendedWithTypeAware: VizeLintFlatConfig;
+};
+/**
+ * Collapses Flat Config-style fragments into the object shape Vite+ accepts.
+ *
+ * `vp lint` currently expects a single Oxlint config object under `lint`, so this
+ * helper lets `vite.config.ts` keep a flat, spread-friendly authoring style while
+ * still handing Vite+ the object it can read.
+ */
+declare function defineVizeLintConfig(...entries: readonly (VizeLintConfigFragment | VizeLintFlatConfig)[]): VizeLintConfig;
+//#endregion
+export { type OxlintRuleConfig, type OxlintRuleEntry, type OxlintRuleSeverity, VIZE_JS_PLUGIN_SPECIFIER, type VitePlusLintPlugin, type VizeLintConfig, type VizeLintConfigFragment, type VizeLintConfigOptions, type VizeLintConfigSettings, type VizeLintFlatConfig, type VizeLintPreset, type VizeLintPresetInput, type VizeRuleConfigOptions, type VizeRuleConfigPreset, type VizeRuleConfigPresetInput, configs, createVizeLintConfig, createVizeLintFlatConfig, createVizeRuleConfig, _default as default, defineVizeLintConfig, flatConfigs };

package/dist/index.mjs

@@ -194,10 +194,10 @@ const PRESET_ALIASES = new Map([
 	["ecosystem", "ecosystem"],
 	["eco", "ecosystem"],
 	["incremental", "incremental"],
+	["all", "incremental"],
 	["opinionated", "opinionated"],
 	["opnionated", "opinionated"],
 	["strict", "opinionated"],
-	["all", "opinionated"],
 	["nuxt", "nuxt"]
 ]);
 function getVizeSettings(context) {
@@ -271,6 +271,7 @@ if (import.meta.vitest) {
 		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" });
@@ -583,11 +584,11 @@ var plugin_default = definePlugin({
 //#region src/configs.ts
 const TYPE_AWARE_RULE_PREFIX = "type/";
 function createVizeRuleConfig(options = {}) {
-	const preset = options.preset ?? "general-recommended";
+	const presets = resolveRuleConfigPresets(options);
 	const includeTypeAware = options.includeTypeAware ?? false;
 	const rules = {};
 	for (const ruleMeta of getPatinaRules()) {
-		if (!matchesPreset(ruleMeta, preset)) continue;
+		if (!matchesPresets(ruleMeta, presets)) continue;
 		if (!includeTypeAware && isTypeAwareRule(ruleMeta)) continue;
 		rules[`vize/${ruleMeta.name}`] = toOxlintSeverity(ruleMeta.defaultSeverity);
 	}
@@ -601,6 +602,11 @@ const configs = {
 		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({
@@ -613,8 +619,18 @@ const configs = {
 		preset: "general-recommended"
 	})
 };
-function matchesPreset(ruleMeta, preset) {
-	return preset === "all" || ruleMeta.presets.includes(preset);
+function normalizeRuleConfigPreset(preset) {
+	return preset === "happy-path" ? "general-recommended" : preset;
+}
+function resolveRuleConfigPresets(options) {
+	const requestedPresets = [...toPresetArray$1((options.preset === void 0 && options.presets === void 0 ? "general-recommended" : options.preset) ?? []), ...options.presets ?? []].map(normalizeRuleConfigPreset);
+	return [...new Set(requestedPresets)];
+}
+function toPresetArray$1(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);
@@ -628,10 +644,41 @@ if (import.meta.vitest) {
 		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");
@@ -677,6 +724,7 @@ if (import.meta.vitest) {
 */
 const VIZE_JS_PLUGIN_SPECIFIER = "oxlint-plugin-vize";
 const VIZE_RULE_PREFIX = "vize/";
+const DEFAULT_VIZE_LINT_PRESET = "general-recommended";
 /**
 * Builds the Oxlint configuration block that runs Patina through this bridge.
 *
@@ -703,55 +751,74 @@ const VIZE_RULE_PREFIX = "vize/";
 * - An unknown `vize/*` id only produces Oxlint's
 *   `Rule '...' not found in plugin 'vize'` error when Oxlint actually reads the
 *   config. A typo in a config Oxlint never reads reports nothing at all.
-* - A `vize/*` id that is outside the active preset is dropped by the bridge's
-*   runtime preset gate (`plugin.ts`), so it stays listed in `rules` and reports
-*   nothing. `preset: "incremental"` is the supported way to run an arbitrary
-*   subset.
+* - A `vize/*` id that is outside a single active preset is dropped by the
+*   bridge's runtime preset gate (`plugin.ts`), so it stays listed in `rules` and
+*   reports nothing. `preset: "incremental"` is the supported way to run an
+*   arbitrary subset.
 *
 * @throws {Error} When `options.rules` names a `vize/*` id the native bridge does
-*   not register, or one the resolved preset would silently suppress.
+*   not register, or one a single resolved preset would silently suppress.
 */
 function createVizeLintConfig(options = {}) {
-	const preset = options.preset ?? "general-recommended";
+	return buildVizeLintConfig(options, { forceIncrementalRuntime: false });
+}
+function buildVizeLintConfig(options, buildOptions) {
+	const presets = resolveLintPresets(options);
+	const runtimePreset = buildOptions.forceIncrementalRuntime ? "incremental" : toRuntimePreset(presets);
 	const extraRules = options.rules ?? {};
-	assertUsableVizeRules(extraRules, preset);
+	assertUsableVizeRules(extraRules, presets, runtimePreset);
 	return {
 		jsPlugins: [VIZE_JS_PLUGIN_SPECIFIER],
 		plugins: [...new Set(["vue", ...options.plugins ?? []])],
 		rules: {
-			...createPresetRules(preset, options.includeTypeAware),
+			...createPresetRules(presets, options.includeTypeAware),
 			...extraRules
 		},
 		settings: { vize: {
 			...options.settings,
-			preset: toRuntimePreset(preset)
+			preset: runtimePreset
 		} }
 	};
 }
-function createPresetRules(preset, includeTypeAware) {
-	return preset === "incremental" ? {} : createVizeRuleConfig({
+function createPresetRules(presets, includeTypeAware) {
+	const ruleConfigPresets = presets.filter(isRuleConfigPreset);
+	if (ruleConfigPresets.length === 0) return {};
+	return createVizeRuleConfig({
 		includeTypeAware,
-		preset
+		presets: ruleConfigPresets
 	});
 }
+function resolveLintPresets(options) {
+	const requestedPresets = [...toPresetArray((options.preset === void 0 && options.presets === void 0 ? DEFAULT_VIZE_LINT_PRESET : options.preset) ?? []), ...options.presets ?? []].map(normalizeLintPreset);
+	return [...new Set(requestedPresets)];
+}
+function toPresetArray(preset) {
+	return Array.isArray(preset) ? preset : [preset];
+}
+function normalizeLintPreset(preset) {
+	return preset === "happy-path" ? DEFAULT_VIZE_LINT_PRESET : preset;
+}
+function isRuleConfigPreset(preset) {
+	return preset !== "incremental";
+}
 /**
-* Maps a rule bundle to the `settings.vize.preset` the bridge must run with.
+* Maps rule bundles to the `settings.vize.preset` the bridge must run with.
 *
-* `"all"` becomes `"incremental"` because the bridge gates each rule on preset
-* membership; gating an all-bundles rule map by any single preset would suppress
-* the rules that only belong to the other bundles.
+* `"all"` and multiple concrete presets become `"incremental"` because the
+* bridge gates each rule on preset membership; gating a combined rule map by any
+* single preset would suppress the rules that only belong to the other bundles.
 */
-function toRuntimePreset(preset) {
-	return preset === "all" ? "incremental" : preset;
+function toRuntimePreset(presets) {
+	if (presets.length === 1 && presets[0] !== "all") return presets[0];
+	return "incremental";
 }
-function assertUsableVizeRules(rules, preset) {
+function assertUsableVizeRules(rules, presets, runtimePreset) {
 	const ruleMetaById = new Map(getPatinaRules().map((ruleMeta) => [`${VIZE_RULE_PREFIX}${ruleMeta.name}`, ruleMeta]));
 	const configuredIds = Object.keys(rules).filter((ruleId) => ruleId.startsWith(VIZE_RULE_PREFIX)).sort();
 	const unknownIds = configuredIds.filter((ruleId) => !ruleMetaById.has(ruleId));
 	if (unknownIds.length > 0) throw new Error(`Unknown Vize rule ${pluralizeIds(unknownIds)}: ${unknownIds.join(", ")}. Check the id against the rules oxlint-plugin-vize registers.`);
-	const runtimePreset = toRuntimePreset(preset);
 	const suppressedIds = configuredIds.filter((ruleId) => isSuppressedByPreset(ruleMetaById.get(ruleId), runtimePreset));
-	if (suppressedIds.length > 0) throw new Error(`Vize rule ${pluralizeIds(suppressedIds)} outside the "${preset}" preset: ${suppressedIds.join(", ")}. Use preset: "incremental" to run an explicit rule subset, or pick the preset that owns these rules.`);
+	if (suppressedIds.length > 0) throw new Error(`Vize rule ${pluralizeIds(suppressedIds)} outside ${describePresetSelection(presets)}: ${suppressedIds.join(", ")}. Use preset: "incremental" to run an explicit rule subset, or pick the preset that owns these rules.`);
 }
 /**
 * Mirrors the runtime gate in `plugin.ts`: rules with no preset membership are
@@ -760,8 +827,139 @@ function assertUsableVizeRules(rules, preset) {
 function isSuppressedByPreset(ruleMeta, runtimePreset) {
 	return ruleMeta.presets.length > 0 && runtimePreset !== "incremental" && !ruleMeta.presets.includes(runtimePreset);
 }
+function describePresetSelection(presets) {
+	const names = presets.map((preset) => preset === DEFAULT_VIZE_LINT_PRESET ? "happy-path" : preset);
+	return `the "${names.length === 0 ? "empty" : names.join(", ")}" ${names.length === 1 ? "preset" : "presets"}`;
+}
 function pluralizeIds(ids) {
 	return ids.length === 1 ? "id" : "ids";
 }
 //#endregion
-export { VIZE_JS_PLUGIN_SPECIFIER, configs, createVizeLintConfig, createVizeRuleConfig, plugin_default as default };
+//#region src/vite-plus-flat-config.ts
+/**
+* Returns spreadable Oxlint/Vite+ config fragments for Flat Config style use.
+*
+* The fragments intentionally set `settings.vize.preset` to `"incremental"` so
+* multiple fragments can be composed without one preset's runtime gate
+* suppressing rules emitted by another fragment.
+*/
+function createVizeLintFlatConfig(options = {}) {
+	return [buildVizeLintConfig(options, { forceIncrementalRuntime: true })];
+}
+const flatConfigs = {
+	all: createVizeLintFlatConfig({ preset: "all" }),
+	ecosystem: createVizeLintFlatConfig({ preset: "ecosystem" }),
+	ecosystemWithTypeAware: createVizeLintFlatConfig({
+		includeTypeAware: true,
+		preset: "ecosystem"
+	}),
+	essential: createVizeLintFlatConfig({ preset: "essential" }),
+	happyPath: createVizeLintFlatConfig({ preset: "happy-path" }),
+	happyPathWithTypeAware: createVizeLintFlatConfig({
+		includeTypeAware: true,
+		preset: "happy-path"
+	}),
+	nuxt: createVizeLintFlatConfig({ preset: "nuxt" }),
+	opinionated: createVizeLintFlatConfig({ preset: "opinionated" }),
+	opinionatedWithTypeAware: createVizeLintFlatConfig({
+		includeTypeAware: true,
+		preset: "opinionated"
+	}),
+	recommended: createVizeLintFlatConfig({ preset: "general-recommended" }),
+	recommendedWithTypeAware: createVizeLintFlatConfig({
+		includeTypeAware: true,
+		preset: "general-recommended"
+	})
+};
+/**
+* Collapses Flat Config-style fragments into the object shape Vite+ accepts.
+*
+* `vp lint` currently expects a single Oxlint config object under `lint`, so this
+* helper lets `vite.config.ts` keep a flat, spread-friendly authoring style while
+* still handing Vite+ the object it can read.
+*/
+function defineVizeLintConfig(...entries) {
+	const config = {
+		jsPlugins: [],
+		plugins: [],
+		rules: {},
+		settings: { vize: {} }
+	};
+	const runtimePresets = [];
+	for (const entry of entries) mergeFlatConfigEntry(config, runtimePresets, entry);
+	config.jsPlugins = [...new Set(config.jsPlugins)];
+	config.plugins = [...new Set(config.plugins)];
+	if (runtimePresets.includes("incremental")) config.settings.vize.preset = "incremental";
+	else {
+		const uniquePresets = [...new Set(runtimePresets)];
+		if (uniquePresets.length === 1) config.settings.vize.preset = uniquePresets[0];
+		else if (uniquePresets.length > 1) config.settings.vize.preset = "incremental";
+	}
+	return config;
+}
+function mergeFlatConfigEntry(target, runtimePresets, entry) {
+	if (Array.isArray(entry)) {
+		for (const item of entry) mergeFlatConfigEntry(target, runtimePresets, item);
+		return;
+	}
+	for (const extended of entry.extends ?? []) mergeFlatConfigEntry(target, runtimePresets, extended);
+	mergeFlatConfigItem(target, runtimePresets, entry);
+}
+function mergeFlatConfigItem(target, runtimePresets, item) {
+	if (item.jsPlugins !== void 0) target.jsPlugins.push(...item.jsPlugins);
+	if (item.plugins !== void 0) target.plugins.push(...item.plugins);
+	if (item.rules !== void 0) target.rules = {
+		...target.rules,
+		...item.rules
+	};
+	if (item.ignorePatterns !== void 0) target.ignorePatterns = [...new Set([...readStringArray(target.ignorePatterns) ?? [], ...item.ignorePatterns])];
+	if (item.overrides !== void 0) target.overrides = [...readUnknownArray(target.overrides) ?? [], ...item.overrides];
+	if (item.settings !== void 0) mergeSettings(target.settings, runtimePresets, item.settings);
+	for (const [key, value] of Object.entries(item)) {
+		if (value === void 0 || key === "extends" || key === "ignorePatterns" || key === "jsPlugins" || key === "overrides" || key === "plugins" || key === "rules" || key === "settings") continue;
+		target[key] = value;
+	}
+}
+function mergeSettings(target, runtimePresets, settings) {
+	for (const [key, value] of Object.entries(settings)) if (key !== "vize") target[key] = value;
+	if (isRecord(settings.vize)) {
+		const runtimePreset = normalizeRuntimePresetSetting(settings.vize.preset);
+		if (runtimePreset !== null) runtimePresets.push(runtimePreset);
+		target.vize = {
+			...target.vize,
+			...settings.vize
+		};
+	}
+}
+function normalizeRuntimePresetSetting(value) {
+	if (typeof value !== "string") return null;
+	switch (value.replaceAll(/[-_\s]/gu, "").toLowerCase()) {
+		case "generalrecommended":
+		case "happypath":
+		case "happy":
+		case "default":
+		case "recommended": return "general-recommended";
+		case "essential": return "essential";
+		case "ecosystem":
+		case "eco": return "ecosystem";
+		case "incremental":
+		case "all": return "incremental";
+		case "opinionated":
+		case "opnionated":
+		case "strict": return "opinionated";
+		case "nuxt": return "nuxt";
+		default: return null;
+	}
+}
+function readStringArray(value) {
+	if (!Array.isArray(value) || !value.every((entry) => typeof entry === "string")) return null;
+	return value;
+}
+function readUnknownArray(value) {
+	return Array.isArray(value) ? value : null;
+}
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+//#endregion
+export { VIZE_JS_PLUGIN_SPECIFIER, configs, createVizeLintConfig, createVizeLintFlatConfig, createVizeRuleConfig, plugin_default as default, defineVizeLintConfig, flatConfigs };

package/package.json

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