@rspack/core 0.1.12 → 0.2.1

package/dist/config/zod/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/config/zod/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAiBxB,wBAAgB,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiC3B"}

package/dist/config/zod/index.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.configSchema = void 0;
+const zod_1 = require("zod");
+const entry_1 = require("./entry");
+const experiments_1 = require("./experiments");
+const externals_1 = require("./externals");
+const externals_type_1 = require("./externals-type");
+const externals_presets_1 = require("./externals-presets");
+const infrastructure_logging_1 = require("./infrastructure-logging");
+const node_1 = require("./node");
+const builtins_1 = require("./builtins");
+const watch_options_1 = require("./watch-options");
+const target_1 = require("./target");
+const stats_1 = require("./stats");
+const snapshot_1 = require("./snapshot");
+const output_1 = require("./output");
+const devtool_1 = require("./devtool");
+const optimization_1 = require("./optimization");
+function configSchema() {
+    return zod_1.z
+        .object({
+        target: (0, target_1.target)().optional(),
+        mode: zod_1.z.enum(["development", "production", "none"]).optional(),
+        entry: (0, entry_1.entry)().optional(),
+        experiments: (0, experiments_1.experiments)().optional(),
+        externals: (0, externals_1.externals)().optional(),
+        externalsType: (0, externals_type_1.externalsType)().optional(),
+        externalsPresets: (0, externals_presets_1.externalsPresets)().optional(),
+        infrastructureLogging: (0, infrastructure_logging_1.infrastructureLogging)().optional(),
+        cache: zod_1.z.boolean().optional(),
+        context: zod_1.z.string().optional(),
+        dependencies: zod_1.z.string().array().optional(),
+        devtool: (0, devtool_1.devtool)().optional(),
+        node: (0, node_1.node)().optional(),
+        ignoreWarnings: zod_1.z.instanceof(RegExp).or(zod_1.z.function()).array().optional(),
+        watchOptions: (0, watch_options_1.watchOptions)().optional(),
+        watch: zod_1.z.boolean().optional(),
+        stats: (0, stats_1.stats)().optional(),
+        snapshot: (0, snapshot_1.snapshot)().optional(),
+        optimization: (0, optimization_1.optimization)().optional(),
+        // TODO(hyf0): what's the usage of this?
+        name: zod_1.z.string().optional(),
+        // TODO
+        devServer: zod_1.z.object({}).optional(),
+        output: (0, output_1.output)().optional(),
+        resolve: zod_1.z.any().optional(),
+        plugins: zod_1.z.any().optional(),
+        builtins: (0, builtins_1.builtins)().optional(),
+        module: zod_1.z.any().optional()
+    })
+        .strict();
+}
+exports.configSchema = configSchema;
+//# sourceMappingURL=index.js.map

package/dist/config/zod/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/config/zod/index.ts"],"names":[],"mappings":";;;AAAA,6BAAwB;AACxB,mCAAgC;AAChC,+CAA4C;AAC5C,2CAAwC;AACxC,qDAAiD;AACjD,2DAAuD;AACvD,qEAAiE;AACjE,iCAA8B;AAC9B,yCAAsC;AACtC,mDAA+C;AAC/C,qCAAkC;AAClC,mCAAgC;AAChC,yCAAsC;AACtC,qCAAkC;AAClC,uCAAoC;AACpC,iDAA8C;AAE9C,SAAgB,YAAY;IAC3B,OAAO,OAAC;SACN,MAAM,CAAC;QACP,MAAM,EAAE,IAAA,eAAM,GAAE,CAAC,QAAQ,EAAE;QAC3B,IAAI,EAAE,OAAC,CAAC,IAAI,CAAC,CAAC,aAAa,EAAE,YAAY,EAAE,MAAM,CAAC,CAAC,CAAC,QAAQ,EAAE;QAC9D,KAAK,EAAE,IAAA,aAAK,GAAE,CAAC,QAAQ,EAAE;QACzB,WAAW,EAAE,IAAA,yBAAW,GAAE,CAAC,QAAQ,EAAE;QACrC,SAAS,EAAE,IAAA,qBAAS,GAAE,CAAC,QAAQ,EAAE;QACjC,aAAa,EAAE,IAAA,8BAAa,GAAE,CAAC,QAAQ,EAAE;QACzC,gBAAgB,EAAE,IAAA,oCAAgB,GAAE,CAAC,QAAQ,EAAE;QAC/C,qBAAqB,EAAE,IAAA,8CAAqB,GAAE,CAAC,QAAQ,EAAE;QACzD,KAAK,EAAE,OAAC,CAAC,OAAO,EAAE,CAAC,QAAQ,EAAE;QAC7B,OAAO,EAAE,OAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;QAC9B,YAAY,EAAE,OAAC,CAAC,MAAM,EAAE,CAAC,KAAK,EAAE,CAAC,QAAQ,EAAE;QAC3C,OAAO,EAAE,IAAA,iBAAO,GAAE,CAAC,QAAQ,EAAE;QAC7B,IAAI,EAAE,IAAA,WAAI,GAAE,CAAC,QAAQ,EAAE;QACvB,cAAc,EAAE,OAAC,CAAC,UAAU,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,OAAC,CAAC,QAAQ,EAAE,CAAC,CAAC,KAAK,EAAE,CAAC,QAAQ,EAAE;QACxE,YAAY,EAAE,IAAA,4BAAY,GAAE,CAAC,QAAQ,EAAE;QACvC,KAAK,EAAE,OAAC,CAAC,OAAO,EAAE,CAAC,QAAQ,EAAE;QAC7B,KAAK,EAAE,IAAA,aAAK,GAAE,CAAC,QAAQ,EAAE;QACzB,QAAQ,EAAE,IAAA,mBAAQ,GAAE,CAAC,QAAQ,EAAE;QAC/B,YAAY,EAAE,IAAA,2BAAY,GAAE,CAAC,QAAQ,EAAE;QACvC,wCAAwC;QACxC,IAAI,EAAE,OAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;QAC3B,OAAO;QACP,SAAS,EAAE,OAAC,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC,QAAQ,EAAE;QAClC,MAAM,EAAE,IAAA,eAAM,GAAE,CAAC,QAAQ,EAAE;QAC3B,OAAO,EAAE,OAAC,CAAC,GAAG,EAAE,CAAC,QAAQ,EAAE;QAC3B,OAAO,EAAE,OAAC,CAAC,GAAG,EAAE,CAAC,QAAQ,EAAE;QAC3B,QAAQ,EAAE,IAAA,mBAAQ,GAAE,CAAC,QAAQ,EAAE;QAC/B,MAAM,EAAE,OAAC,CAAC,GAAG,EAAE,CAAC,QAAQ,EAAE;KAC1B,CAAC;SACD,MAAM,EAAE,CAAC;AACZ,CAAC;AAjCD,oCAiCC"}

