@rspack/core 1.0.0-alpha.3 → 1.0.0-alpha.5

package/dist/util/createHash.js

@@ -159,11 +159,11 @@ const createHash = algorithm => {
             return new BatchedHash(createMd4());
         case "native-md4":
             if (crypto === undefined)
-                crypto = require("crypto");
+                crypto = require("node:crypto");
             return new BulkUpdateDecorator(() => crypto.createHash("md4"), "md4");
         default:
             if (crypto === undefined)
-                crypto = require("crypto");
+                crypto = require("node:crypto");
             return new BulkUpdateDecorator(() => crypto.createHash(algorithm), algorithm);
     }
 };

package/dist/util/fs.js

@@ -13,8 +13,8 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.mkdirp = exports.rmrf = void 0;
-const assert_1 = __importDefault(require("assert"));
-const path_1 = __importDefault(require("path"));
+const node_assert_1 = __importDefault(require("node:assert"));
+const node_path_1 = __importDefault(require("node:path"));
 function rmrf(fs, p, callback) {
     fs.stat(p, (err, stats) => {
         if (err) {
@@ -34,7 +34,7 @@ function rmrf(fs, p, callback) {
                 }
                 else {
                     files.forEach(file => {
-                        (0, assert_1.default)(typeof file === "string");
+                        (0, node_assert_1.default)(typeof file === "string");
                         const fullPath = join(fs, p, file);
                         rmrf(fs, fullPath, err => {
                             if (err) {
@@ -59,11 +59,11 @@ const join = (fs, rootPath, filename) => {
     if (fs && fs.join) {
         return fs.join(rootPath, filename);
     }
-    else if (path_1.default.posix.isAbsolute(rootPath)) {
-        return path_1.default.posix.join(rootPath, filename);
+    else if (node_path_1.default.posix.isAbsolute(rootPath)) {
+        return node_path_1.default.posix.join(rootPath, filename);
     }
-    else if (path_1.default.win32.isAbsolute(rootPath)) {
-        return path_1.default.win32.join(rootPath, filename);
+    else if (node_path_1.default.win32.isAbsolute(rootPath)) {
+        return node_path_1.default.win32.join(rootPath, filename);
     }
     else {
         throw new Error(`${rootPath} is neither a posix nor a windows path, and there is no 'join' method defined in the file system`);
@@ -73,11 +73,11 @@ const dirname = (fs, absPath) => {
     if (fs && fs.dirname) {
         return fs.dirname(absPath);
     }
-    else if (path_1.default.posix.isAbsolute(absPath)) {
-        return path_1.default.posix.dirname(absPath);
+    else if (node_path_1.default.posix.isAbsolute(absPath)) {
+        return node_path_1.default.posix.dirname(absPath);
     }
-    else if (path_1.default.win32.isAbsolute(absPath)) {
-        return path_1.default.win32.dirname(absPath);
+    else if (node_path_1.default.win32.isAbsolute(absPath)) {
+        return node_path_1.default.win32.dirname(absPath);
     }
     else {
         throw new Error(`${absPath} is neither a posix nor a windows path, and there is no 'dirname' method defined in the file system`);

package/dist/util/identifier.d.ts

@@ -1,76 +1,79 @@
-/**
- * @param {string} context context used to create relative path
- * @param {string} identifier identifier used to create relative path
- * @param {Object=} associatedObjectForCache an object to which the cache will be attached
- * @returns {string} the returned relative path
- */
-export function makePathsRelative(context: string, identifier: string, associatedObjectForCache?: Object | undefined): string;
-export namespace makePathsRelative {
+interface ParsedResource {
+    resource: string;
+    path: string;
+    query: string;
+    fragment: string;
+}
+type ParsedResourceWithoutFragment = Omit<ParsedResource, "fragment">;
+export declare const makePathsRelative: {
+    (context: string, identifier: string, associatedObjectForCache: object | undefined): string;
     /**
      * @param {Object=} associatedObjectForCache an object to which the cache will be attached
      * @returns {function(string, string): string} cached function
      */
-    function bindCache(associatedObjectForCache?: Object | undefined): (arg0: string, arg1: string) => string;
+    bindCache(associatedObjectForCache: object | undefined): (arg0: string, arg1: string) => string;
     /**
      * @param {string} context context used to create relative path
      * @param {Object=} associatedObjectForCache an object to which the cache will be attached
      * @returns {function(string): string} cached function
      */
-    function bindContextCache(context: string, associatedObjectForCache?: Object | undefined): (arg0: string) => string;
-}
-/**
- * @param {string} context context used to create relative path
- * @param {string} identifier identifier used to create relative path
- * @param {Object=} associatedObjectForCache an object to which the cache will be attached
- * @returns {string} the returned relative path
- */
-export function makePathsAbsolute(context: string, identifier: string, associatedObjectForCache?: Object | undefined): string;
-export namespace makePathsAbsolute { }
-/**
- * @param {string} str the path with query and fragment
- * @param {Object=} associatedObjectForCache an object to which the cache will be attached
- * @returns {ParsedResource} parsed parts
- */
-export function parseResource(str: string, associatedObjectForCache?: Object | undefined): ParsedResource;
-export namespace parseResource {
-    function bindCache(associatedObjectForCache: any): (str: any) => any;
-}
-/**
- * @param {string} str the path with query and fragment
- * @param {Object=} associatedObjectForCache an object to which the cache will be attached
- * @returns {ParsedResource} parsed parts
- */
-export function parseResourceWithoutFragment(str: string, associatedObjectForCache?: Object | undefined): ParsedResource;
-export namespace parseResourceWithoutFragment { }
-export function getUndoPath(filename: string, outputPath: string, enforceRelative: boolean): string;
-export type MakeRelativePathsCache = {
-    relativePaths?: Map<string, Map<string, string>> | undefined;
+    bindContextCache(context: string, associatedObjectForCache: object | undefined): (arg0: string) => string;
 };
-export type ParsedResource = {
-    resource: string;
-    path: string;
-    query: string;
-    fragment: string;
+export declare const makePathsAbsolute: {
+    (context: string, identifier: string, associatedObjectForCache: object | undefined): string;
+    /**
+     * @param {Object=} associatedObjectForCache an object to which the cache will be attached
+     * @returns {function(string, string): string} cached function
+     */
+    bindCache(associatedObjectForCache: object | undefined): (arg0: string, arg1: string) => string;
+    /**
+     * @param {string} context context used to create relative path
+     * @param {Object=} associatedObjectForCache an object to which the cache will be attached
+     * @returns {function(string): string} cached function
+     */
+    bindContextCache(context: string, associatedObjectForCache: object | undefined): (arg0: string) => string;
 };
-export type ParsedResourceWithoutFragment = {
-    resource: string;
-    path: string;
-    query: string;
+export declare const contextify: {
+    (context: string, identifier: string, associatedObjectForCache: object | undefined): string;
+    /**
+     * @param {Object=} associatedObjectForCache an object to which the cache will be attached
+     * @returns {function(string, string): string} cached function
+     */
+    bindCache(associatedObjectForCache: object | undefined): (arg0: string, arg1: string) => string;
+    /**
+     * @param {string} context context used to create relative path
+     * @param {Object=} associatedObjectForCache an object to which the cache will be attached
+     * @returns {function(string): string} cached function
+     */
+    bindContextCache(context: string, associatedObjectForCache: object | undefined): (arg0: string) => string;
+};
+export declare const absolutify: {
+    (context: string, identifier: string, associatedObjectForCache: object | undefined): string;
+    /**
+     * @param {Object=} associatedObjectForCache an object to which the cache will be attached
+     * @returns {function(string, string): string} cached function
+     */
+    bindCache(associatedObjectForCache: object | undefined): (arg0: string, arg1: string) => string;
+    /**
+     * @param {string} context context used to create relative path
+     * @param {Object=} associatedObjectForCache an object to which the cache will be attached
+     * @returns {function(string): string} cached function
+     */
+    bindContextCache(context: string, associatedObjectForCache: object | undefined): (arg0: string) => string;
+};
+export declare const parseResource: {
+    (str: string, associatedObjectForCache?: object): ParsedResource;
+    bindCache(associatedObjectForCache: object): (str: string) => ParsedResource;
+};
+export declare const parseResourceWithoutFragment: {
+    (str: string, associatedObjectForCache?: object): ParsedResourceWithoutFragment;
+    bindCache(associatedObjectForCache: object): (str: string) => ParsedResourceWithoutFragment;
 };
 /**
- * @param {string} context context used to create relative path
- * @param {string} identifier identifier used to create relative path
- * @param {Object=} associatedObjectForCache an object to which the cache will be attached
- * @returns {string} the returned relative path
- */
-export function contextify(context: string, identifier: string, associatedObjectForCache?: Object | undefined): string;
-export namespace contextify { }
-/**
- * @param {string} context context used to create relative path
- * @param {string} identifier identifier used to create relative path
- * @param {Object=} associatedObjectForCache an object to which the cache will be attached
- * @returns {string} the returned relative path
+ * @param {string} filename the filename which should be undone
+ * @param {string} outputPath the output path that is restored (only relevant when filename contains "..")
+ * @param {boolean} enforceRelative true returns ./ for empty paths
+ * @returns {string} repeated ../ to leave the directory of the provided filename to be back on output dir
  */
-export function absolutify(context: string, identifier: string, associatedObjectForCache?: Object | undefined): string;
-export namespace absolutify { }
-import path = require("path");
+export declare const getUndoPath: (filename: string, outputPath: string, enforceRelative: boolean) => string;
+export {};

package/dist/util/identifier.js

@@ -1,17 +1,17 @@
+"use strict";
 /*
     MIT License http://www.opensource.org/licenses/mit-license.php
 */
-"use strict";
-const path = require("path");
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getUndoPath = exports.parseResourceWithoutFragment = exports.parseResource = exports.absolutify = exports.contextify = exports.makePathsAbsolute = exports.makePathsRelative = void 0;
+const node_path_1 = __importDefault(require("node:path"));
 const WINDOWS_ABS_PATH_REGEXP = /^[a-zA-Z]:[\\/]/;
 const SEGMENTS_SPLIT_REGEXP = /([|!])/;
 const WINDOWS_PATH_SEPARATOR_REGEXP = /\\/g;
-/**
- * @typedef {Object} MakeRelativePathsCache
- * @property {Map<string, Map<string, string>>=} relativePaths
- */
-// @ts-expect-error
-const relativePathToRequest = relativePath => {
+const relativePathToRequest = (relativePath) => {
     if (relativePath === "")
         return "./.";
     if (relativePath === "..")
@@ -37,7 +37,7 @@ const absoluteToRequest = (context, maybeAbsolutePath) => {
         let resource = querySplitPos === -1
             ? maybeAbsolutePath
             : maybeAbsolutePath.slice(0, querySplitPos);
-        resource = relativePathToRequest(path.posix.relative(context, resource));
+        resource = relativePathToRequest(node_path_1.default.posix.relative(context, resource));
         return querySplitPos === -1
             ? resource
             : resource + maybeAbsolutePath.slice(querySplitPos);
@@ -47,7 +47,7 @@ const absoluteToRequest = (context, maybeAbsolutePath) => {
         let resource = querySplitPos === -1
             ? maybeAbsolutePath
             : maybeAbsolutePath.slice(0, querySplitPos);
-        resource = path.win32.relative(context, resource);
+        resource = node_path_1.default.win32.relative(context, resource);
         if (!WINDOWS_ABS_PATH_REGEXP.test(resource)) {
             resource = relativePathToRequest(resource.replace(WINDOWS_PATH_SEPARATOR_REGEXP, "/"));
         }
@@ -65,28 +65,19 @@ const absoluteToRequest = (context, maybeAbsolutePath) => {
  */
 const requestToAbsolute = (context, relativePath) => {
     if (relativePath.startsWith("./") || relativePath.startsWith("../"))
-        return path.join(context, relativePath);
+        return node_path_1.default.join(context, relativePath);
     return relativePath;
 };
-// @ts-expect-error
-const makeCacheable = realFn => {
-    /** @type {WeakMap<object, Map<string, ParsedResource>>} */
+const makeCacheable = (realFn) => {
     const cache = new WeakMap();
-    // @ts-expect-error
-    const getCache = associatedObjectForCache => {
+    const getCache = (associatedObjectForCache) => {
         const entry = cache.get(associatedObjectForCache);
         if (entry !== undefined)
             return entry;
-        /** @type {Map<string, ParsedResource>} */
         const map = new Map();
         cache.set(associatedObjectForCache, map);
         return map;
     };
-    /**
-     * @param {string} str the path with query and fragment
-     * @param {Object=} associatedObjectForCache an object to which the cache will be attached
-     * @returns {ParsedResource} parsed parts
-     */
     const fn = (str, associatedObjectForCache) => {
         if (!associatedObjectForCache)
             return realFn(str);
@@ -98,11 +89,9 @@ const makeCacheable = realFn => {
         cache.set(str, result);
         return result;
     };
-    // @ts-expect-error
-    fn.bindCache = associatedObjectForCache => {
+    fn.bindCache = (associatedObjectForCache) => {
         const cache = getCache(associatedObjectForCache);
-        // @ts-expect-error
-        return str => {
+        return (str) => {
             const entry = cache.get(str);
             if (entry !== undefined)
                 return entry;
@@ -113,9 +102,7 @@ const makeCacheable = realFn => {
     };
     return fn;
 };
-// @ts-expect-error
-const makeCacheableWithContext = fn => {
-    /** @type {WeakMap<object, Map<string, Map<string, string>>>} */
+const makeCacheableWithContext = (fn) => {
     const cache = new WeakMap();
     /**
      * @param {string} context context used to create relative path
@@ -126,6 +113,7 @@ const makeCacheableWithContext = fn => {
     const cachedFn = (context, identifier, associatedObjectForCache) => {
         if (!associatedObjectForCache)
             return fn(context, identifier);
+        /** @type {Map<string, Map<string, string>> | undefined} */
         let innerCache = cache.get(associatedObjectForCache);
         if (innerCache === undefined) {
             innerCache = new Map();
@@ -152,8 +140,7 @@ const makeCacheableWithContext = fn => {
      * @param {Object=} associatedObjectForCache an object to which the cache will be attached
      * @returns {function(string, string): string} cached function
      */
-    cachedFn.bindCache = associatedObjectForCache => {
-        // @ts-expect-error
+    cachedFn.bindCache = (associatedObjectForCache) => {
         let innerCache;
         if (associatedObjectForCache) {
             innerCache = cache.get(associatedObjectForCache);
@@ -172,11 +159,10 @@ const makeCacheableWithContext = fn => {
          */
         const boundFn = (context, identifier) => {
             let cachedResult;
-            // @ts-expect-error
-            let innerSubCache = innerCache.get(context);
+            let innerSubCache = innerCache?.get(context);
             if (innerSubCache === undefined) {
-                // @ts-expect-error
-                innerCache.set(context, (innerSubCache = new Map()));
+                innerSubCache = new Map();
+                innerCache?.set(context, innerSubCache);
             }
             else {
                 cachedResult = innerSubCache.get(identifier);
@@ -198,7 +184,6 @@ const makeCacheableWithContext = fn => {
      * @returns {function(string): string} cached function
      */
     cachedFn.bindContextCache = (context, associatedObjectForCache) => {
-        // @ts-expect-error
         let innerSubCache;
         if (associatedObjectForCache) {
             let innerCache = cache.get(associatedObjectForCache);
@@ -218,16 +203,14 @@ const makeCacheableWithContext = fn => {
          * @param {string} identifier identifier used to create relative path
          * @returns {string} the returned relative path
          */
-        const boundFn = identifier => {
-            // @ts-expect-error
-            const cachedResult = innerSubCache.get(identifier);
+        const boundFn = (identifier) => {
+            const cachedResult = innerSubCache?.get(identifier);
             if (cachedResult !== undefined) {
                 return cachedResult;
             }
             else {
                 const result = fn(context, identifier);
-                // @ts-expect-error
-                innerSubCache.set(identifier, result);
+                innerSubCache?.set(identifier, result);
                 return result;
             }
         };
@@ -272,8 +255,7 @@ const _contextify = (context, request) => {
         .map(r => absoluteToRequest(context, r))
         .join("!");
 };
-const contextify = makeCacheableWithContext(_contextify);
-exports.contextify = contextify;
+exports.contextify = makeCacheableWithContext(_contextify);
 /**
  * @param {string} context absolute context path
  * @param {string} request any request string
@@ -285,25 +267,19 @@ const _absolutify = (context, request) => {
         .map(r => requestToAbsolute(context, r))
         .join("!");
 };
-const absolutify = makeCacheableWithContext(_absolutify);
-exports.absolutify = absolutify;
+exports.absolutify = makeCacheableWithContext(_absolutify);
 const PATH_QUERY_FRAGMENT_REGEXP = /^((?:\u200b.|[^?#\u200b])*)(\?(?:\u200b.|[^#\u200b])*)?(#.*)?$/;
 const PATH_QUERY_REGEXP = /^((?:\u200b.|[^?\u200b])*)(\?.*)?$/;
-/** @typedef {{ resource: string, path: string, query: string, fragment: string }} ParsedResource */
-/** @typedef {{ resource: string, path: string, query: string }} ParsedResourceWithoutFragment */
 /**
  * @param {string} str the path with query and fragment
  * @returns {ParsedResource} parsed parts
  */
-const _parseResource = str => {
+const _parseResource = (str) => {
     const match = PATH_QUERY_FRAGMENT_REGEXP.exec(str);
     return {
         resource: str,
-        // @ts-expect-error
         path: match[1].replace(/\u200b(.)/g, "$1"),
-        // @ts-expect-error
         query: match[2] ? match[2].replace(/\u200b(.)/g, "$1") : "",
-        // @ts-expect-error
         fragment: match[3] || ""
     };
 };
@@ -313,13 +289,11 @@ exports.parseResource = makeCacheable(_parseResource);
  * @param {string} str the path with query and fragment
  * @returns {ParsedResourceWithoutFragment} parsed parts
  */
-const _parseResourceWithoutFragment = str => {
+const _parseResourceWithoutFragment = (str) => {
     const match = PATH_QUERY_REGEXP.exec(str);
     return {
         resource: str,
-        // @ts-expect-error
         path: match[1].replace(/\u200b(.)/g, "$1"),
-        // @ts-expect-error
         query: match[2] ? match[2].replace(/\u200b(.)/g, "$1") : ""
     };
 };
@@ -330,7 +304,7 @@ exports.parseResourceWithoutFragment = makeCacheable(_parseResourceWithoutFragme
  * @param {boolean} enforceRelative true returns ./ for empty paths
  * @returns {string} repeated ../ to leave the directory of the provided filename to be back on output dir
  */
-exports.getUndoPath = (filename, outputPath, enforceRelative) => {
+const getUndoPath = (filename, outputPath, enforceRelative) => {
     let depth = -1;
     let append = "";
     outputPath = outputPath.replace(/[\\/]$/, "");
@@ -359,3 +333,4 @@ exports.getUndoPath = (filename, outputPath, enforceRelative) => {
             ? `./${append}`
             : append;
 };
+exports.getUndoPath = getUndoPath;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rspack/core",
-  "version": "1.0.0-alpha.3",
+  "version": "1.0.0-alpha.5",
   "webpackVersion": "5.75.0",
   "license": "MIT",
   "description": "The fast Rust-based web bundler with webpack-compatible API",
@@ -39,24 +39,27 @@
     "@swc/core": "1.4.0",
     "@types/neo-async": "^2.6.6",
     "@types/watchpack": "^2.4.0",
+    "@types/webpack-sources": "3.2.3",
     "browserslist": "^4.21.3",
     "cross-env": "^7.0.3",
     "enhanced-resolve": "5.12.0",
     "graceful-fs": "4.2.10",
+    "@types/graceful-fs": "4.1.9",
     "json-parse-even-better-errors": "^3.0.0",
     "neo-async": "2.6.2",
     "prebundle": "^1.1.0",
     "tsc-alias": "^1.8.8",
     "watchpack": "^2.4.0",
     "webpack-sources": "3.2.3",
+    "webpack-dev-server": "4.13.1",
     "zod": "^3.21.4",
     "zod-validation-error": "1.3.1"
   },
   "dependencies": {
     "@module-federation/runtime-tools": "0.2.3",
     "caniuse-lite": "^1.0.30001616",
-    "@rspack/binding": "1.0.0-alpha.3",
-    "@rspack/lite-tapable": "1.0.0-alpha.3"
+    "@rspack/binding": "1.0.0-alpha.5",
+    "@rspack/lite-tapable": "1.0.0-alpha.5"
   },
   "peerDependencies": {
     "@swc/helpers": ">=0.5.1"