@rspack/core 1.0.0-alpha.2 → 1.0.0-alpha.4

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 path_1 = __importDefault(require("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(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 = 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 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/dist/util/index.d.ts

@@ -1,6 +1,6 @@
 /// <reference types="node" />
 import type { JsRspackError, JsStatsError } from "@rspack/binding";
-import { LoaderObject } from "../loader-runner";
+import type { LoaderObject } from "../loader-runner";
 export declare function mapValues(record: Record<string, string>, fn: (key: string) => string): {
     [k: string]: string;
 };

package/dist/util/index.js

@@ -63,10 +63,12 @@ function concatErrorMsgAndStack(err) {
     if (typeof err === "string") {
         return new Error(err);
     }
-    if ("stack" in err) {
+    const hideStack = "hideStack" in err && err.hideStack;
+    if (!hideStack && "stack" in err) {
         err.message = err.stack || err.message;
-        return err;
     }
+    // maybe `null`, use `undefined` to compatible with `Option<String>`
+    err.stack = err.stack || undefined;
     return err;
 }
 exports.concatErrorMsgAndStack = concatErrorMsgAndStack;

package/dist/util/validate.d.ts

@@ -1,3 +1,3 @@
-import { z } from "../../compiled/zod";
+import type { z } from "../../compiled/zod";
 export declare function validate<T extends z.ZodType>(opts: any, schema: T): void;
 export declare function isValidate<T extends z.ZodType>(opts: any, schema: T): boolean;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rspack/core",
-  "version": "1.0.0-alpha.2",
+  "version": "1.0.0-alpha.4",
   "webpackVersion": "5.75.0",
   "license": "MIT",
   "description": "The fast Rust-based web bundler with webpack-compatible API",
@@ -36,57 +36,30 @@
     "directory": "packages/rspack"
   },
   "devDependencies": {
-    "@swc/plugin-remove-console": "1.5.121",
+    "@swc/core": "1.4.0",
     "@types/neo-async": "^2.6.6",
     "@types/watchpack": "^2.4.0",
     "@types/webpack-sources": "3.2.3",
-    "@types/ws": "8.5.10",
-    "babel-loader": "^9.1.0",
-    "babel-plugin-import": "^1.13.5",
     "browserslist": "^4.21.3",
-    "copy-webpack-plugin": "5.1.2",
     "cross-env": "^7.0.3",
-    "del": "^6.0.0",
     "enhanced-resolve": "5.12.0",
-    "file-loader": "^6.2.0",
-    "glob": "^10.3.10",
     "graceful-fs": "4.2.10",
-    "html-loader": "^5.0.0",
-    "html-webpack-plugin": "^5.5.0",
-    "identity-obj-proxy": "3.0.0",
-    "jest-environment-jsdom": "^29",
-    "jest-serializer-path": "^0.1.15",
-    "jsdom": "^24.0.0",
+    "@types/graceful-fs": "4.1.9",
     "json-parse-even-better-errors": "^3.0.0",
-    "less": "4.2.0",
-    "less-loader": "^12.0.0",
     "neo-async": "2.6.2",
-    "node-polyfill-webpack-plugin": "3.0.0",
-    "postcss-loader": "^8.0.0",
-    "postcss-pxtorem": "^6.0.0",
     "prebundle": "^1.1.0",
-    "pug-loader": "^2.4.0",
-    "react-relay": "^16.0.0",
-    "sass": "1.56.2",
-    "sass-loader": "14.2.1",
-    "source-map": "^0.7.4",
-    "source-map-loader": "^5.0.0",
-    "styled-components": "^6.0.8",
-    "terser": "5.27.2",
     "tsc-alias": "^1.8.8",
-    "wast-loader": "^1.11.4",
     "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",
-    "@rspack/core": "1.0.0-alpha.2",
-    "@rspack/plugin-minify": "^1.0.0-alpha.2"
+    "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.2",
-    "@rspack/lite-tapable": "1.0.0-alpha.2"
+    "@rspack/lite-tapable": "1.0.0-alpha.4",
+    "@rspack/binding": "1.0.0-alpha.4"
   },
   "peerDependencies": {
     "@swc/helpers": ">=0.5.1"