package/dist/config/zod/infrastructure-logging.d.ts

@@ -0,0 +1,24 @@
+import { z } from "zod";
+export declare function infrastructureLogging(): z.ZodObject<{
+    appendOnly: z.ZodOptional<z.ZodBoolean>;
+    colors: z.ZodOptional<z.ZodBoolean>;
+    console: z.ZodOptional<z.ZodBoolean>;
+    debug: z.ZodOptional<z.ZodUnion<[z.ZodBoolean, z.ZodAny]>>;
+    level: z.ZodOptional<z.ZodEnum<["none", "error", "warn", "info", "log", "verbose"]>>;
+    stream: z.ZodOptional<z.ZodUnion<[z.ZodBoolean, z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>]>>;
+}, "strict", z.ZodTypeAny, {
+    appendOnly?: boolean | undefined;
+    colors?: boolean | undefined;
+    console?: boolean | undefined;
+    debug?: any;
+    level?: "error" | "none" | "warn" | "info" | "log" | "verbose" | undefined;
+    stream?: boolean | {} | undefined;
+}, {
+    appendOnly?: boolean | undefined;
+    colors?: boolean | undefined;
+    console?: boolean | undefined;
+    debug?: any;
+    level?: "error" | "none" | "warn" | "info" | "log" | "verbose" | undefined;
+    stream?: boolean | {} | undefined;
+}>;
+//# sourceMappingURL=infrastructure-logging.d.ts.map

package/dist/config/zod/infrastructure-logging.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"infrastructure-logging.d.ts","sourceRoot":"","sources":["../../../src/config/zod/infrastructure-logging.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,wBAAgB,qBAAqB;;;;;;;;;;;;;;;;;;;;;GAapC"}

package/dist/config/zod/infrastructure-logging.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.infrastructureLogging = void 0;
+const zod_1 = require("zod");
+function infrastructureLogging() {
+    return zod_1.z
+        .object({
+        appendOnly: zod_1.z.boolean().optional(),
+        colors: zod_1.z.boolean().optional(),
+        console: zod_1.z.boolean().optional(),
+        debug: zod_1.z.boolean().or(zod_1.z.any()).optional(),
+        level: zod_1.z
+            .enum(["none", "error", "warn", "info", "log", "verbose"])
+            .optional(),
+        stream: zod_1.z.boolean().or(zod_1.z.object({})).optional()
+    })
+        .strict();
+}
+exports.infrastructureLogging = infrastructureLogging;
+//# sourceMappingURL=infrastructure-logging.js.map

