@rspack/core 1.0.0-beta.0 → 1.0.0-beta.2

package/dist/lib/cache/MemoryCachePlugin.d.ts

@@ -0,0 +1,5 @@
+import type { Compiler } from "../../Compiler";
+export default class MemoryCachePlugin {
+    static PLUGIN_NAME: string;
+    apply(compiler: Compiler): void;
+}

package/dist/lib/cache/MemoryCachePlugin.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const Cache_1 = require("../Cache");
+class MemoryCachePlugin {
+    apply(compiler) {
+        const cache = new Map();
+        compiler.cache.hooks.store.tap({ name: MemoryCachePlugin.PLUGIN_NAME, stage: Cache_1.Cache.STAGE_MEMORY }, (identifier, etag, data) => {
+            const dataEtag = typeof etag?.toString === "function"
+                ? etag.toString()
+                : etag;
+            cache.set(identifier, { etag: dataEtag, data });
+        });
+        compiler.cache.hooks.get.tap({ name: MemoryCachePlugin.PLUGIN_NAME, stage: Cache_1.Cache.STAGE_MEMORY }, (identifier, etag, gotHandlers) => {
+            const cacheEntry = cache.get(identifier);
+            const dataEtag = typeof etag?.toString === "function"
+                ? etag.toString()
+                : etag;
+            if (cacheEntry === null) {
+                return null;
+            }
+            if (cacheEntry !== undefined) {
+                return cacheEntry.etag === dataEtag ? cacheEntry.data : null;
+            }
+            gotHandlers.push((result, callback) => {
+                if (result === undefined) {
+                    cache.set(identifier, null);
+                }
+                else {
+                    cache.set(identifier, { etag: dataEtag, data: result });
+                }
+                return callback(null);
+            });
+        });
+        compiler.cache.hooks.shutdown.tap({ name: MemoryCachePlugin.PLUGIN_NAME, stage: Cache_1.Cache.STAGE_MEMORY }, () => {
+            cache.clear();
+        });
+    }
+}
+MemoryCachePlugin.PLUGIN_NAME = "MemoryCachePlugin";
+exports.default = MemoryCachePlugin;

package/dist/lib/cache/getLazyHashedEtag.d.ts

@@ -1,35 +1,35 @@
-export = getter;
 /**
- * @param {HashableObject} obj object with updateHash method
- * @param {string | HashConstructor} hashFunction the hash function to use
- * @returns {LazyHashedEtag} etag
+ * The following code is modified based on
+ * https://github.com/webpack/webpack/blob/4b4ca3b/lib/cache/getLazyHashedEtag.js
+ *
+ * MIT Licensed
+ * Author Tobias Koppers @sokra
+ * Copyright (c) JS Foundation and other contributors
+ * https://github.com/webpack/webpack/blob/main/LICENSE
  */
