@rspack/core 0.3.1 → 0.3.2

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

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

package/dist/config/zod/index.js

@@ -1,58 +0,0 @@
-"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");
-const resolve_1 = require("./resolve");
-const plugins_1 = require("./plugins");
-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(),
-        resolve: (0, resolve_1.resolve)().optional(),
-        resolveLoader: (0, resolve_1.resolve)().optional(),
-        plugins: (0, plugins_1.plugins)().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(),
-        builtins: (0, builtins_1.builtins)().optional(),
-        module: zod_1.z.any().optional(),
-        profile: zod_1.z.boolean().optional()
-    })
-        .strict();
-}
-exports.configSchema = configSchema;

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

@@ -1 +0,0 @@
-{"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;AAC9C,uCAAoC;AACpC,uCAAoC;AAEpC,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,OAAO,EAAE,IAAA,iBAAO,GAAE,CAAC,QAAQ,EAAE;QAC7B,aAAa,EAAE,IAAA,iBAAO,GAAE,CAAC,QAAQ,EAAE;QACnC,OAAO,EAAE,IAAA,iBAAO,GAAE,CAAC,QAAQ,EAAE;QAC7B,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,QAAQ,EAAE,IAAA,mBAAQ,GAAE,CAAC,QAAQ,EAAE;QAC/B,MAAM,EAAE,OAAC,CAAC,GAAG,EAAE,CAAC,QAAQ,EAAE;QAC1B,OAAO,EAAE,OAAC,CAAC,OAAO,EAAE,CAAC,QAAQ,EAAE;KAC/B,CAAC;SACD,MAAM,EAAE,CAAC;AACZ,CAAC;AAnCD,oCAmCC"}

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

@@ -1,23 +0,0 @@
-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;
-}>;

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

@@ -1 +0,0 @@
-{"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

@@ -1,19 +0,0 @@
-"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;

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

@@ -1 +0,0 @@
-{"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.map

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

package/dist/config/zod/module.js

@@ -1 +0,0 @@
-"use strict";

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

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

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

@@ -1,14 +0,0 @@
-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;
-}>]>;

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

@@ -1 +0,0 @@
-{"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

@@ -1,23 +0,0 @@
-"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;

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

@@ -1 +0,0 @@
-{"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

@@ -1,257 +0,0 @@
-import { z } from "zod";
-export declare function optimization(): z.ZodObject<{
-    moduleIds: z.ZodOptional<z.ZodEnum<["named", "deterministic"]>>;
-    chunkIds: 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.ZodUnion<[z.ZodEnum<["initial", "async", "all"]>, z.ZodType<RegExp, z.ZodTypeDef, RegExp>]>>;
-        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.ZodUnion<[z.ZodEnum<["initial", "async", "all"]>, z.ZodType<RegExp, z.ZodTypeDef, RegExp>]>>;
-            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>;
-            type: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodType<RegExp, z.ZodTypeDef, RegExp>]>>;
-            idHint: z.ZodOptional<z.ZodString>;
-        }, "strict", z.ZodTypeAny, {
-            chunks?: RegExp | "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;
-            type?: string | RegExp | undefined;
-            idHint?: string | undefined;
-        }, {
-            chunks?: RegExp | "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;
-            type?: string | RegExp | undefined;
-            idHint?: string | undefined;
-        }>]>>>;
-        maxAsyncRequests: z.ZodOptional<z.ZodNumber>;
-        maxInitialRequests: z.ZodOptional<z.ZodNumber>;
-        fallbackCacheGroup: z.ZodOptional<z.ZodObject<{
-            chunks: z.ZodOptional<z.ZodUnion<[z.ZodEnum<["initial", "async", "all"]>, z.ZodType<RegExp, z.ZodTypeDef, RegExp>]>>;
-            minSize: z.ZodOptional<z.ZodNumber>;
-            maxSize: z.ZodOptional<z.ZodNumber>;
-            maxAsyncSize: z.ZodOptional<z.ZodNumber>;
-            maxInitialSize: z.ZodOptional<z.ZodNumber>;
-        }, "strict", z.ZodTypeAny, {
-            chunks?: RegExp | "async" | "all" | "initial" | undefined;
-            minSize?: number | undefined;
-            maxSize?: number | undefined;
-            maxAsyncSize?: number | undefined;
-            maxInitialSize?: number | undefined;
-        }, {
-            chunks?: RegExp | "async" | "all" | "initial" | undefined;
-            minSize?: number | undefined;
-            maxSize?: number | undefined;
-            maxAsyncSize?: number | undefined;
-            maxInitialSize?: number | undefined;
-        }>>;
-    }, "strip", z.ZodTypeAny, {
-        chunks?: RegExp | "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?: RegExp | "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;
-            type?: string | RegExp | undefined;
-            idHint?: string | undefined;
-        }> | undefined;
-        maxAsyncRequests?: number | undefined;
-        maxInitialRequests?: number | undefined;
-        fallbackCacheGroup?: {
-            chunks?: RegExp | "async" | "all" | "initial" | undefined;
-            minSize?: number | undefined;
-            maxSize?: number | undefined;
-            maxAsyncSize?: number | undefined;
-            maxInitialSize?: number | undefined;
-        } | undefined;
-    }, {
-        chunks?: RegExp | "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?: RegExp | "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;
-            type?: string | RegExp | undefined;
-            idHint?: string | undefined;
-        }> | undefined;
-        maxAsyncRequests?: number | undefined;
-        maxInitialRequests?: number | undefined;
-        fallbackCacheGroup?: {
-            chunks?: RegExp | "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;
-    chunkIds?: "named" | "deterministic" | undefined;
-    minimize?: boolean | undefined;
-    minimizer?: ("..." | {
-        apply: (...args: unknown[]) => unknown;
-    })[] | undefined;
-    splitChunks?: false | {
-        chunks?: RegExp | "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?: RegExp | "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;
-            type?: string | RegExp | undefined;
-            idHint?: string | undefined;
-        }> | undefined;
-        maxAsyncRequests?: number | undefined;
-        maxInitialRequests?: number | undefined;
-        fallbackCacheGroup?: {
-            chunks?: RegExp | "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;
-    chunkIds?: "named" | "deterministic" | undefined;
-    minimize?: boolean | undefined;
-    minimizer?: ("..." | {
-        apply: (...args: unknown[]) => unknown;
-    })[] | undefined;
-    splitChunks?: false | {
-        chunks?: RegExp | "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?: RegExp | "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;
-            type?: string | RegExp | undefined;
-            idHint?: string | undefined;
-        }> | undefined;
-        maxAsyncRequests?: number | undefined;
-        maxInitialRequests?: number | undefined;
-        fallbackCacheGroup?: {
-            chunks?: RegExp | "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"]>;

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

@@ -1 +0,0 @@
-{"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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwB3B;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

@@ -1,32 +0,0 @@
-"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(),
-        chunkIds: 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;

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

@@ -1 +0,0 @@
-{"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,IAAI,CAAC,CAAC,OAAO,EAAE,eAAe,CAAC,CAAC,CAAC,QAAQ,EAAE;QACvD,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;AAxBD,oCAwBC"}