@rspack/core 0.7.5-canary-0d03907-20240624125011 → 0.7.5

package/dist/Module.js

@@ -27,7 +27,6 @@ class Module {
         this.request = module.request;
         this.userRequest = module.userRequest;
         this.rawRequest = module.rawRequest;
-        this.factoryMeta = module.factoryMeta;
         const customModule = compilation?.__internal__getCustomModule(module.moduleIdentifier);
         this.buildInfo = customModule?.buildInfo || {};
         this.buildMeta = customModule?.buildMeta || {};

package/dist/NormalModule.d.ts

@@ -3,6 +3,7 @@ import { AsyncSeriesBailHook, HookMap, SyncHook } from "tapable";
 import { Compilation } from "./Compilation";
 import { LoaderContext } from "./config";
 export declare class NormalModule {
+    constructor();
     static getCompilationHooks(compilation: Compilation): {
         loader: SyncHook<[LoaderContext<{}>], void, import("tapable").UnsetAdditionalOptions>;
         readResourceForScheme: any;

package/dist/NormalModule.js

@@ -46,7 +46,10 @@ const deprecateAllProperties = (obj, message, code) => {
     }
     return newObj;
 };
+// Actually it is just a NormalModule proxy, used for hooks api alignment
+// Maybe we can 1:1 align to webpack NormalModule once we found a better way to reduce communicate overhead between rust and js
 class NormalModule {
+    constructor() { }
     static getCompilationHooks(compilation) {
         if (!(compilation instanceof Compilation_1.Compilation)) {
             throw new TypeError("The 'compilation' argument must be an instance of Compilation");
@@ -55,6 +58,9 @@ class NormalModule {
         if (hooks === undefined) {
             hooks = {
                 loader: new tapable_1.SyncHook(["loaderContext"]),
+                // beforeLoaders: new SyncHook(["loaders", "module", "loaderContext"]),
+                // beforeParse: new SyncHook(["module"]),
+                // beforeSnapshot: new SyncHook(["module"]),
                 // TODO webpack 6 deprecate
                 readResourceForScheme: new tapable_1.HookMap(scheme => {
                     const hook = hooks.readResource.for(scheme);
@@ -65,6 +71,7 @@ class NormalModule {
                     });
                 }),
                 readResource: new tapable_1.HookMap(() => new tapable_1.AsyncSeriesBailHook(["loaderContext"]))
+                // needBuild: new AsyncSeriesBailHook(["module", "context"])
             };
             compilationHooksMap.set(compilation, hooks);
         }

package/dist/NormalModuleFactory.js

@@ -28,13 +28,35 @@ const liteTapable = __importStar(require("./lite-tapable"));
 class NormalModuleFactory {
     constructor() {
         this.hooks = {
+            // /** @type {AsyncSeriesBailHook<[ResolveData], Module | false | void>} */
+            // resolve: new AsyncSeriesBailHook(["resolveData"]),
+            // /** @type {HookMap<AsyncSeriesBailHook<[ResourceDataWithData, ResolveData], true | void>>} */
             resolveForScheme: new liteTapable.HookMap(() => new liteTapable.AsyncSeriesBailHook(["resourceData"])),
+            // /** @type {HookMap<AsyncSeriesBailHook<[ResourceDataWithData, ResolveData], true | void>>} */
+            // resolveInScheme: new HookMap(
+            // 	() => new AsyncSeriesBailHook(["resourceData", "resolveData"])
+            // ),
+            // /** @type {AsyncSeriesBailHook<[ResolveData], Module>} */
+            // factorize: new AsyncSeriesBailHook(["resolveData"]),
+            // /** @type {AsyncSeriesBailHook<[ResolveData], false | void>} */
             beforeResolve: new liteTapable.AsyncSeriesBailHook(["resolveData"]),
+            // /** @type {AsyncSeriesBailHook<[ResolveData], false | void>} */
             afterResolve: new liteTapable.AsyncSeriesBailHook(["resolveData"]),
+            // /** @type {AsyncSeriesBailHook<[ResolveData["createData"], ResolveData], Module | void>} */
             createModule: new liteTapable.AsyncSeriesBailHook([
                 "createData",
                 "resolveData"
             ])
+            // /** @type {SyncWaterfallHook<[Module, ResolveData["createData"], ResolveData], Module>} */
+            // module: new SyncWaterfallHook(["module", "createData", "resolveData"]),
+            // createParser: new HookMap(() => new SyncBailHook(["parserOptions"])),
+            // parser: new HookMap(() => new SyncHook(["parser", "parserOptions"])),
+            // createGenerator: new HookMap(
+            // 	() => new SyncBailHook(["generatorOptions"])
+            // ),
+            // generator: new HookMap(
+            // 	() => new SyncHook(["generator", "generatorOptions"])
+            // )
         };
     }
 }

package/dist/Stats.d.ts

@@ -1,4 +1,4 @@
-import { Compilation } from "./Compilation";
+import { Compilation } from ".";
 import { StatsOptions, StatsValue } from "./config";
 import type { StatsCompilation } from "./stats/statsFactoryUtils";
 export type { StatsAsset, StatsChunk, StatsCompilation, StatsError, StatsModule, StatsWarnings } from "./stats/statsFactoryUtils";
@@ -6,7 +6,7 @@ export declare class Stats {
     #private;
     compilation: Compilation;
     constructor(compilation: Compilation);
-    get hash(): Readonly<string | null>;
+    get hash(): string | null;
     hasErrors(): boolean;
     hasWarnings(): boolean;
     toJson(opts?: StatsValue, forToString?: boolean): StatsCompilation;

package/dist/builtin-loader/swc/emotion.d.ts

@@ -0,0 +1,17 @@
+type EmotionConfigImportMap = {
+    [packageName: string]: {
+        [exportName: string]: {
+            canonicalImport?: [string, string];
+        };
+    };
+};
+type EmotionConfig = {
+    sourceMap?: boolean;
+    autoLabel?: "never" | "dev-only" | "always";
+    labelFormat?: string;
+    importMap?: EmotionConfigImportMap;
+};
+type EmotionOptions = boolean | EmotionConfig | undefined;
+declare function resolveEmotion(emotion: EmotionOptions, isProduction: boolean): EmotionConfig | undefined;
+export { resolveEmotion };
+export type { EmotionOptions };

package/dist/builtin-loader/swc/emotion.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveEmotion = void 0;
+function resolveEmotion(emotion, isProduction) {
+    if (!emotion) {
+        return undefined;
+    }
+    if (emotion === true) {
+        emotion = {};
+    }
+    const autoLabel = emotion?.autoLabel ?? "dev-only";
+    const emotionConfig = {
+        enabled: true,
+        // @ts-expect-error autoLabel is string for JavaScript interface, however is boolean for Rust interface
+        autoLabel: autoLabel === "dev-only" ? !isProduction : autoLabel === "always",
+        importMap: emotion?.importMap,
+        labelFormat: emotion?.labelFormat ?? "[local]",
+        sourcemap: isProduction ? false : emotion?.sourceMap ?? true
+    };
+    return emotionConfig;
+}
+exports.resolveEmotion = resolveEmotion;

package/dist/builtin-loader/swc/index.d.ts

@@ -1,7 +1,11 @@
+export type { EmotionOptions } from "./emotion";
+export { resolveEmotion } from "./emotion";
 export { resolvePluginImport } from "./pluginImport";
 export type { PluginImportOptions } from "./pluginImport";
 export type { ReactOptions } from "./react";
 export { resolveReact } from "./react";
 export { resolvePreact } from "./preact";
 export type { PreactOptions } from "./preact";
+export type { RelayOptions } from "./relay";
+export { resolveRelay } from "./relay";
 export type { SwcLoaderEnvConfig, SwcLoaderEsParserConfig, SwcLoaderJscConfig, SwcLoaderModuleConfig, SwcLoaderOptions, SwcLoaderParserConfig, SwcLoaderTransformConfig, SwcLoaderTsParserConfig } from "./types";

package/dist/builtin-loader/swc/index.js

@@ -1,9 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.resolvePreact = exports.resolveReact = exports.resolvePluginImport = void 0;
+exports.resolveRelay = exports.resolvePreact = exports.resolveReact = exports.resolvePluginImport = exports.resolveEmotion = void 0;
+var emotion_1 = require("./emotion");
+Object.defineProperty(exports, "resolveEmotion", { enumerable: true, get: function () { return emotion_1.resolveEmotion; } });
 var pluginImport_1 = require("./pluginImport");
 Object.defineProperty(exports, "resolvePluginImport", { enumerable: true, get: function () { return pluginImport_1.resolvePluginImport; } });
 var react_1 = require("./react");
 Object.defineProperty(exports, "resolveReact", { enumerable: true, get: function () { return react_1.resolveReact; } });
 var preact_1 = require("./preact");
 Object.defineProperty(exports, "resolvePreact", { enumerable: true, get: function () { return preact_1.resolvePreact; } });
+var relay_1 = require("./relay");
+Object.defineProperty(exports, "resolveRelay", { enumerable: true, get: function () { return relay_1.resolveRelay; } });

package/dist/builtin-loader/swc/preact.d.ts

@@ -1,6 +1,7 @@
 type RawPreactOptions = {
     library?: string;
 };
-export type PreactOptions = RawPreactOptions | boolean | undefined;
-export declare function resolvePreact(preact: PreactOptions): RawPreactOptions | undefined;
-export {};
+type PreactOptions = RawPreactOptions | boolean | undefined;
+declare function resolvePreact(preact: PreactOptions): RawPreactOptions | undefined;
+export { resolvePreact };
+export type { PreactOptions };

package/dist/builtin-loader/swc/relay.d.ts

@@ -0,0 +1,5 @@
+import type { RawRelayConfig } from "@rspack/binding";
+type RelayOptions = boolean | RawRelayConfig | undefined;
+declare function resolveRelay(relay: RelayOptions, rootDir: string): RawRelayConfig | undefined;
+export { resolveRelay };
+export type { RelayOptions };

package/dist/builtin-loader/swc/relay.js

@@ -0,0 +1,48 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveRelay = void 0;
+const path_1 = __importDefault(require("path"));
+function getRelayConfigFromProject(rootDir) {
+    for (const configName of [
+        "relay.config.json",
+        "relay.config.js",
+        "package.json"
+    ]) {
+        const configPath = path_1.default.join(rootDir, configName);
+        try {
+            let config = require(configPath);
+            let finalConfig;
+            if (configName === "package.json") {
+                finalConfig = config?.relay;
+            }
+            else {
+                finalConfig = config;
+            }
+            if (finalConfig) {
+                return {
+                    language: finalConfig.language,
+                    artifactDirectory: finalConfig.artifactDirectory
+                };
+            }
+        }
+        catch (_) { }
+    }
+}
+function resolveRelay(relay, rootDir) {
+    if (!relay) {
+        return undefined;
+    }
+    // Search relay config based on
+    if (relay === true) {
+        return (getRelayConfigFromProject(rootDir) || {
+            language: "javascript"
+        });
+    }
+    else {
+        return relay;
+    }
+}
+exports.resolveRelay = resolveRelay;

package/dist/builtin-loader/swc/types.d.ts

@@ -2,9 +2,22 @@
  * Some types are modified from https://github.com/swc-project/swc/blob/16a38851/packages/types/index.ts#L647
  * license at https://github.com/swc-project/swc/blob/main/LICENSE
  */
+import type { EmotionOptions } from "./emotion";
 import type { PluginImportOptions } from "./pluginImport";
-import type { PreactOptions } from "./preact";
 import type { ReactOptions } from "./react";
+import type { RelayOptions } from "./relay";
+export type StyledComponentsOptions = {
+    displayName?: boolean;
+    ssr?: boolean;
+    fileName?: boolean;
+    meaninglessFileNames?: string[];
+    namespace?: string;
+    topLevelImportPaths?: string[];
+    transpileTemplateLiterals?: boolean;
+    minify?: boolean;
+    pure?: boolean;
+    cssProps?: boolean;
+};
 export type JscTarget = "es3" | "es5" | "es2015" | "es2016" | "es2017" | "es2018" | "es2019" | "es2020" | "es2021" | "es2022" | "esnext";
 export type SwcLoaderParserConfig = SwcLoaderTsParserConfig | SwcLoaderEsParserConfig;
 export interface SwcLoaderTsParserConfig {
@@ -441,7 +454,9 @@ export type SwcLoaderOptions = {
      * @experimental
      */
     rspackExperiments?: {
+        relay?: RelayOptions;
+        emotion?: EmotionOptions;
         import?: PluginImportOptions;
-        preact?: PreactOptions;
+        styledComponents?: StyledComponentsOptions;
     };
 };

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

@@ -1,16 +1,10 @@
-import { BuiltinPlugin, BuiltinPluginName } from "@rspack/binding";
-import { Compilation } from "../Compilation";
-import * as liteTapable from "../lite-tapable";
-import { RspackBuiltinPlugin } from "./base";
-import Hash = require("../util/hash");
-import { Chunk } from "../Chunk";
-export type CompilationHooks = {
-    chunkHash: liteTapable.SyncHook<[Chunk, Hash]>;
+import { BuiltinPluginName } from "@rspack/binding";
+export declare const JavascriptModulesPlugin: {
+    new (): {
+        name: BuiltinPluginName;
+        _options: void;
+        affectedHooks: "make" | "compile" | "emit" | "afterEmit" | "invalid" | "done" | "thisCompilation" | "afterDone" | "compilation" | "normalModuleFactory" | "contextModuleFactory" | "initialize" | "shouldEmit" | "infrastructureLog" | "beforeRun" | "run" | "assetEmitted" | "failed" | "shutdown" | "watchRun" | "watchClose" | "environment" | "afterEnvironment" | "afterPlugins" | "afterResolvers" | "beforeCompile" | "afterCompile" | "finishMake" | "entryOption" | undefined;
+        raw(): import("@rspack/binding").BuiltinPlugin;
+        apply(compiler: import("../Compiler").Compiler): void;
+    };
 };
-export declare class JavascriptModulesPlugin extends RspackBuiltinPlugin {
-    name: BuiltinPluginName;
-    affectedHooks: "compilation";
-    constructor();
-    raw(): BuiltinPlugin;
-    static getCompilationHooks(compilation: Compilation): CompilationHooks;
-}

package/dist/builtin-plugin/JavascriptModulesPlugin.js

@@ -1,55 +1,6 @@
 "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.JavascriptModulesPlugin = void 0;
 const binding_1 = require("@rspack/binding");
-const Compilation_1 = require("../Compilation");
-const liteTapable = __importStar(require("../lite-tapable"));
 const base_1 = require("./base");
-const compilationHooksMap = new WeakMap();
-class JavascriptModulesPlugin extends base_1.RspackBuiltinPlugin {
-    constructor() {
-        super();
-        this.name = binding_1.BuiltinPluginName.JavascriptModulesPlugin;
-        this.affectedHooks = "compilation";
-    }
-    raw() {
-        return (0, base_1.createBuiltinPlugin)(this.name, undefined);
-    }
-    static getCompilationHooks(compilation) {
-        if (!(compilation instanceof Compilation_1.Compilation)) {
-            throw new TypeError("The 'compilation' argument must be an instance of Compilation");
-        }
-        let hooks = compilationHooksMap.get(compilation);
-        if (hooks === undefined) {
-            hooks = {
-                chunkHash: new liteTapable.SyncHook(["chunk", "hash"])
-            };
-            compilationHooksMap.set(compilation, hooks);
-        }
-        return hooks;
-    }
-}
-exports.JavascriptModulesPlugin = JavascriptModulesPlugin;
+exports.JavascriptModulesPlugin = (0, base_1.create)(binding_1.BuiltinPluginName.JavascriptModulesPlugin, () => { }, "compilation");

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

@@ -3,8 +3,8 @@ import { Compiler } from "../..";
 export * from "./loader";
 export type { CssExtractRspackLoaderOptions } from "./loader";
 export interface CssExtractRspackPluginOptions {
-    filename?: RawCssExtractPluginOption["filename"];
-    chunkFilename?: RawCssExtractPluginOption["chunkFilename"];
+    filename?: string;
+    chunkFilename?: string;
     ignoreOrder?: boolean;
     insert?: string | ((linkTag: HTMLLinkElement) => void);
     attributes?: Record<string, string>;

package/dist/config/adapter.js

@@ -85,24 +85,21 @@ function getRawResolveByDependency(byDependency) {
         return byDependency;
     return Object.fromEntries(Object.entries(byDependency).map(([k, v]) => [k, getRawResolve(v)]));
 }
-function getRawTsConfig(tsConfig) {
-    (0, assert_1.default)(typeof tsConfig !== "string", "should resolve string tsConfig in normalization");
-    if (tsConfig === undefined)
-        return tsConfig;
-    const { configFile, references } = tsConfig;
-    return {
-        configFile,
-        referencesType: references == "auto" ? "auto" : references ? "manual" : "disabled",
-        references: references == "auto" ? undefined : references
-    };
-}
 function getRawResolve(resolve) {
+    let references = resolve.tsConfig?.references;
+    let tsconfigConfigFile = resolve.tsConfigPath ?? resolve.tsConfig?.configFile;
     return {
         ...resolve,
         alias: getRawAlias(resolve.alias),
         fallback: getRawAlias(resolve.fallback),
         extensionAlias: getRawExtensionAlias(resolve.extensionAlias),
-        tsconfig: getRawTsConfig(resolve.tsConfig),
+        tsconfig: tsconfigConfigFile
+            ? {
+                configFile: tsconfigConfigFile,
+                referencesType: references == "auto" ? "auto" : references ? "manual" : "disabled",
+                references: references == "auto" ? undefined : references
+            }
+            : undefined,
         byDependency: getRawResolveByDependency(resolve.byDependency)
     };
 }
@@ -467,19 +464,9 @@ function getRawJavascriptParserOptions(parser) {
         reexportExportsPresence: parser.reexportExportsPresence === false
             ? "false"
             : parser.reexportExportsPresence,
-        strictExportPresence: parser.strictExportPresence ?? false,
-        worker: getRawJavascriptParserOptionsWorker(parser.worker)
+        strictExportPresence: parser.strictExportPresence ?? false
     };
 }
-function getRawJavascriptParserOptionsWorker(worker) {
-    const DEFAULT_SYNTAX = [
-        "Worker",
-        "SharedWorker",
-        // "navigator.serviceWorker.register()",
-        "Worker from worker_threads"
-    ];
-    return (worker === false ? [] : Array.isArray(worker) ? worker : ["..."]).flatMap(item => (item === "..." ? DEFAULT_SYNTAX : item));
-}
 function getRawAssetParserOptions(parser) {
     return {
         dataUrlCondition: parser.dataUrlCondition

package/dist/config/adapterRuleUse.js

@@ -16,9 +16,20 @@ exports.createRawModuleRuleUses = createRawModuleRuleUses;
 const getSwcLoaderOptions = (o, options) => {
     if (o && typeof o === "object" && o.rspackExperiments) {
         let expr = o.rspackExperiments;
+        const contextPath = options.context;
+        const production = options.mode === "production" || !options.mode;
+        if (expr.emotion) {
+            expr.emotion = (0, builtin_loader_1.resolveEmotion)(expr.emotion, production);
+        }
+        if (expr.relay) {
+            expr.relay = (0, builtin_loader_1.resolveRelay)(expr.relay, contextPath);
+        }
         if (expr.import || expr.pluginImport) {
             expr.import = (0, builtin_loader_1.resolvePluginImport)(expr.import || expr.pluginImport);
         }
+        if (expr.react) {
+            expr.react = (0, builtin_loader_1.resolveReact)(expr.react);
+        }
         if (expr.preact) {
             expr.preact = (0, builtin_loader_1.resolvePreact)(expr.preact);
         }

package/dist/config/defaults.js

@@ -155,7 +155,6 @@ const applyJavascriptParserOptionsDefaults = (parserOptions, fallback) => {
     D(parserOptions, "importExportsPresence", fallback?.importExportsPresence);
     D(parserOptions, "reexportExportsPresence", fallback?.reexportExportsPresence);
     D(parserOptions, "strictExportPresence", fallback?.strictExportPresence ?? false);
-    D(parserOptions, "worker", fallback?.worker ?? ["..."]);
 };
 const applyModuleDefaults = (module, { asyncWebAssembly, css, targetProperties }) => {
     (0, assertNotNil_1.assertNotNill)(module.parser);

package/dist/config/normalization.js

@@ -123,20 +123,10 @@ const getNormalizedRspackOptions = (config) => {
             };
         }),
         resolve: nestedConfig(config.resolve, resolve => ({
-            ...resolve,
-            tsConfig: optionalNestedConfig(resolve.tsConfig, tsConfig => {
-                return typeof tsConfig === "string"
-                    ? { configFile: tsConfig }
-                    : tsConfig;
-            })
+            ...resolve
         })),
         resolveLoader: nestedConfig(config.resolveLoader, resolve => ({
-            ...resolve,
-            tsConfig: optionalNestedConfig(resolve.tsConfig, tsConfig => {
-                return typeof tsConfig === "string"
-                    ? { configFile: tsConfig }
-                    : tsConfig;
-            })
+            ...resolve
         })),
         module: nestedConfig(config.module, module => ({
             noParse: module.noParse,