package/dist/config/zod/infrastructure-logging.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"infrastructure-logging.js","sourceRoot":"","sources":["../../../src/config/zod/infrastructure-logging.ts"],"names":[],"mappings":";;;AAAA,6BAAwB;AAExB,SAAgB,qBAAqB;IACpC,OAAO,OAAC;SACN,MAAM,CAAC;QACP,UAAU,EAAE,OAAC,CAAC,OAAO,EAAE,CAAC,QAAQ,EAAE;QAClC,MAAM,EAAE,OAAC,CAAC,OAAO,EAAE,CAAC,QAAQ,EAAE;QAC9B,OAAO,EAAE,OAAC,CAAC,OAAO,EAAE,CAAC,QAAQ,EAAE;QAC/B,KAAK,EAAE,OAAC,CAAC,OAAO,EAAE,CAAC,EAAE,CAAC,OAAC,CAAC,GAAG,EAAE,CAAC,CAAC,QAAQ,EAAE;QACzC,KAAK,EAAE,OAAC;aACN,IAAI,CAAC,CAAC,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,SAAS,CAAC,CAAC;aACzD,QAAQ,EAAE;QACZ,MAAM,EAAE,OAAC,CAAC,OAAO,EAAE,CAAC,EAAE,CAAC,OAAC,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC,CAAC,QAAQ,EAAE;KAC/C,CAAC;SACD,MAAM,EAAE,CAAC;AACZ,CAAC;AAbD,sDAaC"}

package/dist/config/zod/module.d.ts

@@ -0,0 +1 @@
+//# sourceMappingURL=module.d.ts.map

package/dist/config/zod/module.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"module.d.ts","sourceRoot":"","sources":["../../../src/config/zod/module.ts"],"names":[],"mappings":""}

package/dist/config/zod/module.js

@@ -0,0 +1,2 @@
+"use strict";
+//# sourceMappingURL=module.js.map

package/dist/config/zod/module.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"module.js","sourceRoot":"","sources":["../../../src/config/zod/module.ts"],"names":[],"mappings":""}

package/dist/config/zod/node.d.ts

@@ -0,0 +1,15 @@
+import { z } from "zod";
+export declare function node(): z.ZodUnion<[z.ZodLiteral<false>, z.ZodObject<{
+    __dirname: z.ZodOptional<z.ZodUnion<[z.ZodBoolean, z.ZodEnum<["warn-mock", "mock", "eval-only"]>]>>;
+    __filename: z.ZodOptional<z.ZodUnion<[z.ZodBoolean, z.ZodEnum<["warn-mock", "mock", "eval-only"]>]>>;
+    global: z.ZodOptional<z.ZodUnion<[z.ZodBoolean, z.ZodEnum<["warn"]>]>>;
+}, "strict", z.ZodTypeAny, {
+    __dirname?: boolean | "warn-mock" | "mock" | "eval-only" | undefined;
+    __filename?: boolean | "warn-mock" | "mock" | "eval-only" | undefined;
+    global?: boolean | "warn" | undefined;
+}, {
+    __dirname?: boolean | "warn-mock" | "mock" | "eval-only" | undefined;
+    __filename?: boolean | "warn-mock" | "mock" | "eval-only" | undefined;
+    global?: boolean | "warn" | undefined;
+}>]>;
+//# sourceMappingURL=node.d.ts.map

package/dist/config/zod/node.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"node.d.ts","sourceRoot":"","sources":["../../../src/config/zod/node.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,wBAAgB,IAAI;;;;;;;;;;;;KAmBnB"}

package/dist/config/zod/node.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.node = void 0;
+const zod_1 = require("zod");
+function node() {
+    return zod_1.z.literal(false).or(zod_1.z
+        .object({
+        __dirname: zod_1.z
+            .boolean()
+            .or(zod_1.z.enum(["warn-mock", "mock", "eval-only"]))
+            .optional(),
+        __filename: zod_1.z
+            .boolean()
+            .or(zod_1.z.enum(["warn-mock", "mock", "eval-only"]))
+            .optional(),
+        global: zod_1.z
+            .boolean()
+            .or(zod_1.z.enum(["warn"]))
+            .optional()
+    })
+        .strict());
+}
+exports.node = node;
+//# sourceMappingURL=node.js.map

package/dist/config/zod/node.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"node.js","sourceRoot":"","sources":["../../../src/config/zod/node.ts"],"names":[],"mappings":";;;AAAA,6BAAwB;AAExB,SAAgB,IAAI;IACnB,OAAO,OAAC,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,EAAE,CACzB,OAAC;SACC,MAAM,CAAC;QACP,SAAS,EAAE,OAAC;aACV,OAAO,EAAE;aACT,EAAE,CAAC,OAAC,CAAC,IAAI,CAAC,CAAC,WAAW,EAAE,MAAM,EAAE,WAAW,CAAC,CAAC,CAAC;aAC9C,QAAQ,EAAE;QACZ,UAAU,EAAE,OAAC;aACX,OAAO,EAAE;aACT,EAAE,CAAC,OAAC,CAAC,IAAI,CAAC,CAAC,WAAW,EAAE,MAAM,EAAE,WAAW,CAAC,CAAC,CAAC;aAC9C,QAAQ,EAAE;QACZ,MAAM,EAAE,OAAC;aACP,OAAO,EAAE;aACT,EAAE,CAAC,OAAC,CAAC,IAAI,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC;aACpB,QAAQ,EAAE;KACZ,CAAC;SACD,MAAM,EAAE,CACV,CAAC;AACH,CAAC;AAnBD,oBAmBC"}

package/dist/config/zod/optimization/index.d.ts

