@rspack/core 1.3.1 → 1.3.3

package/compiled/tinypool/package.json

@@ -0,0 +1,55 @@
+{
+  "name": "tinypool",
+  "type": "module",
+  "version": "1.0.2",
+  "description": "A minimal and tiny Node.js Worker Thread Pool implementation, a fork of piscina, but with fewer features",
+  "license": "MIT",
+  "homepage": "https://github.com/tinylibs/tinypool#readme",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/tinylibs/tinypool.git"
+  },
+  "bugs": {
+    "url": "https://github.com/tinylibs/tinypool/issues"
+  },
+  "keywords": [
+    "fast",
+    "worker threads",
+    "thread pool"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "devDependencies": {
+    "@types/node": "^20.12.8",
+    "clean-publish": "^3.4.4",
+    "eslint": "^9.4.0",
+    "eslint-config-prettier": "^9.1.0",
+    "eslint-plugin-prettier": "^5.1.3",
+    "eslint-plugin-unicorn": "^53.0.0",
+    "prettier": "^3.3.2",
+    "tsup": "^8.0.2",
+    "typescript": "^5.4.5",
+    "typescript-eslint": "^7.13.0",
+    "vite": "^5.2.11",
+    "vitest": "^2.0.5"
+  },
+  "scripts": {
+    "test": "vitest",
+    "bench": "vitest bench",
+    "dev": "tsup --watch",
+    "build": "tsup",
+    "lint": "eslint --max-warnings=0",
+    "typecheck": "tsc --noEmit"
+  }
+}

package/dist/RuntimeGlobals.d.ts

@@ -322,3 +322,4 @@ export declare const RuntimeGlobals: {
      */
     readonly asyncModule: "__webpack_require__.a";
 };
+export declare const isReservedRuntimeGlobal: (r: string) => boolean;

package/dist/index.js

