@rspack/core 1.0.0-alpha.5 → 1.0.0-beta.1

package/dist/lib/CacheFacade.js

@@ -1,89 +1,101 @@
-/*
-    MIT License http://www.opensource.org/licenses/mit-license.php
-    Author Tobias Koppers @sokra
-*/
 "use strict";
-const { forEachBail } = require("../../compiled/enhanced-resolve");
-const asyncLib = require("../../compiled/neo-async");
-const getLazyHashedEtag = require("./cache/getLazyHashedEtag.js");
-const mergeEtags = require("./cache/mergeEtags.js");
-/** @typedef {import("./Cache")} Cache */
-/** @typedef {import("./Cache").Etag} Etag */
-/** @typedef {import("./WebpackError")} WebpackError */
-/** @typedef {import("./cache/getLazyHashedEtag").HashableObject} HashableObject */
-// /** @typedef {typeof import("./util/Hash")} HashConstructor */
-/** @typedef {any} HashConstructor */
 /**
- * @template T
- * @callback CallbackCache
- * @param {(WebpackError | null)=} err
- * @param {T=} result
- * @returns {void}
- */
-/**
- * @template T
- * @callback CallbackNormalErrorCache
- * @param {(Error | null)=} err
- * @param {T=} result
- * @returns {void}
+ * The following code is modified based on
+ * https://github.com/webpack/webpack/blob/4b4ca3b/lib/CacheFacade.js
+ *
+ * MIT Licensed
+ * Author Tobias Koppers @sokra
+ * Copyright (c) JS Foundation and other contributors
+ * https://github.com/webpack/webpack/blob/main/LICENSE
  */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CacheFacade = exports.ItemCacheFacade = exports.MultiItemCache = void 0;
