@rspack/core 1.0.9 → 1.0.11

package/dist/lib/Cache.js

@@ -1,111 +0,0 @@
-"use strict";
-/**
- * The following code is modified based on
- * https://github.com/webpack/webpack/blob/4b4ca3b/lib/Cache.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.Cache = void 0;
-const lite_tapable_1 = require("@rspack/lite-tapable");
-const HookWebpackError_1 = require("./HookWebpackError");
-const needCalls = (times, callback) => {
-    let leftTimes = times;
-    return err => {
-        if (--leftTimes === 0) {
-            return callback();
-        }
-        if (err && leftTimes > 0) {
-            leftTimes = 0;
-            return callback();
-        }
-    };
-};
-class Cache {
-    constructor() {
-        this.hooks = {
-            get: new lite_tapable_1.AsyncSeriesBailHook(["identifier", "etag", "gotHandlers"]),
-            store: new lite_tapable_1.AsyncParallelHook(["identifier", "etag", "data"]),
-            storeBuildDependencies: new lite_tapable_1.AsyncParallelHook(["dependencies"]),
-            beginIdle: new lite_tapable_1.SyncHook([]),
-            endIdle: new lite_tapable_1.AsyncParallelHook([]),
-            shutdown: new lite_tapable_1.AsyncParallelHook([])
-        };
-    }
-    /**
-     * @param identifier the cache identifier
-     * @param etag the etag
-     * @param callback signals when the value is retrieved
-     * @returns
-     */
-    get(identifier, etag, callback) {
-        const gotHandlers = [];
-        this.hooks.get.callAsync(identifier, etag, gotHandlers, (err, res) => {
-            if (err) {
-                callback((0, HookWebpackError_1.makeWebpackError)(err, "Cache.hooks.get"));
-                return;
-            }
-            let result = res;
-            if (result === null) {
-                result = undefined;
-            }
-            if (gotHandlers.length > 1) {
-                const innerCallback = needCalls(gotHandlers.length, () => callback(null, result));
-                for (const gotHandler of gotHandlers) {
-                    gotHandler(result, innerCallback);
-                }
-            }
-            else if (gotHandlers.length === 1) {
-                gotHandlers[0](result, () => callback(null, result));
-            }
-            else {
-                callback(null, result);
-            }
-        });
-    }
-    /**
-     * @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.hooks.store.callAsync(identifier, etag, data, (0, HookWebpackError_1.makeWebpackErrorCallback)(callback, "Cache.hooks.store"));
-    }
-    /**
-     * After this method has succeeded the cache can only be restored when build dependencies are
-     * @param dependencies list of all build dependencies
-     * @param callback signals when the dependencies are stored
-     * @returns
-     */
-    storeBuildDependencies(dependencies, callback) {
-        this.hooks.storeBuildDependencies.callAsync(dependencies, (0, HookWebpackError_1.makeWebpackErrorCallback)(callback, "Cache.hooks.storeBuildDependencies"));
-    }
-    beginIdle() {
-        this.hooks.beginIdle.call();
-    }
-    /**
-     * @param callback signals when the call finishes
-     * @returns
-     */
-    endIdle(callback) {
-        this.hooks.endIdle.callAsync((0, HookWebpackError_1.makeWebpackErrorCallback)(callback, "Cache.hooks.endIdle"));
-    }
-    /**
-     * @param callback signals when the call finishes
-     * @returns
-     */
-    shutdown(callback) {
-        this.hooks.shutdown.callAsync((0, HookWebpackError_1.makeWebpackErrorCallback)(callback, "Cache.hooks.shutdown"));
-    }
-}
-Cache.STAGE_DISK = 10;
-Cache.STAGE_MEMORY = -10;
-Cache.STAGE_DEFAULT = 0;
-Cache.STAGE_NETWORK = 20;
-exports.Cache = Cache;
-exports.default = Cache;

package/dist/lib/CacheFacade.js

