@vizejs/rspack-plugin 0.33.0 → 0.34.0

package/README.md

@@ -29,15 +29,49 @@ pnpm add -D @vizejs/rspack-plugin @rspack/core
 
 ## Usage
 
-### Auto Preset
+### Simple Mode (Recommended)
 
-Use `createVizeVueRules()` to generate `.vue` rules automatically.
-If you don't call it, write rules manually.
+Write a single `.vue` rule and your normal CSS rules. `VizePlugin` automatically clones your CSS rules for Vue style sub-requests.
 
 ```javascript
 // rspack.config.mjs
-import { rspack } from "@rspack/core";
-import { VizePlugin, createVizeVueRules } from "@vizejs/rspack-plugin";
+import { VizePlugin } from "@vizejs/rspack-plugin";
+
+const isProduction = process.env.NODE_ENV === "production";
+
+export default {
+  mode: isProduction ? "production" : "development",
+
+  experiments: {
+    css: true, // Enable Rspack native CSS
+  },
+
+  module: {
+    rules: [
+      {
+        test: /\.vue$/,
+        use: [{ loader: "@vizejs/rspack-plugin/loader" }],
+      },
+    ],
+  },
+
+  plugins: [
+    new VizePlugin({
+      isProduction,
+      css: { native: true },
+    }),
+  ],
+};
+```
+
+### Native CSS with SCSS (Simple Mode)
+
+Uses Rspack's built-in `experiments.css` for optimal performance. Just add your SCSS rule — VizePlugin handles the rest.
+
+```javascript
+// rspack.config.mjs
+import { VizePlugin } from "@vizejs/rspack-plugin";
+import path from "node:path";
 
 const isProduction = process.env.NODE_ENV === "production";
 
@@ -50,34 +84,36 @@ export default {
 
   module: {
     rules: [
-      ...createVizeVueRules({
-        isProduction,
-        nativeCss: true,
-        typescript: true, // auto-add SWC post-processing to strip TS types
-        styleLanguages: ["scss", "sass", "less", "stylus", "styl"],
-        loaderOptions: {
-          include: [/src\/.*\.vue$/],
-          exclude: [/node_modules/],
-          sourceMap: !isProduction,
-        },
-      }),
+      {
+        test: /\.scss$/,
+        type: "css/auto",
+        use: ["sass-loader"],
+      },
+      {
+        test: /\.vue$/,
+        loader: "@vizejs/rspack-plugin/loader",
+      },
     ],
   },
 
   plugins: [
     new VizePlugin({
       isProduction,
-      include: [/src\/.*\.vue$/],
-      exclude: [/node_modules/],
       css: { native: true },
     }),
   ],
+
+  resolve: {
+    alias: {
+      "@": path.resolve(import.meta.dirname, "src"),
+    },
+  },
 };
 ```
 
-### Option A: Native CSS (Recommended)
+### CssExtractRspackPlugin (Simple Mode)
 