@@ -0,0 +1,241 @@
+import { z } from "zod";
+export declare function optimization(): z.ZodObject<{
+    moduleIds: z.ZodOptional<z.ZodEnum<["named", "deterministic"]>>;
+    minimize: z.ZodOptional<z.ZodBoolean>;
+    minimizer: z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodLiteral<"...">, z.ZodObject<{
+        apply: z.ZodFunction<z.ZodTuple<[], z.ZodUnknown>, z.ZodUnknown>;
+    }, "strip", z.ZodTypeAny, {
+        apply: (...args: unknown[]) => unknown;
+    }, {
+        apply: (...args: unknown[]) => unknown;
+    }>]>, "many">>;
+    splitChunks: z.ZodOptional<z.ZodUnion<[z.ZodLiteral<false>, z.ZodObject<{
+        chunks: z.ZodOptional<z.ZodEnum<["initial", "async", "all"]>>;
+        minChunks: z.ZodOptional<z.ZodNumber>;
+        name: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodLiteral<false>]>>;
+        minSize: z.ZodOptional<z.ZodNumber>;
+        maxSize: z.ZodOptional<z.ZodNumber>;
+        maxAsyncSize: z.ZodOptional<z.ZodNumber>;
+        maxInitialSize: z.ZodOptional<z.ZodNumber>;
+        cacheGroups: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodLiteral<false>, z.ZodObject<{
+            chunks: z.ZodOptional<z.ZodEnum<["initial", "async", "all"]>>;
+            minChunks: z.ZodOptional<z.ZodNumber>;
+            name: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodLiteral<false>]>>;
+            minSize: z.ZodOptional<z.ZodNumber>;
+            maxSize: z.ZodOptional<z.ZodNumber>;
+            maxAsyncSize: z.ZodOptional<z.ZodNumber>;
+            maxInitialSize: z.ZodOptional<z.ZodNumber>;
+            test: z.ZodOptional<z.ZodType<RegExp, z.ZodTypeDef, RegExp>>;
+            priority: z.ZodOptional<z.ZodNumber>;
+            enforce: z.ZodOptional<z.ZodBoolean>;
+            reuseExistingChunk: z.ZodOptional<z.ZodBoolean>;
+        }, "strict", z.ZodTypeAny, {
+            chunks?: "async" | "all" | "initial" | undefined;
+            minChunks?: number | undefined;
+            name?: string | false | undefined;
+            minSize?: number | undefined;
+            maxSize?: number | undefined;
+            maxAsyncSize?: number | undefined;
+            maxInitialSize?: number | undefined;
+            test?: RegExp | undefined;
+            priority?: number | undefined;
+            enforce?: boolean | undefined;
+            reuseExistingChunk?: boolean | undefined;
+        }, {
+            chunks?: "async" | "all" | "initial" | undefined;
+            minChunks?: number | undefined;
+            name?: string | false | undefined;
+            minSize?: number | undefined;
+            maxSize?: number | undefined;
+            maxAsyncSize?: number | undefined;
+            maxInitialSize?: number | undefined;
+            test?: RegExp | undefined;
+            priority?: number | undefined;
+            enforce?: boolean | undefined;
+            reuseExistingChunk?: boolean | undefined;
+        }>]>>>;
+        maxAsyncRequests: z.ZodOptional<z.ZodNumber>;
+        maxInitialRequests: z.ZodOptional<z.ZodNumber>;
+        fallbackCacheGroup: z.ZodOptional<z.ZodObject<{
+            chunks: z.ZodOptional<z.ZodEnum<["initial", "async", "all"]>>;
+            minSize: z.ZodOptional<z.ZodNumber>;
+            maxSize: z.ZodOptional<z.ZodNumber>;
+            maxAsyncSize: z.ZodOptional<z.ZodNumber>;
+            maxInitialSize: z.ZodOptional<z.ZodNumber>;
+        }, "strict", z.ZodTypeAny, {
+            chunks?: "async" | "all" | "initial" | undefined;
+            minSize?: number | undefined;
+            maxSize?: number | undefined;
+            maxAsyncSize?: number | undefined;
+            maxInitialSize?: number | undefined;
+        }, {
+            chunks?: "async" | "all" | "initial" | undefined;
+            minSize?: number | undefined;
+            maxSize?: number | undefined;
+            maxAsyncSize?: number | undefined;
+            maxInitialSize?: number | undefined;
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        chunks?: "async" | "all" | "initial" | undefined;
+        minChunks?: number | undefined;
+        name?: string | false | undefined;
+        minSize?: number | undefined;
+        maxSize?: number | undefined;
+        maxAsyncSize?: number | undefined;
+        maxInitialSize?: number | undefined;
+        cacheGroups?: Record<string, false | {
+            chunks?: "async" | "all" | "initial" | undefined;
+            minChunks?: number | undefined;
+            name?: string | false | undefined;
+            minSize?: number | undefined;
+            maxSize?: number | undefined;
+            maxAsyncSize?: number | undefined;
+            maxInitialSize?: number | undefined;
+            test?: RegExp | undefined;
+            priority?: number | undefined;
+            enforce?: boolean | undefined;
+            reuseExistingChunk?: boolean | undefined;
+        }> | undefined;
+        maxAsyncRequests?: number | undefined;
+        maxInitialRequests?: number | undefined;
+        fallbackCacheGroup?: {
+            chunks?: "async" | "all" | "initial" | undefined;
+            minSize?: number | undefined;
+            maxSize?: number | undefined;
+            maxAsyncSize?: number | undefined;
+            maxInitialSize?: number | undefined;
+        } | undefined;
+    }, {
+        chunks?: "async" | "all" | "initial" | undefined;
+        minChunks?: number | undefined;
+        name?: string | false | undefined;
+        minSize?: number | undefined;
+        maxSize?: number | undefined;
+        maxAsyncSize?: number | undefined;
+        maxInitialSize?: number | undefined;
+        cacheGroups?: Record<string, false | {
+            chunks?: "async" | "all" | "initial" | undefined;
+            minChunks?: number | undefined;
+            name?: string | false | undefined;
+            minSize?: number | undefined;
+            maxSize?: number | undefined;
+            maxAsyncSize?: number | undefined;
+            maxInitialSize?: number | undefined;
+            test?: RegExp | undefined;
+            priority?: number | undefined;
+            enforce?: boolean | undefined;
+            reuseExistingChunk?: boolean | undefined;
+        }> | undefined;
+        maxAsyncRequests?: number | undefined;
+        maxInitialRequests?: number | undefined;
+        fallbackCacheGroup?: {
+            chunks?: "async" | "all" | "initial" | undefined;
+            minSize?: number | undefined;
+            maxSize?: number | undefined;
+            maxAsyncSize?: number | undefined;
+            maxInitialSize?: number | undefined;
+        } | undefined;
+    }>]>>;
+    runtimeChunk: z.ZodOptional<z.ZodUnion<[z.ZodUnion<[z.ZodEnum<["single", "multiple"]>, z.ZodBoolean]>, z.ZodObject<{
+        name: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodFunction<z.ZodTuple<[], z.ZodUnknown>, z.ZodUnion<[z.ZodString, z.ZodUndefined]>>]>>;
+    }, "strict", z.ZodTypeAny, {
+        name?: string | ((...args: unknown[]) => string | undefined) | undefined;
+    }, {
+        name?: string | ((...args: unknown[]) => string | undefined) | undefined;
+    }>]>>;
+    removeAvailableModules: z.ZodOptional<z.ZodBoolean>;
+    removeEmptyChunks: z.ZodOptional<z.ZodBoolean>;
+    realContentHash: z.ZodOptional<z.ZodBoolean>;
+    sideEffects: z.ZodOptional<z.ZodUnion<[z.ZodEnum<["flag"]>, z.ZodBoolean]>>;
+}, "strict", z.ZodTypeAny, {
+    moduleIds?: "named" | "deterministic" | undefined;
+    minimize?: boolean | undefined;
+    minimizer?: ("..." | {
+        apply: (...args: unknown[]) => unknown;
+    })[] | undefined;
+    splitChunks?: false | {
+        chunks?: "async" | "all" | "initial" | undefined;
+        minChunks?: number | undefined;
+        name?: string | false | undefined;
+        minSize?: number | undefined;
+        maxSize?: number | undefined;
+        maxAsyncSize?: number | undefined;
+        maxInitialSize?: number | undefined;
+        cacheGroups?: Record<string, false | {
+            chunks?: "async" | "all" | "initial" | undefined;
+            minChunks?: number | undefined;
+            name?: string | false | undefined;
+            minSize?: number | undefined;
+            maxSize?: number | undefined;
+            maxAsyncSize?: number | undefined;
+            maxInitialSize?: number | undefined;
+            test?: RegExp | undefined;
+            priority?: number | undefined;
+            enforce?: boolean | undefined;
+            reuseExistingChunk?: boolean | undefined;
+        }> | undefined;
+        maxAsyncRequests?: number | undefined;
+        maxInitialRequests?: number | undefined;
+        fallbackCacheGroup?: {
+            chunks?: "async" | "all" | "initial" | undefined;
+            minSize?: number | undefined;
+            maxSize?: number | undefined;
+            maxAsyncSize?: number | undefined;
+            maxInitialSize?: number | undefined;
+        } | undefined;
+    } | undefined;
+    runtimeChunk?: boolean | "single" | "multiple" | {
+        name?: string | ((...args: unknown[]) => string | undefined) | undefined;
+    } | undefined;
+    removeAvailableModules?: boolean | undefined;
+    removeEmptyChunks?: boolean | undefined;
+    realContentHash?: boolean | undefined;
+    sideEffects?: boolean | "flag" | undefined;
+}, {
+    moduleIds?: "named" | "deterministic" | undefined;
+    minimize?: boolean | undefined;
+    minimizer?: ("..." | {
+        apply: (...args: unknown[]) => unknown;
+    })[] | undefined;
+    splitChunks?: false | {
+        chunks?: "async" | "all" | "initial" | undefined;
+        minChunks?: number | undefined;
+        name?: string | false | undefined;
+        minSize?: number | undefined;
+        maxSize?: number | undefined;
+        maxAsyncSize?: number | undefined;
+        maxInitialSize?: number | undefined;
+        cacheGroups?: Record<string, false | {
+            chunks?: "async" | "all" | "initial" | undefined;
+            minChunks?: number | undefined;
+            name?: string | false | undefined;
+            minSize?: number | undefined;
+            maxSize?: number | undefined;
+            maxAsyncSize?: number | undefined;
+            maxInitialSize?: number | undefined;
+            test?: RegExp | undefined;
+            priority?: number | undefined;
+            enforce?: boolean | undefined;
+            reuseExistingChunk?: boolean | undefined;
+        }> | undefined;
+        maxAsyncRequests?: number | undefined;
+        maxInitialRequests?: number | undefined;
+        fallbackCacheGroup?: {
+            chunks?: "async" | "all" | "initial" | undefined;
+            minSize?: number | undefined;
+            maxSize?: number | undefined;
+            maxAsyncSize?: number | undefined;
+            maxInitialSize?: number | undefined;
+        } | undefined;
+    } | undefined;
+    runtimeChunk?: boolean | "single" | "multiple" | {
+        name?: string | ((...args: unknown[]) => string | undefined) | undefined;
+    } | undefined;
+    removeAvailableModules?: boolean | undefined;
+    removeEmptyChunks?: boolean | undefined;
+    realContentHash?: boolean | undefined;
+    sideEffects?: boolean | "flag" | undefined;
+}>;
+export type OptimizationConfig = z.TypeOf<ReturnType<typeof optimization>>;
+export type OptimizationRuntimeChunkConfig = NonNullable<OptimizationConfig["runtimeChunk"]>;
+//# sourceMappingURL=index.d.ts.map