@@ -1,321 +0,0 @@
-"use strict";
-/**
- * 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 items item caches
-     * @returns
-     */
-    constructor(items) {
-        this._items = items;
-        if (items.length === 1)
-            return items[0];
-    }
-    /**
-     * @param callback signals when the value is retrieved
-     * @returns
-     */
-    get(callback) {
-        forEachBail(this._items, (item, callback) => item.get(callback), callback);
-    }
-    /**
-     * @returns promise with the data
-     */
-    async getPromise() {
-        for (let i = 0; i < this._items.length; i++) {
-            const result = await this._items[i].getPromise();
-            if (result !== undefined) {
-                return result;
-            }
-        }
-        return undefined;
-    }
-    /**
-     * @param data the value to store
-     * @param callback signals when the value is stored
-     * @returns
-     */
-    store(data, callback) {
-        neo_async_1.default.each(this._items, (item, callback) => item.store(data, callback), callback);
-    }
-    /**
-     * @param data the value to store
-     * @returns promise signals when the value is stored
-     */
-    async storePromise(data) {
-        await Promise.all(this._items.map(item => item.storePromise(data)));
-    }
-}
-exports.MultiItemCache = MultiItemCache;
-class ItemCacheFacade {
-    /**
-     * @param cache the root cache
-     * @param name the child cache item name
-     * @param etag the etag
-     * @returns
-     */
-    constructor(cache, name, etag) {
-        this._cache = cache;
-        this._name = name;
-        this._etag = etag;
-    }
-    /**
-     * @param callback signals when the value is retrieved
-     * @returns
-     */
-    get(callback) {
-        this._cache.get(this._name, this._etag, callback);
-    }
-    /**
-     * @returns promise with the data
-     */
-    getPromise() {
-        return new Promise((resolve, reject) => {
-            this._cache.get(this._name, this._etag, (err, data) => {
-                if (err) {
-                    reject(err);
-                }
-                else {
-                    resolve(data);
-                }
-            });
-        });
-    }
-    /**
-     * @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);
-    }
-    /**
-     * @param data the value to store
-     * @returns promise signals when the value is stored
-     */
-    storePromise(data) {
-        return new Promise((resolve, reject) => {
-            this._cache.store(this._name, this._etag, data, err => {
-                if (err) {
-                    reject(err);
-                }
-                else {
-                    resolve();
-                }
-            });
-        });
-    }
-    /**
-     * @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) => {
-            if (err)
-                return callback(err);
-            if (cacheEntry !== undefined)
-                return cacheEntry;
-            computer((err, result) => {
-                if (err)
-                    return callback(err);
-                this.store(result, err => {
-                    if (err)
-                        return callback(err);
-                    callback(null, result);
-                });
-            });
-        });
-    }
-    /**
-     * @param computer function to compute the value if not cached
-     * @returns promise with the data
-     */
-    async providePromise(computer) {
-        const cacheEntry = await this.getPromise();
-        if (cacheEntry !== undefined)
-            return cacheEntry;
-        const result = await computer();
-        await this.storePromise(result);
-        return result;
-    }
-}
-exports.ItemCacheFacade = ItemCacheFacade;
-class CacheFacade {
-    /**
-     * @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;
-        this._name = name;
-        this._hashFunction = hashFunction;
-    }
-    /**
-     * @param name the child cache name#
-     * @returns child cache
-     */
-    getChildCache(name) {
-        return new CacheFacade(this._cache, `${this._name}|${name}`, this._hashFunction);
-    }
-    /**
-     * @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 obj an hashable object
-     * @returns an etag that is lazy hashed
-     */
-    getLazyHashedEtag(obj) {
-        return (0, getLazyHashedEtag_js_1.getter)(obj, this._hashFunction);
-    }
-    /**
-     * @param a an etag
-     * @param b another etag
-     * @returns an etag that represents both
-     */
-    mergeEtags(a, b) {
-        return (0, mergeEtags_js_1.mergeEtags)(a, b);
-    }
-    /**
-     * @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);
-    }
-    /**
-     * @param identifier the cache identifier
-     * @param etag the etag
-     * @returns promise with the data
-     */
-    getPromise(identifier, etag) {
-        return new Promise((resolve, reject) => {
-            this._cache.get(`${this._name}|${identifier}`, etag, (err, data) => {
-                if (err) {
-                    reject(err);
-                }
-                else {
-                    resolve(data);
-                }
-            });
-        });
-    }
-    /**
-     * @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);
-    }
-    /**
-     * @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) => {
-            this._cache.store(`${this._name}|${identifier}`, etag, data, err => {
-                if (err) {
-                    reject(err);
-                }
-                else {
-                    resolve();
-                }
-            });
-        });
-    }
-    /**
-     * @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) => {
-            if (err)
-                return callback(err);
-            if (cacheEntry !== undefined)
-                return cacheEntry;
-            computer((err, result) => {
-                if (err)
-                    return callback(err);
-                this.store(identifier, etag, result, err => {
-                    if (err)
-                        return callback(err);
-                    callback(null, result);
-                });
-            });
-        });
-    }
-    /**
-     * @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);
-        if (cacheEntry !== undefined)
-            return cacheEntry;
-        const result = await computer();
-        await this.storePromise(identifier, etag, result);
-        return result;
-    }
-}
-exports.CacheFacade = CacheFacade;
-exports.default = CacheFacade;

package/dist/lib/Dependency.js

@@ -1,11 +0,0 @@
-"use strict";
-/**
- * The following code is modified based on
- * https://github.com/webpack/webpack/blob/4b4ca3b/lib/Dependency.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 });

package/dist/lib/EntryOptionPlugin.js

@@ -1,89 +0,0 @@
-"use strict";
-/**
- * The following code is modified based on
- * https://github.com/webpack/webpack/blob/4b4ca3b/lib/EntryOptionPlugin.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.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);
-        }
-        else {
-            for (const name of Object.keys(entry)) {
-                const desc = entry[name];
-                const options = EntryOptionPlugin.entryDescriptionToOptions(compiler, name, desc);
-                (0, node_assert_1.default)(desc.import !== undefined, "desc.import should not be `undefined` once `EntryOptionPlugin.applyEntryOption` is called");
-                for (const entry of desc.import) {
-                    new builtin_plugin_1.EntryPlugin(context, entry, options).apply(compiler);
-                }
-            }
-        }
-    }
-    /**
-     * @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,
-            dependOn: desc.dependOn,
-            baseUri: desc.baseUri,
-            publicPath: desc.publicPath,
-            chunkLoading: desc.chunkLoading,
-            asyncChunks: desc.asyncChunks,
-            // 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.chunkLoading) {
-        // 	const EnableChunkLoadingPlugin = require("./javascript/EnableChunkLoadingPlugin");
-        // 	EnableChunkLoadingPlugin.checkEnabled(compiler, desc.chunkLoading);
-        // }
-        // if (desc.wasmLoading) {
-        // 	const EnableWasmLoadingPlugin = require("./wasm/EnableWasmLoadingPlugin");
-        // 	EnableWasmLoadingPlugin.checkEnabled(compiler, desc.wasmLoading);
-        // }
-        // if (desc.library) {
-        // 	const EnableLibraryPlugin = require("./library/EnableLibraryPlugin");
-        // 	EnableLibraryPlugin.checkEnabled(compiler, desc.library.type);
-        // }
-        return options;
-    }
-}
-exports.EntryOptionPlugin = EntryOptionPlugin;
-exports.default = EntryOptionPlugin;

package/dist/lib/EnvironmentPlugin.js

@@ -1,57 +0,0 @@
-"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_1 = __importDefault(require("./WebpackError"));
-class EnvironmentPlugin {
-    constructor(...keys) {
-        if (keys.length === 1 && Array.isArray(keys[0])) {
-            this.keys = keys[0];
-            this.defaultValues = {};
-        }
-        else if (keys.length === 1 && keys[0] && typeof keys[0] === "object") {
-            this.keys = Object.keys(keys[0]);
-            this.defaultValues = keys[0];
-        }
-        else {
-            this.keys = keys;
-            this.defaultValues = {};
-        }
-    }
-    /**
-     * Apply the plugin
-     * @param compiler the compiler instance
-     * @returns
-     */
-    apply(compiler) {
-        const definitions = {};
-        for (const key of this.keys) {
-            const value = process.env[key] !== undefined
-                ? process.env[key]
-                : this.defaultValues[key];
-            if (value === undefined) {
-                compiler.hooks.thisCompilation.tap("EnvironmentPlugin", compilation => {
-                    const error = new WebpackError_1.default(`EnvironmentPlugin - ${key} environment variable is undefined.\n\nYou can pass an object with default values to suppress this warning.\nSee https://rspack.dev/plugins/webpack/environment-plugin for example.`);
-                    error.name = "EnvVariableNotDefinedError";
-                    compilation.errors.push(error);
-                });
-            }
-            definitions[`process.env.${key}`] =
-                value === undefined ? "undefined" : JSON.stringify(value);
-        }
-        new builtin_plugin_1.DefinePlugin(definitions).apply(compiler);
-    }
-}
-exports.EnvironmentPlugin = EnvironmentPlugin;