@@ -5256,7 +5256,7 @@ var ensureLoaderWorkerPool = async () => {
   if (pool) {
     return pool;
   }
-  return pool = import("tinypool").then(({ Tinypool }) => {
+  return pool = import("../compiled/tinypool").then(({ Tinypool }) => {
     const cpus = require("os").cpus().length;
     const availableThreads = Math.max(cpus - 1, 1);
     const pool2 = new Tinypool({
@@ -5354,10 +5354,14 @@ var run = async (task, options) => ensureLoaderWorkerPool().then(async (pool2) =
         switch (message.requestType) {
           case "WaitForPendingRequest" /* WaitForPendingRequest */: {
             const pendingRequestId = message.data[0];
-            const ids = Array.isArray(pendingRequestId) ? pendingRequestId : [pendingRequestId];
+            const isArray = Array.isArray(pendingRequestId);
+            const ids = isArray ? pendingRequestId : [pendingRequestId];
             result2 = await Promise.all(
               ids.map((id) => pendingRequests.get(id))
             );
+            if (!isArray) {
+              result2 = result2[0];
+            }
             break;
           }
           default:
@@ -6078,6 +6082,7 @@ async function runLoaders(compiler, context2) {
     get: () => context2.__internal__parseMeta
   });
   const getWorkerLoaderContext = () => {
+    const normalModule = loaderContext._module instanceof import_binding2.NormalModule ? loaderContext._module : void 0;
     const workerLoaderContext = {
       hot: loaderContext.hot,
       context: loaderContext.context,
@@ -6109,11 +6114,27 @@ async function runLoaders(compiler, context2) {
         }
       },
       _compilation: {
-        outputOptions: compiler._lastCompilation.outputOptions
+        options: {
+          output: {
+            // css-loader
+            environment: compiler._lastCompilation.outputOptions.environment
+          }
+        },
+        // css-loader
+        outputOptions: {
+          hashSalt: compiler._lastCompilation.outputOptions.hashSalt,
+          hashFunction: compiler._lastCompilation.outputOptions.hashFunction,
+          hashDigest: compiler._lastCompilation.outputOptions.hashDigest,
+          hashDigestLength: compiler._lastCompilation.outputOptions.hashDigestLength
+        }
       },
       _module: {
         type: loaderContext._module.type,
-        identifier: loaderContext._module.identifier()
+        identifier: loaderContext._module.identifier(),
+        matchResource: normalModule == null ? void 0 : normalModule.matchResource,
+        request: normalModule == null ? void 0 : normalModule.request,
+        userRequest: normalModule == null ? void 0 : normalModule.userRequest,
+        rawRequest: normalModule == null ? void 0 : normalModule.rawRequest
       }
     };
     Object.assign(workerLoaderContext, compiler.options.loader);
@@ -6207,6 +6228,9 @@ async function runLoaders(compiler, context2) {
             loaderContext.cacheable(cacheable);
             break;
           }
+          case "ImportModule" /* ImportModule */: {
+            return loaderContext.importModule(args[0], args[1]);
+          }
           case "UpdateLoaderObjects" /* UpdateLoaderObjects */: {
             const updates = args[0];
             loaderContext.loaders = loaderContext.loaders.map((item, index) => {
@@ -6222,6 +6246,29 @@ async function runLoaders(compiler, context2) {
             });
             break;
           }
+          case "CompilationGetPath" /* CompilationGetPath */: {
+            const filename2 = args[0];
+            const data = args[1];
+            return compiler._lastCompilation.getPath(filename2, data);
+          }
+          case "CompilationGetPathWithInfo" /* CompilationGetPathWithInfo */: {
+            const filename2 = args[0];
+            const data = args[1];
+            return compiler._lastCompilation.getPathWithInfo(filename2, data);
+          }
+          case "CompilationGetAssetPath" /* CompilationGetAssetPath */: {
+            const filename2 = args[0];
+            const data = args[1];
+            return compiler._lastCompilation.getAssetPath(filename2, data);
+          }
+          case "CompilationGetAssetPathWithInfo" /* CompilationGetAssetPathWithInfo */: {
+            const filename2 = args[0];
+            const data = args[1];
+            return compiler._lastCompilation.getAssetPathWithInfo(
+              filename2,
+              data
+            );
+          }
           default: {
             throw new Error(`Unknown request type: ${requestType}`);
           }
@@ -12753,7 +12800,7 @@ var CodeGenerationResult = class {
 };
 
 // src/RuntimeGlobals.ts
-var REVERSE_RUNTIME_GLOBALS = /* @__PURE__ */ new Map();
+var RESERVED_RUNTIME_GLOBALS = /* @__PURE__ */ new Map();
 function __from_binding_runtime_globals(runtimeRequirements) {
   const res = /* @__PURE__ */ new Set();
   for (const flag of runtimeRequirements.value) {
@@ -12770,7 +12817,7 @@ function __to_binding_runtime_globals(runtimeRequirements) {
     value: []
   };
   for (const flag of Array.from(runtimeRequirements)) {
-    const item = REVERSE_RUNTIME_GLOBALS.get(flag);
+    const item = RESERVED_RUNTIME_GLOBALS.get(flag);
     if (typeof item === "string") {
       res.value.push(item);
     } else {
@@ -13092,8 +13139,9 @@ var RuntimeGlobals = {
   asyncModule: "__webpack_require__.a"
 };
 for (const entry2 of Object.entries(RuntimeGlobals)) {
-  REVERSE_RUNTIME_GLOBALS.set(entry2[1], entry2[0]);
+  RESERVED_RUNTIME_GLOBALS.set(entry2[1], entry2[0]);
 }
+var isReservedRuntimeGlobal = (r) => RESERVED_RUNTIME_GLOBALS.has(r);
 
 // src/taps/compilation.ts
 var createCompilationHooksRegisters = (getCompiler, createTap, createMapTap) => {
@@ -13124,15 +13172,29 @@ var createCompilationHooksRegisters = (getCompiler, createTap, createMapTap) =>
       function(queried) {
         return function({
           chunk: chunkBinding,
+          allRuntimeRequirements,
           runtimeRequirements
         }) {
           const set = __from_binding_runtime_globals(runtimeRequirements);
+          const all = __from_binding_runtime_globals(allRuntimeRequirements);
           const chunk = Chunk.__from_binding(chunkBinding);
+          const customRuntimeGlobals = /* @__PURE__ */ new Set();
+          const originalAdd = all.add.bind(all);
+          const add = function add2(r) {
+            if (all.has(r)) return all;
+            if (isReservedRuntimeGlobal(r)) return originalAdd(r);
+            customRuntimeGlobals.add(r);
+            return originalAdd(r);
+          };
+          all.add = add.bind(add);
           for (const r of set) {
-            queried.for(r).call(chunk, set);
+            queried.for(r).call(chunk, all);
+          }
+          for (const r of customRuntimeGlobals) {
+            queried.for(r).call(chunk, all);
           }
           return {
-            runtimeRequirements: __to_binding_runtime_globals(set)
+            allRuntimeRequirements: __to_binding_runtime_globals(all)
           };
         };
       }

package/dist/loader-runner/service.d.ts

@@ -1,4 +1,4 @@
-import type { Tinypool } from "tinypool" with { "resolution-mode": "import" };
+import type { Tinypool } from "../../compiled/tinypool" with { "resolution-mode": "import" };
 type RunOptions = Parameters<Tinypool["run"]>[1];
 export interface WorkerResponseMessage {
     type: "response";
@@ -51,7 +51,12 @@ export declare enum RequestType {
     EmitFile = "EmitFile",
     EmitDiagnostic = "EmitDiagnostic",
     SetCacheable = "SetCacheable",
-    UpdateLoaderObjects = "UpdateLoaderObjects"
+    ImportModule = "ImportModule",
+    UpdateLoaderObjects = "UpdateLoaderObjects",
+    CompilationGetPath = "CompilationGetPath",
+    CompilationGetPathWithInfo = "CompilationGetPathWithInfo",
+    CompilationGetAssetPath = "CompilationGetAssetPath",
+    CompilationGetAssetPathWithInfo = "CompilationGetAssetPathWithInfo"
 }
 export declare enum RequestSyncType {
     WaitForPendingRequest = "WaitForPendingRequest"

package/dist/worker.js

@@ -1461,9 +1461,6 @@ async function loaderImpl({ args, loaderContext, loaderState }, sendRequest, wai
   loaderContext.clearDependencies = function clearDependencies() {
     pendingDependencyRequest.push(sendRequest("ClearDependencies" /* ClearDependencies */));
   };
-  loaderContext.importModule = function() {
-    throw new Error("importModule is not supported in worker");
-  };
   loaderContext.resolve = function resolve(context, request, callback) {
     sendRequest("Resolve" /* Resolve */, context, request).then(
       (result) => {
@@ -1598,7 +1595,7 @@ async function loaderImpl({ args, loaderContext, loaderState }, sendRequest, wai
   };
   loaderContext._compiler = {
     ...loaderContext._compiler,
-    // @ts-ignore
+    // @ts-expect-error: some properties are missing.
     webpack: {
       util: {
         createHash: (init_createHash(), __toCommonJS(createHash_exports)).createHash,
@@ -1606,13 +1603,67 @@ async function loaderImpl({ args, loaderContext, loaderState }, sendRequest, wai
       }
     }
   };
+  loaderContext._compilation = {
+    ...loaderContext._compilation,
+    getPath(filename, data) {
+      return sendRequest("CompilationGetPath" /* CompilationGetPath */, filename, data).wait();
+    },
+    getPathWithInfo(filename, data) {
+      return sendRequest(
+        "CompilationGetPathWithInfo" /* CompilationGetPathWithInfo */,
+        filename,
+        data
+      ).wait();
+    },
+    getAssetPath(filename, data) {
+      return sendRequest(
+        "CompilationGetAssetPath" /* CompilationGetAssetPath */,
+        filename,
+        data
+      ).wait();
+    },
+    getAssetPathWithInfo(filename, data) {
+      return sendRequest(
+        "CompilationGetAssetPathWithInfo" /* CompilationGetAssetPathWithInfo */,
+        filename,
+        data
+      ).wait();
+    }
+  };
   const _module = loaderContext._module;
   loaderContext._module = {
     type: _module.type,
     identifier() {
       return _module.identifier;
+    },
+    matchResource: _module.matchResource,
+    request: _module.request,
+    userRequest: _module.userRequest,
+    rawRequest: _module.rawRequest
+  };
+  loaderContext.importModule = function importModule(request, options, callback) {
+    if (!callback) {
+      return new Promise((resolve, reject) => {
+        sendRequest("ImportModule" /* ImportModule */, request, options).then(
+          (result) => {
+            resolve(result);
+          },
+          (err) => {
+            reject(err);
+          }
+        );
+      });
     }
+    sendRequest("ImportModule" /* ImportModule */, request, options).then(
+      (result) => {
+        callback(null, result);
+      },
+      (err) => {
+        callback(err);
+      }
+    );
   };
+  loaderContext.fs = require("fs");
   Object.defineProperty(loaderContext, "request", {
     enumerable: true,
     get: () => loaderContext.loaders.map((o) => o.request).concat(loaderContext.resource || "").join("!")

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rspack/core",
-  "version": "1.3.1",
+  "version": "1.3.3",
   "webpackVersion": "5.75.0",
   "license": "MIT",
   "description": "The fast Rust-based web bundler with webpack-compatible API",
@@ -37,8 +37,8 @@
     "directory": "packages/rspack"
   },
   "devDependencies": {
-    "@swc/core": "1.11.11",
-    "@swc/types": "0.1.19",
+    "@swc/core": "1.11.13",
+    "@swc/types": "0.1.20",
     "@types/graceful-fs": "4.1.9",
     "@types/watchpack": "^2.4.4",
     "@types/webpack-sources": "3.2.3",
@@ -48,23 +48,23 @@
     "graceful-fs": "^4.2.11",
     "json-parse-even-better-errors": "^3.0.2",
     "prebundle": "^1.2.7",
-    "tsc-alias": "^1.8.11",
+    "tsc-alias": "^1.8.13",
     "tsup": "^8.4.0",
     "tsx": "^4.19.3",
     "typescript": "^5.7.3",
     "watchpack": "^2.4.2",
-    "webpack-dev-server": "5.2.0",
+    "webpack-dev-server": "5.2.1",
     "webpack-sources": "3.2.3",
     "zod": "^3.24.2",
     "zod-validation-error": "3.4.0",
-    "@rspack/tracing": "1.3.1"
+    "tinypool": "^1.0.2",
+    "@rspack/tracing": "1.3.3"
   },
   "dependencies": {
-    "@module-federation/runtime-tools": "0.11.1",
+    "@module-federation/runtime-tools": "0.11.2",
     "@rspack/lite-tapable": "1.0.1",
-    "caniuse-lite": "^1.0.30001706",
-    "tinypool": "^1.0.2",
-    "@rspack/binding": "1.3.1"
+    "caniuse-lite": "^1.0.30001707",
+    "@rspack/binding": "1.3.3"
   },
   "peerDependencies": {
     "@rspack/tracing": "^1.x",