@rspack/core 0.5.9 → 0.6.0-canary-f5973db-20240409131230

package/dist/builtin-plugin/css-extract/loader-options.json

@@ -0,0 +1,32 @@
+{
+    "title": "Mini CSS Extract Plugin Loader options",
+    "type": "object",
+    "additionalProperties": false,
+    "properties": {
+        "publicPath": {
+            "anyOf": [
+                {
+                    "type": "string"
+                },
+                {
+                    "instanceof": "Function"
+                }
+            ],
+            "description": "Specifies a custom public path for the external resources like images, files, etc inside CSS.",
+            "link": "https://github.com/webpack-contrib/mini-css-extract-plugin#publicpath"
+        },
+        "emit": {
+            "type": "boolean",
+            "description": "If true, emits a file (writes a file to the filesystem). If false, the plugin will extract the CSS but will not emit the file",
+            "link": "https://github.com/webpack-contrib/mini-css-extract-plugin#emit"
+        },
+        "esModule": {
+            "type": "boolean",
+            "description": "Generates JS modules that use the ES modules syntax.",
+            "link": "https://github.com/webpack-contrib/mini-css-extract-plugin#esmodule"
+        },
+        "layer": {
+            "type": "string"
+        }
+    }
+}

package/dist/builtin-plugin/css-extract/loader.d.ts

@@ -0,0 +1,15 @@
+import type { LoaderDefinition } from "../..";
+export declare const MODULE_TYPE = "css/mini-extract";
+export declare const AUTO_PUBLIC_PATH = "__mini_css_extract_plugin_public_path_auto__";
+export declare const ABSOLUTE_PUBLIC_PATH = "webpack:///mini-css-extract-plugin/";
+export declare const BASE_URI = "webpack://";
+export declare const SINGLE_DOT_PATH_SEGMENT = "__mini_css_extract_plugin_single_dot_path_segment__";
+export interface LoaderOptions {
+    publicPath?: string | ((resourcePath: string, context: string) => string);
+    emit?: boolean;
+    esModule?: boolean;
+    layer?: boolean;
+}
+declare const loader: LoaderDefinition;
+export declare const pitch: LoaderDefinition["pitch"];
+export default loader;

package/dist/builtin-plugin/css-extract/loader.js

