@esmx/rspack 3.0.0-rc.77 → 3.0.0-rc.79

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-export { type RspackAppConfigContext, type RspackAppChainContext, type RspackAppOptions, type BuildTarget, createRspackApp, RSPACK_LOADER } from './rspack';
+export { type BuildTarget, createRspackApp, RSPACK_LOADER, type RspackAppChainContext, type RspackAppConfigContext, type RspackAppOptions } from './rspack';
 export { createRspackHtmlApp, type RspackHtmlAppOptions } from './rspack-html';
 import * as rspack from '@rspack/core';
 export { rspack };

package/dist/module-link/config.d.ts

@@ -0,0 +1,5 @@
+import type RspackChain from 'rspack-chain';
+import type { ParsedModuleLinkPluginOptions } from './types';
+export declare function applyEntryConfig(chain: RspackChain, opts: ParsedModuleLinkPluginOptions): void;
+export declare function applyModuleConfig(chain: RspackChain): void;
+export declare function applyExternalsConfig(chain: RspackChain, opts: ParsedModuleLinkPluginOptions): void;

package/dist/module-link/config.mjs

@@ -0,0 +1,100 @@
+export function applyEntryConfig(chain, opts) {
+  if (chain.entryPoints.has("main")) {
+    const mainEntry = chain.entry("main");
+    if (mainEntry.values().length === 0) {
+      chain.entryPoints.clear();
+    }
+  }
+  for (const value of Object.values(opts.exports)) {
+    if (value.file) {
+      const entry = chain.entry(value.name);
+      for (const preEntry of opts.preEntries) {
+        entry.add(preEntry);
+      }
+      entry.add(value.file);
+    }
+  }
+}
+export function applyModuleConfig(chain) {
+  chain.output.set("module", true).set("chunkFormat", "module").set("chunkLoading", "import").set("workerChunkLoading", "import");
+  chain.output.library({
+    type: "module"
+  });
+}
+export function applyExternalsConfig(chain, opts) {
+  const existingExternals = chain.get("externals") || [];
+  const externals = Array.isArray(existingExternals) ? [...existingExternals] : [existingExternals];
+  const compilerContext = chain.get("context") ?? process.cwd();
+  const externalFunc = createExternalsFunction(opts, compilerContext);
+  externals.push(externalFunc);
+  chain.externals(externals);
+}
+function createExternalsFunction(opts, compilerContext) {
+  const importMap = /* @__PURE__ */ new Map();
+  let initPromise = null;
+  const init = (resolvePath) => {
+    if (initPromise) return initPromise;
+    initPromise = (async () => {
+      await Promise.all(
+        Object.values(opts.exports).map(async (value) => {
+          const identifier = value.pkg ? value.name : value.identifier;
+          importMap.set(identifier, identifier);
+          importMap.set(value.name, identifier);
+          const resolvedPath = await resolvePath(value.file);
+          if (resolvedPath) {
+            importMap.set(resolvedPath, identifier);
+          }
+        })
+      );
+      for (const key of Object.keys(opts.imports)) {
+        importMap.set(key, key);
+      }
+    })();
+    return initPromise;
+  };
+  const match = async (request, context, resolvePath) => {
+    if (!request) return null;
+    if (opts.deps.length > 0) {
+      const matchedDep = opts.deps.find(
+        (dep) => request === dep || request.startsWith(`${dep}/`)
+      );
+      if (matchedDep) {
+        return request;
+      }
+    }
+    let importName = importMap.get(request);
+    if (!importName) {
+      const resolvedPath = await resolvePath(request, context);
+      if (resolvedPath) {
+        importName = importMap.get(resolvedPath);
+      }
+    }
+    return importName || null;
+  };
+  const FILE_EXT_REGEX = /\.worker\.(js|mjs|cjs|jsx|mjsx|cjsx|ts|mts|cts|tsx|mtsx|ctsx)$/i;
+  return async (data) => {
+    if (!data.request || !data.context || !data.contextInfo?.issuer || FILE_EXT_REGEX.test(data.contextInfo.issuer))
+      return;
+    const defaultContext = compilerContext;
+    const resolvePath = async (request, context = defaultContext) => {
+      if (!data.getResolve) {
+        return null;
+      }
+      const resolveFunc = data.getResolve();
+      return new Promise((resolve) => {
+        resolveFunc(context, request, (err, res) => {
+          resolve(typeof res === "string" ? res : null);
+        });
+      });
+    };
+    await init(resolvePath);
+    const matchedIdentifier = await match(
+      data.request,
+      data.context,
+      resolvePath
+    );
+    if (matchedIdentifier) {
+      return `module-import ${matchedIdentifier}`;
+    }
+  };
+}