-Uses Rspack's built-in `experiments.css` for optimal performance. CSS is processed by Rust-side LightningCSS.
+Compatible with webpack ecosystem, suitable for projects requiring PostCSS plugin chains.
 
 ```javascript
 // rspack.config.mjs
@@ -90,7 +126,103 @@ const isProduction = process.env.NODE_ENV === "production";
 export default {
   mode: isProduction ? "production" : "development",
 
-  // Enable Rspack native CSS support
+  module: {
+    rules: [
+      {
+        test: /\.css$/,
+        type: "javascript/auto",
+        use: [isProduction ? rspack.CssExtractRspackPlugin.loader : "style-loader", "css-loader"],
+      },
+      {
+        test: /\.scss$/,
+        type: "javascript/auto",
+        use: [
+          isProduction ? rspack.CssExtractRspackPlugin.loader : "style-loader",
+          "css-loader",
+          "sass-loader",
+        ],
+      },
+
+      {
+        test: /\.vue$/,
+        loader: "@vizejs/rspack-plugin/loader",
+      },
+    ],
+  },
+
+  plugins: [
+    new VizePlugin({
+      isProduction,
+    }),
+
+    ...(isProduction
+      ? [
+          new rspack.CssExtractRspackPlugin({
+            filename: "styles/[name].[contenthash:8].css",
+            chunkFilename: "styles/[name].[contenthash:8].chunk.css",
+          }),
+        ]
+      : []),
+  ],
+
+  resolve: {
+    alias: {
+      "@": path.resolve(import.meta.dirname, "src"),
+    },
+  },
+};
+```
+
+### Advanced: Manual `oneOf` Rules
+
+`VizePlugin` will automatically:
+
+1. Find the `.vue` rule containing the vize loader
+2. Clone your CSS/SCSS/Less/Stylus rules for `?vue&type=style` sub-requests
+3. Inject the vize scope-loader + style-loader at the end of each cloned chain
+   (execution order: style-loader extracts block → preprocessor compiles → scope-loader applies native scoped CSS)
+4. Build `oneOf` branches inside the `.vue` rule
+5. Add `resourceQuery: { not: [/vue/] }` to original CSS rules so they don't conflict
+
+To opt out and write manual rules, set `autoRules: false`:
+
+```javascript
+new VizePlugin({ autoRules: false });
+```
+
+If you need full control over the loader chain, set `autoRules: false` and write `oneOf` branches manually.
+
+#### Request Routing: Main vs Style Sub-Requests
+
+When writing manual rules, you must ensure the main `.vue` loader and the style loader see different requests.
+
+The main loader produces `import './App.vue?vue&type=style&index=0&...'` statements. These style sub-requests must be routed through `@vizejs/rspack-plugin/scope-loader` and `@vizejs/rspack-plugin/style-loader` — **not** back into the main loader. If the main loader receives a `?type=style` query it will emit an explicit error.
+
+Use `oneOf` to guarantee mutual exclusion:
+
+```javascript
+{
+  test: /\.vue$/,
+  oneOf: [
+    { resourceQuery: /type=style/, use: [/* style pipeline */] },
+    { use: [/* main vize loader */] },
+  ],
+}
+```
+
+<details>
+<summary>Native CSS with manual oneOf</summary>
+
+```javascript
+// rspack.config.mjs
+import { VizePlugin } from "@vizejs/rspack-plugin";
+import path from "node:path";
+
+const isProduction = process.env.NODE_ENV === "production";
+
+export default {
+  mode: isProduction ? "production" : "development",
+
   experiments: {
     css: true,
   },
@@ -105,9 +237,8 @@ export default {
             resourceQuery: /vue&type=style.*module/,
             type: "css/module",
             use: [
-              {
-                loader: "@vizejs/rspack-plugin/style-loader",
-              },
+              { loader: "@vizejs/rspack-plugin/scope-loader" },
+              { loader: "@vizejs/rspack-plugin/style-loader" },
             ],
           },
 
@@ -116,10 +247,9 @@ export default {
             resourceQuery: /vue&type=style.*lang=scss/,
             type: "css/auto",
             use: [
+              { loader: "@vizejs/rspack-plugin/scope-loader" },
               "sass-loader",
-              {
-                loader: "@vizejs/rspack-plugin/style-loader",
-              },
+              { loader: "@vizejs/rspack-plugin/style-loader" },
             ],
           },
 
@@ -128,9 +258,8 @@ export default {
             resourceQuery: /vue&type=style/,
             type: "css/auto",
             use: [
-              {
-                loader: "@vizejs/rspack-plugin/style-loader",
-              },
+              { loader: "@vizejs/rspack-plugin/scope-loader" },
+              { loader: "@vizejs/rspack-plugin/style-loader" },
             ],
           },
 
@@ -139,11 +268,6 @@ export default {
             use: [
               {
                 loader: "@vizejs/rspack-plugin/loader",
-                options: {
-                  include: [/src\/.*\.vue$/],
-                  exclude: [/node_modules/],
-                  sourceMap: !isProduction,
-                },
               },
             ],
           },
@@ -155,11 +279,8 @@ export default {
   plugins: [
     new VizePlugin({
       isProduction,
-      include: [/src\/.*\.vue$/],
-      exclude: [/node_modules/],
-      css: {
-        native: true,
-      },
+      autoRules: false,
+      css: { native: true },
     }),
   ],
 
@@ -171,9 +292,10 @@ export default {
 };
 ```
 
-### Option B: CssExtractRspackPlugin
+</details>
 