@@ -0,0 +1,191 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pitch = exports.SINGLE_DOT_PATH_SEGMENT = exports.BASE_URI = exports.ABSOLUTE_PUBLIC_PATH = exports.AUTO_PUBLIC_PATH = exports.MODULE_TYPE = void 0;
+const loader_options_json_1 = __importDefault(require("./loader-options.json"));
+const index_1 = require("./index");
+const path_1 = __importDefault(require("path"));
+const utils_1 = require("./utils");
+exports.MODULE_TYPE = "css/mini-extract";
+exports.AUTO_PUBLIC_PATH = "__mini_css_extract_plugin_public_path_auto__";
+exports.ABSOLUTE_PUBLIC_PATH = "webpack:///mini-css-extract-plugin/";
+exports.BASE_URI = "webpack://";
+exports.SINGLE_DOT_PATH_SEGMENT = "__mini_css_extract_plugin_single_dot_path_segment__";
+const SERIALIZE_SEP = "__RSPACK_CSS_EXTRACT_SEP__";
+function hotLoader(content, context) {
+    const accept = context.locals
+        ? ""
+        : "module.hot.accept(undefined, cssReload);";
+    return `${content}
+    if(module.hot) {
+      // ${Date.now()}
+      var cssReload = require(${(0, utils_1.stringifyRequest)(context.loaderContext, path_1.default.join(__dirname, "./hmr/hotModuleReplacement.js"))})(module.id, ${JSON.stringify({
+        ...context.options,
+        locals: !!context.locals
+    })});
+      module.hot.dispose(cssReload);
+      ${accept}
+    }
+  `;
+}
+const loader = function loader(content) {
+    if (this._compiler &&
+        this._compiler.options &&
+        this._compiler.options.experiments &&
+        this._compiler.options.experiments.css) {
+        return content;
+    }
+};
+const pitch = function (request, _, data) {
+    if (this._compiler &&
+        this._compiler.options &&
+        this._compiler.options.experiments &&
+        this._compiler.options.experiments.css) {
+        let e = new Error("You can't use `experiments.css` and `css-extract-rspack-plugin` together, please set `experiments.css` to `false`");
+        e.stack = undefined;
+        this.emitWarning(e);
+        return;
+    }
+    if (this._compiler &&
+        this._compiler.options &&
+        this._compiler.options.experiments &&
+        this._compiler.options.experiments.rspackFuture &&
+        this._compiler.options.experiments.rspackFuture.newTreeshaking === false) {
+        this.emitError(new Error("Cannot use CssExtractRspackPlugin without newTreeshaking"));
+        return;
+    }
+    const options = this.getOptions(loader_options_json_1.default);
+    const emit = typeof options.emit !== "undefined" ? options.emit : true;
+    const callback = this.async();
+    const filepath = this.resourcePath;
+    let { publicPath } = 
+    /** @type {Compilation} */
+    this._compilation.outputOptions;
+    if (typeof options.publicPath === "string") {
+        // eslint-disable-next-line prefer-destructuring
+        publicPath = options.publicPath;
+    }
+    else if (typeof options.publicPath === "function") {
+        publicPath = options.publicPath(this.resourcePath, this.rootContext);
+    }
+    if (publicPath === "auto") {
+        publicPath = exports.AUTO_PUBLIC_PATH;
+    }
+    let publicPathForExtract;
+    if (typeof publicPath === "string") {
+        const isAbsolutePublicPath = /^[a-zA-Z][a-zA-Z\d+\-.]*?:/.test(publicPath);
+        publicPathForExtract = isAbsolutePublicPath
+            ? publicPath
+            : `${exports.ABSOLUTE_PUBLIC_PATH}${publicPath.replace(/\./g, exports.SINGLE_DOT_PATH_SEGMENT)}`;
+    }
+    else {
+        publicPathForExtract = publicPath;
+    }
+    const handleExports = (originalExports) => {
+        /** @type {Locals | undefined} */
+        let locals;
+        let namedExport;
+        const esModule = typeof options.esModule !== "undefined" ? options.esModule : true;
+        let dependencies = [];
+        try {
+            // eslint-disable-next-line no-underscore-dangle
+            const exports = originalExports.__esModule
+                ? originalExports.default
+                : originalExports;
+            namedExport =
+                // eslint-disable-next-line no-underscore-dangle
+                originalExports.__esModule &&
+                    (!originalExports.default || !("locals" in originalExports.default));
+            if (namedExport) {
+                Object.keys(originalExports).forEach(key => {
+                    if (key !== "default") {
+                        if (!locals) {
+                            locals = {};
+                        }
+                        /** @type {Locals} */ locals[key] = originalExports[key];
+                    }
+                });
+            }
+            else {
+                locals = exports && exports.locals;
+            }
+            if (Array.isArray(exports) && emit) {
+                const identifierCountMap = new Map();
+                dependencies = exports
+                    .map(([id, content, media, sourceMap, supports, layer]) => {
+                    let identifier = id;
+                    let context = this.rootContext;
+                    const count = identifierCountMap.get(identifier) || 0;
+                    identifierCountMap.set(identifier, count + 1);
+                    return {
+                        identifier,
+                        context,
+                        content,
+                        media,
+                        supports,
+                        layer,
+                        identifierIndex: count,
+                        sourceMap: sourceMap
+                            ? JSON.stringify(sourceMap)
+                            : // eslint-disable-next-line no-undefined
+                                undefined,
+                        filepath
+                    };
+                })
+                    .filter(item => item !== null);
+            }
+        }
+        catch (e) {
+            callback(e);
+            return;
+        }
+        const result = locals
+            ? namedExport
+                ? Object.keys(locals)
+                    .map(key => `\nexport var ${key} = ${(0, utils_1.stringifyLocal)(
+                /** @type {Locals} */ locals[key])};`)
+                    .join("")
+                : `\n${esModule ? "export default" : "module.exports ="} ${JSON.stringify(locals)};`
+            : esModule
+                ? `\nexport {};`
+                : "";
+        let resultSource = `// extracted by ${index_1.CssExtractRspackPlugin.pluginName}`;
+        // only attempt hotreloading if the css is actually used for something other than hash values
+        resultSource +=
+            this.hot && emit
+                ? hotLoader(result, { loaderContext: this, options, locals: locals })
+                : result;
+        const additionalData = { ...data };
+        if (dependencies.length > 0) {
+            additionalData[index_1.CssExtractRspackPlugin.pluginName] = dependencies
+                .map(dep => {
+                return [
+                    dep.identifier,
+                    dep.content,
+                    dep.context,
+                    dep.media,
+                    dep.supports,
+                    dep.sourceMap,
+                    dep.identifierIndex,
+                    dep.filepath
+                ].join(SERIALIZE_SEP);
+            })
+                .join(SERIALIZE_SEP);
+        }
+        callback(null, resultSource, undefined, additionalData);
+    };
+    this.importModule(`${this.resourcePath}.webpack[javascript/auto]!=!!!${request}`, {
+        publicPath: /** @type {string} */ publicPathForExtract,
+        baseUri: `${exports.BASE_URI}/`
+    }, (error, exports) => {
+        if (error) {
+            callback(error);
+            return;
+        }
+        handleExports(exports);
+    });
+};
+exports.pitch = pitch;
+exports.default = loader;