package/dist/config/zod/optimization/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/config/zod/optimization/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAQxB,wBAAgB,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuB3B;AAED,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,MAAM,CAAC,UAAU,CAAC,OAAO,YAAY,CAAC,CAAC,CAAC;AAE3E,MAAM,MAAM,8BAA8B,GAAG,WAAW,CACvD,kBAAkB,CAAC,cAAc,CAAC,CAClC,CAAC"}

package/dist/config/zod/optimization/index.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.optimization = void 0;
+const zod_1 = require("zod");
+const split_chunks_1 = require("./split-chunks");
+const rspackPluginInstance = zod_1.z.object({
+    apply: zod_1.z.function()
+});
+function optimization() {
+    return zod_1.z.strictObject({
+        moduleIds: zod_1.z.enum(["named", "deterministic"]).optional(),
+        minimize: zod_1.z.boolean().optional(),
+        minimizer: zod_1.z.literal("...").or(rspackPluginInstance).array().optional(),
+        splitChunks: (0, split_chunks_1.splitChunks)().optional(),
+        runtimeChunk: zod_1.z
+            .enum(["single", "multiple"])
+            .or(zod_1.z.boolean())
+            .or(zod_1.z.strictObject({
+            name: zod_1.z
+                .string()
+                .or(zod_1.z.function().returns(zod_1.z.string().or(zod_1.z.undefined())))
+                .optional()
+        }))
+            .optional(),
+        removeAvailableModules: zod_1.z.boolean().optional(),
+        removeEmptyChunks: zod_1.z.boolean().optional(),
+        realContentHash: zod_1.z.boolean().optional(),
+        sideEffects: zod_1.z.enum(["flag"]).or(zod_1.z.boolean()).optional()
+    });
+}
+exports.optimization = optimization;
+//# sourceMappingURL=index.js.map

