@rspack/core 0.5.9-canary-73d1234-20240407005733 → 0.5.9-canary-ba4ea23-20240407091611

package/dist/ExecuteModulePlugin.js

@@ -13,10 +13,10 @@ class ExecuteModulePlugin {
                 const moduleObject = options.moduleObject;
                 const source = options.codeGenerationResult.get("javascript");
                 try {
-                    const fn = node_vm_1.default.runInThisContext(`(function(module, __webpack_exports__, ${_1.RuntimeGlobals.require}) {\n${source}\n})`, {
+                    const fn = node_vm_1.default.runInThisContext(`(function(module, __webpack_module__, __webpack_exports__, exports, ${_1.RuntimeGlobals.require}) {\n${source}\n})`, {
                         filename: moduleObject.id
                     });
-                    fn.call(moduleObject.exports, moduleObject, moduleObject.exports, context.__webpack_require__);
+                    fn.call(moduleObject.exports, moduleObject, moduleObject, moduleObject.exports, moduleObject.exports, context.__webpack_require__);
                 }
                 catch (e) {
                     let err = e instanceof Error ? e : new Error(e);

package/dist/Module.d.ts

@@ -21,6 +21,7 @@ export type ResolveData = {
 export declare class Module {
     #private;
     _originalSource?: Source;
+    rawRequest?: string;
     static __from_binding(module: JsModule): Module;
     constructor(module: JsModule);
     get context(): string | undefined;

package/dist/Module.js

@@ -21,6 +21,7 @@ class Module {
     constructor(module) {
         _Module_inner.set(this, void 0);
         __classPrivateFieldSet(this, _Module_inner, module, "f");
+        this.rawRequest = module.rawRequest;
     }
     get context() {
         return __classPrivateFieldGet(this, _Module_inner, "f").context;

package/dist/builtin-plugin/SplitChunksPlugin.js

@@ -65,10 +65,11 @@ function toRawSplitChunksOptions(sc, compiler) {
             return chunks;
         }
     }
-    const { name, chunks, cacheGroups = {}, fallbackCacheGroup, ...passThrough } = sc;
+    const { name, chunks, defaultSizeTypes, cacheGroups = {}, fallbackCacheGroup, ...passThrough } = sc;
     return {
         name: getName(name),
         chunks: getChunks(chunks),
+        defaultSizeTypes: defaultSizeTypes || ["javascript", "unknown"],
         cacheGroups: Object.entries(cacheGroups)
             .filter(([_key, group]) => group !== false)
             .map(([key, group]) => {

package/dist/builtin-plugin/css-extract/hmr/hotModuleReplacement.d.ts

@@ -0,0 +1,3 @@
+declare function _exports(moduleId: TODO, options: TODO): TODO;
+export = _exports;
+export type TODO = any;

package/dist/builtin-plugin/css-extract/hmr/hotModuleReplacement.js

@@ -0,0 +1,222 @@
+"use strict";
+/* eslint-env browser */
+/*
+  eslint-disable
+  no-console,
+  func-names
+*/
+/** @typedef {any} TODO */
+const normalizeUrl = require("./normalize-url");
+const srcByModuleId = Object.create(null);
+const noDocument = typeof document === "undefined";
+const { forEach } = Array.prototype;
+/**
+ * @param {function} fn
+ * @param {number} time
+ * @returns {(function(): void)|*}
+ */
+function debounce(fn, time) {
+    let timeout = 0;
+    return function () {
+        // @ts-ignore
+        const self = this;
+        // eslint-disable-next-line prefer-rest-params
+        const args = arguments;
+        const functionCall = function functionCall() {
+            return fn.apply(self, args);
+        };
+        clearTimeout(timeout);
+        // @ts-ignore
+        timeout = setTimeout(functionCall, time);
+    };
+}
+function noop() { }
+/**
+ * @param {TODO} moduleId
+ * @returns {TODO}
+ */
+function getCurrentScriptUrl(moduleId) {
+    let src = srcByModuleId[moduleId];
+    if (!src) {
+        if (document.currentScript) {
+            ({ src } = /** @type {HTMLScriptElement} */ (document.currentScript));
+        }
+        else {
+            const scripts = document.getElementsByTagName("script");
+            const lastScriptTag = scripts[scripts.length - 1];
+            if (lastScriptTag) {
+                ({ src } = lastScriptTag);
+            }
+        }
+        srcByModuleId[moduleId] = src;
+    }
+    /**
+     * @param {string} fileMap
+     * @returns {null | string[]}
+     */
+    return function (fileMap) {
+        if (!src) {
+            return null;
+        }
+        const splitResult = src.split(/([^\\/]+)\.js$/);
+        const filename = splitResult && splitResult[1];
+        if (!filename) {
+            return [src.replace(".js", ".css")];
+        }
+        if (!fileMap) {
+            return [src.replace(".js", ".css")];
+        }
+        return fileMap.split(",").map(mapRule => {
+            const reg = new RegExp(`${filename}\\.js$`, "g");
+            return normalizeUrl(src.replace(reg, `${mapRule.replace(/{fileName}/g, filename)}.css`));
+        });
+    };
+}
+/**
+ * @param {TODO} el
+ * @param {string} [url]
+ */
+function updateCss(el, url) {
+    if (!url) {
+        if (!el.href) {
+            return;
+        }
+        // eslint-disable-next-line
+        url = el.href.split("?")[0];
+    }
+    if (!isUrlRequest(/** @type {string} */ (url))) {
+        return;
+    }
+    if (el.isLoaded === false) {
+        // We seem to be about to replace a css link that hasn't loaded yet.
+        // We're probably changing the same file more than once.
+        return;
+    }
+    if (!url || !(url.indexOf(".css") > -1)) {
+        return;
+    }
+    // eslint-disable-next-line no-param-reassign
+    el.visited = true;
+    const newEl = el.cloneNode();
+    newEl.isLoaded = false;
+    newEl.addEventListener("load", () => {
+        if (newEl.isLoaded) {
+            return;
+        }
+        newEl.isLoaded = true;
+        el.parentNode.removeChild(el);
+    });
+    newEl.addEventListener("error", () => {
+        if (newEl.isLoaded) {
+            return;
+        }
+        newEl.isLoaded = true;
+        el.parentNode.removeChild(el);
+    });
+    newEl.href = `${url}?${Date.now()}`;
+    if (el.nextSibling) {
+        el.parentNode.insertBefore(newEl, el.nextSibling);
+    }
+    else {
+        el.parentNode.appendChild(newEl);
+    }
+}
+/**
+ * @param {string} href
+ * @param {TODO} src
+ * @returns {TODO}
+ */
+function getReloadUrl(href, src) {
+    let ret;
+    // eslint-disable-next-line no-param-reassign
+    href = normalizeUrl(href);
+    src.some(
+    /**
+     * @param {string} url
+     */
+    // eslint-disable-next-line array-callback-return
+    url => {
+        if (href.indexOf(src) > -1) {
+            ret = url;
+        }
+    });
+    return ret;
+}
+/**
+ * @param {string} [src]
+ * @returns {boolean}
+ */
+function reloadStyle(src) {
+    if (!src) {
+        return false;
+    }
+    const elements = document.querySelectorAll("link");
+    let loaded = false;
+    forEach.call(elements, el => {
+        if (!el.href) {
+            return;
+        }
+        const url = getReloadUrl(el.href, src);
+        if (!isUrlRequest(url)) {
+            return;
+        }
+        if (el.visited === true) {
+            return;
+        }
+        if (url) {
+            updateCss(el, url);
+            loaded = true;
+        }
+    });
+    return loaded;
+}
+function reloadAll() {
+    const elements = document.querySelectorAll("link");
+    forEach.call(elements, el => {
+        if (el.visited === true) {
+            return;
+        }
+        updateCss(el);
+    });
+}
+/**
+ * @param {string} url
+ * @returns {boolean}
+ */
+function isUrlRequest(url) {
+    // An URL is not an request if
+    // It is not http or https
+    if (!/^[a-zA-Z][a-zA-Z\d+\-.]*:/.test(url)) {
+        return false;
+    }
+    return true;
+}
+/**
+ * @param {TODO} moduleId
+ * @param {TODO} options
+ * @returns {TODO}
+ */
+module.exports = function (moduleId, options) {
+    if (noDocument) {
+        console.log("no window.document found, will not HMR CSS");
+        return noop;
+    }
+    const getScriptSrc = getCurrentScriptUrl(moduleId);
+    function update() {
+        const src = getScriptSrc(options.filename);
+        const reloaded = reloadStyle(src);
+        if (options.locals) {
+            console.log("[HMR] Detected local css modules. Reload all css");
+            reloadAll();
+            return;
+        }
+        if (reloaded) {
+            console.log("[HMR] css reload %s", src.join(" "));
+        }
+        else {
+            console.log("[HMR] Reload all css");
+            reloadAll();
+        }
+    }
+    return debounce(update, 50);
+};

package/dist/builtin-plugin/css-extract/hmr/normalize-url.d.ts

@@ -0,0 +1,2 @@
+declare function _exports(urlString: string): string;
+export = _exports;

package/dist/builtin-plugin/css-extract/hmr/normalize-url.js

@@ -0,0 +1,38 @@
+"use strict";
+/* eslint-disable */
+/**
+ * @param {string[]} pathComponents
+ * @returns {string}
+ */
+function normalizeUrl(pathComponents) {
+    return pathComponents
+        .reduce(function (accumulator, item) {
+        switch (item) {
+            case "..":
+                accumulator.pop();
+                break;
+            case ".":
+                break;
+            default:
+                accumulator.push(item);
+        }
+        return accumulator;
+    }, /** @type {string[]} */ ([]))
+        .join("/");
+}
+/**
+ * @param {string} urlString
+ * @returns {string}
+ */
+module.exports = function (urlString) {
+    urlString = urlString.trim();
+    if (/^data:/i.test(urlString)) {
+        return urlString;
+    }
+    var protocol = urlString.indexOf("//") !== -1 ? urlString.split("//")[0] + "//" : "";
+    var components = urlString.replace(new RegExp(protocol, "i"), "").split("/");
+    var host = components[0].toLowerCase().replace(/\.$/, "");
+    components[0] = "";
+    var path = normalizeUrl(components);
+    return protocol + host + path;
+};

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

@@ -0,0 +1,22 @@
+import type { RawCssExtractPluginOption } from "@rspack/binding";
+import { Compiler } from "../..";
+export * from "./loader";
+export interface PluginOptions {
+    filename?: string;
+    chunkFilename?: string;
+    ignoreOrder?: boolean;
+    insert?: string | ((linkTag: HTMLLinkElement) => void);
+    attributes?: Record<string, string>;
+    linkType?: string | "text/css" | false;
+    runtime?: boolean;
+    pathinfo?: boolean;
+}
+export declare class CssExtractRspackPlugin {
+    static pluginName: string;
+    static loader: string;
+    options: PluginOptions;
+    constructor(options?: PluginOptions);
+    apply(compiler: Compiler): void;
+    normalizeOptions(options: PluginOptions): RawCssExtractPluginOption;
+}
+export default CssExtractRspackPlugin;

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

@@ -0,0 +1,109 @@
+"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 });
+exports.CssExtractRspackPlugin = void 0;
+const loader_1 = require("./loader");
+__exportStar(require("./loader"), exports);
+const DEFAULT_FILENAME = "[name].css";
+const LOADER_PATH = require.resolve("./loader");
+class CssExtractRspackPlugin {
+    constructor(options) {
+        this.options = options || {};
+    }
+    apply(compiler) {
+        const { splitChunks } = compiler.options.optimization;
+        if (splitChunks) {
+            if (
+            /** @type {string[]} */ splitChunks.defaultSizeTypes.includes("...")) {
+                /** @type {string[]} */
+                splitChunks.defaultSizeTypes.push(loader_1.MODULE_TYPE);
+            }
+        }
+        if (
+        // @ts-expect-error rspack don't support pathinfo for now
+        compiler.options.output.pathinfo &&
+            this.options.pathinfo === undefined) {
+            this.options.pathinfo = true;
+        }
+        compiler.__internal__registerBuiltinPlugin({
+            // @ts-expect-error CssExtractPlugin is a constant value of BuiltinPlugin
+            name: "CssExtractPlugin",
+            options: this.normalizeOptions(this.options)
+        });
+    }
+    normalizeOptions(options) {
+        var _a, _b, _c;
+        let chunkFilename = options.chunkFilename;
+        if (!chunkFilename) {
+            const filename = options.filename || DEFAULT_FILENAME;
+            if (typeof filename !== "function") {
+                const hasName = /** @type {string} */ filename.includes("[name]");
+                const hasId = /** @type {string} */ filename.includes("[id]");
+                const hasChunkHash = 
+                /** @type {string} */
+                filename.includes("[chunkhash]");
+                const hasContentHash = 
+                /** @type {string} */
+                filename.includes("[contenthash]");
+                // Anything changing depending on chunk is fine
+                if (hasChunkHash || hasContentHash || hasName || hasId) {
+                    chunkFilename = filename;
+                }
+                else {
+                    // Otherwise prefix "[id]." in front of the basename to make it changing
+                    chunkFilename =
+                        /** @type {string} */
+                        filename.replace(/(^|\/)([^/]*(?:\?|$))/, "$1[id].$2");
+                }
+            }
+            else {
+                chunkFilename = "[id].css";
+            }
+        }
+        const normalzedOptions = {
+            filename: options.filename || DEFAULT_FILENAME,
+            chunkFilename: chunkFilename,
+            ignoreOrder: (_a = options.ignoreOrder) !== null && _a !== void 0 ? _a : false,
+            runtime: (_b = options.runtime) !== null && _b !== void 0 ? _b : true,
+            insert: typeof options.insert === "function"
+                ? options.insert.toString()
+                : JSON.stringify(options.insert),
+            linkType: typeof options.linkType === "undefined"
+                ? JSON.stringify("text/css")
+                : options.linkType === false
+                    ? undefined
+                    : JSON.stringify(options.linkType),
+            attributes: options.attributes
+                ? Reflect.ownKeys(options.attributes)
+                    .map(k => [
+                    JSON.stringify(k),
+                    JSON.stringify(options.attributes[k])
+                ])
+                    .reduce((obj, [k, v]) => {
+                    // @ts-expect-error
+                    obj[k] = v;
+                    return obj;
+                }, {})
+                : {},
+            pathinfo: (_c = options.pathinfo) !== null && _c !== void 0 ? _c : false
+        };
+        return normalzedOptions;
+    }
+}
+CssExtractRspackPlugin.pluginName = "css-extract-rspack-plugin";
+CssExtractRspackPlugin.loader = LOADER_PATH;
+exports.CssExtractRspackPlugin = CssExtractRspackPlugin;
+exports.default = CssExtractRspackPlugin;

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,180 @@
+"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}
+    }
+  `;
+}
+// mini-css-extract-plugin
+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) {
+        this.emitWarning(new Error("You can't use `experiments.css` and `mini-css-extract-plugin` together, please set `experiments.css` to `false`"));
+        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
+                    };
+                });
+            }
+        }
+        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;