-declare function getter(obj: HashableObject, hashFunction?: string | HashConstructor): LazyHashedEtag;
-declare namespace getter {
-    export { Hash, HashConstructor, HashableObject };
+import type Hash from "../../util/hash";
+export type HashConstructor = typeof Hash;
+export interface HashableObject {
+    updateHash(hash: Hash): void;
 }
-type HashableObject = {
-    updateHash: (arg0: Hash) => void;
-};
-type HashConstructor = any;
-/** @typedef {any} Hash */
-/** @typedef {any} HashConstructor */
-/**
- * @typedef {Object} HashableObject
- * @property {function(Hash): void} updateHash
- */
 declare class LazyHashedEtag {
+    _obj: HashableObject;
+    _hash?: string;
+    _hashFunction: string | HashConstructor;
     /**
-     * @param {HashableObject} obj object with updateHash method
-     * @param {string | HashConstructor} hashFunction the hash function to use
+     * @param obj object with updateHash method
+     * @param hashFunction the hash function to use
      */
     constructor(obj: HashableObject, hashFunction?: string | HashConstructor);
-    _obj: HashableObject;
-    _hash: string | undefined;
-    _hashFunction: any;
     /**
-     * @returns {string} hash of object
+     * @returns hash of object
      */
     toString(): string;
 }
-type Hash = any;
+/**
+ * @param obj object with updateHash method
+ * @param ashFunction the hash function to use
+ * @returns etag
+ */
+export declare const getter: (obj: HashableObject, hashFunction?: string | HashConstructor) => LazyHashedEtag;
+export default getter;

package/dist/lib/cache/getLazyHashedEtag.js

@@ -1,21 +1,20 @@
-/*
-    MIT License http://www.opensource.org/licenses/mit-license.php
-    Author Tobias Koppers @sokra
-*/
 "use strict";
-const createHash = require("../../util/createHash");
-// /** @typedef {import("../util/Hash")} Hash */
-// /** @typedef {typeof import("../util/Hash")} HashConstructor */
-/** @typedef {any} Hash */
-/** @typedef {any} HashConstructor */
 /**
- * @typedef {Object} HashableObject
- * @property {function(Hash): void} updateHash
+ * The following code is modified based on
+ * https://github.com/webpack/webpack/blob/4b4ca3b/lib/cache/getLazyHashedEtag.js
+ *
+ * MIT Licensed
+ * Author Tobias Koppers @sokra
+ * Copyright (c) JS Foundation and other contributors
+ * https://github.com/webpack/webpack/blob/main/LICENSE
  */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getter = void 0;
+const createHash_1 = require("../../util/createHash");
 class LazyHashedEtag {
     /**
-     * @param {HashableObject} obj object with updateHash method
-     * @param {string | HashConstructor} hashFunction the hash function to use
+     * @param obj object with updateHash method
+     * @param hashFunction the hash function to use
      */
     constructor(obj, hashFunction = "md4") {
         this._obj = obj;
@@ -23,26 +22,23 @@ class LazyHashedEtag {
         this._hashFunction = hashFunction;
     }
     /**
-     * @returns {string} hash of object
+     * @returns hash of object
      */
     toString() {
         if (this._hash === undefined) {
-            // @ts-expect-error
-            const hash = createHash(this._hashFunction);
+            const hash = (0, createHash_1.createHash)(this._hashFunction);
             this._obj.updateHash(hash);
-            this._hash = /** @type {string} */ (hash.digest("base64"));
+            this._hash = hash.digest("base64");
         }
         return this._hash;
     }
 }
-/** @type {Map<string | HashConstructor, WeakMap<HashableObject, LazyHashedEtag>>} */
 const mapStrings = new Map();
-/** @type {WeakMap<HashConstructor, WeakMap<HashableObject, LazyHashedEtag>>} */
 const mapObjects = new WeakMap();
 /**
- * @param {HashableObject} obj object with updateHash method
- * @param {string | HashConstructor} hashFunction the hash function to use
- * @returns {LazyHashedEtag} etag
+ * @param obj object with updateHash method
+ * @param ashFunction the hash function to use
+ * @returns etag
  */
 const getter = (obj, hashFunction = "md4") => {
     let innerMap;
@@ -73,4 +69,5 @@ const getter = (obj, hashFunction = "md4") => {
     innerMap.set(obj, newHash);
     return newHash;
 };
-module.exports = getter;
+exports.getter = getter;
+exports.default = exports.getter;

package/dist/lib/cache/mergeEtags.d.ts

@@ -1,11 +1,17 @@
-export = mergeEtags;
 /**
- * @param {Etag} a first
- * @param {Etag} b second
- * @returns {Etag} result
+ * The following code is modified based on
+ * https://github.com/webpack/webpack/blob/4b4ca3b/lib/cache/mergeEtags.js
+ *
+ * MIT Licensed
+ * Author Tobias Koppers @sokra
+ * Copyright (c) JS Foundation and other contributors
+ * https://github.com/webpack/webpack/blob/main/LICENSE
  */
-declare function mergeEtags(a: Etag, b: Etag): Etag;
-declare namespace mergeEtags {
-    export { Etag };
-}
-type Etag = import("../Cache").Etag;
+import type { Etag } from "../Cache";
+/**
+ * @param a first
+ * @param b second
+ * @returns result
+ */
+export declare const mergeEtags: (a: Etag, b: Etag) => Etag;
+export default mergeEtags;

package/dist/lib/cache/mergeEtags.js

@@ -1,13 +1,19 @@
-/*
-    MIT License http://www.opensource.org/licenses/mit-license.php
-    Author Tobias Koppers @sokra
-*/
 "use strict";
-/** @typedef {import("../Cache").Etag} Etag */
+/**
+ * The following code is modified based on
+ * https://github.com/webpack/webpack/blob/4b4ca3b/lib/cache/mergeEtags.js
+ *
+ * MIT Licensed
+ * Author Tobias Koppers @sokra
+ * Copyright (c) JS Foundation and other contributors
+ * https://github.com/webpack/webpack/blob/main/LICENSE
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mergeEtags = void 0;
 class MergedEtag {
     /**
-     * @param {Etag} a first
-     * @param {Etag} b second
+     * @param a first
+     * @param b second
      */
     constructor(a, b) {
         this.a = a;
@@ -20,9 +26,9 @@ class MergedEtag {
 const dualObjectMap = new WeakMap();
 const objectStringMap = new WeakMap();
 /**
- * @param {Etag} a first
- * @param {Etag} b second
- * @returns {Etag} result
+ * @param a first
+ * @param b second
+ * @returns result
  */
 const mergeEtags = (a, b) => {
     if (typeof a === "string") {
@@ -62,4 +68,5 @@ const mergeEtags = (a, b) => {
     }
     return mergedEtag;
 };
-module.exports = mergeEtags;
+exports.mergeEtags = mergeEtags;
+exports.default = exports.mergeEtags;

package/dist/lib/formatLocation.d.ts

@@ -1,11 +1,16 @@
-export = formatLocation;
 /**
- * @param {DependencyLocation} loc location
- * @returns {string} formatted location
+ * The following code is modified based on
+ * https://github.com/webpack/webpack/blob/4b4ca3b/lib/formatLocation.js
+ *
+ * MIT Licensed
+ * Author Tobias Koppers @sokra
+ * Copyright (c) JS Foundation and other contributors
+ * https://github.com/webpack/webpack/blob/main/LICENSE
  */
-declare function formatLocation(loc: DependencyLocation): string;
-declare namespace formatLocation {
-    export { DependencyLocation, SourcePosition };
-}
-type DependencyLocation = any;
-type SourcePosition = any;
+import type { DependencyLocation } from "./Dependency";
+/**
+ * @param loc location
+ * @returns formatted location
+ */
+declare const formatLocation: (loc: DependencyLocation) => string;
+export default formatLocation;

package/dist/lib/formatLocation.js

@@ -1,17 +1,19 @@
-/*
-    MIT License http://www.opensource.org/licenses/mit-license.php
-    Author Tobias Koppers @sokra
-*/
 "use strict";
-// /** @typedef {import("./Dependency").DependencyLocation} DependencyLocation */
-// /** @typedef {import("./Dependency").SourcePosition} SourcePosition */
-/** @typedef {any} DependencyLocation */
-/** @typedef {any} SourcePosition */
 /**
- * @param {SourcePosition} pos position
- * @returns {string} formatted position
+ * The following code is modified based on
+ * https://github.com/webpack/webpack/blob/4b4ca3b/lib/formatLocation.js
+ *
+ * MIT Licensed
+ * Author Tobias Koppers @sokra
+ * Copyright (c) JS Foundation and other contributors
+ * https://github.com/webpack/webpack/blob/main/LICENSE
  */
-const formatPosition = pos => {
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * @param pos position
+ * @returns formatted position
+ */
+const formatPosition = (pos) => {
     if (pos && typeof pos === "object") {
         if ("line" in pos && "column" in pos) {
             return `${pos.line}:${pos.column}`;
@@ -23,10 +25,10 @@ const formatPosition = pos => {
     return "";
 };
 /**
- * @param {DependencyLocation} loc location
- * @returns {string} formatted location
+ * @param loc location
+ * @returns formatted location
  */
-const formatLocation = loc => {
+const formatLocation = (loc) => {
     if (loc && typeof loc === "object") {
         if ("start" in loc && loc.start && "end" in loc && loc.end) {
             if (typeof loc.start === "object" &&
@@ -59,4 +61,4 @@ const formatLocation = loc => {
     }
     return "";
 };
-module.exports = formatLocation;
+exports.default = formatLocation;

package/dist/loader-runner/index.js

@@ -40,7 +40,7 @@ const identifier_1 = require("../util/identifier");
 const memoize_1 = require("../util/memoize");
 const loadLoader_1 = __importDefault(require("./loadLoader"));
 function createLoaderObject(loader, compiler) {
-    var obj = {
+    const obj = {
         path: null,
         query: null,
         fragment: null,
@@ -88,13 +88,13 @@ function createLoaderObject(loader, compiler) {
             else if (obj.options === undefined)
                 obj.query = "";
             else if (typeof obj.options === "string")
-                obj.query = "?" + obj.options;
+                obj.query = `?${obj.options}`;
             else if (obj.ident)
-                obj.query = "??" + obj.ident;
+                obj.query = `??${obj.ident}`;
             else if (typeof obj.options === "object" && obj.options.ident)
-                obj.query = "??" + obj.options.ident;
+                obj.query = `??${obj.options.ident}`;
             else
-                obj.query = "?" + JSON.stringify(obj.options);
+                obj.query = `?${JSON.stringify(obj.options)}`;
         }
     });
     obj.request = loader;
@@ -268,8 +268,7 @@ function dirname(path) {
     return path.slice(0, idx);
 }
 function getCurrentLoader(loaderContext, index = loaderContext.loaderIndex) {
-    if (loaderContext.loaders &&
-        loaderContext.loaders.length &&
+    if (loaderContext.loaders?.length &&
         index < loaderContext.loaders.length &&
         index >= 0 &&
         loaderContext.loaders[index]) {

package/dist/loader-runner/loadLoader.js

@@ -13,14 +13,14 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const LoaderLoadingError_1 = __importDefault(require("./LoaderLoadingError"));
-var url = undefined;
+let url = undefined;
 function loadLoader(loader, callback) {
     if (loader.type === "module") {
         try {
             if (url === undefined)
                 url = require("node:url");
-            var loaderUrl = url.pathToFileURL(loader.path);
-            var modulePromise = eval("import(" + JSON.stringify(loaderUrl.toString()) + ")");
+            const loaderUrl = url.pathToFileURL(loader.path);
+            const modulePromise = eval(`import(${JSON.stringify(loaderUrl.toString())})`);
             modulePromise.then((module) => {
                 handleResult(loader, module, callback);
             }, callback);
@@ -31,15 +31,16 @@ function loadLoader(loader, callback) {
         }
     }
     else {
+        let module;
         try {
-            var module = require(loader.path);
+            module = require(loader.path);
         }
         catch (e) {
             // it is possible for node to choke on a require if the FD descriptor
             // limit has been reached. give it a chance to recover.
             if (e instanceof Error &&
                 e.code === "EMFILE") {
-                var retry = loadLoader.bind(null, loader, callback);
+                const retry = loadLoader.bind(null, loader, callback);
                 if (typeof setImmediate === "function") {
                     // node >= 0.9.0
                     return void setImmediate(retry);
@@ -55,18 +56,14 @@ function loadLoader(loader, callback) {
 exports.default = loadLoader;
 function handleResult(loader, module, callback) {
     if (typeof module !== "function" && typeof module !== "object") {
-        return callback(new LoaderLoadingError_1.default("Module '" +
-            loader.path +
-            "' is not a loader (export function or es6 module)"));
+        return callback(new LoaderLoadingError_1.default(`Module '${loader.path}' is not a loader (export function or es6 module)`));
     }
     loader.normal = typeof module === "function" ? module : module.default;
     loader.pitch = module.pitch;
     loader.raw = module.raw;
     if (typeof loader.normal !== "function" &&
         typeof loader.pitch !== "function") {
-        return callback(new LoaderLoadingError_1.default("Module '" +
-            loader.path +
-            "' is not a loader (must have normal or pitch function)"));
+        return callback(new LoaderLoadingError_1.default(`Module '${loader.path}' is not a loader (must have normal or pitch function)`));
     }
     callback();
 }

package/dist/logging/Logger.js

@@ -92,7 +92,7 @@ class Logger {
         this[TIMERS_SYMBOL].set(label, process.hrtime());
     }
     timeLog(label) {
-        const prev = this[TIMERS_SYMBOL] && this[TIMERS_SYMBOL].get(label);
+        const prev = this[TIMERS_SYMBOL]?.get(label);
         if (!prev) {
             throw new Error(`No such label '${label}' for WebpackLogger.timeLog()`);
         }
@@ -100,7 +100,7 @@ class Logger {
         this[LOG_SYMBOL](exports.LogType.time, [label, ...time]);
     }
     timeEnd(label) {
-        const prev = this[TIMERS_SYMBOL] && this[TIMERS_SYMBOL].get(label);
+        const prev = this[TIMERS_SYMBOL]?.get(label);
         if (!prev) {
             throw new Error(`No such label '${label}' for WebpackLogger.timeEnd()`);
         }
@@ -109,7 +109,7 @@ class Logger {
         this[LOG_SYMBOL](exports.LogType.time, [label, ...time]);
     }
     timeAggregate(label) {
-        const prev = this[TIMERS_SYMBOL] && this[TIMERS_SYMBOL].get(label);
+        const prev = this[TIMERS_SYMBOL]?.get(label);
         if (!prev) {
             throw new Error(`No such label '${label}' for WebpackLogger.timeAggregate()`);
         }

package/dist/logging/createConsoleLogger.d.ts

@@ -7,9 +7,29 @@
  * Copyright (c) JS Foundation and other contributors
  * https://github.com/webpack/webpack/blob/main/LICENSE
  */
-/**
- * @param {LoggerOptions} options options object
- * @returns {function(string, LogTypeEnum, any[]): void} logging function
- */
-declare const _default: ({ level, debug, console }: any) => (name: any, type: any, args: any) => void;
-export = _default;
+import type { FilterTypes } from "../config";
+import { type LogTypeEnum } from "./Logger";
+export type FilterFunction = (ident: string) => boolean;
+export type LoggerConsole = {
+    clear: () => void;
+    trace: () => void;
+    info: (...args: any[]) => void;
+    log: (...args: any[]) => void;
+    warn: (...args: any[]) => void;
+    error: (...args: any[]) => void;
+    debug?: (...args: any[]) => void;
+    group?: (...args: any[]) => void;
+    groupCollapsed?: (...args: any[]) => void;
+    groupEnd?: (...args: any[]) => void;
+    status?: (...args: any[]) => void;
+    profile?: (...args: any[]) => void;
+    profileEnd?: (...args: any[]) => void;
+    logTime?: (...args: any[]) => void;
+};
+export type LoggerOptions = {
+    level: "none" | "error" | "warn" | "info" | "log" | "verbose" | boolean;
+    debug: FilterTypes | boolean;
+    console: LoggerConsole;
+};
+declare const createConsoleLogger: ({ level, debug, console }: LoggerOptions) => (name: string, type: LogTypeEnum, args: any[]) => void;
+export { createConsoleLogger };