package/dist/config/zod/optimization/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/config/zod/optimization/index.ts"],"names":[],"mappings":";;;AAAA,6BAAwB;AAExB,iDAA6C;AAE7C,MAAM,oBAAoB,GAAG,OAAC,CAAC,MAAM,CAAC;IACrC,KAAK,EAAE,OAAC,CAAC,QAAQ,EAAE;CACnB,CAAC,CAAC;AAEH,SAAgB,YAAY;IAC3B,OAAO,OAAC,CAAC,YAAY,CAAC;QACrB,SAAS,EAAE,OAAC,CAAC,IAAI,CAAC,CAAC,OAAO,EAAE,eAAe,CAAC,CAAC,CAAC,QAAQ,EAAE;QACxD,QAAQ,EAAE,OAAC,CAAC,OAAO,EAAE,CAAC,QAAQ,EAAE;QAChC,SAAS,EAAE,OAAC,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,oBAAoB,CAAC,CAAC,KAAK,EAAE,CAAC,QAAQ,EAAE;QACvE,WAAW,EAAE,IAAA,0BAAW,GAAE,CAAC,QAAQ,EAAE;QACrC,YAAY,EAAE,OAAC;aACb,IAAI,CAAC,CAAC,QAAQ,EAAE,UAAU,CAAC,CAAC;aAC5B,EAAE,CAAC,OAAC,CAAC,OAAO,EAAE,CAAC;aACf,EAAE,CACF,OAAC,CAAC,YAAY,CAAC;YACd,IAAI,EAAE,OAAC;iBACL,MAAM,EAAE;iBACR,EAAE,CAAC,OAAC,CAAC,QAAQ,EAAE,CAAC,OAAO,CAAC,OAAC,CAAC,MAAM,EAAE,CAAC,EAAE,CAAC,OAAC,CAAC,SAAS,EAAE,CAAC,CAAC,CAAC;iBACtD,QAAQ,EAAE;SACZ,CAAC,CACF;aACA,QAAQ,EAAE;QACZ,sBAAsB,EAAE,OAAC,CAAC,OAAO,EAAE,CAAC,QAAQ,EAAE;QAC9C,iBAAiB,EAAE,OAAC,CAAC,OAAO,EAAE,CAAC,QAAQ,EAAE;QACzC,eAAe,EAAE,OAAC,CAAC,OAAO,EAAE,CAAC,QAAQ,EAAE;QACvC,WAAW,EAAE,OAAC,CAAC,IAAI,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,OAAC,CAAC,OAAO,EAAE,CAAC,CAAC,QAAQ,EAAE;KACxD,CAAC,CAAC;AACJ,CAAC;AAvBD,oCAuBC"}