package/dist/builtin-plugin/css-extract/plugin-options.json

@@ -0,0 +1,79 @@
+{
+    "title": "Mini CSS Extract Plugin options",
+    "type": "object",
+    "additionalProperties": false,
+    "properties": {
+        "filename": {
+            "anyOf": [
+                {
+                    "type": "string",
+                    "absolutePath": false,
+                    "minLength": 1
+                },
+                {
+                    "instanceof": "Function"
+                }
+            ],
+            "description": "This option determines the name of each output CSS file.",
+            "link": "https://github.com/webpack-contrib/mini-css-extract-plugin#filename"
+        },
+        "chunkFilename": {
+            "anyOf": [
+                {
+                    "type": "string",
+                    "absolutePath": false,
+                    "minLength": 1
+                },
+                {
+                    "instanceof": "Function"
+                }
+            ],
+            "description": "This option determines the name of non-entry chunk files.",
+            "link": "https://github.com/webpack-contrib/mini-css-extract-plugin#chunkfilename"
+        },
+        "experimentalUseImportModule": {
+            "type": "boolean",
+            "description": "Enable the experimental importModule approach instead of using child compilers. This uses less memory and is faster.",
+            "link": "https://github.com/webpack-contrib/mini-css-extract-plugin#experimentaluseimportmodule"
+        },
+        "ignoreOrder": {
+            "type": "boolean",
+            "description": "Remove Order Warnings.",
+            "link": "https://github.com/webpack-contrib/mini-css-extract-plugin#ignoreorder"
+        },
+        "insert": {
+            "description": "Inserts the `link` tag at the given position for non-initial (async) (https://webpack.js.org/concepts/under-the-hood/#chunks) CSS chunks.",
+            "link": "https://github.com/webpack-contrib/mini-css-extract-plugin#insert",
+            "anyOf": [
+                {
+                    "type": "string"
+                },
+                {
+                    "instanceof": "Function"
+                }
+            ]
+        },
+        "attributes": {
+            "description": "Adds custom attributes to the `link` tag for non-initial (async) (https://webpack.js.org/concepts/under-the-hood/#chunks) CSS chunks.",
+            "link": "https://github.com/webpack-contrib/mini-css-extract-plugin#attributes",
+            "type": "object"
+        },
+        "linkType": {
+            "anyOf": [
+                {
+                    "enum": ["text/css"]
+                },
+                {
+                    "type": "boolean"
+                }
+            ],
+            "description": "This option allows loading asynchronous chunks with a custom link type",
+            "link": "https://github.com/webpack-contrib/mini-css-extract-plugin#linktype"
+        },
+        "runtime": {
+            "type": "boolean",
+            "description": "Enabled/Disables runtime generation. CSS will be still extracted and can be used for a custom loading methods.",
+            "link": "https://github.com/webpack-contrib/mini-css-extract-plugin#noRuntime"
+        }
+    }
+}

package/dist/builtin-plugin/css-extract/utils.d.ts

@@ -0,0 +1,5 @@
+import { LoaderContext } from "../..";
+export declare function isAbsolutePath(str: string): boolean;
+export declare function isRelativePath(str: string): boolean;
+export declare function stringifyRequest(loaderContext: LoaderContext, request: string): string;
+export declare function stringifyLocal(value: any): any;

package/dist/builtin-plugin/css-extract/utils.js