-Compatible with webpack ecosystem, suitable for projects requiring PostCSS plugin chains.
+<details>
+<summary>CssExtractRspackPlugin with manual oneOf</summary>
 
 ```javascript
 // rspack.config.mjs
@@ -196,14 +318,11 @@ export default {
             resourceQuery: /vue&type=style.*lang=scss/,
             type: "javascript/auto",
             use: [
-              isProduction
-                ? rspack.CssExtractRspackPlugin.loader
-                : "style-loader",
+              isProduction ? rspack.CssExtractRspackPlugin.loader : "style-loader",
               "css-loader",
+              { loader: "@vizejs/rspack-plugin/scope-loader" },
               "sass-loader",
-              {
-                loader: "@vizejs/rspack-plugin/style-loader",
-              },
+              { loader: "@vizejs/rspack-plugin/style-loader" },
             ],
           },
 
@@ -212,22 +331,18 @@ export default {
             resourceQuery: /vue&type=style/,
             type: "javascript/auto",
             use: [
-              isProduction
-                ? rspack.CssExtractRspackPlugin.loader
-                : "style-loader",
+              isProduction ? rspack.CssExtractRspackPlugin.loader : "style-loader",
               {
                 loader: "css-loader",
                 options: {
                   modules: {
                     auto: (_resourcePath, resourceQuery) =>
-                      typeof resourceQuery === "string" &&
-                      resourceQuery.includes("module="),
+                      typeof resourceQuery === "string" && resourceQuery.includes("module="),
                   },
                 },
               },
-              {
-                loader: "@vizejs/rspack-plugin/style-loader",
-              },
+              { loader: "@vizejs/rspack-plugin/scope-loader" },
+              { loader: "@vizejs/rspack-plugin/style-loader" },
             ],
           },
 
@@ -236,11 +351,6 @@ export default {
             use: [
               {
                 loader: "@vizejs/rspack-plugin/loader",
-                options: {
-                  include: [/src\/.*\.vue$/],
-                  exclude: [/node_modules/],
-                  sourceMap: !isProduction,
-                },
               },
             ],
           },
@@ -251,10 +361,7 @@ export default {
       {
         test: /\.css$/,
         type: "javascript/auto",
-        use: [
-          isProduction ? rspack.CssExtractRspackPlugin.loader : "style-loader",
-          "css-loader",
-        ],
+        use: [isProduction ? rspack.CssExtractRspackPlugin.loader : "style-loader", "css-loader"],
       },
 
       // Regular SCSS files (non-Vue)
@@ -273,11 +380,9 @@ export default {
   plugins: [
     new VizePlugin({
       isProduction,
-      include: [/src\/.*\.vue$/],
-      exclude: [/node_modules/],
+      autoRules: false,
     }),
 
-    // CSS extraction (production only)
     ...(isProduction
       ? [
           new rspack.CssExtractRspackPlugin({
@@ -296,6 +401,8 @@ export default {
 };
 ```
 
+</details>
+
 ## API
 
 ### VizePlugin
@@ -309,13 +416,14 @@ new VizePlugin({
   exclude: string | RegExp | (string | RegExp)[]; // Exclude watched .vue files
   ssr: boolean;             // Enable SSR mode (default: false)
   sourceMap: boolean;       // Enable source maps (default: true in dev)
-  vapor: boolean;           // Enable Vapor mode (default: false, SFC-level not yet supported)
+  vapor: boolean;           // Enable Vapor mode (default: false)
   root: string;             // Root directory (default: Rspack's root)
   css: {
     native: boolean;        // Use experiments.css (default: false), warns if config mismatch
   };
   compilerOptions: {};      // Extra @vizejs/native compileSfc options
   debug: boolean;           // Enable debug logging (default: false)
+  autoRules: boolean;       // Auto-clone CSS rules for Vue style sub-requests (default: true)
 });
 // Debug logging uses Rspack's infrastructure logger.
 // Control verbosity via `infrastructureLogging.level` in your rspack config.