package/dist/config/zod/optimization/split-chunks.d.ts

@@ -0,0 +1,169 @@
+import { z } from "zod";
+declare const cacheGroupOptions: z.ZodObject<{
+    chunks: z.ZodOptional<z.ZodEnum<["initial", "async", "all"]>>;
+    minChunks: z.ZodOptional<z.ZodNumber>;
+    name: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodLiteral<false>]>>;
+    minSize: z.ZodOptional<z.ZodNumber>;
+    maxSize: z.ZodOptional<z.ZodNumber>;
+    maxAsyncSize: z.ZodOptional<z.ZodNumber>;
+    maxInitialSize: z.ZodOptional<z.ZodNumber>;
+    test: z.ZodOptional<z.ZodType<RegExp, z.ZodTypeDef, RegExp>>;
+    priority: z.ZodOptional<z.ZodNumber>;
+    enforce: z.ZodOptional<z.ZodBoolean>;
+    reuseExistingChunk: z.ZodOptional<z.ZodBoolean>;
+}, "strict", z.ZodTypeAny, {
+    chunks?: "async" | "all" | "initial" | undefined;
+    minChunks?: number | undefined;
+    name?: string | false | undefined;
+    minSize?: number | undefined;
+    maxSize?: number | undefined;
+    maxAsyncSize?: number | undefined;
+    maxInitialSize?: number | undefined;
+    test?: RegExp | undefined;
+    priority?: number | undefined;
+    enforce?: boolean | undefined;
+    reuseExistingChunk?: boolean | undefined;
+}, {
+    chunks?: "async" | "all" | "initial" | undefined;
+    minChunks?: number | undefined;
+    name?: string | false | undefined;
+    minSize?: number | undefined;
+    maxSize?: number | undefined;
+    maxAsyncSize?: number | undefined;
+    maxInitialSize?: number | undefined;
+    test?: RegExp | undefined;
+    priority?: number | undefined;
+    enforce?: boolean | undefined;
+    reuseExistingChunk?: boolean | undefined;
+}>;
+export declare function splitChunks(): z.ZodUnion<[z.ZodLiteral<false>, z.ZodObject<{
+    chunks: z.ZodOptional<z.ZodEnum<["initial", "async", "all"]>>;
+    minChunks: z.ZodOptional<z.ZodNumber>;
+    name: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodLiteral<false>]>>;
+    minSize: z.ZodOptional<z.ZodNumber>;
+    maxSize: z.ZodOptional<z.ZodNumber>;
+    maxAsyncSize: z.ZodOptional<z.ZodNumber>;
+    maxInitialSize: z.ZodOptional<z.ZodNumber>;
+    cacheGroups: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodLiteral<false>, z.ZodObject<{
+        chunks: z.ZodOptional<z.ZodEnum<["initial", "async", "all"]>>;
+        minChunks: z.ZodOptional<z.ZodNumber>;
+        name: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodLiteral<false>]>>;
+        minSize: z.ZodOptional<z.ZodNumber>;
+        maxSize: z.ZodOptional<z.ZodNumber>;
+        maxAsyncSize: z.ZodOptional<z.ZodNumber>;
+        maxInitialSize: z.ZodOptional<z.ZodNumber>;
+        test: z.ZodOptional<z.ZodType<RegExp, z.ZodTypeDef, RegExp>>;
+        priority: z.ZodOptional<z.ZodNumber>;
+        enforce: z.ZodOptional<z.ZodBoolean>;
+        reuseExistingChunk: z.ZodOptional<z.ZodBoolean>;
+    }, "strict", z.ZodTypeAny, {
+        chunks?: "async" | "all" | "initial" | undefined;
+        minChunks?: number | undefined;
+        name?: string | false | undefined;
+        minSize?: number | undefined;
+        maxSize?: number | undefined;
+        maxAsyncSize?: number | undefined;
+        maxInitialSize?: number | undefined;
+        test?: RegExp | undefined;
+        priority?: number | undefined;
+        enforce?: boolean | undefined;
+        reuseExistingChunk?: boolean | undefined;
+    }, {
+        chunks?: "async" | "all" | "initial" | undefined;
+        minChunks?: number | undefined;
+        name?: string | false | undefined;
+        minSize?: number | undefined;
+        maxSize?: number | undefined;
+        maxAsyncSize?: number | undefined;
+        maxInitialSize?: number | undefined;
+        test?: RegExp | undefined;
+        priority?: number | undefined;
+        enforce?: boolean | undefined;
+        reuseExistingChunk?: boolean | undefined;
+    }>]>>>;
+    maxAsyncRequests: z.ZodOptional<z.ZodNumber>;
+    maxInitialRequests: z.ZodOptional<z.ZodNumber>;
+    fallbackCacheGroup: z.ZodOptional<z.ZodObject<{
+        chunks: z.ZodOptional<z.ZodEnum<["initial", "async", "all"]>>;
+        minSize: z.ZodOptional<z.ZodNumber>;
+        maxSize: z.ZodOptional<z.ZodNumber>;
+        maxAsyncSize: z.ZodOptional<z.ZodNumber>;
+        maxInitialSize: z.ZodOptional<z.ZodNumber>;
+    }, "strict", z.ZodTypeAny, {
+        chunks?: "async" | "all" | "initial" | undefined;
+        minSize?: number | undefined;
+        maxSize?: number | undefined;
+        maxAsyncSize?: number | undefined;
+        maxInitialSize?: number | undefined;
+    }, {
+        chunks?: "async" | "all" | "initial" | undefined;
+        minSize?: number | undefined;
+        maxSize?: number | undefined;
+        maxAsyncSize?: number | undefined;
+        maxInitialSize?: number | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    chunks?: "async" | "all" | "initial" | undefined;
+    minChunks?: number | undefined;
+    name?: string | false | undefined;
+    minSize?: number | undefined;
+    maxSize?: number | undefined;
+    maxAsyncSize?: number | undefined;
+    maxInitialSize?: number | undefined;
+    cacheGroups?: Record<string, false | {
+        chunks?: "async" | "all" | "initial" | undefined;
+        minChunks?: number | undefined;
+        name?: string | false | undefined;
+        minSize?: number | undefined;
+        maxSize?: number | undefined;
+        maxAsyncSize?: number | undefined;
+        maxInitialSize?: number | undefined;
+        test?: RegExp | undefined;
+        priority?: number | undefined;
+        enforce?: boolean | undefined;
+        reuseExistingChunk?: boolean | undefined;
+    }> | undefined;
+    maxAsyncRequests?: number | undefined;
+    maxInitialRequests?: number | undefined;
+    fallbackCacheGroup?: {
+        chunks?: "async" | "all" | "initial" | undefined;
+        minSize?: number | undefined;
+        maxSize?: number | undefined;
+        maxAsyncSize?: number | undefined;
+        maxInitialSize?: number | undefined;
+    } | undefined;
+}, {
+    chunks?: "async" | "all" | "initial" | undefined;
+    minChunks?: number | undefined;
+    name?: string | false | undefined;
+    minSize?: number | undefined;
+    maxSize?: number | undefined;
+    maxAsyncSize?: number | undefined;
+    maxInitialSize?: number | undefined;
+    cacheGroups?: Record<string, false | {
+        chunks?: "async" | "all" | "initial" | undefined;
+        minChunks?: number | undefined;
+        name?: string | false | undefined;
+        minSize?: number | undefined;
+        maxSize?: number | undefined;
+        maxAsyncSize?: number | undefined;
+        maxInitialSize?: number | undefined;
+        test?: RegExp | undefined;
+        priority?: number | undefined;
+        enforce?: boolean | undefined;
+        reuseExistingChunk?: boolean | undefined;
+    }> | undefined;
+    maxAsyncRequests?: number | undefined;
+    maxInitialRequests?: number | undefined;
+    fallbackCacheGroup?: {
+        chunks?: "async" | "all" | "initial" | undefined;
+        minSize?: number | undefined;
+        maxSize?: number | undefined;
+        maxAsyncSize?: number | undefined;
+        maxInitialSize?: number | undefined;
+    } | undefined;
+}>]>;
+export type SplitChunksConfig = z.TypeOf<ReturnType<typeof splitChunks>>;
+export type CacheGroupOptionsConfig = z.TypeOf<typeof cacheGroupOptions>;
+export {};
+//# sourceMappingURL=split-chunks.d.ts.map

package/dist/config/zod/optimization/split-chunks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"split-chunks.d.ts","sourceRoot":"","sources":["../../../../src/config/zod/optimization/split-chunks.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAoBxB,QAAA,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAMrB,CAAC;AAEH,wBAAgB,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAmB1B;AAED,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,MAAM,CAAC,UAAU,CAAC,OAAO,WAAW,CAAC,CAAC,CAAC;AACzE,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,iBAAiB,CAAC,CAAC"}