@vizejs/rspack-plugin 0.22.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 ubugeeei
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,452 @@
+# @vizejs/rspack-plugin
+
+High-performance Rspack plugin for Vue SFC compilation powered by [Vize](https://github.com/ubugeeei/vize).
+
+> [!NOTE]
+> Rspack intentionally uses the dedicated `@vizejs/rspack-plugin` path instead of an `@vizejs/unplugin/rspack` export.
+> Its loader chain, `experiments.css`, and HMR behavior need Rspack-specific handling.
+>
+> Non-Vite bundler integrations are still unstable.
+> If you need rollup, webpack, or esbuild, use `@vizejs/unplugin` and test carefully before relying on it in production.
+
+## Features
+
+- ⚡ **Blazing Fast** - Powered by Rust-based `@vizejs/native` compiler
+- 🔄 **HMR Support** - Script/template hot reload via `module.hot` + `__VUE_HMR_RUNTIME__`, CSS Modules HMR with targeted rerender
+- 🎨 **CSS Processing** - Support for both native CSS (`experiments.css`) and CssExtractRspackPlugin
+- 📦 **CSS Modules** - First-class CSS Modules support with per-module HMR
+- 🔗 **`<style src>` Support** - Resolves external style files with watch dependency tracking
+- 🔧 **TypeScript** - Full TypeScript support with auto-detection and optional built-in TS stripping
+- 🗄️ **Compilation Cache** - Content-hash based caching to skip re-compilation of unchanged files
+- 🛠️ **Vue DevTools** - Exposes `__file` for component file path in development mode
+- 🧩 **Custom Elements** - Auto-detect `.ce.vue` or configure via `customElement` option
+
+## Installation
+
+```bash
+pnpm add -D @vizejs/rspack-plugin @rspack/core
+```
+
+## Usage
+
+### Auto Preset
+
+Use `createVizeVueRules()` to generate `.vue` rules automatically.
+If you don't call it, write rules manually.
+
+```javascript
+// rspack.config.mjs
+import { rspack } from "@rspack/core";
+import { VizePlugin, createVizeVueRules } from "@vizejs/rspack-plugin";
+
+const isProduction = process.env.NODE_ENV === "production";
+
+export default {
+  mode: isProduction ? "production" : "development",
+
+  experiments: {
+    css: true,
+  },
+
+  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,
+        },
+      }),
+    ],
+  },
+
+  plugins: [
+    new VizePlugin({
+      isProduction,
+      include: [/src\/.*\.vue$/],
+      exclude: [/node_modules/],
+      css: { native: true },
+    }),
+  ],
+};
+```
+
+### Option A: Native CSS (Recommended)
+
+Uses Rspack's built-in `experiments.css` for optimal performance. CSS is processed by Rust-side LightningCSS.
+
+```javascript
+// rspack.config.mjs
+import { rspack } from "@rspack/core";
+import { VizePlugin } from "@vizejs/rspack-plugin";
+import path from "node:path";
+
+const isProduction = process.env.NODE_ENV === "production";
+
+export default {
+  mode: isProduction ? "production" : "development",
+
+  // Enable Rspack native CSS support
+  experiments: {
+    css: true,
+  },
+
+  module: {
+    rules: [
+      {
+        test: /\.vue$/,
+        oneOf: [
+          // CSS Modules (<style module>)
+          {
+            resourceQuery: /vue&type=style.*module/,
+            type: "css/module",
+            use: [
+              {
+                loader: "@vizejs/rspack-plugin/style-loader",
+              },
+            ],
+          },
+
+          // SCSS (<style lang="scss">)
+          {
+            resourceQuery: /vue&type=style.*lang=scss/,
+            type: "css/auto",
+            use: [
+              "sass-loader",
+              {
+                loader: "@vizejs/rspack-plugin/style-loader",
+              },
+            ],
+          },
+
+          // Regular CSS (<style>)
+          {
+            resourceQuery: /vue&type=style/,
+            type: "css/auto",
+            use: [
+              {
+                loader: "@vizejs/rspack-plugin/style-loader",
+              },
+            ],
+          },
+
+          // Main .vue file (compile SFC → JS)
+          {
+            use: [
+              {
+                loader: "@vizejs/rspack-plugin/loader",
+                options: {
+                  include: [/src\/.*\.vue$/],
+                  exclude: [/node_modules/],
+                  sourceMap: !isProduction,
+                },
+              },
+            ],
+          },
+        ],
+      },
+    ],
+  },
+
+  plugins: [
+    new VizePlugin({
+      isProduction,
+      include: [/src\/.*\.vue$/],
+      exclude: [/node_modules/],
+      css: {
+        native: true,
+      },
+    }),
+  ],
+
+  resolve: {
+    alias: {
+      "@": path.resolve(import.meta.dirname, "src"),
+    },
+  },
+};
+```
+
+### Option B: CssExtractRspackPlugin
+
+Compatible with webpack ecosystem, suitable for projects requiring PostCSS plugin chains.
+
+```javascript
+// rspack.config.mjs
+import { rspack } from "@rspack/core";
+import { VizePlugin } from "@vizejs/rspack-plugin";
+import path from "node:path";
+
+const isProduction = process.env.NODE_ENV === "production";
+
+export default {
+  mode: isProduction ? "production" : "development",
+
+  module: {
+    rules: [
+      {
+        test: /\.vue$/,
+        oneOf: [
+          // SCSS style blocks
+          {
+            resourceQuery: /vue&type=style.*lang=scss/,
+            type: "javascript/auto",
+            use: [
+              isProduction
+                ? rspack.CssExtractRspackPlugin.loader
+                : "style-loader",
+              "css-loader",
+              "sass-loader",
+              {
+                loader: "@vizejs/rspack-plugin/style-loader",
+              },
+            ],
+          },
+
+          // Regular CSS style blocks
+          {
+            resourceQuery: /vue&type=style/,
+            type: "javascript/auto",
+            use: [
+              isProduction
+                ? rspack.CssExtractRspackPlugin.loader
+                : "style-loader",
+              {
+                loader: "css-loader",
+                options: {
+                  modules: {
+                    auto: (_resourcePath, resourceQuery) =>
+                      typeof resourceQuery === "string" &&
+                      resourceQuery.includes("module="),
+                  },
+                },
+              },
+              {
+                loader: "@vizejs/rspack-plugin/style-loader",
+              },
+            ],
+          },
+
+          // Main .vue file
+          {
+            use: [
+              {
+                loader: "@vizejs/rspack-plugin/loader",
+                options: {
+                  include: [/src\/.*\.vue$/],
+                  exclude: [/node_modules/],
+                  sourceMap: !isProduction,
+                },
+              },
+            ],
+          },
+        ],
+      },
+
+      // Regular CSS files (non-Vue)
+      {
+        test: /\.css$/,
+        type: "javascript/auto",
+        use: [
+          isProduction ? rspack.CssExtractRspackPlugin.loader : "style-loader",
+          "css-loader",
+        ],
+      },
+
+      // Regular SCSS files (non-Vue)
+      {
+        test: /\.scss$/,
+        type: "javascript/auto",
+        use: [
+          isProduction ? rspack.CssExtractRspackPlugin.loader : "style-loader",
+          "css-loader",
+          "sass-loader",
+        ],
+      },
+    ],
+  },
+
+  plugins: [
+    new VizePlugin({
+      isProduction,
+      include: [/src\/.*\.vue$/],
+      exclude: [/node_modules/],
+    }),
+
+    // CSS extraction (production only)
+    ...(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"),
+    },
+  },
+};
+```
+
+## API
+
+### VizePlugin
+
+```typescript
+import { VizePlugin } from "@vizejs/rspack-plugin";
+
+new VizePlugin({
+  isProduction: boolean;    // Auto-detected from Rspack mode
+  include: string | RegExp | (string | RegExp)[]; // Filter watched .vue files
+  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)
+  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)
+});
+// Debug logging uses Rspack's infrastructure logger.
+// Control verbosity via `infrastructureLogging.level` in your rspack config.
+```
+
+### VizeLoader
+
+```typescript
+// In rspack.config.js
+{
+  loader: "@vizejs/rspack-plugin/loader",
+  options: {
+    include: string | RegExp | (string | RegExp)[]; // Safe compile allowlist
+    exclude: string | RegExp | (string | RegExp)[]; // Safe compile denylist
+    sourceMap: boolean;     // Enable source maps (default: true)
+    ssr: boolean;           // Enable SSR mode (default: false)
+    customElement: boolean | RegExp; // Custom element mode (default: /\.ce\.vue$/)
+    hotReload: boolean;     // Enable HMR (default: true in dev, false in prod/SSR)
+    compilerOptions: {      // Extra @vizejs/native compileSfc options
+      filename?: string;
+      sourceMap?: boolean;
+      ssr?: boolean;
+      isTs?: boolean;       // Preserve TypeScript (auto-detected from <script lang="ts">)
+      scopeId?: string;
+    };
+  };
+}
+```
+
+If `include/exclude` filters out a `.vue` file matched by this loader rule, the loader emits a warning and passes through the source unchanged.
+This avoids hard failures while still alerting you to mismatched rule/filter configuration.
+
+Compilation errors cause the loader to fail immediately (`callback(error)`) instead of returning broken code.
+
+### VizeStyleLoader
+
+```typescript
+// In rspack.config.js
+{
+  loader: "@vizejs/rspack-plugin/style-loader",
+  options: {
+    native: boolean;        // Using experiments.css (default: false)
+  };
+}
+```
+
+### createVizeVueRules
+
+```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
+});
+```
+
+## 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.
+
+## License
+
+MIT

package/dist/index-C1nbpj8i.d.ts

@@ -0,0 +1,7 @@
+import { VizeLoaderOptions } from "./index-Crp9t5G9.js";
+import { LoaderContext } from "@rspack/core";
+
+//#region src/loader/index.d.ts
+
+declare function vizeLoader(this: LoaderContext<VizeLoaderOptions>, source: string): void; //#endregion
+export { vizeLoader as vizeLoader$1 };

package/dist/index-Crp9t5G9.d.ts

@@ -0,0 +1,249 @@
+//#region src/types/index.d.ts
+/**
+ * Type definitions for @vizejs/rspack-plugin
+ * Copied and adapted from vite-plugin-vize
+ */
+interface SfcCompileOptionsNapi {
+  filename?: string;
+  sourceMap?: boolean;
+  ssr?: 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 string (when implemented in @vizejs/native) */
+  map?: string;
+  errors: string[];
+  warnings: string[];
+}
+interface StyleBlockInfo {
+  /** Raw style content (uncompiled for preprocessor langs) */
+  content: string;
+  /** External style source path from `<style src="...">` */
+  src?: string | null;
+  /** Language of the style block (e.g., "css", "scss", "less", "sass", "stylus") */
+  lang: string | null;
+  /** Whether the style block has the scoped attribute */
+  scoped: boolean;
+  /** CSS Modules: true for unnamed `module`, or the binding name for `module="name"` */
+  module: boolean | string;
+  /** Index of this style block in the SFC */
+  index: number;
+}
+interface CustomBlockInfo {
+  /** Tag name of the custom block (e.g., "i18n", "docs") */
+  type: string;
+  /** Raw content of the custom block */
+  content: string;
+  /** External source path from `<block src="...">` */
+  src?: string | null;
+  /** All attributes on the custom block tag */
+  attrs: Record<string, string | true>;
+  /** Index of this custom block in the SFC */
+  index: number;
+}
+interface SfcSrcInfo {
+  /** Whether <script> has a src attribute */
+  scriptSrc?: string | null;
+  /** Whether <template> has a src attribute */
+  templateSrc?: string | null;
+}
+interface CompiledModule {
+  code: string;
+  css?: string;
+  errors: string[];
+  warnings: string[];
+  scopeId: string;
+  hasScoped: boolean;
+  /** Per-block style metadata extracted from the source SFC */
+  styles: StyleBlockInfo[];
+  /** Custom blocks extracted from the source SFC */
+  customBlocks: CustomBlockInfo[];
+  /** Whether this is a custom element SFC (e.g., .ce.vue) */
+  isCustomElement: boolean;
+}
+interface VizeLoaderOptions {
+  /**
+   * Enable source map generation
+   * @default true
+   */
+  sourceMap?: boolean;
+  /**
+   * Enable SSR mode
+   * @default false
+   */
+  ssr?: boolean;
+  /**
+   * Project root directory
+   */
+  root?: string;
+  /**
+   * Files to include in compilation (safe filter)
+   */
+  include?: string | RegExp | (string | RegExp)[];
+  /**
+   * Files to exclude from compilation (safe filter)
+   */
+  exclude?: string | RegExp | (string | RegExp)[];
+  /**
+   * Additional low-level compiler options passed to @vizejs/native compileSfc
+   */
+  compilerOptions?: SfcCompileOptionsNapi;
+  /**
+   * Transform Vue SFCs into custom elements.
+   * - `true`: all `*.vue` imports are converted into custom elements
+   * - `RegExp`: matched files are converted into custom elements
+   *
+   * @default /\.ce\.vue$/
+   */
+  customElement?: boolean | RegExp;
+  /**
+   * Enable HMR (Hot Module Replacement) for Vue SFCs.
+   * Set to `false` to explicitly disable HMR even in development mode.
+   *
+   * @default true (enabled in development, disabled in production/SSR)
+   */
+  hotReload?: boolean;
+}
+interface VizeStyleLoaderOptions {
+  /**
+   * Whether to use native CSS mode (experiments.css)
+   * In both modes, the loader outputs pure CSS
+   * @default false
+   */
+  native?: boolean;
+}
+type VizeStyleLanguage = "css" | "scss" | "sass" | "less" | "styl" | "stylus";
+interface CreateVizeVueRulesOptions {
+  /**
+   * Production mode flag
+   * @default false
+   */
+  isProduction?: boolean;
+  /**
+   * Use Rspack native CSS pipeline (`experiments.css`)
+   * @default true
+   */
+  nativeCss?: boolean;
+  /**
+   * Extra languages to handle automatically in addition to `css`
+   * @default ["scss", "sass", "less", "stylus", "styl"]
+   */
+  styleLanguages?: VizeStyleLanguage[];
+  /**
+   * Loader entry for the main `.vue` compiler loader
+   * @default "@vizejs/rspack-plugin/loader"
+   */
+  vizeLoader?: string;
+  /**
+   * Loader entry for the `.vue` style extractor loader
+   * @default "@vizejs/rspack-plugin/style-loader"
+   */
+  vizeStyleLoader?: string;
+  /**
+   * Dev style injector / prod extractor loader entry used in non-native CSS mode
+   * @default "style-loader"
+   */
+  styleInjectLoader?: LoaderEntry;
+  /**
+   * Production CSS extractor loader entry used in non-native CSS mode
+   * (e.g. `rspack.CssExtractRspackPlugin.loader`)
+   */
+  styleExtractLoader?: LoaderEntry;
+  /**
+   * css-loader entry used in non-native CSS mode
+   * @default "css-loader"
+   */
+  cssLoader?: LoaderEntry;
+  /**
+   * Main vize loader options
+   */
+  loaderOptions?: VizeLoaderOptions;
+  /**
+   * Vize style loader options
+   */
+  styleLoaderOptions?: VizeStyleLoaderOptions;
+  /**
+   * Add a post-processing rule to strip TypeScript type annotations from
+   * the compiled `.vue` output.
+   *
+   * This is needed because `@vizejs/native compileSfc` preserves TypeScript
+   * syntax in its output (same as `@vue/compiler-sfc`), and a downstream
+   * transpiler must strip the types before the browser/runtime can execute it.
+   *
+   * - `true`:  use Rspack built-in SWC loader (`builtin:swc-loader`)
+   * - `LoaderEntry`: use a custom loader (e.g. `esbuild-loader`)
+   * - `false` / omitted: no post-processing (user handles it separately)
+   *
+   * @default false
+   */
+  typescript?: boolean | LoaderEntry;
+}
+interface VizeRspackPluginOptions {
+  /**
+   * Files to include in compilation
+   * @default /\.vue$/
+   */
+  include?: string | RegExp | (string | RegExp)[];
+  /**
+   * Files to exclude from compilation
+   * @default /node_modules/
+   */
+  exclude?: string | RegExp | (string | RegExp)[];
+  /**
+   * Force production mode
+   * @default auto-detected from Rspack config
+   */
+  isProduction?: boolean;
+  /**
+   * Enable SSR mode
+   * @default false
+   */
+  ssr?: boolean;
+  /**
+   * Enable source map generation
+   * @default true in development, false in production
+   */
+  sourceMap?: boolean;
+  /**
+   * Enable Vapor mode compilation
+   * @default false
+   */
+  vapor?: boolean;
+  /**
+   * Root directory to scan for .vue files
+   * @default Rspack's root
+   */
+  root?: string;
+  /**
+   * CSS configuration
+   */
+  css?: {
+    /**
+     * Use Rspack native CSS processing (experiments.css)
+     * When enabled, no need for css-loader/style-loader/CssExtractRspackPlugin
+     * Handled by Rust-side LightningCSS, better performance
+     * @default false
+     */
+    native?: boolean;
+  };
+  /**
+   * Custom compiler options
+   */
+  compilerOptions?: SfcCompileOptionsNapi;
+  /**
+   * Enable debug logging
+   * @default false
+   */
+  debug?: 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 { CompiledModule, CreateVizeVueRulesOptions, CustomBlockInfo, LoaderEntry, SfcCompileOptionsNapi, SfcCompileResultNapi, SfcSrcInfo, StyleBlockInfo, VizeLoaderOptions, VizeRspackPluginOptions, VizeStyleLanguage, VizeStyleLoaderOptions };

package/dist/index.d.ts

@@ -0,0 +1,159 @@
+import { CompiledModule, CreateVizeVueRulesOptions, CustomBlockInfo, LoaderEntry, SfcCompileOptionsNapi, SfcCompileResultNapi, SfcSrcInfo, StyleBlockInfo, VizeLoaderOptions, VizeRspackPluginOptions, VizeStyleLanguage, VizeStyleLoaderOptions } from "./index-Crp9t5G9.js";
+import { vizeLoader$1 as vizeLoader } from "./index-C1nbpj8i.js";
+import { vizeStyleLoader$1 as vizeStyleLoader } from "./style-loader-zO0F0c6t.js";
+import { Compiler } from "@rspack/core";
+
+//#region src/plugin/index.d.ts
+
+declare class VizePlugin {
+  static readonly name = "VizePlugin";
+  private options;
+  constructor(options?: VizeRspackPluginOptions);
+  apply(compiler: Compiler): void;
+  private shouldHandleFile;
+} //#endregion
+//#region src/shared/utils.d.ts
+/**
+ * Generate a unique scope ID for scoped CSS based on file path.
+ * Uses SHA256 hash and takes the first 8 characters.
+ *
+ * Uses relative path (when rootContext is provided) for cross-environment
+ * consistency (e.g. SSR hydration).  In production, mixes source content
+ * into the hash to avoid collisions across packages with identically-named files.
+ */
+declare function generateScopeId(filename: string, rootContext?: string, isProduction?: boolean, source?: string): string;
+/**
+ * Extract style block metadata from a Vue SFC source string.
+ * Parses `<style>` tags to determine lang, scoped, and module attributes.
+ *
+ * Copied from vite-plugin-vize/src/compiler.ts
+ */
+declare function extractStyleBlocks(source: string): StyleBlockInfo[];
+/**
+ * Fallback scoped CSS transformer using simple regex.
+ *
+ * ⚠️ Known limitations:
+ *   - Does not support @media / @supports nested selectors
+ *   - Does not support Vue's :deep() / :global() / :slotted() pseudo-classes
+ *   - Does not handle CSS comments containing { or ,
+ *   - Does not support :root and other pseudo-class selectors
+ *
+ * Recommendation: This regex implementation is for MVP stage only;
+ * production-grade scoped semantics should use native-side precise API.
+ *
+ * Copied from rspack-plugin-design.md
+ */
+declare function addScopeToCssFallback(css: string, scopeId: string): string;
+/**
+ * Extract custom block metadata from a Vue SFC source string.
+ * Parses root-level tags that are not <script>, <template>, or <style>.
+ */
+declare function extractCustomBlocks(source: string): CustomBlockInfo[];
+/**
+ * Extract <script src> and <template src> references from an SFC source.
+ * Returns null for each if no src attribute is present.
+ */
+declare function extractSrcInfo(source: string): SfcSrcInfo;
+/**
+ * Replace <script src="..."> or <template src="..."> with inline content
+ * read from external files. This produces a self-contained SFC string
+ * that can be passed to compileSfc.
+ */
+declare function inlineSrcBlocks(source: string, scriptContent: string | null, templateContent: string | null): string;
+/**
+ * Create a conditional logger.
+ *
+ * Copied from vite-plugin-vize/src/transform.ts
+ */
+declare function createLogger(debug: boolean): {
+  log: (...args: unknown[]) => false | void;
+  info: (...args: unknown[]) => void;
+  warn: (...args: unknown[]) => void;
+  error: (...args: unknown[]) => void;
+};
+/**
+ * Match a file path against include/exclude patterns.
+ * Used by both the main loader and the plugin for consistent filtering.
+ *
+ * Normalizes backslashes to forward slashes before matching,
+ * so patterns like /src\/.*\.vue$/ work on Windows.
+ */
+declare function matchesPattern(file: string, pattern: string | RegExp | (string | RegExp)[] | undefined, defaultValue: boolean): boolean;
+
+//#endregion
+//#region src/shared/hotReload.d.ts
+/**
+ * HMR (Hot Module Replacement) code generation for Vue SFC modules.
+ *
+ * Uses `module.hot` (Rspack/webpack CommonJS HMR API), NOT `import.meta.hot`.
+ * Reference: rspack-vue-loader's hotReload.ts
+ *
+ * __VUE_HMR_RUNTIME__ is injected into global scope by @vue/runtime-core.
+ */
+/**
+ * Generate HMR boilerplate code for a compiled Vue SFC module.
+ *
+ * The generated code:
+ * 1. Assigns `__hmrId` to the component for Vue devtools
+ * 2. Calls `module.hot.accept()` to make the module self-accepting
+ * 3. Registers or reloads the component via `__VUE_HMR_RUNTIME__`
+ *
+ * @param id - Unique HMR identifier for this component (typically the scopeId hash)
+ */
+declare function genHotReloadCode(id: string): string;
+
+//#endregion
+//#region src/shared/compiler.d.ts
+/**
+ * Generate HMR code for a CSS Module import.
+ *
+ * When the CSS Module file changes, this code:
+ * 1. Updates the __cssModules binding with the new values
+ * 2. Triggers a Vue component rerender (NOT a full reload)
+ */
+/**
+ * Clear the compilation cache.  Exposed for testing and manual invalidation.
+ */
+declare function clearCompilationCache(): void;
+/**
+ * Compile a single .vue file.
+ *
+ * Adapted from vite-plugin-vize for Rspack loader scenario:
+ * - Uses content-hash based cache to skip re-compilation of unchanged files
+ * - Does not read file (source is passed as parameter)
+ * - Returns styles metadata for loader chain processing
+ */
+declare function compileFile(filePath: string, source: string, options?: {
+  sourceMap?: boolean;
+  ssr?: boolean;
+  compilerOptions?: SfcCompileOptionsNapi;
+  isCustomElement?: boolean;
+  rootContext?: string;
+  isProduction?: boolean;
+}): CompiledModule;
+/**
+ * Generate output code with style imports and custom block imports injected.
+ *
+ * Key difference from Vite version:
+ * - Generates import statements with query parameters for style blocks
+ * - Rspack will route these to the appropriate style loader via resourceQuery matching
+ * - Injects `module.hot` based HMR code when `hmr` is enabled
+ */
+declare function generateOutput(compiled: CompiledModule, options: {
+  requestPath: string;
+  /** Inject HMR boilerplate using `module.hot` (Rspack/webpack CJS API) */
+  hmr?: boolean;
+  /** Original file path (for __file exposure in dev mode) */
+  filePath?: string;
+  /** Whether this is a production build */
+  isProduction?: boolean;
+  /** Project root context (for computing relative __file path) */
+  rootContext?: string;
+}): string;
+
+//#endregion
+//#region src/preset/rules.d.ts
+declare function createVizeVueRules(options?: CreateVizeVueRulesOptions): Record<string, unknown>[];
+
+//#endregion
+export { CompiledModule, CreateVizeVueRulesOptions, CustomBlockInfo, LoaderEntry, SfcCompileOptionsNapi, SfcCompileResultNapi, SfcSrcInfo, StyleBlockInfo, VizeLoaderOptions, VizePlugin, VizeRspackPluginOptions, VizeStyleLanguage, VizeStyleLoaderOptions, addScopeToCssFallback, clearCompilationCache, compileFile, createLogger, createVizeVueRules, extractCustomBlocks, extractSrcInfo, extractStyleBlocks, genHotReloadCode, generateOutput, generateScopeId, inlineSrcBlocks, matchesPattern, vizeLoader, vizeStyleLoader };

package/dist/index.js

@@ -0,0 +1 @@
+import{addScopeToCssFallback as e,createLogger as t,extractCustomBlocks as n,extractSrcInfo as r,extractStyleBlocks as i,generateScopeId as a,inlineSrcBlocks as o,matchesPattern as s}from"./utils-Cw44tFia.js";import{clearCompilationCache as c,compileFile as l,genHotReloadCode as u,generateOutput as d,vizeLoader as f}from"./loader-DyzGJOBD.js";import{vizeStyleLoader as p}from"./style-loader-DPvk-BhE.js";var m=class e{static name=`VizePlugin`;options;constructor(e={}){this.options=e}apply(t){let n=t.getInfrastructureLogger(e.name),r=this.options.isProduction??t.options.mode===`production`;this.options.vapor&&n.warn("Vapor mode is enabled but SFC-level Vapor compilation is not yet supported by @vizejs/native. Only `__VUE_PROD_HYDRATION_MISMATCH_DETAILS__` will be set. Track https://github.com/nicepkg/vize for updates.");let i=!!t.options.experiments?.css;this.options.css?.native&&!i&&n.warn("`css.native: true` is set but `experiments.css` is not enabled in rspack config.");let{DefinePlugin:a}=t.webpack,o=new Set;for(let e of t.options.plugins??[]){let t=e?.definitions;if(t)for(let e of Object.keys(t))o.add(e)}let s={};o.has(`__VUE_OPTIONS_API__`)||(s.__VUE_OPTIONS_API__=JSON.stringify(!0)),o.has(`__VUE_PROD_DEVTOOLS__`)||(s.__VUE_PROD_DEVTOOLS__=JSON.stringify(!r)),o.has(`__VUE_PROD_HYDRATION_MISMATCH_DETAILS__`)||(s.__VUE_PROD_HYDRATION_MISMATCH_DETAILS__=JSON.stringify(!r)),Object.keys(s).length>0&&new a(s).apply(t),r||t.hooks.watchRun.tap(e.name,e=>{let t=e.modifiedFiles,r=e.removedFiles;if(t)for(let e of t)e.endsWith(`.vue`)&&this.shouldHandleFile(e)&&n.debug(`Vue file changed: ${e}`);if(r)for(let e of r)e.endsWith(`.vue`)&&this.shouldHandleFile(e)&&n.debug(`Vue file removed: ${e}`)})}shouldHandleFile(e){return!(!s(e,this.options.include,!0)||s(e,this.options.exclude,!1))}};const h=[`scss`,`sass`,`less`,`stylus`,`styl`],g={scss:`sass-loader`,sass:`sass-loader`,less:`less-loader`,styl:`stylus-loader`,stylus:`stylus-loader`};function _(e={}){let{isProduction:t=!1,nativeCss:n=!0,styleLanguages:r=h,vizeLoader:i=`@vizejs/rspack-plugin/loader`,vizeStyleLoader:a=`@vizejs/rspack-plugin/style-loader`,styleInjectLoader:o=`style-loader`,styleExtractLoader:s,cssLoader:c=`css-loader`,loaderOptions:l,styleLoaderOptions:u,typescript:d=!1}=e,f=Array.from(new Set(r.filter(e=>e!==`css`))),p={loader:a,...u?{options:u}:{}},m=[];for(let e of f){let r=g[e];if(!r)continue;m.push(v({lang:e,module:!0,nativeCss:n,styleLoaderEntry:p,preprocessorLoader:r,isProduction:t,styleInjectLoader:o,styleExtractLoader:s,cssLoader:c}))}m.push(v({module:!0,nativeCss:n,styleLoaderEntry:p,isProduction:t,styleInjectLoader:o,styleExtractLoader:s,cssLoader:c}));for(let e of f){let r=g[e];if(!r)continue;m.push(v({lang:e,module:!1,nativeCss:n,styleLoaderEntry:p,preprocessorLoader:r,isProduction:t,styleInjectLoader:o,styleExtractLoader:s,cssLoader:c}))}return m.push(v({module:!1,nativeCss:n,styleLoaderEntry:p,isProduction:t,styleInjectLoader:o,styleExtractLoader:s,cssLoader:c})),m.push({use:[{loader:i,options:l}]}),[{test:/\.vue$/,oneOf:m},...d?[{test:/\.vue$/,resourceQuery:{not:[/type=/]},enforce:`post`,...d===!0?{loader:`builtin:swc-loader`,options:{jsc:{parser:{syntax:`typescript`}}}}:typeof d==`string`?{loader:d}:d,type:`javascript/auto`}]:[]]}function v(e){let{lang:t,module:n,nativeCss:r,styleLoaderEntry:i,preprocessorLoader:a,isProduction:o,styleInjectLoader:s,styleExtractLoader:c,cssLoader:l}=e,u=[`type=style`];n&&u.push(`module`),t&&u.push(`lang=${t}`);let d=new RegExp(u.map(e=>`(?=.*${e})`).join(``));if(r)return{resourceQuery:d,type:n?`css/module`:`css/auto`,use:a?[a,i]:[i]};let f=typeof l==`string`?{loader:l,options:{modules:{auto:(e,t)=>typeof t==`string`&&t.includes(`module=`)}}}:l;return{resourceQuery:d,type:`javascript/auto`,use:[o&&c?c:s,f,...a?[a]:[],i]}}export{m as VizePlugin,e as addScopeToCssFallback,c as clearCompilationCache,l as compileFile,t as createLogger,_ as createVizeVueRules,n as extractCustomBlocks,r as extractSrcInfo,i as extractStyleBlocks,u as genHotReloadCode,d as generateOutput,a as generateScopeId,o as inlineSrcBlocks,s as matchesPattern,f as vizeLoader,p as vizeStyleLoader};

package/dist/loader/index.d.ts

@@ -0,0 +1,3 @@
+import "../index-Crp9t5G9.js";
+import { vizeLoader$1 as vizeLoader } from "../index-C1nbpj8i.js";
+export { vizeLoader as default };

package/dist/loader/index.js

@@ -0,0 +1 @@
+import"../utils-Cw44tFia.js";import{vizeLoader as e}from"../loader-DyzGJOBD.js";export{e as default};

package/dist/loader/style-loader.d.ts

@@ -0,0 +1,3 @@
+import "../index-Crp9t5G9.js";
+import { vizeStyleLoader$1 as vizeStyleLoader } from "../style-loader-zO0F0c6t.js";
+export { vizeStyleLoader as default };

package/dist/loader/style-loader.js

@@ -0,0 +1 @@
+import"../utils-Cw44tFia.js";import{vizeStyleLoader as e}from"../style-loader-DPvk-BhE.js";export{e as default};

package/dist/loader-DyzGJOBD.js

@@ -0,0 +1,22 @@
+import{extractCustomBlocks as e,extractSrcInfo as t,extractStyleBlocks as n,generateScopeId as r,inlineSrcBlocks as i,matchesPattern as a}from"./utils-Cw44tFia.js";import{createHash as o}from"node:crypto";import s from"node:path";import c from"node:fs";import*as l from"@vizejs/native";function u(e){return`
+/* hot reload */
+if (module.hot) {
+  _sfc_main.__hmrId = "${e}"
+  const api = __VUE_HMR_RUNTIME__
+  module.hot.accept()
+  if (!api.createRecord('${e}', _sfc_main)) {
+    api.reload('${e}', _sfc_main)
+  }
+}`}function d(e,t,n,r){return`
+if (module.hot) {
+  module.hot.accept(${t}, () => {
+    _sfc_main.__cssModules[${JSON.stringify(r)}] = ${n}
+    __VUE_HMR_RUNTIME__.rerender("${e}")
+  })
+}`}const{compileSfc:f}=l,p=new Map;function m(e){return o(`sha256`).update(e).digest(`hex`).slice(0,16)}function h(){p.clear()}function g(t,i,a={}){let o=a.compilerOptions?.isTs??/<script[^>]*\blang=["']ts["']/.test(i),s=a.ssr??a.compilerOptions?.ssr??!1,c=a.sourceMap??a.compilerOptions?.sourceMap??!0,l=a.isCustomElement??!1,u=a.rootContext??``,d=a.isProduction??!1,h=`${t}:ssr=${s}:ts=${o}:map=${c}:ce=${l}:root=${u}:prod=${d}`,g=m(i),_=p.get(h);if(_&&_.contentHash===g)return _.result;let v=r(t,a.rootContext,a.isProduction,i),y=/<style[^>]*\bscoped\b/.test(i),b={...a.compilerOptions,filename:t,sourceMap:a.sourceMap??a.compilerOptions?.sourceMap??!0,ssr:s,isTs:o,scopeId:y?`data-v-${v}`:void 0},x=f(i,b),S=n(i),C=e(i),w={code:x.code,css:x.css,errors:x.errors,warnings:x.warnings,scopeId:v,hasScoped:y,styles:S,customBlocks:C,isCustomElement:l};return w.errors.length===0&&p.set(h,{contentHash:g,result:w}),w}function _(e,t){let n=e.code,r=e.isCustomElement,i=/^export default /m,a=i.test(n),o=/\bconst\s+_sfc_main\s*=/.test(n);if(a&&!o?(n=n.replace(i,`const _sfc_main = `),e.hasScoped&&e.scopeId&&(n+=`\n_sfc_main.__scopeId = "data-v-${e.scopeId}";`),n+=`
+export default _sfc_main;`):a&&o&&e.hasScoped&&e.scopeId&&(n=n.replace(/^export default _sfc_main/m,`_sfc_main.__scopeId = "data-v-${e.scopeId}";\nexport default _sfc_main`)),e.styles.length>0){if(r){let t=e.styles.some(e=>e.module);if(t)throw Error(`[vize] <style module> is not supported in custom elements mode.`)}let i=e.styles.filter(e=>e.module===!0).length;if(i>1)throw Error(`[vize] Found ${i} unnamed <style module> blocks. Only one unnamed <style module> is allowed per SFC. Use named modules instead: <style module="name">`);let a=e.styles.filter(e=>e.src||/\S/.test(e.content)),o=[],s=a.map(n=>{let i=[`vue`,`type=style`,`index=${n.index}`,`lang=${n.lang||`css`}`,...n.scoped?[`scoped=${e.scopeId}`]:[],...n.module?[`module=${typeof n.module==`string`?n.module:`true`}`]:[],...r?[`inline`]:[]],a=i.join(`&`),s=`${t.requestPath}?${a}`;if(r)return`import _style_${n.index} from ${JSON.stringify(s)};`;if(n.module){let e=typeof n.module==`string`?n.module:`$style`,t=`_cssModule_${n.index}`;return o.push({request:s,varName:t,bindingName:e}),`import ${t} from ${JSON.stringify(s)};`}return`import ${JSON.stringify(s)};`}).join(`
+`);if(n=s+`
+`+n,r){let e=a.map(e=>`_style_${e.index}`).join(`,`);n=n.replace(/^export default _sfc_main;/m,`_sfc_main.styles = [${e}];\nexport default _sfc_main;`)}if(!r&&o.length>0){let r=o.map(e=>`_sfc_main.__cssModules = _sfc_main.__cssModules || {};\n_sfc_main.__cssModules[${JSON.stringify(e.bindingName)}] = ${e.varName};`).join(`
+`),i=t.hmr&&e.scopeId?o.map(t=>d(e.scopeId,JSON.stringify(t.request),t.varName,t.bindingName)).join(`
+`):``;n=n.replace(/^export default _sfc_main;/m,`${r}\n${i}\nexport default _sfc_main;`)}}if(t.filePath&&!t.isProduction){let e=t.rootContext?s.relative(t.rootContext,t.filePath).replace(/\\/g,`/`):s.basename(t.filePath);n=n.replace(/^export default _sfc_main;/m,`_sfc_main.__file = ${JSON.stringify(e)};\nexport default _sfc_main;`)}if(t.hmr&&e.scopeId&&(n=n.replace(/^export default _sfc_main;/m,`${u(e.scopeId)}\nexport default _sfc_main;`)),e.customBlocks.length>0){let r=e.customBlocks.map((e,n)=>{let r=[`vue`,`type=${e.type}`,`index=${n}`,...e.src?[`src=true`]:[]];for(let[t,n]of Object.entries(e.attrs)){if(t===`src`)continue;n===!0?r.push(t):r.push(`${t}=${n}`)}let i=r.join(`&`),a=t.requestPath;return`import block${n} from ${JSON.stringify(`${a}?${i}`)};\nif (typeof block${n} === 'function') block${n}(_sfc_main);`}).join(`
+`);n=n.replace(/^export default _sfc_main;/m,`${r}\nexport default _sfc_main;`)}return n}const v=/\.ce\.vue$/;function y(n){let r=this.async(),a=this.getOptions(),o=this.resourcePath,l=this.resourceQuery,u=S(this,o),d=this.mode===`production`||process.env.NODE_ENV===`production`,f=a.ssr??!1,p=!f&&!d&&a.hotReload!==!1;if(this.addDependency(o),l?.includes(`type=style`)){r(Error(`[vize] Main loader received style sub-request: ${o}${l}. Use module.rules[].oneOf with resourceQuery branches so style requests are handled by @vizejs/rspack-plugin/style-loader.`));return}if(l&&l.includes(`vue`)&&l.includes(`type=`)&&!l.includes(`type=style`)){let t=new URLSearchParams(l.slice(1)),i=t.get(`type`);if(i&&i!==`style`){let a=parseInt(t.get(`index`)||`0`,10),l=e(n),u=l[a];if(u){if(u.src){let e=s.resolve(s.dirname(o),u.src);this.addDependency(e);try{let t=c.readFileSync(e,`utf-8`);r(null,t)}catch{r(Error(`[vize] Custom block <${i} src="${u.src}"> not found (resolved: ${e}) in ${o}`))}return}r(null,u.content)}else r(null,``);return}}if(!b(o,a)){this.emitWarning(Error(`[vize] File is filtered out by loader options include/exclude: ${o}. Passing through source unchanged.`)),r(null,n);return}try{let e=x(o,a.customElement),l=t(n),f=n;if(l.scriptSrc){let e=s.resolve(s.dirname(o),l.scriptSrc);this.addDependency(e);try{let t=c.readFileSync(e,`utf-8`);f=i(f,t,null)}catch{r(Error(`[vize] <script src="${l.scriptSrc}"> not found (resolved: ${e}) in ${o}`));return}}if(l.templateSrc){let e=s.resolve(s.dirname(o),l.templateSrc);this.addDependency(e);try{let t=c.readFileSync(e,`utf-8`);f=i(f,null,t)}catch{r(Error(`[vize] <template src="${l.templateSrc}"> not found (resolved: ${e}) in ${o}`));return}}let m=g(o,f,{sourceMap:a.sourceMap??this.sourceMap??!0,ssr:a.ssr??!1,compilerOptions:a.compilerOptions,isCustomElement:e,rootContext:this.rootContext,isProduction:d});for(let e of m.warnings)this.emitWarning(Error(`[vize] ${e}`));if(m.errors.length>0){for(let e of m.errors)this.emitError(Error(`[vize] ${e}`));let e=m.errors.join(`\\n`);r(Error(`[vize] Compilation failed for ${o}:\n${e}`));return}let h=_(m,{requestPath:u,hmr:p,filePath:o,isProduction:d,rootContext:this.rootContext});r(null,h)}catch(e){r(e)}}function b(e,t){return!(!a(e,t.include,!0)||a(e,t.exclude,!1))}function x(e,t){return t===!0?!0:t===!1||t===void 0?v.test(e):t.test(e)}function S(e,t){let n=s.basename(t);return`./${n}`}export{h as clearCompilationCache,g as compileFile,u as genHotReloadCode,_ as generateOutput,y as vizeLoader};

package/dist/style-loader-DPvk-BhE.js

@@ -0,0 +1 @@
+import{addScopeToCssFallback as e,extractStyleBlocks as t}from"./utils-Cw44tFia.js";import n from"node:path";import r from"node:fs/promises";const i=new Set;function a(e){let i=this.async(),{resourceQuery:a,resourcePath:s}=this;if(!a){i(null,e);return}let c=new URLSearchParams(a.slice(1)),l=c.get(`type`);if(l!==`style`){i(null,e);return}let u=parseInt(c.get(`index`)||`0`,10),d=c.get(`scoped`);this.addDependency(s);let f=t(e),p=f[u];if(!p){this.emitError(Error(`[vize] Style block at index ${u} not found in ${s}`)),i(null,``);return}if(p.src){let e=n.resolve(n.dirname(s),p.src);this.addDependency(e),r.readFile(e,`utf-8`).then(e=>{let t=o(this,e,p.scoped,d,s);i(null,t)}).catch(()=>{this.emitWarning(Error(`[vize] <style src> target not found: ${p.src} (resolved: ${e}) in ${s}`)),i(null,``)});return}let m=o(this,p.content,p.scoped,d,s);i(null,m)}function o(t,n,r,a,o){return r&&a?(i.has(o)||(i.add(o),t.emitWarning(Error(`[vize] scoped CSS uses fallback transformer with limitations: no :deep()/:global()/:slotted(), no nested @media. File: ${o}`))),e(n,a)):n}export{a as vizeStyleLoader};

package/dist/style-loader-zO0F0c6t.d.ts

@@ -0,0 +1,7 @@
+import { VizeStyleLoaderOptions } from "./index-Crp9t5G9.js";
+import { LoaderContext } from "@rspack/core";
+
+//#region src/loader/style-loader.d.ts
+
+declare function vizeStyleLoader(this: LoaderContext<VizeStyleLoaderOptions>, source: string): void; //#endregion
+export { vizeStyleLoader as vizeStyleLoader$1 };

package/dist/utils-Cw44tFia.js

@@ -0,0 +1,3 @@
+import{createHash as e}from"node:crypto";import t from"node:path";function n(n,r,i,a){let o;if(r){let e=t.relative(r,n).replace(/^(\.\.[/\\])+/,``).replace(/\\/g,`/`);o=i&&a?e+`
+`+a.replace(/\r\n/g,`
+`):e}else o=n;let s=e(`sha256`).update(o).digest(`hex`);return s.slice(0,8)}function r(e){let t=[],n=/<style([^>]*)>([\s\S]*?)<\/style>/gi,r,i=0;for(;(r=n.exec(e))!==null;){let e=r[1],n=r[2],a=e.match(/\bsrc=["']([^"']+)["']/)?.[1]??null,o=e.match(/\blang=["']([^"']+)["']/)?.[1]??null,s=/\bscoped\b/.test(e),c=e.match(/\bmodule(?:=["']([^"']+)["'])?\b/),l=c?c[1]||!0:!1;t.push({content:n,src:a,lang:o,scoped:s,module:l,index:i}),i++}return t}function i(e,t){let n=`[data-v-${t}]`,r=``,i=0,o=0,s=0;for(;o<e.length;){let t=e[o];if(t===`{`){if(i===0){let t=e.slice(s,o);r+=a(t,n),r+=`{`}else r+=t;i++,o++,s=o}else t===`}`?(i--,r+=t,o++,s=o):(i>0&&(r+=t),o++)}return s<e.length&&i===0&&(r+=e.slice(s)),r}function a(e,t){let n=e.trim();return n.startsWith(`@`)?e:e.split(`,`).map(e=>{let n=e.trim();if(!n||n.startsWith(`@`))return e;let r=e.match(/^(\s*)/)?.[1]??``;return`${r}${n}${t}`}).join(`,`)}function o(e){let t=e.replace(/<(script|template|style)\b[^>]*>[\s\S]*?<\/\1>/gi,``),n=[],r=/<([a-z][a-z0-9-]*)([^>]*)>([\s\S]*?)<\/\1>/gi,i,a=0;for(;(i=r.exec(t))!==null;){let e=i[1],t=i[2],r=i[3],o=t.match(/\bsrc=["']([^"']+)["']/)?.[1]??null,c=s(t);n.push({type:e,content:r,src:o,attrs:c,index:a}),a++}return n}function s(e){let t={},n=/\b([a-z][a-z0-9-]*)(?:=["']([^"']*)["'])?/gi,r;for(;(r=n.exec(e))!==null;)t[r[1]]=r[2]??!0;return t}function c(e){let t=e.match(/<script([^>]*)>/i),n=e.match(/<template([^>]*)>/i),r=t?.[1]?.match(/\bsrc=["']([^"']+)["']/)?.[1]??null,i=n?.[1]?.match(/\bsrc=["']([^"']+)["']/)?.[1]??null;return{scriptSrc:r,templateSrc:i}}function l(e,t,n){let r=e;return t!==null&&(r=r.replace(/(<script)([^>]*)\bsrc=["'][^"']+["']([^>]*>)[\s\S]*?(<\/script>)/i,(e,n,r,i,a)=>{let o=(r+i).replace(/\bsrc=["'][^"']+["']\s*/g,``);return`${n}${o}\n${t}\n${a}`})),n!==null&&(r=r.replace(/(<template)([^>]*)\bsrc=["'][^"']+["']([^>]*>)[\s\S]*?(<\/template>)/i,(e,t,r,i,a)=>{let o=(r+i).replace(/\bsrc=["'][^"']+["']\s*/g,``);return`${t}${o}\n${n}\n${a}`})),r}function u(e){return{log:(...t)=>e&&console.log(`[vize:rspack]`,...t),info:(...e)=>console.log(`[vize:rspack]`,...e),warn:(...e)=>console.warn(`[vize:rspack]`,...e),error:(...e)=>console.error(`[vize:rspack]`,...e)}}function d(e,t,n){if(!t)return n;let r=e.replace(/\\/g,`/`),i=Array.isArray(t)?t:[t];return i.some(t=>typeof t==`string`?r.includes(t)||e.includes(t):t.test(r))}export{i as addScopeToCssFallback,u as createLogger,o as extractCustomBlocks,c as extractSrcInfo,r as extractStyleBlocks,n as generateScopeId,l as inlineSrcBlocks,d as matchesPattern};

package/package.json

@@ -0,0 +1,70 @@
+{
+  "name": "@vizejs/rspack-plugin",
+  "version": "0.22.0",
+  "description": "High-performance Rspack plugin for Vue SFC compilation powered by Vize",
+  "publishConfig": {
+    "access": "public"
+  },
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    },
+    "./loader": {
+      "types": "./dist/loader/index.d.ts",
+      "import": "./dist/loader/index.js",
+      "default": "./dist/loader/index.js"
+    },
+    "./style-loader": {
+      "types": "./dist/loader/style-loader.d.ts",
+      "import": "./dist/loader/style-loader.js",
+      "default": "./dist/loader/style-loader.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "keywords": [
+    "rspack",
+    "vue",
+    "plugin",
+    "loader",
+    "sfc",
+    "compiler",
+    "native",
+    "fast"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/ubugeeei/vize",
+    "directory": "npm/rspack-vize-plugin"
+  },
+  "license": "MIT",
+  "dependencies": {
+    "@vizejs/native": "0.24.0"
+  },
+  "peerDependencies": {
+    "@rspack/core": ">=1.0.0"
+  },
+  "devDependencies": {
+    "@rspack/core": "^1.7.7",
+    "@types/node": "^22.0.0",
+    "tsdown": "^0.9.0",
+    "tsx": "^4.21.0",
+    "typescript": "~5.6.0"
+  },
+  "scripts": {
+    "build": "tsdown",
+    "dev": "tsdown --watch",
+    "lint": "oxlint --deny-warnings --type-aware --tsconfig tsconfig.json",
+    "lint:fix": "oxlint --type-aware --tsconfig tsconfig.json --fix",
+    "fmt": "oxfmt --write src tsdown.config.ts",
+    "fmt:check": "oxfmt src tsdown.config.ts",
+    "test": "pnpm build && node --import tsx --test src/*.test.ts src/**/*.test.ts",
+    "test:update": "pnpm build && node --import tsx --test --test-update-snapshots src/*.test.ts src/**/*.test.ts"
+  }
+}