+const neo_async_1 = __importDefault(require("../../compiled/neo-async"));
+const getLazyHashedEtag_js_1 = require("./cache/getLazyHashedEtag.js");
+const mergeEtags_js_1 = require("./cache/mergeEtags.js");
+function forEachBail(array, iterator, callback) {
+    if (array.length === 0) {
+        callback();
+        return;
+    }
+    let i = 0;
+    const next = () => {
+        /** @type {boolean|undefined} */
+        let loop = undefined;
+        iterator(array[i++], (err, result) => {
+            if (err || result !== undefined || i >= array.length) {
+                return callback(err, result, i);
+            }
+            if (loop === false)
+                while (next())
+                    ;
+            loop = true;
+        }, i);
+        if (!loop)
+            loop = false;
+        return loop;
+    };
+    while (next())
+        ;
+}
+class BaseCache {
+}
 class MultiItemCache {
     /**
-     * @param {ItemCacheFacade[]} items item caches
+     * @param items item caches
+     * @returns
      */
     constructor(items) {
         this._items = items;
         if (items.length === 1)
-            return /** @type {any} */ (items[0]);
+            return items[0];
     }
     /**
-     * @template T
-     * @param {CallbackCache<T>} callback signals when the value is retrieved
-     * @returns {void}
+     * @param callback signals when the value is retrieved
+     * @returns
      */
     get(callback) {
-        // @ts-expect-error
         forEachBail(this._items, (item, callback) => item.get(callback), callback);
     }
     /**
-     * @template T
-     * @returns {Promise<T>} promise with the data
+     * @returns promise with the data
      */
     getPromise() {
-        // @ts-expect-error
-        const next = i => {
-            return this._items[i].getPromise().then(result => {
-                if (result !== undefined)
-                    return result;
-                if (++i < this._items.length)
-                    return next(i);
-            });
+        const next = async (i) => {
+            const result_1 = await this._items[i].getPromise();
+            if (result_1 !== undefined)
+                return result_1;
+            if (++i < this._items.length)
+                return next(i);
         };
         return next(0);
     }
     /**
-     * @template T
-     * @param {T} data the value to store
-     * @param {CallbackCache<void>} callback signals when the value is stored
-     * @returns {void}
+     * @param data the value to store
+     * @param callback signals when the value is stored
+     * @returns
      */
     store(data, callback) {
-        asyncLib.each(this._items, (item, callback) => item.store(data, callback), callback);
+        neo_async_1.default.each(this._items, (item, callback) => item.store(data, callback), callback);
     }
     /**
-     * @template T
-     * @param {T} data the value to store
-     * @returns {Promise<void>} promise signals when the value is stored
+     * @param data the value to store
+     * @returns promise signals when the value is stored
      */
-    storePromise(data) {
-        return Promise.all(this._items.map(item => item.storePromise(data))).then(() => { });
+    async storePromise(data) {
+        await Promise.all(this._items.map(item => item.storePromise(data)));
     }
 }
+exports.MultiItemCache = MultiItemCache;
 class ItemCacheFacade {
     /**
-     * @param {Cache} cache the root cache
-     * @param {string} name the child cache item name
-     * @param {Etag | null} etag the etag
+     * @param cache the root cache
+     * @param name the child cache item name
+     * @param etag the etag
+     * @returns
      */
     constructor(cache, name, etag) {
         this._cache = cache;
@@ -91,16 +103,14 @@ class ItemCacheFacade {
         this._etag = etag;
     }
     /**
-     * @template T
-     * @param {CallbackCache<T>} callback signals when the value is retrieved
-     * @returns {void}
+     * @param callback signals when the value is retrieved
+     * @returns
      */
     get(callback) {
         this._cache.get(this._name, this._etag, callback);
     }
     /**
-     * @template T
-     * @returns {Promise<T>} promise with the data
+     * @returns promise with the data
      */
     getPromise() {
         return new Promise((resolve, reject) => {
@@ -115,18 +125,16 @@ class ItemCacheFacade {
         });
     }
     /**
-     * @template T
-     * @param {T} data the value to store
-     * @param {CallbackCache<void>} callback signals when the value is stored
-     * @returns {void}
+     * @param data the value to store
+     * @param callback signals when the value is stored
+     * @returns
      */
     store(data, callback) {
         this._cache.store(this._name, this._etag, data, callback);
     }
     /**
-     * @template T
-     * @param {T} data the value to store
-     * @returns {Promise<void>} promise signals when the value is stored
+     * @param data the value to store
+     * @returns promise signals when the value is stored
      */
     storePromise(data) {
         return new Promise((resolve, reject) => {
@@ -141,10 +149,9 @@ class ItemCacheFacade {
         });
     }
     /**
-     * @template T
-     * @param {function(CallbackNormalErrorCache<T>): void} computer function to compute the value if not cached
-     * @param {CallbackNormalErrorCache<T>} callback signals when the value is retrieved
-     * @returns {void}
+     * @param computer function to compute the value if not cached
+     * @param callback signals when the value is retrieved
+     * @returns
      */
     provide(computer, callback) {
         this.get((err, cacheEntry) => {
@@ -164,9 +171,8 @@ class ItemCacheFacade {
         });
     }
     /**
-     * @template T
-     * @param {function(): Promise<T> | T} computer function to compute the value if not cached
-     * @returns {Promise<T>} promise with the data
+     * @param computer function to compute the value if not cached
+     * @returns promise with the data
      */
     async providePromise(computer) {
         const cacheEntry = await this.getPromise();
@@ -177,11 +183,12 @@ class ItemCacheFacade {
         return result;
     }
 }
+exports.ItemCacheFacade = ItemCacheFacade;
 class CacheFacade {
     /**
-     * @param {Cache} cache the root cache
-     * @param {string} name the child cache name
-     * @param {string | HashConstructor} hashFunction the hash function to use
+     * @param cache the root cache
+     * @param name the child cache name
+     * @param hashFunction the hash function to use
      */
     constructor(cache, name, hashFunction) {
         this._cache = cache;
@@ -189,50 +196,48 @@ class CacheFacade {
         this._hashFunction = hashFunction;
     }
     /**
-     * @param {string} name the child cache name#
-     * @returns {CacheFacade} child cache
+     * @param name the child cache name#
+     * @returns child cache
      */
     getChildCache(name) {
         return new CacheFacade(this._cache, `${this._name}|${name}`, this._hashFunction);
     }
     /**
-     * @param {string} identifier the cache identifier
-     * @param {Etag | null} etag the etag
-     * @returns {ItemCacheFacade} item cache
+     * @param identifier the cache identifier
+     * @param  etag the etag
+     * @returns item cache
      */
     getItemCache(identifier, etag) {
         return new ItemCacheFacade(this._cache, `${this._name}|${identifier}`, etag);
     }
     /**
-     * @param {HashableObject} obj an hashable object
-     * @returns {Etag} an etag that is lazy hashed
+     * @param obj an hashable object
+     * @returns an etag that is lazy hashed
      */
     getLazyHashedEtag(obj) {
-        return getLazyHashedEtag(obj, this._hashFunction);
+        return (0, getLazyHashedEtag_js_1.getter)(obj, this._hashFunction);
     }
     /**
-     * @param {Etag} a an etag
-     * @param {Etag} b another etag
-     * @returns {Etag} an etag that represents both
+     * @param a an etag
+     * @param b another etag
+     * @returns an etag that represents both
      */
     mergeEtags(a, b) {
-        return mergeEtags(a, b);
+        return (0, mergeEtags_js_1.mergeEtags)(a, b);
     }
     /**
-     * @template T
-     * @param {string} identifier the cache identifier
-     * @param {Etag | null} etag the etag
-     * @param {CallbackCache<T>} callback signals when the value is retrieved
-     * @returns {void}
+     * @param identifier the cache identifier
+     * @param etag the etag
+     * @param callback signals when the value is retrieved
+     * @returns
      */
     get(identifier, etag, callback) {
         this._cache.get(`${this._name}|${identifier}`, etag, callback);
     }
     /**
-     * @template T
-     * @param {string} identifier the cache identifier
-     * @param {Etag | null} etag the etag
-     * @returns {Promise<T>} promise with the data
+     * @param identifier the cache identifier
+     * @param etag the etag
+     * @returns promise with the data
      */
     getPromise(identifier, etag) {
         return new Promise((resolve, reject) => {
@@ -247,22 +252,20 @@ class CacheFacade {
         });
     }
     /**
-     * @template T
-     * @param {string} identifier the cache identifier
-     * @param {Etag | null} etag the etag
-     * @param {T} data the value to store
-     * @param {CallbackCache<void>} callback signals when the value is stored
-     * @returns {void}
+     * @param identifier the cache identifier
+     * @param etag the etag
+     * @param data the value to store
+     * @param callback signals when the value is stored
+     * @returns
      */
     store(identifier, etag, data, callback) {
         this._cache.store(`${this._name}|${identifier}`, etag, data, callback);
     }
     /**
-     * @template T
-     * @param {string} identifier the cache identifier
-     * @param {Etag | null} etag the etag
-     * @param {T} data the value to store
-     * @returns {Promise<void>} promise signals when the value is stored
+     * @param identifier the cache identifier
+     * @param etag the etag
+     * @param data the value to store
+     * @returns promise signals when the value is stored
      */
     storePromise(identifier, etag, data) {
         return new Promise((resolve, reject) => {
@@ -277,12 +280,11 @@ class CacheFacade {
         });
     }
     /**
-     * @template T
-     * @param {string} identifier the cache identifier
-     * @param {Etag | null} etag the etag
-     * @param {function(CallbackNormalErrorCache<T>): void} computer function to compute the value if not cached
-     * @param {CallbackNormalErrorCache<T>} callback signals when the value is retrieved
-     * @returns {void}
+     * @param identifier the cache identifier
+     * @param etag the etag
+     * @param computer function to compute the value if not cached
+     * @param callback signals when the value is retrieved
+     * @returns
      */
     provide(identifier, etag, computer, callback) {
         this.get(identifier, etag, (err, cacheEntry) => {
@@ -302,11 +304,10 @@ class CacheFacade {
         });
     }
     /**
-     * @template T
-     * @param {string} identifier the cache identifier
-     * @param {Etag | null} etag the etag
-     * @param {function(): Promise<T> | T} computer function to compute the value if not cached
-     * @returns {Promise<T>} promise with the data
+     * @param identifier the cache identifier
+     * @param etag the etag
+     * @param computer function to compute the value if not cached
+     * @returns promise with the data
      */
     async providePromise(identifier, etag, computer) {
         const cacheEntry = await this.getPromise(identifier, etag);
@@ -317,6 +318,5 @@ class CacheFacade {
         return result;
     }
 }
-module.exports = CacheFacade;
-module.exports.ItemCacheFacade = ItemCacheFacade;
-module.exports.MultiItemCache = MultiItemCache;
+exports.CacheFacade = CacheFacade;
+exports.default = CacheFacade;

package/dist/lib/EntryOptionPlugin.d.ts

@@ -8,9 +8,26 @@
  * https://github.com/webpack/webpack/blob/main/LICENSE
  */
 import type { Compiler, EntryDescriptionNormalized, EntryNormalized } from "..";
-import { type EntryOptions } from "../builtin-plugin";
-export default class EntryOptionPlugin {
+import type { EntryOptions } from "../builtin-plugin";
+export declare class EntryOptionPlugin {
+    /**
+     * @param compiler the compiler instance one is tapping into
+     * @returns
+     */
     apply(compiler: Compiler): void;
+    /**
+     * @param compiler the compiler
+     * @param context context directory
+     * @param entry request
+     * @returns
+     */
     static applyEntryOption(compiler: Compiler, context: string, entry: EntryNormalized): void;
+    /**
+     * @param compiler the compiler
+     * @param name entry name
+     * @param desc entry description
+     * @returns options for the entry
+     */
     static entryDescriptionToOptions(compiler: Compiler, name: string, desc: EntryDescriptionNormalized): EntryOptions;
 }
+export default EntryOptionPlugin;

package/dist/lib/EntryOptionPlugin.js

@@ -12,15 +12,26 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.EntryOptionPlugin = void 0;
 const node_assert_1 = __importDefault(require("node:assert"));
 const builtin_plugin_1 = require("../builtin-plugin");
 class EntryOptionPlugin {
+    /**
+     * @param compiler the compiler instance one is tapping into
+     * @returns
+     */
     apply(compiler) {
         compiler.hooks.entryOption.tap("EntryOptionPlugin", (context, entry) => {
             EntryOptionPlugin.applyEntryOption(compiler, context, entry);
             return true;
         });
     }
+    /**
+     * @param compiler the compiler
+     * @param context context directory
+     * @param entry request
+     * @returns
+     */
     static applyEntryOption(compiler, context, entry) {
         if (typeof entry === "function") {
             new builtin_plugin_1.DynamicEntryPlugin(context, entry).apply(compiler);
@@ -36,12 +47,18 @@ class EntryOptionPlugin {
             }
         }
     }
+    /**
+     * @param compiler the compiler
+     * @param name entry name
+     * @param desc entry description
+     * @returns options for the entry
+     */
     static entryDescriptionToOptions(compiler, name, desc) {
         const options = {
             name,
             filename: desc.filename,
             runtime: desc.runtime,
-            // layer: desc.layer,
+            layer: desc.layer,
             dependOn: desc.dependOn,
             baseUri: desc.baseUri,
             publicPath: desc.publicPath,
@@ -50,11 +67,9 @@ class EntryOptionPlugin {
             // wasmLoading: desc.wasmLoading,
             library: desc.library
         };
-        // if (desc.layer !== undefined && !compiler.options.experiments.layers) {
-        // 	throw new Error(
-        // 		"'entryOptions.layer' is only allowed when 'experiments.layers' is enabled"
-        // 	);
-        // }
+        if (desc.layer !== undefined && !compiler.options.experiments.layers) {
+            throw new Error("'entryOptions.layer' is only allowed when 'experiments.layers' is enabled");
+        }
         // if (desc.chunkLoading) {
         // 	const EnableChunkLoadingPlugin = require("./javascript/EnableChunkLoadingPlugin");
         // 	EnableChunkLoadingPlugin.checkEnabled(compiler, desc.chunkLoading);
@@ -70,4 +85,5 @@ class EntryOptionPlugin {
         return options;
     }
 }
+exports.EntryOptionPlugin = EntryOptionPlugin;
 exports.default = EntryOptionPlugin;

package/dist/lib/EnvironmentPlugin.d.ts

@@ -1,15 +1,22 @@
-export type Compiler = any;
-export type CodeValue = any;
-/** @typedef {any} Compiler */
-/** @typedef {any} CodeValue */
-export class EnvironmentPlugin {
-    constructor(...keys: any[]);
-    keys: any[];
-    defaultValues: any;
+/**
+ * The following code is modified based on
+ * https://github.com/webpack/webpack/blob/4b4ca3b/lib/EnvironmentPlugin.js
+ *
+ * MIT Licensed
+ * Author Tobias Koppers @sokra
+ * Copyright (c) JS Foundation and other contributors
+ * https://github.com/webpack/webpack/blob/main/LICENSE
+ */
+import type { Compiler } from "../Compiler";
+declare class EnvironmentPlugin {
+    keys: string[];
+    defaultValues: Record<string, string>;
+    constructor(...keys: string[] | [Record<string, string> | string]);
     /**
      * Apply the plugin
-     * @param {Compiler} compiler the compiler instance
-     * @returns {void}
+     * @param compiler the compiler instance
+     * @returns
      */
     apply(compiler: Compiler): void;
 }
+export { EnvironmentPlugin };

package/dist/lib/EnvironmentPlugin.js

@@ -1,18 +1,21 @@
-/*
-    MIT License http://www.opensource.org/licenses/mit-license.php
-    Authors Simen Brekken @simenbrekken, Einar Löve @einarlove
-*/
 "use strict";
+/**
+ * The following code is modified based on
+ * https://github.com/webpack/webpack/blob/4b4ca3b/lib/EnvironmentPlugin.js
+ *
+ * MIT Licensed
+ * Author Tobias Koppers @sokra
+ * Copyright (c) JS Foundation and other contributors
+ * https://github.com/webpack/webpack/blob/main/LICENSE
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.EnvironmentPlugin = void 0;
 const builtin_plugin_1 = require("../builtin-plugin");
-const WebpackError = require("./WebpackError");
-// /** @typedef {import("./Compiler")} Compiler */
-// /** @typedef {import("./DefinePlugin").CodeValue} CodeValue */
-/** @typedef {any} Compiler */
-/** @typedef {any} CodeValue */
+const WebpackError_1 = __importDefault(require("./WebpackError"));
 class EnvironmentPlugin {
-    // @ts-expect-error
     constructor(...keys) {
         if (keys.length === 1 && Array.isArray(keys[0])) {
             this.keys = keys[0];
@@ -29,20 +32,18 @@ class EnvironmentPlugin {
     }
     /**
      * Apply the plugin
-     * @param {Compiler} compiler the compiler instance
-     * @returns {void}
+     * @param compiler the compiler instance
+     * @returns
      */
     apply(compiler) {
-        /** @type {Record<string, CodeValue>} */
         const definitions = {};
         for (const key of this.keys) {
             const value = process.env[key] !== undefined
                 ? process.env[key]
                 : this.defaultValues[key];
             if (value === undefined) {
-                // @ts-expect-error
                 compiler.hooks.thisCompilation.tap("EnvironmentPlugin", compilation => {
-                    const error = new WebpackError(`EnvironmentPlugin - ${key} environment variable is undefined.\n\n` +
+                    const error = new WebpackError_1.default(`EnvironmentPlugin - ${key} environment variable is undefined.\n\n` +
                         "You can pass an object with default values to suppress this warning.\n" +
                         "See https://webpack.js.org/plugins/environment-plugin for example.");
                     error.name = "EnvVariableNotDefinedError";

package/dist/lib/HookWebpackError.d.ts

@@ -1,46 +1,40 @@
-export = HookWebpackError;
-/** @typedef {any} Module */
 /**
- * @template T
- * @callback Callback
- * @param {Error=} err
- * @param {T=} stats
- * @returns {void}
+ * The following code is modified based on
+ * https://github.com/webpack/webpack/blob/4b4ca3b/lib/HookWebpackError.js
+ *
+ * MIT Licensed
+ * Author Tobias Koppers @sokra
+ * Copyright (c) JS Foundation and other contributors
+ * https://github.com/webpack/webpack/blob/main/LICENSE
  */
-declare class HookWebpackError extends WebpackError {
+import type { Callback } from "@rspack/lite-tapable";
+import WebpackError from "./WebpackError";
+export declare class HookWebpackError extends WebpackError {
+    hook: string;
+    error: Error;
     /**
      * Creates an instance of HookWebpackError.
-     * @param {Error} error inner error
-     * @param {string} hook name of hook
+     * @param error inner error
+     * @param hook name of hook
      */
     constructor(error: Error, hook: string);
-    hook: string;
-    error: Error;
-    details: string;
-}
-declare namespace HookWebpackError {
-    export { makeWebpackError, makeWebpackErrorCallback, tryRunOrWebpackError, Module, Callback };
 }
-import WebpackError = require("./WebpackError.js");
+export default HookWebpackError;
 /**
- * @param {Error} error an error
- * @param {string} hook name of the hook
- * @returns {WebpackError} a webpack error
+ * @param error an error
+ * @param hook name of the hook
+ * @returns a webpack error
  */
-declare function makeWebpackError(error: Error, hook: string): WebpackError;
+export declare const makeWebpackError: (error: Error, hook: string) => WebpackError;
 /**
- * @template T
- * @param {function((WebpackError | null)=, T=): void} callback webpack error callback
- * @param {string} hook name of hook
- * @returns {Callback<T>} generic callback
+ * @param callback webpack error callback
+ * @param hook name of hook
+ * @returns generic callback
  */
-declare function makeWebpackErrorCallback<T>(callback: (arg0?: (WebpackError | null) | undefined, arg1?: T | undefined) => void, hook: string): Callback<T>;
+export declare const makeWebpackErrorCallback: <T>(callback: (error?: WebpackError | null, result?: T | undefined) => void, hook: string) => Callback<Error, T>;
 /**
- * @template T
- * @param {function(): T} fn function which will be wrapping in try catch
- * @param {string} hook name of hook
- * @returns {T} the result
+ * @param fn function which will be wrapping in try catch
+ * @param hook name of hook
+ * @returns the result
  */
-declare function tryRunOrWebpackError<T>(fn: () => T, hook: string): T;
-type Module = any;
-type Callback<T> = (err?: Error | undefined, stats?: T | undefined) => void;
+export declare const tryRunOrWebpackError: <T>(fn: () => T, hook: string) => T;