package/dist/lib/HookWebpackError.js

@@ -1,83 +0,0 @@
-"use strict";
-/**
- * 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
- */
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.tryRunOrWebpackError = exports.makeWebpackErrorCallback = exports.makeWebpackError = exports.HookWebpackError = void 0;
-const WebpackError_1 = __importDefault(require("./WebpackError"));
-class HookWebpackError extends WebpackError_1.default {
-    /**
-     * Creates an instance of HookWebpackError.
-     * @param error inner error
-     * @param hook name of hook
-     */
-    constructor(error, hook) {
-        super(error.message);
-        this.name = "HookWebpackError";
-        this.hook = hook;
-        this.error = error;
-        this.hideStack = true;
-        this.details = `caused by plugins in ${hook}\n${error.stack}`;
-        this.stack += `\n-- inner error --\n${error.stack}`;
-    }
-}
-exports.HookWebpackError = HookWebpackError;
-exports.default = HookWebpackError;
-/**
- * @param error an error
- * @param hook name of the hook
- * @returns a webpack error
- */
-const makeWebpackError = (error, hook) => {
-    if (error instanceof WebpackError_1.default)
-        return error;
-    return new HookWebpackError(error, hook);
-};
-exports.makeWebpackError = makeWebpackError;
-/**
- * @param callback webpack error callback
- * @param hook name of hook
- * @returns generic callback
- */
-const makeWebpackErrorCallback = (callback, hook) => {
-    return (err, result) => {
-        if (err) {
-            if (err instanceof WebpackError_1.default) {
-                callback(err);
-                return;
-            }
-            callback(new HookWebpackError(err, hook));
-            return;
-        }
-        callback(null, result);
-    };
-};
-exports.makeWebpackErrorCallback = makeWebpackErrorCallback;
-/**
- * @param fn function which will be wrapping in try catch
- * @param hook name of hook
- * @returns the result
- */
-const tryRunOrWebpackError = (fn, hook) => {
-    let r;
-    try {
-        r = fn();
-    }
-    catch (err) {
-        if (err instanceof WebpackError_1.default) {
-            throw err;
-        }
-        throw new HookWebpackError(err, hook);
-    }
-    return r;
-};
-exports.tryRunOrWebpackError = tryRunOrWebpackError;