perf: create zod schema on demand

packages/rspack/src/builtin-plugin/IgnorePlugin.ts

@@ -5,6 +5,7 @@ import {
 import { z } from "zod";
 
 import { anyFunction } from "../config/utils";
+import { memoize } from "../util/memoize";
 import { validate } from "../util/validate";
 import { create } from "./base";
 
@@ -21,20 +22,23 @@ export type IgnorePluginOptions =
 			checkResource: NonNullable<RawIgnorePluginOptions["checkResource"]>;
 	  };
 
-const IgnorePluginOptions = z.union([
-	z.object({
-		contextRegExp: z.instanceof(RegExp).optional(),
-		resourceRegExp: z.instanceof(RegExp)
-	}),
-	z.object({
-		checkResource: anyFunction
-	})
-]) satisfies z.ZodType<IgnorePluginOptions>;
+const getIgnorePluginOptionsSchema = memoize(
+	() =>
+		z.union([
+			z.object({
+				contextRegExp: z.instanceof(RegExp).optional(),
+				resourceRegExp: z.instanceof(RegExp)
+			}),
+			z.object({
+				checkResource: anyFunction
+			})
+		]) satisfies z.ZodType<IgnorePluginOptions>
+);
 
 export const IgnorePlugin = create(
 	BuiltinPluginName.IgnorePlugin,
 	(options: IgnorePluginOptions): RawIgnorePluginOptions => {
-		validate(options, IgnorePluginOptions);
+		validate(options, getIgnorePluginOptionsSchema());
 
 		return options;
 	}

packages/rspack/src/builtin-plugin/RsdoctorPlugin.ts

@@ -29,6 +29,7 @@ import { z } from "zod";
 import { type Compilation, checkCompilation } from "../Compilation";
 import type { Compiler } from "../Compiler";
 import type { CreatePartialRegisters } from "../taps/types";
+import { memoize } from "../util/memoize";
 import { validate } from "../util/validate";
 import { create } from "./base";
 
@@ -62,14 +63,18 @@ export type RsdoctorPluginOptions = {
 	moduleGraphFeatures?: boolean | Array<"graph" | "ids" | "sources">;
 	chunkGraphFeatures?: boolean | Array<"graph" | "assets">;
 };
-const rsdoctorPluginSchema = z.strictObject({
-	moduleGraphFeatures: z
-		.union([z.boolean(), z.array(z.enum(["graph", "ids", "sources"]))])
-		.optional(),
-	chunkGraphFeatures: z
-		.union([z.boolean(), z.array(z.enum(["graph", "assets"]))])
-		.optional()
-}) satisfies z.ZodType<RsdoctorPluginOptions>;
+
+const getRsdoctorPluginSchema = memoize(
+	() =>
+		z.strictObject({
+			moduleGraphFeatures: z
+				.union([z.boolean(), z.array(z.enum(["graph", "ids", "sources"]))])
+				.optional(),
+			chunkGraphFeatures: z
+				.union([z.boolean(), z.array(z.enum(["graph", "assets"]))])
+				.optional()
+		}) satisfies z.ZodType<RsdoctorPluginOptions>
+);
 
 const RsdoctorPluginImpl = create(
 	BuiltinPluginName.RsdoctorPlugin,
@@ -80,7 +85,7 @@ const RsdoctorPluginImpl = create(
 			chunkGraphFeatures: true
 		}
 	): RawRsdoctorPluginOptions {
-		validate(c, rsdoctorPluginSchema);
+		validate(c, getRsdoctorPluginSchema());
 		return {
 			moduleGraphFeatures: c.moduleGraphFeatures ?? true,
 			chunkGraphFeatures: c.chunkGraphFeatures ?? true

packages/rspack/src/builtin-plugin/SubresourceIntegrityPlugin.ts

@@ -12,6 +12,7 @@ import { z } from "zod";
 import type { Compilation } from "../Compilation";
 import type { Compiler } from "../Compiler";
 import type { CrossOriginLoading } from "../config/types";
+import { memoize } from "../util/memoize";
 import { validate } from "../util/validate";
 import { create } from "./base";
 
@@ -67,15 +68,18 @@ export type SubresourceIntegrityPluginOptions = {
 	enabled?: "auto" | boolean;
 };
 
-const hashFunctionSchema = z.enum(["sha256", "sha384", "sha512"]);
-const pluginOptionsSchema = z.object({
-	hashFuncNames: z
-		.tuple([hashFunctionSchema])
-		.rest(hashFunctionSchema)
-		.optional(),
-	htmlPlugin: z.string().or(z.literal(false)).optional(),
-	enabled: z.literal("auto").or(z.boolean()).optional()
-}) satisfies z.ZodType<SubresourceIntegrityPluginOptions>;
+const getPluginOptionsSchema = memoize(() => {
+	const hashFunctionSchema = z.enum(["sha256", "sha384", "sha512"]);
+
+	return z.object({
+		hashFuncNames: z
+			.tuple([hashFunctionSchema])
+			.rest(hashFunctionSchema)
+			.optional(),
+		htmlPlugin: z.string().or(z.literal(false)).optional(),
+		enabled: z.literal("auto").or(z.boolean()).optional()
+	}) satisfies z.ZodType<SubresourceIntegrityPluginOptions>;
+});
 
 export type NativeSubresourceIntegrityPluginOptions = Omit<
 	RawSubresourceIntegrityPluginOptions,
@@ -322,7 +326,7 @@ export class SubresourceIntegrityPlugin extends NativeSubresourceIntegrityPlugin
 function validateSubresourceIntegrityPluginOptions(
 	options: SubresourceIntegrityPluginOptions
 ) {
-	validate(options, pluginOptionsSchema);
+	validate(options, getPluginOptionsSchema());
 }
 
 function isErrorWithCode<T extends Error>(obj: T): boolean {

packages/rspack/src/builtin-plugin/html-plugin/options.ts

@@ -1,6 +1,7 @@
 import { z } from "zod";
 import { Compilation } from "../../Compilation";
 import { anyFunction } from "../../config/utils";
+import { memoize } from "../../util/memoize";
 import { validate } from "../../util/validate";
 
 const compilationOptionsMap: WeakMap<Compilation, HtmlRspackPluginOptions> =
@@ -113,53 +114,56 @@ export type HtmlRspackPluginOptions = {
 	[key: string]: any;
 };
 
-const pluginOptionsSchema = z.object({
-	filename: z.string().or(anyFunction).optional(),
-	template: z
-		.string()
-		.refine(
-			val => !val.includes("!"),
-			() => ({
-				message:
-					"HtmlRspackPlugin does not support template path with loader yet"
-			})
-		)
-		.optional(),
-	templateContent: z.string().or(templateRenderFunction).optional(),
-	templateParameters: z
-		.record(z.string(), z.string())
-		.or(z.boolean())
-		.or(templateParamFunction)
-		.optional(),
-	inject: z.enum(["head", "body"]).or(z.boolean()).optional(),
-	publicPath: z.string().optional(),
-	base: z
-		.string()
-		.or(
-			z.strictObject({
-				href: z.string().optional(),
-				target: z.enum(["_self", "_blank", "_parent", "_top"]).optional()
-			})
-		)
-		.optional(),
-	scriptLoading: z
-		.enum(["blocking", "defer", "module", "systemjs-module"])
-		.optional(),
-	chunks: z.string().array().optional(),
-	excludeChunks: z.string().array().optional(),
-	chunksSortMode: z.enum(["auto", "manual"]).optional(),
-	sri: z.enum(["sha256", "sha384", "sha512"]).optional(),
-	minify: z.boolean().optional(),
-	title: z.string().optional(),
-	favicon: z.string().optional(),
-	meta: z
-		.record(z.string(), z.string().or(z.record(z.string(), z.string())))
-		.optional(),
-	hash: z.boolean().optional()
-}) satisfies z.ZodType<HtmlRspackPluginOptions>;
+const getPluginOptionsSchema = memoize(
+	() =>
+		z.object({
+			filename: z.string().or(anyFunction).optional(),
+			template: z
+				.string()
+				.refine(
+					val => !val.includes("!"),
+					() => ({
+						message:
+							"HtmlRspackPlugin does not support template path with loader yet"
+					})
+				)
+				.optional(),
+			templateContent: z.string().or(templateRenderFunction).optional(),
+			templateParameters: z
+				.record(z.string(), z.string())
+				.or(z.boolean())
+				.or(templateParamFunction)
+				.optional(),
+			inject: z.enum(["head", "body"]).or(z.boolean()).optional(),
+			publicPath: z.string().optional(),
+			base: z
+				.string()
+				.or(
+					z.strictObject({
+						href: z.string().optional(),
+						target: z.enum(["_self", "_blank", "_parent", "_top"]).optional()
+					})
+				)
+				.optional(),
+			scriptLoading: z
+				.enum(["blocking", "defer", "module", "systemjs-module"])
+				.optional(),
+			chunks: z.string().array().optional(),
+			excludeChunks: z.string().array().optional(),
+			chunksSortMode: z.enum(["auto", "manual"]).optional(),
+			sri: z.enum(["sha256", "sha384", "sha512"]).optional(),
+			minify: z.boolean().optional(),
+			title: z.string().optional(),
+			favicon: z.string().optional(),
+			meta: z
+				.record(z.string(), z.string().or(z.record(z.string(), z.string())))
+				.optional(),
+			hash: z.boolean().optional()
+		}) satisfies z.ZodType<HtmlRspackPluginOptions>
+);
 
 export function validateHtmlPluginOptions(options: HtmlRspackPluginOptions) {
-	return validate(options, pluginOptionsSchema);
+	return validate(options, getPluginOptionsSchema());
 }
 
 export const getPluginOptions = (compilation: Compilation, uid: number) => {

packages/rspack/src/config/zod.ts

@@ -1,6 +1,6 @@
 import nodePath from "node:path";
 import { ZodIssueCode, z } from "zod";
-import { ZodSwcLoaderOptions } from "../builtin-loader/swc/types";
+import { getZodSwcLoaderOptionsSchema } from "../builtin-loader/swc/types";
 import { validate } from "../util/validate";
 import type * as t from "./types";
 import { ZodRspackCrossChecker, anyFunction } from "./utils";
@@ -458,15 +458,19 @@ const ruleSetLoaderWithOptions =
 				type: z.strictObject({
 					ident: z.string().optional(),
 					loader: z.literal("builtin:swc-loader"),
-					options: ZodSwcLoaderOptions,
+					options: getZodSwcLoaderOptionsSchema(),
 					parallel: z.boolean().optional()
 				}),
 				issue: (res, _, input) => {
 					try {
-						const message = validate(input.data.options, ZodSwcLoaderOptions, {
-							output: false,
-							strategy: "strict"
-						});
+						const message = validate(
+							input.data.options,
+							getZodSwcLoaderOptionsSchema(),
+							{
+								output: false,
+								strategy: "strict"
+							}
+						);
 						if (message) {
 							return [
 								{
@@ -540,7 +544,7 @@ const extendedBaseRuleSetRule: z.ZodType<t.RuleSetRule> =
 const extendedSwcRuleSetRule: z.ZodType<t.RuleSetRule> = baseRuleSetRule
 	.extend({
 		loader: z.literal("builtin:swc-loader"),
-		options: ZodSwcLoaderOptions
+		options: getZodSwcLoaderOptionsSchema()
 	})
 	.extend({
 		oneOf: z.lazy(() => ruleSetRule.or(falsy).array()).optional(),
@@ -556,10 +560,14 @@ const ruleSetRule = new ZodRspackCrossChecker<t.RuleSetRule>({
 			type: extendedSwcRuleSetRule,
 			issue: (res, _, input) => {
 				try {
-					const message = validate(input.data.options, ZodSwcLoaderOptions, {
-						output: false,
-						strategy: "strict"
-					});
+					const message = validate(
+						input.data.options,
+						getZodSwcLoaderOptionsSchema(),
+						{
+							output: false,
+							strategy: "strict"
+						}
+					);
 					if (message) {
 						return [
 							{

packages/rspack/src/lib/DllPlugin.ts

@@ -13,6 +13,7 @@ import type { Compiler } from "../Compiler";
 import { LibManifestPlugin } from "../builtin-plugin";
 import { DllEntryPlugin } from "../builtin-plugin/DllEntryPlugin";
 import { FlagAllModulesAsUsedPlugin } from "../builtin-plugin/FlagAllModulesAsUsedPlugin";
+import { memoize } from "../util/memoize";
 import { validate } from "../util/validate";
 
 export type DllPluginOptions = {
@@ -48,20 +49,23 @@ export type DllPluginOptions = {
 	type?: string;
 };
 
-const dllPluginOptions = z.object({
-	context: z.string().optional(),
-	entryOnly: z.boolean().optional(),
-	format: z.boolean().optional(),
-	name: z.string().optional(),
-	path: z.string(),
-	type: z.string().optional()
-}) satisfies z.ZodType<DllPluginOptions>;
+const getDllPluginOptionsSchema = memoize(
+	() =>
+		z.object({
+			context: z.string().optional(),
+			entryOnly: z.boolean().optional(),
+			format: z.boolean().optional(),
+			name: z.string().optional(),
+			path: z.string(),
+			type: z.string().optional()
+		}) satisfies z.ZodType<DllPluginOptions>
+);
 
 export class DllPlugin {
 	private options: DllPluginOptions;
 
 	constructor(options: DllPluginOptions) {
-		validate(options, dllPluginOptions);
+		validate(options, getDllPluginOptionsSchema());
 		this.options = {
 			...options,
 			entryOnly: options.entryOnly !== false