@@ -332,13 +440,16 @@ new VizePlugin({
     exclude: string | RegExp | (string | RegExp)[]; // Safe compile denylist
     sourceMap: boolean;     // Enable source maps (default: true)
     ssr: boolean;           // Enable SSR mode (default: false)
+    vapor: boolean;         // Enable Vapor mode (default: false)
     customElement: boolean | RegExp; // Custom element mode (default: /\.ce\.vue$/)
     hotReload: boolean;     // Enable HMR (default: true in dev, false in prod/SSR)
+    transformAssetUrls: boolean | Record<string, string[]>; // See below (default: true)
     compilerOptions: {      // Extra @vizejs/native compileSfc options
       filename?: string;
       sourceMap?: boolean;
       ssr?: boolean;
       isTs?: boolean;       // Preserve TypeScript (auto-detected from <script lang="ts">)
+      vapor?: boolean;      // Enable Vapor mode compilation
       scopeId?: string;
     };
   };
@@ -350,6 +461,46 @@ This avoids hard failures while still alerting you to mismatched rule/filter con
 
 Compilation errors cause the loader to fail immediately (`callback(error)`) instead of returning broken code.
 
+#### TypeScript
+
+`@vizejs/native compileSfc` preserves TypeScript syntax in its output (same behavior as `@vue/compiler-sfc`). A downstream transpiler is needed to strip type annotations:
+
+- **Recommended**: Add a `builtin:swc-loader` post-processing rule for `.vue` files
+- **Custom loader**: Use `esbuild-loader` or any other TS transpiler
+- **Manual**: Add your own `enforce: "post"` rule for `.vue` files (exclude `type=style` requests)
+
+The `isTs` option is auto-detected from `<script lang="ts">` and passed to the native compiler for correct parsing.
+
+#### `transformAssetUrls`
+
+Static asset URLs in template element attributes (e.g. `<img src="./logo.png">`) are automatically rewritten into JavaScript `import` bindings so that Rspack can process them through its asset pipeline.
+
+| Value                      | Behaviour                                                                                                                   |
+| -------------------------- | --------------------------------------------------------------------------------------------------------------------------- |
+| `true` (default)           | Apply built-in transforms: `img[src]`, `video[src,poster]`, `source[src]`, `image[xlink:href,href]`, `use[xlink:href,href]` |
+| `false`                    | Disable the feature entirely — URL strings are left as-is                                                                   |
+| `Record<string, string[]>` | Custom element/attribute mapping that **replaces** the built-in defaults                                                    |
+
+Only relative (`./`, `../`), alias (`@/`), and tilde (`~/`, `~pkg`) URLs are transformed. External (`https://…`), protocol-relative (`//…`), and data URIs are left unchanged.
+
+```js
+// Custom mapping example
+{
+  loader: "@vizejs/rspack-plugin/loader",
+  options: {
+    transformAssetUrls: {
+      "my-image": ["data-src"],
+      img: ["src"],
+    },
+  },
+}
+```
+
+> **Known limitations**
+>
+> - URL rewriting operates via string replacement on the compiled JS output, not on AST nodes. If a `<script>` block contains an identical string literal it will also be replaced (extremely unlikely in practice).
+> - URLs with hash fragments (e.g. `./icons.svg#home`) are split: the base path becomes the `import` specifier and the fragment is concatenated at runtime.
+
 ### VizeStyleLoader
 
 ```typescript
@@ -362,90 +513,19 @@ Compilation errors cause the loader to fail immediately (`callback(error)`) inst
 }
 ```
 
-### createVizeVueRules
+### VizeScopeLoader
+
+Applies native scoped CSS transformation using `@vizejs/native compileCss`. Runs **after** preprocessors (SCSS/Less/Stylus → CSS) and **before** css-loader or `experiments.css`.
 
 ```typescript
-import { createVizeVueRules } from "@vizejs/rspack-plugin";
-
-const rules = createVizeVueRules({
-  isProduction: false,
-  nativeCss: true, // true: css/auto + css/module, false: css-loader chain
-  styleLanguages: ["scss", "sass", "less", "stylus", "styl"],
-  styleInjectLoader: "style-loader",
-  styleExtractLoader: undefined, // e.g. rspack.CssExtractRspackPlugin.loader
-  cssLoader: "css-loader",
-  loaderOptions: {
-    include: [/src\/.*\.vue$/],
-    exclude: [/node_modules/],
-    sourceMap: true,
-  },
-  styleLoaderOptions: {
-    native: true, // match nativeCss setting
-  },
-  typescript: true, // or a custom LoaderEntry
-});
+// In rspack.config.js
+{
+  loader: "@vizejs/rspack-plugin/scope-loader",
+  // No options — scope metadata is extracted from the query string (?scoped=xxxxx)
+}
 ```
 
-## Comparison
-
-| Feature            | Native CSS (`experiments.css`) | CssExtractRspackPlugin |
-| ------------------ | ------------------------------ | ---------------------- |
-| **CSS Engine**     | Rust (LightningCSS)            | JS (css-loader)        |
-| **CSS Extraction** | Rspack automatic               | CssExtractRspackPlugin |
-| **CSS Modules**    | `type: 'css/module'`           | css-loader config      |
-| **HMR**            | Rspack native                  | style-loader           |
-| **Vendor Prefix**  | LightningCSS built-in          | Requires autoprefixer  |
-| **Performance**    | **Excellent** (Rust)           | Good (JS)              |
-| **Use Case**       | **New projects**               | webpack compatibility  |
-
-## Known Limitations
-
-### HMR
-
-Script and template changes trigger a component-level hot reload via `module.hot.accept()` + `__VUE_HMR_RUNTIME__.reload()`. CSS Module changes trigger a targeted rerender without full reload. Plain `<style>` HMR is handled natively by Rspack's CSS pipeline.
-
-### Path Resolution
-
-Style imports injected by the main loader are normalized to resolver-friendly request paths.
-In modern Rspack setups this avoids most absolute-path query edge cases, especially across platforms.
-
-### Diagnostics
-
-Compiler diagnostics are emitted via loader APIs:
-
-- Compile errors: `callback(error)` — fails the build immediately
-- Compile warnings: `this.emitWarning(...)`
-- Missing `<style src>` files: build error (fail fast, no silent style loss)
-- Scoped CSS fallback: warning emitted once per file (deduplicated in watch mode)
-
-Scoped preprocessor blocks such as `<style scoped lang="scss">` are currently rejected.
-The fallback transformer only understands plain CSS selectors, so allowing SCSS/Less/Stylus here would silently produce incorrect scoped output.
-
-### Scoped CSS
-
-Scoped CSS scope IDs are derived from the file's **relative path** (relative to Rspack's `rootContext`). In production builds, the file content is also mixed into the hash to prevent collisions across packages with identically-named files. This ensures consistent scope IDs across different machines for SSR hydration.
-
-The current scoped CSS implementation uses a fallback regex transformer with the following limitations:
-
-- ❌ No support for `:deep()`, `:global()`, `:slotted()` pseudo-classes
-- ❌ No support for nested `@media` / `@supports` selectors
-- ❌ May not handle CSS comments containing `{` or `,` correctly
-
-**Recommendation**: This is an MVP implementation. For production-grade scoped CSS, consider waiting for native-side precise API support.
-
-### Source Maps
-
-The current `@vizejs/native` NAPI does not yet return a source map field. The type definition reserves a `map?: string` field for forward-compatibility. Once the Rust side implements source map output, the loader will pass it to Rspack automatically.
-
-### TypeScript Output
-
-`@vizejs/native compileSfc` preserves TypeScript syntax in its output (same behavior as `@vue/compiler-sfc`). A downstream transpiler is needed to strip type annotations:
-
-- **Recommended**: Use `createVizeVueRules({ typescript: true })` to auto-add a `builtin:swc-loader` post-processing rule
-- **Custom loader**: Pass a `LoaderEntry` — e.g. `typescript: "esbuild-loader"` or `typescript: { loader: "esbuild-loader", options: { ... } }`
-- **Manual**: Add your own `enforce: "post"` rule for `.vue` files (exclude `type=style` requests)
-
-The `isTs` option is auto-detected from `<script lang="ts">` and passed to the native compiler for correct parsing.
+The scope-loader is automatically injected by `VizePlugin` when `autoRules: true` (default). Only needed in manual `oneOf` configurations.
 
 ## License
 