@@ -0,0 +1,51 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stringifyLocal = exports.stringifyRequest = exports.isRelativePath = exports.isAbsolutePath = void 0;
+const path_1 = __importDefault(require("path"));
+function isAbsolutePath(str) {
+    return path_1.default.posix.isAbsolute(str) || path_1.default.win32.isAbsolute(str);
+}
+exports.isAbsolutePath = isAbsolutePath;
+const RELATIVE_PATH_REGEXP = /^\.\.?[/\\]/;
+function isRelativePath(str) {
+    return RELATIVE_PATH_REGEXP.test(str);
+}
+exports.isRelativePath = isRelativePath;
+function stringifyRequest(loaderContext, request) {
+    if (typeof loaderContext.utils !== "undefined" &&
+        typeof loaderContext.utils.contextify === "function") {
+        return JSON.stringify(loaderContext.utils.contextify(loaderContext.context || loaderContext.rootContext, request));
+    }
+    const splitted = request.split("!");
+    const { context } = loaderContext;
+    return JSON.stringify(splitted
+        .map(part => {
+        // First, separate singlePath from query, because the query might contain paths again
+        const splittedPart = part.match(/^(.*?)(\?.*)/);
+        const query = splittedPart ? splittedPart[2] : "";
+        let singlePath = splittedPart ? splittedPart[1] : part;
+        if (isAbsolutePath(singlePath) && context) {
+            singlePath = path_1.default.relative(context, singlePath);
+            if (isAbsolutePath(singlePath)) {
+                // If singlePath still matches an absolute path, singlePath was on a different drive than context.
+                // In this case, we leave the path platform-specific without replacing any separators.
+                // @see https://github.com/webpack/loader-utils/pull/14
+                return singlePath + query;
+            }
+            if (isRelativePath(singlePath) === false) {
+                // Ensure that the relative path starts at least with ./ otherwise it would be a request into the modules directory (like node_modules).
+                singlePath = `./${singlePath}`;
+            }
+        }
+        return singlePath.replace(/\\/g, "/") + query;
+    })
+        .join("!"));
+}
+exports.stringifyRequest = stringifyRequest;
+function stringifyLocal(value) {
+    return typeof value === "function" ? value.toString() : JSON.stringify(value);
+}
+exports.stringifyLocal = stringifyLocal;

package/dist/builtin-plugin/index.d.ts

@@ -46,19 +46,17 @@ export * from "./FlagDependencyUsagePlugin";
 export * from "./MangleExportsPlugin";
 export * from "./BundlerInfoRspackPlugin";
 export * from "./ModuleConcatenationPlugin";
+export * from "./CssModulesPlugin";
+export * from "./APIPlugin";
 export * from "./HtmlRspackPlugin";
 export * from "./CopyRspackPlugin";
 export * from "./SwcJsMinimizerPlugin";
 export * from "./SwcCssMinimizerPlugin";
 export * from "./JsLoaderRspackPlugin";
-import { RawBuiltins, RawCssModulesConfig } from "@rspack/binding";
+export * from "./css-extract";
+import { RawBuiltins } from "@rspack/binding";
 import { RspackOptionsNormalized } from "..";
-type BuiltinsCssConfig = {
-    modules?: Partial<RawCssModulesConfig>;
-    namedExports?: boolean;
-};
 export interface Builtins {
-    css?: BuiltinsCssConfig;
     treeShaking?: boolean | "module";
 }
 export declare function deprecated_resolveBuiltins(builtins: Builtins, options: RspackOptionsNormalized): RawBuiltins;

package/dist/builtin-plugin/index.js

@@ -64,11 +64,14 @@ __exportStar(require("./FlagDependencyUsagePlugin"), exports);
 __exportStar(require("./MangleExportsPlugin"), exports);
 __exportStar(require("./BundlerInfoRspackPlugin"), exports);
 __exportStar(require("./ModuleConcatenationPlugin"), exports);
+__exportStar(require("./CssModulesPlugin"), exports);
+__exportStar(require("./APIPlugin"), exports);
 __exportStar(require("./HtmlRspackPlugin"), exports);
 __exportStar(require("./CopyRspackPlugin"), exports);
 __exportStar(require("./SwcJsMinimizerPlugin"), exports);
 __exportStar(require("./SwcCssMinimizerPlugin"), exports);
 __exportStar(require("./JsLoaderRspackPlugin"), exports);
