@rspack/core 1.0.10 → 1.0.11

package/dist/config/index.js

@@ -1,20 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./adapter"), exports);
-__exportStar(require("./defaults"), exports);
-__exportStar(require("./normalization"), exports);
-__exportStar(require("./zod"), exports);

package/dist/config/normalization.js

@@ -1,299 +0,0 @@
-"use strict";
-/**
- * The following code is modified based on
- * https://github.com/webpack/webpack/blob/4b4ca3b/lib/config/normalization.js
- *
- * MIT Licensed
- * Author Tobias Koppers @sokra
- * Copyright (c) JS Foundation and other contributors
- * https://github.com/webpack/webpack/blob/main/LICENSE
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getNormalizedRspackOptions = void 0;
-const getNormalizedRspackOptions = (config) => {
-    return {
-        ignoreWarnings: config.ignoreWarnings !== undefined
-            ? config.ignoreWarnings.map(ignore => {
-                if (typeof ignore === "function") {
-                    return ignore;
-                }
-                return (warning) => {
-                    return ignore.test(warning.message);
-                };
-            })
-            : undefined,
-        name: config.name,
-        dependencies: config.dependencies,
-        context: config.context,
-        mode: config.mode,
-        entry: config.entry === undefined
-            ? { main: {} }
-            : typeof config.entry === "function"
-                ? (fn => () => Promise.resolve().then(fn).then(getNormalizedEntryStatic))(config.entry)
-                : getNormalizedEntryStatic(config.entry),
-        output: nestedConfig(config.output, output => {
-            const { library } = output;
-            const libraryAsName = library;
-            const libraryBase = typeof library === "object" &&
-                library &&
-                !Array.isArray(library) &&
-                "type" in library
-                ? library
-                : libraryAsName || output.libraryTarget
-                    ? {
-                        name: libraryAsName
-                    }
-                    : undefined;
-            return {
-                path: output.path,
-                pathinfo: output.pathinfo,
-                publicPath: output.publicPath,
-                filename: output.filename,
-                clean: output.clean,
-                chunkFormat: output.chunkFormat,
-                chunkLoading: output.chunkLoading,
-                chunkFilename: output.chunkFilename,
-                crossOriginLoading: output.crossOriginLoading,
-                cssHeadDataCompression: output.cssHeadDataCompression,
-                cssFilename: output.cssFilename,
-                cssChunkFilename: output.cssChunkFilename,
-                hotUpdateMainFilename: output.hotUpdateMainFilename,
-                hotUpdateChunkFilename: output.hotUpdateChunkFilename,
-                hotUpdateGlobal: output.hotUpdateGlobal,
-                assetModuleFilename: output.assetModuleFilename,
-                wasmLoading: output.wasmLoading,
-                enabledChunkLoadingTypes: output.enabledChunkLoadingTypes
-                    ? [...output.enabledChunkLoadingTypes]
-                    : ["..."],
-                enabledWasmLoadingTypes: output.enabledWasmLoadingTypes
-                    ? [...output.enabledWasmLoadingTypes]
-                    : ["..."],
-                webassemblyModuleFilename: output.webassemblyModuleFilename,
-                uniqueName: output.uniqueName,
-                chunkLoadingGlobal: output.chunkLoadingGlobal,
-                enabledLibraryTypes: output.enabledLibraryTypes
-                    ? [...output.enabledLibraryTypes]
-                    : ["..."],
-                globalObject: output.globalObject,
-                importFunctionName: output.importFunctionName,
-                importMetaName: output.importMetaName,
-                iife: output.iife,
-                module: output.module,
-                sourceMapFilename: output.sourceMapFilename,
-                library: libraryBase && {
-                    type: output.libraryTarget !== undefined
-                        ? output.libraryTarget
-                        : libraryBase.type,
-                    auxiliaryComment: output.auxiliaryComment !== undefined
-                        ? output.auxiliaryComment
-                        : libraryBase.auxiliaryComment,
-                    amdContainer: libraryBase.amdContainer,
-                    export: output.libraryExport !== undefined
-                        ? output.libraryExport
-                        : libraryBase.export,
-                    name: libraryBase.name,
-                    umdNamedDefine: output.umdNamedDefine !== undefined
-                        ? output.umdNamedDefine
-                        : libraryBase.umdNamedDefine
-                },
-                strictModuleErrorHandling: output.strictModuleErrorHandling ??
-                    output.strictModuleExceptionHandling,
-                trustedTypes: optionalNestedConfig(output.trustedTypes, trustedTypes => {
-                    if (trustedTypes === true)
-                        return {};
-                    if (typeof trustedTypes === "string")
-                        return { policyName: trustedTypes };
-                    return { ...trustedTypes };
-                }),
-                hashDigest: output.hashDigest,
-                hashDigestLength: output.hashDigestLength,
-                hashFunction: output.hashFunction,
-                hashSalt: output.hashSalt,
-                asyncChunks: output.asyncChunks,
-                workerChunkLoading: output.workerChunkLoading,
-                workerWasmLoading: output.workerWasmLoading,
-                workerPublicPath: output.workerPublicPath,
-                scriptType: output.scriptType,
-                devtoolNamespace: output.devtoolNamespace,
-                devtoolModuleFilenameTemplate: output.devtoolModuleFilenameTemplate,
-                devtoolFallbackModuleFilenameTemplate: output.devtoolFallbackModuleFilenameTemplate,
-                chunkLoadTimeout: output.chunkLoadTimeout,
-                charset: output.charset,
-                environment: cloneObject(output.environment)
-            };
-        }),
-        resolve: nestedConfig(config.resolve, resolve => ({
-            ...resolve,
-            tsConfig: optionalNestedConfig(resolve.tsConfig, tsConfig => {
-                return typeof tsConfig === "string"
-                    ? { configFile: tsConfig }
-                    : tsConfig;
-            })
-        })),
-        resolveLoader: nestedConfig(config.resolveLoader, resolve => ({
-            ...resolve,
-            tsConfig: optionalNestedConfig(resolve.tsConfig, tsConfig => {
-                return typeof tsConfig === "string"
-                    ? { configFile: tsConfig }
-                    : tsConfig;
-            })
-        })),
-        module: nestedConfig(config.module, module => ({
-            noParse: module.noParse,
-            parser: keyedNestedConfig(module.parser, cloneObject, {}),
-            generator: keyedNestedConfig(module.generator, cloneObject, {}),
-            defaultRules: optionalNestedArray(module.defaultRules, r => [...r]),
-            rules: nestedArray(module.rules, r => [...r])
-        })),
-        target: config.target,
-        externals: config.externals,
-        externalsType: config.externalsType,
-        externalsPresets: cloneObject(config.externalsPresets),
-        infrastructureLogging: cloneObject(config.infrastructureLogging),
-        devtool: config.devtool,
-        node: nestedConfig(config.node, node => node && {
-            ...node
-        }),
-        loader: cloneObject(config.loader),
-        snapshot: nestedConfig(config.snapshot, _snapshot => ({})),
-        cache: optionalNestedConfig(config.cache, cache => cache),
-        stats: nestedConfig(config.stats, stats => {
-            if (stats === false) {
-                return {
-                    preset: "none"
-                };
-            }
-            if (stats === true) {
-                return {
-                    preset: "normal"
-                };
-            }
-            if (typeof stats === "string") {
-                return {
-                    preset: stats
-                };
-            }
-            return {
-                ...stats
-            };
-        }),
-        optimization: nestedConfig(config.optimization, optimization => {
-            return {
-                ...optimization,
-                runtimeChunk: getNormalizedOptimizationRuntimeChunk(optimization.runtimeChunk),
-                splitChunks: nestedConfig(optimization.splitChunks, splitChunks => splitChunks && {
-                    ...splitChunks,
-                    defaultSizeTypes: splitChunks.defaultSizeTypes
-                        ? [...splitChunks.defaultSizeTypes]
-                        : ["..."],
-                    cacheGroups: cloneObject(splitChunks.cacheGroups)
-                })
-            };
-        }),
-        performance: config.performance,
-        plugins: nestedArray(config.plugins, p => [...p]),
-        experiments: nestedConfig(config.experiments, experiments => ({
-            ...experiments,
-            lazyCompilation: optionalNestedConfig(experiments.lazyCompilation, options => (options === true ? {} : options)),
-            incremental: optionalNestedConfig(experiments.incremental, options => options === true ? {} : options)
-        })),
-        watch: config.watch,
-        watchOptions: cloneObject(config.watchOptions),
-        devServer: config.devServer,
-        profile: config.profile,
-        bail: config.bail
-    };
-};
-exports.getNormalizedRspackOptions = getNormalizedRspackOptions;
-const getNormalizedEntryStatic = (entry) => {
-    if (typeof entry === "string") {
-        return {
-            main: {
-                import: [entry]
-            }
-        };
-    }
-    if (Array.isArray(entry)) {
-        return {
-            main: {
-                import: entry
-            }
-        };
-    }
-    const result = {};
-    for (const key of Object.keys(entry)) {
-        const value = entry[key];
-        if (typeof value === "string") {
-            result[key] = {
-                import: [value]
-            };
-        }
-        else if (Array.isArray(value)) {
-            result[key] = {
-                import: value
-            };
-        }
-        else {
-            result[key] = {
-                import: Array.isArray(value.import) ? value.import : [value.import],
-                runtime: value.runtime,
-                publicPath: value.publicPath,
-                baseUri: value.baseUri,
-                chunkLoading: value.chunkLoading,
-                asyncChunks: value.asyncChunks,
-                filename: value.filename,
-                library: value.library,
-                layer: value.layer,
-                dependOn: Array.isArray(value.dependOn)
-                    ? value.dependOn
-                    : value.dependOn
-                        ? [value.dependOn]
-                        : undefined
-            };
-        }
-    }
-    return result;
-};
-const getNormalizedOptimizationRuntimeChunk = (runtimeChunk) => {
-    if (runtimeChunk === undefined)
-        return undefined;
-    if (runtimeChunk === false)
-        return false;
-    if (runtimeChunk === "single") {
-        return {
-            name: "single"
-        };
-    }
-    if (runtimeChunk === true || runtimeChunk === "multiple") {
-        return {
-            name: "multiple"
-        };
-    }
-    if (runtimeChunk.name) {
-        const opts = {
-            name: runtimeChunk.name
-        };
-        return opts;
-    }
-};
-const nestedConfig = (value, fn) => value === undefined ? fn({}) : fn(value);
-const optionalNestedConfig = (value, fn) => (value === undefined ? undefined : fn(value));
-const nestedArray = (value, fn) => Array.isArray(value) ? fn(value) : fn([]);
-const optionalNestedArray = (value, fn) => (Array.isArray(value) ? fn(value) : undefined);
-const cloneObject = (value) => ({ ...value });
-const keyedNestedConfig = (value, fn, customKeys) => {
-    const result = value === undefined
-        ? {}
-        : Object.keys(value).reduce((obj, key) => {
-            obj[key] = (customKeys && key in customKeys ? customKeys[key] : fn)(value[key]);
-            return obj;
-        }, {});
-    if (customKeys) {
-        for (const key of Object.keys(customKeys)) {
-            if (!(key in result)) {
-                result[key] = customKeys[key]({});
-            }
-        }
-    }
-    return result;
-};

package/dist/config/target.js

@@ -1,318 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getTargetsProperties = exports.getTargetProperties = exports.getDefaultTarget = void 0;
-/**
- * The following code is modified based on
- * https://github.com/webpack/webpack/blob/4b4ca3b/lib/config/target.js
- *
- * MIT Licensed
- * Author Tobias Koppers @sokra
- * Copyright (c) JS Foundation and other contributors
- * https://github.com/webpack/webpack/blob/main/LICENSE
- */
-const memoize_1 = require("../util/memoize");
-const browserslistTargetHandler = __importStar(require("./browserslistTargetHandler"));
-const getBrowserslistTargetHandler = (0, memoize_1.memoize)(() => browserslistTargetHandler);
-/**
- * @param context the context directory
- * @returns default target
- */
-const getDefaultTarget = (context) => {
-    const browsers = getBrowserslistTargetHandler().load(null, context);
-    return browsers ? "browserslist" : "web";
-};
-exports.getDefaultTarget = getDefaultTarget;
-/**
- * @param major major version
- * @param minor minor version
- * @returns check if version is greater or equal
- */
-const versionDependent = (major, minor) => {
-    if (!major) {
-        return () => undefined;
-    }
-    const nMajor = +major;
-    const nMinor = minor ? +minor : 0;
-    return (vMajor, vMinor = 0) => {
-        return nMajor > vMajor || (nMajor === vMajor && nMinor >= vMinor);
-    };
-};
-const TARGETS = [
-    [
-        "browserslist / browserslist:env / browserslist:query / browserslist:path-to-config / browserslist:path-to-config:env",
-        "Resolve features from browserslist. Will resolve browserslist config automatically. Only browser or node queries are supported (electron is not supported). Examples: 'browserslist:modern' to use 'modern' environment from browserslist config",
-        /^browserslist(?::(.+))?$/,
-        (rest, context) => {
-            const browserslistTargetHandler = getBrowserslistTargetHandler();
-            const browsers = browserslistTargetHandler.load(rest ? rest.trim() : null, context);
-            if (!browsers) {
-                throw new Error(`No browserslist config found to handle the 'browserslist' target.
-See https://github.com/browserslist/browserslist#queries for possible ways to provide a config.
-The recommended way is to add a 'browserslist' key to your package.json and list supported browsers (resp. node.js versions).
-You can also more options via the 'target' option: 'browserslist' / 'browserslist:env' / 'browserslist:query' / 'browserslist:path-to-config' / 'browserslist:path-to-config:env'`);
-            }
-            return browserslistTargetHandler.resolve(browsers);
-        }
-    ],
-    [
-        "web",
-        "Web browser.",
-        /^web$/,
-        () => {
-            return {
-                web: true,
-                browser: true,
-                webworker: null,
-                node: false,
-                electron: false,
-                nwjs: false,
-                document: true,
-                importScriptsInWorker: true,
-                fetchWasm: true,
-                nodeBuiltins: false,
-                importScripts: false,
-                require: false,
-                global: false
-            };
-        }
-    ],
-    [
-        "webworker",
-        "Web Worker, SharedWorker or Service Worker.",
-        /^webworker$/,
-        () => {
-            return {
-                web: true,
-                browser: true,
-                webworker: true,
-                node: false,
-                electron: false,
-                nwjs: false,
-                importScripts: true,
-                importScriptsInWorker: true,
-                fetchWasm: true,
-                nodeBuiltins: false,
-                require: false,
-                document: false,
-                global: false
-            };
-        }
-    ],
-    [
-        "[async-]node[X[.Y]]",
-        "Node.js in version X.Y. The 'async-' prefix will load chunks asynchronously via 'fs' and 'vm' instead of 'require()'. Examples: node14.5, async-node10.",
-        /^(async-)?node((\d+)(?:\.(\d+))?)?$/,
-        (asyncFlag, _, major, minor) => {
-            const v = versionDependent(major, minor);
-            // see https://node.green/
-            return {
-                node: true,
-                electron: false,
-                nwjs: false,
-                web: false,
-                webworker: false,
-                browser: false,
-                require: !asyncFlag,
-                nodeBuiltins: true,
-                // v16.0.0, v14.18.0
-                nodePrefixForCoreModules: +major < 15 ? v(14, 18) : v(16),
-                global: true,
-                document: false,
-                fetchWasm: false,
-                importScripts: false,
-                importScriptsInWorker: false,
-                globalThis: v(12),
-                const: v(6),
-                templateLiteral: v(4),
-                optionalChaining: v(14),
-                arrowFunction: v(6),
-                asyncFunction: v(7, 6),
-                forOf: v(5),
-                destructuring: v(6),
-                bigIntLiteral: v(10, 4),
-                dynamicImport: v(12, 17),
-                dynamicImportInWorker: major ? false : undefined,
-                module: v(12, 17)
-            };
-        }
-    ],
-    [
-        "electron[X[.Y]]-main/preload/renderer",
-        "Electron in version X.Y. Script is running in main, preload resp. renderer context.",
-        /^electron((\d+)(?:\.(\d+))?)?-(main|preload|renderer)$/,
-        (_, major, minor, context) => {
-            const v = versionDependent(major, minor);
-            // see https://node.green/ + https://github.com/electron/releases
-            return {
-                node: true,
-                electron: true,
-                web: context !== "main",
-                webworker: false,
-                browser: false,
-                nwjs: false,
-                electronMain: context === "main",
-                electronPreload: context === "preload",
-                electronRenderer: context === "renderer",
-                global: true,
-                nodeBuiltins: true,
-                // 15.0.0	- Node.js	v16.5
-                // 14.0.0 - Mode.js v14.17, but prefixes only since v14.18
-                nodePrefixForCoreModules: v(15),
-                require: true,
-                document: context === "renderer",
-                fetchWasm: context === "renderer",
-                importScripts: false,
-                importScriptsInWorker: true,
-                globalThis: v(5),
-                const: v(1, 1),
-                templateLiteral: v(1, 1),
-                optionalChaining: v(8),
-                arrowFunction: v(1, 1),
-                asyncFunction: v(1, 7),
-                forOf: v(0, 36),
-                destructuring: v(1, 1),
-                bigIntLiteral: v(4),
-                dynamicImport: v(11),
-                dynamicImportInWorker: major ? false : undefined,
-                module: v(11)
-            };
-        }
-    ],
-    [
-        "nwjs[X[.Y]] / node-webkit[X[.Y]]",
-        "NW.js in version X.Y.",
-        /^(?:nwjs|node-webkit)((\d+)(?:\.(\d+))?)?$/,
-        (_, major, minor) => {
-            const v = versionDependent(major, minor);
-            // see https://node.green/ + https://github.com/nwjs/nw.js/blob/nw48/CHANGELOG.md
-            return {
-                node: true,
-                web: true,
-                nwjs: true,
-                webworker: null,
-                browser: false,
-                electron: false,
-                global: true,
-                nodeBuiltins: true,
-                document: false,
-                importScriptsInWorker: false,
-                fetchWasm: false,
-                importScripts: false,
-                require: false,
-                globalThis: v(0, 43),
-                const: v(0, 15),
-                templateLiteral: v(0, 13),
-                optionalChaining: v(0, 44),
-                arrowFunction: v(0, 15),
-                asyncFunction: v(0, 21),
-                forOf: v(0, 13),
-                destructuring: v(0, 15),
-                bigIntLiteral: v(0, 32),
-                dynamicImport: v(0, 43),
-                dynamicImportInWorker: major ? false : undefined,
-                module: v(0, 43)
-            };
-        }
-    ],
-    [
-        "esX",
-        "EcmaScript in this version. Examples: es2020, es5.",
-        /^es(\d+)$/,
-        version => {
-            let v = +version;
-            if (v < 1000)
-                v = v + 2009;
-            return {
-                const: v >= 2015,
-                templateLiteral: v >= 2015,
-                optionalChaining: v >= 2020,
-                arrowFunction: v >= 2015,
-                forOf: v >= 2015,
-                destructuring: v >= 2015,
-                module: v >= 2015,
-                asyncFunction: v >= 2017,
-                globalThis: v >= 2020,
-                bigIntLiteral: v >= 2020,
-                dynamicImport: v >= 2020,
-                dynamicImportInWorker: v >= 2020
-            };
-        }
-    ]
-];
-/**
- * @param target the target
- * @param context the context directory
- * @returns target properties
- */
-const getTargetProperties = (target, context) => {
-    for (const [, , regExp, handler] of TARGETS) {
-        const match = regExp.exec(target);
-        if (match) {
-            const [, ...args] = match;
-            const result = handler(...args, context);
-            if (result)
-                return result;
-        }
-    }
-    throw new Error(`Unknown target '${target}'. The following targets are supported:\n${TARGETS.map(([name, description]) => `* ${name}: ${description}`).join("\n")}`);
-};
-exports.getTargetProperties = getTargetProperties;
-const mergeTargetProperties = (targetProperties) => {
-    const keys = new Set();
-    for (const tp of targetProperties) {
-        for (const key of Object.keys(tp)) {
-            keys.add(key);
-        }
-    }
-    const result = {};
-    for (const key of keys) {
-        let hasTrue = false;
-        let hasFalse = false;
-        for (const tp of targetProperties) {
-            const value = tp[key];
-            switch (value) {
-                case true:
-                    hasTrue = true;
-                    break;
-                case false:
-                    hasFalse = true;
-                    break;
-            }
-        }
-        if (hasTrue || hasFalse)
-            result[key] = hasFalse && hasTrue ? null : hasTrue;
-    }
-    return result;
-};
-/**
- * @param targets the targets
- * @param context the context directory
- * @returns target properties
- */
-const getTargetsProperties = (targets, context) => {
-    return mergeTargetProperties(targets.map(t => (0, exports.getTargetProperties)(t, context)));
-};
-exports.getTargetsProperties = getTargetsProperties;

package/dist/config/types.js

@@ -1,3 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-//#endregion