package/dist/module-link/config1.d.ts

@@ -0,0 +1,3 @@
+import type RspackChain from 'rspack-chain';
+import type { ParsedModuleLinkPluginOptions } from './types';
+export declare function applyChainConfig1(chain: RspackChain, opts: ParsedModuleLinkPluginOptions): void;

package/dist/module-link/config1.mjs

@@ -0,0 +1,16 @@
+import {
+  applyEntryConfig,
+  applyExternalsConfig,
+  applyModuleConfig
+} from "./config.mjs";
+export function applyChainConfig1(chain, opts) {
+  applyEntryConfig(chain, opts);
+  applyExternalsConfig(chain, opts);
+  applyModuleConfig(chain);
+  if (chain.get("mode") === "production") {
+    chain.output.library({
+      type: "modern-module"
+    });
+    chain.optimization.set("avoidEntryIife", true);
+  }
+}

package/dist/module-link/config2.d.ts

@@ -0,0 +1,3 @@
+import type RspackChain from 'rspack-chain';
+import type { ParsedModuleLinkPluginOptions } from './types';
+export declare function applyChainConfig2(chain: RspackChain, opts: ParsedModuleLinkPluginOptions): void;

package/dist/module-link/config2.mjs

@@ -0,0 +1,17 @@
+import { rspack } from "@rspack/core";
+import {
+  applyEntryConfig,
+  applyExternalsConfig,
+  applyModuleConfig
+} from "./config.mjs";
+export function applyChainConfig2(chain, opts) {
+  applyEntryConfig(chain, opts);
+  applyExternalsConfig(chain, opts);
+  if (chain.get("mode") === "production") {
+    chain.output.set("module", true);
+    chain.plugin("esm-library").use(new rspack.experiments.EsmLibraryPlugin());
+    chain.optimization.set("runtimeChunk", "single");
+  } else {
+    applyModuleConfig(chain);
+  }
+}

package/dist/module-link/index.d.ts

@@ -0,0 +1,4 @@
+import type RspackChain from 'rspack-chain';
+import type { ModuleLinkPluginOptions } from './types';
+export declare function initModuleLink(chain: RspackChain, options: ModuleLinkPluginOptions): void;
+export type { ModuleLinkPluginOptions } from './types';

package/dist/module-link/index.mjs

@@ -0,0 +1,8 @@
+import { applyChainConfig1 } from "./config1.mjs";
+import { ManifestPlugin } from "./manifest-plugin.mjs";
+import { parseOptions } from "./parse.mjs";
+export function initModuleLink(chain, options) {
+  const opts = parseOptions(options);
+  applyChainConfig1(chain, opts);
+  chain.plugin("module-link-manifest").use(ManifestPlugin, [opts]);
+}

package/dist/module-link/manifest-plugin.d.ts

@@ -0,0 +1,14 @@
+import type { Compiler, StatsCompilation } from '@rspack/core';
+import type { ManifestJsonExports, ParsedModuleLinkPluginOptions } from './types';
+export declare const RSPACK_PLUGIN_NAME = "rspack-module-link-plugin";
+export declare class ManifestPlugin {
+    private opts;
+    constructor(opts: ParsedModuleLinkPluginOptions);
+    apply(compiler: Compiler): void;
+}
+export declare function getExports(opts: ParsedModuleLinkPluginOptions, stats: StatsCompilation): ManifestJsonExports;
+export declare function generateIdentifier({ root, name, filePath }: {
+    root: string;
+    name: string;
+    filePath: string;
+}): string;