+__exportStar(require("./css-extract"), exports);
 function resolveTreeShaking(treeShaking, production) {
     return treeShaking !== undefined
         ? treeShaking.toString()
@@ -77,23 +80,8 @@ function resolveTreeShaking(treeShaking, production) {
             : "false";
 }
 function deprecated_resolveBuiltins(builtins, options) {
-    var _a, _b;
     const production = options.mode === "production" || !options.mode;
     return {
-        // TODO: discuss with webpack, this should move to css generator options
-        css: options.experiments.css
-            ? {
-                modules: {
-                    localsConvention: "asIs",
-                    localIdentName: production
-                        ? "[hash]"
-                        : "[path][name][ext]__[local]",
-                    exportsOnly: false,
-                    ...(_a = builtins.css) === null || _a === void 0 ? void 0 : _a.modules
-                },
-                namedExports: (_b = builtins.css) === null || _b === void 0 ? void 0 : _b.namedExports
-            }
-            : undefined,
         treeShaking: resolveTreeShaking(builtins.treeShaking, production)
     };
 }

package/dist/config/adapter.js

@@ -336,8 +336,7 @@ const getRawModuleRule = (rule, path, options) => {
             if (rule.resourceQuery && !tryMatch(query, rule.resourceQuery)) {
                 return false;
             }
-            if (rule.resourceFragment &&
-                !tryMatch(fragment, rule.resourceFragment)) {
+            if (rule.resourceFragment && !tryMatch(fragment, rule.resourceFragment)) {
                 return false;
             }
             return true;
@@ -409,9 +408,26 @@ function getRawParserOptions(parser, type) {
             javascript: getRawJavascriptParserOptions(parser)
         };
     }
-    return {
-        type: "unknown"
-    };
+    else if (type === "css") {
+        return {
+            type: "css",
+            css: getRawCssParserOptions(parser)
+        };
+    }
+    else if (type === "css/auto") {
+        return {
+            type: "css/auto",
+            cssAuto: getRawCssParserOptions(parser)
+        };
+    }
+    else if (type === "css/module") {
+        return {
+            type: "css/module",
+            cssModule: getRawCssParserOptions(parser)
+        };
+    }
+    // FIXME: shouldn't depend on module type, for example: `rules: [{ test: /\.css/, generator: {..} }]` will error
+    throw new Error(`unreachable: unknow module type: ${type}`);
 }
 function getRawJavascriptParserOptions(parser) {
     var _a, _b, _c, _d, _e;
@@ -444,6 +460,11 @@ function getRawAssetParserDataUrl(dataUrlCondition) {
     }
     throw new Error(`unreachable: AssetParserDataUrl type should be one of "options", but got ${dataUrlCondition}`);
 }
+function getRawCssParserOptions(parser) {
+    return {
+        namedExports: parser.namedExports
+    };
+}
 function getRawGeneratorOptions(generator, type) {
     if (type === "asset") {
         return {
@@ -467,9 +488,25 @@ function getRawGeneratorOptions(generator, type) {
                 : undefined
         };
     }
-    return {
-        type: "unknown"
-    };
+    if (type === "css") {
+        return {
+            type: "css",
+            css: getRawCssGeneratorOptions(generator)
+        };
+    }
+    if (type === "css/auto") {
+        return {
+            type: "css/auto",
+            cssAuto: getRawCssAutoOrModuleGeneratorOptions(generator)
+        };
+    }
+    if (type === "css/module") {
+        return {
+            type: "css/module",
+            cssModule: getRawCssAutoOrModuleGeneratorOptions(generator)
+        };
+    }
+    throw new Error(`unreachable: unknow module type: ${type}`);
 }
 function getRawAssetGeneratorOptions(options) {
     return {
@@ -503,6 +540,19 @@ function getRawAssetGeneratorDataUrl(dataUrl) {
     }
     throw new Error(`unreachable: AssetGeneratorDataUrl type should be one of "options", "function", but got ${dataUrl}`);
 }
+function getRawCssGeneratorOptions(options) {
+    return {
+        exportsConvention: options.exportsConvention,
+        exportsOnly: options.exportsOnly
+    };
+}
+function getRawCssAutoOrModuleGeneratorOptions(options) {
+    return {
+        localIdentName: options.localIdentName,
+        exportsConvention: options.exportsConvention,
+        exportsOnly: options.exportsOnly
+    };
+}
 function getRawOptimization(optimization) {
     (0, assert_1.default)(!(0, util_1.isNil)(optimization.removeAvailableModules) &&
         !(0, util_1.isNil)(optimization.sideEffects) &&

package/dist/config/adapterRuleUse.d.ts

@@ -96,8 +96,8 @@ export interface LoaderContext<OptionsType = {}> {
     getMissingDependencies(): string[];
     addBuildDependency(file: string): void;
     importModule(request: string, options: {
-        publicPath: string;
-        baseUri: string;
+        publicPath?: string;
+        baseUri?: string;
     }, callback: (err?: Error, res?: any) => void): void;
     fs: any;
     utils: {