package/dist/index-Bvwqw7T6.d.mts

@@ -0,0 +1,138 @@
+//#region src/types/index.d.ts
+/** Type definitions for @vizejs/rspack-plugin. */
+interface SfcCompileOptionsNapi {
+  filename?: string;
+  sourceMap?: boolean;
+  ssr?: boolean;
+  /** Enable Vapor mode compilation */
+  vapor?: boolean;
+  /** Preserve TypeScript in output when true */
+  isTs?: boolean;
+  /** Scope ID for scoped CSS (e.g., "data-v-abc123") */
+  scopeId?: string;
+}
+interface SfcCompileResultNapi {
+  code: string;
+  css?: string;
+  /** Source map JSON (when implemented) */
+  map?: string;
+  errors: string[];
+  warnings: string[];
+}
+interface StyleBlockInfo {
+  /** Raw style content */
+  content: string;
+  /** External source from `<style src="...">` */
+  src?: string | null;
+  /** Language of the style block (e.g., "css", "scss", "less", "sass", "stylus") */
+  lang: string | null;
+  /** Whether scoped */
+  scoped: boolean;
+  /** CSS Modules: true for unnamed, or binding name for named */
+  module: boolean | string;
+  /** Block index in the SFC */
+  index: number;
+}
+interface CustomBlockInfo {
+  /** Tag name (e.g., "i18n", "docs") */
+  type: string;
+  /** Raw content */
+  content: string;
+  /** External source from `<block src="...">` */
+  src?: string | null;
+  /** All attributes on the tag */
+  attrs: Record<string, string | true>;
+  /** Block index in the SFC */
+  index: number;
+}
+interface SfcSrcInfo {
+  /** <script src> path, or null */
+  scriptSrc?: string | null;
+  /** <template src> path, or null */
+  templateSrc?: string | null;
+}
+/** Static asset URL in template to be rewritten as an import binding. */
+interface TemplateAssetUrl {
+  /** Raw URL as in template (e.g., "./logo.png") */
+  url: string;
+  /** JS identifier for the import (e.g., "_imports_0") */
+  varName: string;
+}
+interface CompiledModule {
+  code: string;
+  css?: string;
+  errors: string[];
+  warnings: string[];
+  scopeId: string;
+  hasScoped: boolean;
+  /** Per-block style metadata */
+  styles: StyleBlockInfo[];
+  /** Custom blocks from the SFC */
+  customBlocks: CustomBlockInfo[];
+  /** Whether custom element (e.g., .ce.vue) */
+  isCustomElement: boolean;
+  /** Static asset URLs needing import rewrite. Empty when transformAssetUrls is false. */
+  templateAssetUrls: TemplateAssetUrl[];
+}
+interface VizeLoaderOptions {
+  /** Source maps @default true */
+  sourceMap?: boolean;
+  /** SSR mode @default false */
+  ssr?: boolean;
+  /** Project root */
+  root?: string;
+  /** Include filter */
+  include?: string | RegExp | (string | RegExp)[];
+  /** Exclude filter */
+  exclude?: string | RegExp | (string | RegExp)[];
+  /** Low-level compiler options for @vizejs/native compileSfc */
+  compilerOptions?: SfcCompileOptionsNapi;
+  /** Custom element mode. true=all, RegExp=matched. @default /\.ce\.vue$/ */
+  customElement?: boolean | RegExp;
+  /** Vapor mode @default false */
+  vapor?: boolean;
+  /** HMR. false to disable in dev. @default true (dev), false (prod/SSR) */
+  hotReload?: boolean;
+  /**
+   * Transform static asset URLs in templates into import bindings.
+   * true=built-in tags, false=disabled, object=custom map. @default true
+   */
+  transformAssetUrls?: boolean | Record<string, string[]>;
+}
+interface VizeStyleLoaderOptions {
+  /** Native CSS mode (experiments.css) @default false */
+  native?: boolean;
+}
+interface VizeRspackPluginOptions {
+  /** Include filter @default /\.vue$/ */
+  include?: string | RegExp | (string | RegExp)[];
+  /** Exclude filter @default /node_modules/ */
+  exclude?: string | RegExp | (string | RegExp)[];
+  /** Force production mode @default auto-detected */
+  isProduction?: boolean;
+  /** SSR mode @default false */
+  ssr?: boolean;
+  /** Source maps @default true (dev), false (prod) */
+  sourceMap?: boolean;
+  /** Vapor mode @default false */
+  vapor?: boolean;
+  /** Root directory @default Rspack's root */
+  root?: string;
+  /** CSS config */
+  css?: {
+    /** Native CSS (experiments.css), uses LightningCSS @default false */native?: boolean;
+  };
+  /** Compiler options */
+  compilerOptions?: SfcCompileOptionsNapi;
+  /** Debug logging @default false */
+  debug?: boolean;
+  /** Auto-clone CSS rules for Vue style sub-requests (like VueLoaderPlugin). @default true */
+  autoRules?: boolean;
+}
+/** Loader entry: either a string (loader name/path) or an object with loader + options */
+type LoaderEntry = string | {
+  loader: string;
+  options?: Record<string, unknown>;
+};
+//#endregion
+export { SfcCompileResultNapi as a, VizeLoaderOptions as c, SfcCompileOptionsNapi as i, VizeRspackPluginOptions as l, CustomBlockInfo as n, SfcSrcInfo as o, LoaderEntry as r, StyleBlockInfo as s, CompiledModule as t, VizeStyleLoaderOptions as u };