package/dist/module-link/manifest-plugin.mjs

@@ -0,0 +1,141 @@
+import upath from "upath";
+export const RSPACK_PLUGIN_NAME = "rspack-module-link-plugin";
+export class ManifestPlugin {
+  constructor(opts) {
+    this.opts = opts;
+  }
+  apply(compiler) {
+    const opts = this.opts;
+    const { Compilation } = compiler.rspack;
+    compiler.hooks.thisCompilation.tap(
+      RSPACK_PLUGIN_NAME,
+      (compilation) => {
+        let manifestJson = {
+          name: opts.name,
+          exports: {},
+          scopes: opts.scopes,
+          files: [],
+          chunks: {}
+        };
+        compilation.hooks.processAssets.tap(
+          {
+            name: RSPACK_PLUGIN_NAME,
+            stage: Compilation.PROCESS_ASSETS_STAGE_ADDITIONAL
+          },
+          (assets) => {
+            const stats = compilation.getStats().toJson({
+              hash: true,
+              entrypoints: true
+            });
+            const exports = getExports(opts, stats);
+            const resources = Object.keys(assets).map(transFileName).filter((file) => !file.includes("hot-update"));
+            manifestJson = {
+              name: opts.name,
+              exports,
+              scopes: opts.scopes,
+              files: resources,
+              chunks: getChunks(opts, compilation)
+            };
+            const { RawSource } = compiler.rspack.sources;
+            compilation.emitAsset(
+              "manifest.json",
+              new RawSource(JSON.stringify(manifestJson, null, 4))
+            );
+          }
+        );
+        if (opts.injectChunkName) {
+          compilation.hooks.processAssets.tap(
+            {
+              name: RSPACK_PLUGIN_NAME,
+              stage: Compilation.PROCESS_ASSETS_STAGE_ADDITIONS
+            },
+            (assets) => {
+              const { RawSource } = compiler.rspack.sources;
+              for (const [key, value] of Object.entries(
+                manifestJson.chunks
+              )) {
+                const asset = assets[value.js];
+                if (!asset) {
+                  return;
+                }
+                const source = new RawSource(
+                  `import.meta.chunkName = import.meta.chunkName ?? ${JSON.stringify(key)};
+${asset.source()}`
+                );
+                compilation.updateAsset(value.js, source);
+              }
+            }
+          );
+        }
+      }
+    );
+  }
+}
+function transFileName(fileName) {
+  return fileName.replace(/^.\//, "");
+}
+export function getExports(opts, stats) {
+  const entrypoints = stats.entrypoints || {};
+  const exports = {};
+  for (const [key, value] of Object.entries(entrypoints)) {
+    const asset = value.assets?.find((item) => {
+      return item.name.endsWith(opts.ext) && item.name.startsWith(key) && !item.name.includes("hot-update");
+    });
+    if (!asset) continue;
+    if (key in opts.exports) {
+      exports[key] = {
+        ...opts.exports[key],
+        file: asset.name
+      };
+    }
+  }
+  return exports;
+}
+function getChunks(opts, compilation) {
+  const stats = compilation.getStats().toJson({
+    all: false,
+    chunks: true,
+    modules: true,
+    chunkModules: true,
+    ids: true
+  });
+  const buildChunks = {};
+  if (!stats.chunks) return buildChunks;
+  for (const chunk of stats.chunks) {
+    const module = chunk.modules?.sort((a, b) => {
+      return (a.index ?? -1) - (b?.index ?? -1);
+    })?.find((module2) => {
+      return module2.moduleType?.includes("javascript/");
+    });
+    if (!module?.nameForCondition) continue;
+    const js = chunk.files?.find((file) => file.endsWith(opts.ext));
+    if (!js) continue;
+    const root = compilation.options.context ?? process.cwd();
+    const name = generateIdentifier({
+      root,
+      name: opts.name,
+      filePath: module.nameForCondition
+    });
+    const css = chunk.files?.filter((file) => file.endsWith(".css")) ?? [];
+    const resources = chunk.auxiliaryFiles ?? [];
+    buildChunks[name] = {
+      name,
+      js,
+      css,
+      resources
+    };
+  }
+  return buildChunks;
+}
+export function generateIdentifier({
+  root,
+  name,
+  filePath
+}) {
+  const unixFilePath = upath.toUnix(filePath);
+  if (!root) {
+    return `${name}@${unixFilePath}`;
+  }
+  const file = upath.relative(upath.toUnix(root), unixFilePath);
+  return `${name}@${file}`;
+}

package/dist/module-link/parse.d.ts

@@ -0,0 +1,2 @@
+import type { ModuleLinkPluginOptions, ParsedModuleLinkPluginOptions } from './types';
+export declare function parseOptions(options: ModuleLinkPluginOptions): ParsedModuleLinkPluginOptions;

package/dist/module-link/parse.mjs

@@ -0,0 +1,24 @@
+export function parseOptions(options) {
+  const exports = {};
+  if (options.exports) {
+    for (const [name, item] of Object.entries(options.exports)) {
+      exports[name] = {
+        name,
+        pkg: !!item.pkg,
+        file: item.file,
+        identifier: `${options.name}/${name}`
+      };
+    }
+  }
+  const deps = (options.deps ?? []).filter((name) => name !== options.name);
+  return {
+    name: options.name,
+    ext: options.ext ? `.${options.ext}` : ".mjs",
+    exports,
+    imports: options.imports ?? {},
+    scopes: options.scopes ?? {},
+    injectChunkName: options.injectChunkName ?? false,
+    preEntries: options.preEntries ?? [],
+    deps
+  };
+}

package/dist/module-link/types.d.ts

@@ -0,0 +1,25 @@
+import type { ManifestJsonExports } from '@esmx/core';
+export type { ManifestJson, ManifestJsonChunk, ManifestJsonChunks, ManifestJsonExport, ManifestJsonExports } from '@esmx/core';
+export interface ModuleLinkPluginOptions {
+    name: string;
+    ext?: string;
+    imports?: Record<string, string>;
+    scopes?: Record<string, Record<string, string>>;
+    exports?: Record<string, {
+        pkg?: boolean;
+        file: string;
+    }>;
+    injectChunkName?: boolean;
+    preEntries?: string[];
+    deps?: string[];
+}
+export interface ParsedModuleLinkPluginOptions {
+    name: string;
+    ext: string;
+    exports: ManifestJsonExports;
+    imports: Record<string, string>;
+    scopes: Record<string, Record<string, string>>;
+    injectChunkName: boolean;
+    preEntries: string[];
+    deps: string[];
+}

package/dist/rspack/app.mjs

@@ -1,8 +1,8 @@
 import { pathToFileURL } from "node:url";
 import {
-  RenderContext,
   createApp,
-  mergeMiddlewares
+  mergeMiddlewares,
+  RenderContext
 } from "@esmx/core";
 import { createVmImport } from "@esmx/import";
 import hotMiddleware from "webpack-hot-middleware";
@@ -58,14 +58,7 @@ function rewriteRender(esmx) {
     const module = await vmImport(
       `${esmx.name}/src/entry.server`,
       import.meta.url,
-      {
-        console,
-        setTimeout,
-        clearTimeout,
-        process,
-        URL,
-        global
-      }
+      global
     );
     const serverRender = module[rc.entryName];
     if (typeof serverRender === "function") {
@@ -100,6 +93,8 @@ async function start() {
 start();
 `.trim()
     );
+    console.log("\n");
+    console.log(esmx.generateSizeReport().text);
     return pack(esmx);
   };
 }

package/dist/rspack/chain-config.mjs

@@ -1,73 +1,80 @@
-import {
-  moduleLinkPlugin
-} from "@esmx/rspack-module-link-plugin";
 import { rspack } from "@rspack/core";
 import RspackChain from "rspack-chain";
 import nodeExternals from "webpack-node-externals";
+import { initModuleLink } from "../module-link/index.mjs";
 export function createChainConfig(esmx, buildTarget, options) {
   const isHot = buildTarget === "client" && !esmx.isProd;
   const isClient = buildTarget === "client";
   const isServer = buildTarget === "server";
   const isNode = buildTarget === "node";
-  const config = new RspackChain();
-  config.context(esmx.root);
-  config.mode(esmx.isProd ? "production" : "development");
-  config.target(isClient ? "web" : "node24");
-  config.cache(!esmx.isProd);
-  config.output.clean(esmx.isProd).filename(
+  const chain = new RspackChain();
+  chain.context(esmx.root);
+  chain.mode(esmx.isProd ? "production" : "development");
+  chain.target(isClient ? "web" : "node24");
+  chain.cache(!esmx.isProd);
+  chain.output.clean(esmx.isProd).filename(
     !isNode && esmx.isProd ? "[name].[contenthash:8].final.mjs" : "[name].mjs"
   ).chunkFilename(
     esmx.isProd ? "chunks/[name].[contenthash:8].final.mjs" : "chunks/[name].mjs"
   ).publicPath(
     isClient ? "auto" : `${esmx.basePathPlaceholder}${esmx.basePath}`
   );
-  config.output.set(
+  chain.output.set(
     "cssFilename",
     esmx.isProd ? "[name].[contenthash:8].final.css" : "[name].css"
   );
-  config.output.set(
+  chain.output.set(
     "cssChunkFilename",
     esmx.isProd ? "chunks/[name].[contenthash:8].final.css" : "chunks/[name].css"
   );
-  config.output.path(esmx.resolvePath("dist", buildTarget));
-  config.plugin("progress").use(rspack.ProgressPlugin, [
+  chain.output.path(esmx.resolvePath("dist", buildTarget));
+  chain.plugin("progress").use(rspack.ProgressPlugin, [
     {
       prefix: buildTarget
     }
   ]);
-  config.plugin("module-link").use(moduleLinkPlugin, [createModuleLinkConfig(esmx, buildTarget)]);
   if (isHot) {
-    config.plugin("hmr").use(rspack.HotModuleReplacementPlugin);
+    chain.plugin("hmr").use(rspack.HotModuleReplacementPlugin);
   }
-  config.module.parser.set("javascript", {
-    url: isClient ? true : "relative"
+  chain.module.parser.set("javascript", {
+    url: isClient ? true : "relative",
+    importMeta: false,
+    strictExportPresence: true
   });
-  config.module.generator.set("asset", {
+  chain.module.generator.set("asset", {
     emit: isClient
   });
-  config.module.generator.set("asset/resource", {
+  chain.module.generator.set("asset/resource", {
     emit: isClient
   });
-  config.resolve.alias.set(esmx.name, esmx.root);
-  config.optimization.minimize(options.minimize ?? esmx.isProd).emitOnErrors(true);
-  config.externalsPresets({
+  chain.resolve.alias.set(esmx.name, esmx.root);
+  chain.optimization.minimize(options.minimize ?? esmx.isProd).emitOnErrors(true);
+  chain.externalsPresets({
     web: isClient,
     node: isServer || isNode
   });
-  config.externalsType("module-import");
+  chain.experiments({
+    ...chain.get("experiments"),
+    outputModule: true
+  });
+  chain.externalsType("module-import");
   if (isNode) {
-    config.externals([
-      // @ts-ignore
+    chain.externals([
+      // @ts-expect-error
       nodeExternals({
-        // @ts-ignore
+        // @ts-expect-error
         importType: "module-import"
       })
     ]);
   }
-  config.experiments({
-    nativeWatcher: true
+  chain.experiments({
+    nativeWatcher: true,
+    rspackFuture: {
+      bundlerInfo: { force: false }
+    }
   });
-  return config;
+  initModuleLink(chain, createModuleLinkConfig(esmx, buildTarget));
+  return chain;
 }
 function createModuleLinkConfig(esmx, buildTarget) {
   const isClient = buildTarget === "client";

package/dist/rspack/index.d.ts

@@ -1,3 +1,3 @@
-export { type RspackAppConfigContext, type RspackAppChainContext, type RspackAppOptions, createRspackApp } from './app';
+export { createRspackApp, type RspackAppChainContext, type RspackAppConfigContext, type RspackAppOptions } from './app';
 export type { BuildTarget } from './build-target';
 export { RSPACK_LOADER } from './loader';

package/dist/rspack-html/index.mjs

@@ -3,8 +3,8 @@ import {
 } from "@rspack/core";
 import NodePolyfillPlugin from "node-polyfill-webpack-plugin";
 import {
-  RSPACK_LOADER,
-  createRspackApp
+  createRspackApp,
+  RSPACK_LOADER
 } from "../rspack/index.mjs";
 import { getTargetSetting } from "./target-setting.mjs";
 export async function createRspackHtmlApp(esmx, options) {

package/dist/rspack-html/target-setting.test.mjs

@@ -1,5 +1,5 @@
 import { describe, expect, it } from "vitest";
-import { PRESET_TARGETS, getTargetSetting } from "./target-setting.mjs";
+import { getTargetSetting, PRESET_TARGETS } from "./target-setting.mjs";
 describe("getTargetSetting", () => {
   const buildTargets = ["client", "server", "node"];
   describe("when setting is undefined", () => {

package/package.json

@@ -63,8 +63,7 @@
         }
     },
     "dependencies": {
-        "@esmx/import": "3.0.0-rc.77",
-        "@esmx/rspack-module-link-plugin": "3.0.0-rc.77",
+        "@esmx/import": "3.0.0-rc.79",
         "@npmcli/arborist": "^9.1.6",
         "@rspack/core": "1.6.5",
         "css-loader": "^7.1.2",
@@ -74,14 +73,15 @@
         "rspack-chain": "^1.4.1",
         "style-loader": "^4.0.0",
         "style-resources-loader": "^1.5.0",
+        "upath": "^2.0.1",
         "webpack-hot-middleware": "^2.26.1",
         "webpack-node-externals": "~3.0.0",
         "worker-rspack-loader": "^3.1.2"
     },
     "devDependencies": {
-        "@biomejs/biome": "2.3.4",
-        "@esmx/core": "3.0.0-rc.77",
-        "@types/node": "^24.10.0",
+        "@biomejs/biome": "2.3.7",
+        "@esmx/core": "3.0.0-rc.79",
+        "@types/node": "^24.0.0",
         "@types/npmcli__arborist": "^6.3.1",
         "@types/pacote": "^11.1.8",
         "@types/webpack-hot-middleware": "^2.25.12",
@@ -91,7 +91,7 @@
         "unbuild": "3.6.1",
         "vitest": "3.2.4"
     },
-    "version": "3.0.0-rc.77",
+    "version": "3.0.0-rc.79",
     "type": "module",
     "private": false,
     "exports": {
@@ -110,5 +110,5 @@
         "template",
         "public"
     ],
-    "gitHead": "c56120965914f33eca4b21336f705b3cb5fc7f93"
+    "gitHead": "29c95da5062140daffe10ba135ba66bae6e65fc6"
 }

package/src/index.ts

@@ -1,10 +1,10 @@
 export {
-    type RspackAppConfigContext,
-    type RspackAppChainContext,
-    type RspackAppOptions,
     type BuildTarget,
     createRspackApp,
-    RSPACK_LOADER
+    RSPACK_LOADER,
+    type RspackAppChainContext,
+    type RspackAppConfigContext,
+    type RspackAppOptions
 } from './rspack';
 export { createRspackHtmlApp, type RspackHtmlAppOptions } from './rspack-html';