@rspack/core 1.0.10 → 1.0.12

package/dist/util/smartGrouping.js

@@ -1,148 +0,0 @@
-"use strict";
-/**
- * The following code is modified based on
- * https://github.com/webpack/webpack/tree/4b4ca3bb53f36a5b8fc6bc1bd976ed7af161bd80/lib/util
- *
- * 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.smartGrouping = void 0;
-const smartGrouping = (items, groupConfigs) => {
-    const itemsWithGroups = new Set();
-    const allGroups = new Map();
-    for (const item of items) {
-        const groups = new Set();
-        for (let i = 0; i < groupConfigs.length; i++) {
-            const groupConfig = groupConfigs[i];
-            const keys = groupConfig.getKeys(item);
-            if (keys) {
-                for (const name of keys) {
-                    const key = `${i}:${name}`;
-                    let group = allGroups.get(key);
-                    if (group === undefined) {
-                        allGroups.set(key, (group = {
-                            config: groupConfig,
-                            name,
-                            alreadyGrouped: false,
-                            items: undefined
-                        }));
-                    }
-                    groups.add(group);
-                }
-            }
-        }
-        itemsWithGroups.add({
-            item,
-            groups
-        });
-    }
-    const runGrouping = (itemsWithGroups) => {
-        const totalSize = itemsWithGroups.size;
-        for (const entry of itemsWithGroups) {
-            for (const group of entry.groups) {
-                if (group.alreadyGrouped)
-                    continue;
-                const items = group.items;
-                if (items === undefined) {
-                    group.items = new Set([entry]);
-                }
-                else {
-                    items.add(entry);
-                }
-            }
-        }
-        const groupMap = new Map();
-        for (const group of allGroups.values()) {
-            if (group.items) {
-                const items = group.items;
-                group.items = undefined;
-                groupMap.set(group, {
-                    items,
-                    options: undefined,
-                    used: false
-                });
-            }
-        }
-        const results = [];
-        for (;;) {
-            let bestGroup = undefined;
-            let bestGroupSize = -1;
-            let bestGroupItems = undefined;
-            let bestGroupOptions = undefined;
-            for (const [group, state] of groupMap) {
-                const { items, used } = state;
-                let options = state.options;
-                if (options === undefined) {
-                    const groupConfig = group.config;
-                    state.options = options =
-                        groupConfig.getOptions?.(group.name, Array.from(items, ({ item }) => item)) || false;
-                }
-                const force = options !== false && options.force;
-                if (!force) {
-                    if (bestGroupOptions !== false && bestGroupOptions?.force)
-                        continue;
-                    if (used)
-                        continue;
-                    if (items.size <= 1 || totalSize - items.size <= 1) {
-                        continue;
-                    }
-                }
-                const targetGroupCount = (options !== false && options.targetGroupCount) || 4;
-                const sizeValue = force
-                    ? items.size
-                    : Math.min(items.size, (totalSize * 2) / targetGroupCount +
-                        itemsWithGroups.size -
-                        items.size);
-                if (sizeValue > bestGroupSize ||
-                    (force && (!bestGroupOptions || !bestGroupOptions.force))) {
-                    bestGroup = group;
-                    bestGroupSize = sizeValue;
-                    bestGroupItems = items;
-                    bestGroupOptions = options;
-                }
-            }
-            if (bestGroup === undefined) {
-                break;
-            }
-            const items = new Set(bestGroupItems);
-            const options = bestGroupOptions;
-            const groupChildren = !options || options.groupChildren !== false;
-            for (const item of items) {
-                itemsWithGroups.delete(item);
-                // Remove all groups that items have from the map to not select them again
-                for (const group of item.groups) {
-                    const state = groupMap.get(group);
-                    if (state !== undefined) {
-                        state.items.delete(item);
-                        if (state.items.size === 0) {
-                            groupMap.delete(group);
-                        }
-                        else {
-                            state.options = undefined;
-                            if (groupChildren) {
-                                state.used = true;
-                            }
-                        }
-                    }
-                }
-            }
-            groupMap.delete(bestGroup);
-            const key = bestGroup.name;
-            const groupConfig = bestGroup.config;
-            const allItems = Array.from(items, ({ item }) => item);
-            bestGroup.alreadyGrouped = true;
-            const children = groupChildren ? runGrouping(items) : allItems;
-            bestGroup.alreadyGrouped = false;
-            results.push(groupConfig.createGroup(key, children, allItems));
-        }
-        for (const { item } of itemsWithGroups) {
-            results.push(item);
-        }
-        return results;
-    };
-    return runGrouping(itemsWithGroups);
-};
-exports.smartGrouping = smartGrouping;

package/dist/util/source.js

@@ -1,42 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.JsSource = void 0;
-const webpack_sources_1 = require("../../compiled/webpack-sources");
-class JsSource extends webpack_sources_1.Source {
-    static __from_binding(source) {
-        if (source.source instanceof Buffer) {
-            // @ts-expect-error: webpack-sources can accept buffer as source,
-            // see: https://github.com/webpack/webpack-sources/blob/9f98066311d53a153fdc7c633422a1d086528027/lib/RawSource.js#L12
-            return new webpack_sources_1.RawSource(source.source);
-        }
-        if (!source.map) {
-            return new webpack_sources_1.RawSource(source.source);
-        }
-        return new webpack_sources_1.SourceMapSource(source.source, "inmemory://from rust", 
-        // @ts-expect-error: SourceMapSource can accept string as source map,
-        // see: https://github.com/webpack/webpack-sources/blob/9f98066311d53a153fdc7c633422a1d086528027/lib/SourceMapSource.js#L30
-        source.map);
-    }
-    static __to_binding(source) {
-        if (source instanceof webpack_sources_1.RawSource) {
-            // @ts-expect-error: The 'isBuffer' method exists on 'RawSource' in 'webpack-sources',
-            if (source.isBuffer()) {
-                return {
-                    source: source.buffer()
-                };
-            }
-            return {
-                source: source.source()
-            };
-        }
-        const map = JSON.stringify(source.map?.({
-            columns: true
-        }));
-        const code = source.source();
-        return {
-            source: typeof code === "string" ? code : Buffer.from(code).toString("utf-8"),
-            map
-        };
-    }
-}
-exports.JsSource = JsSource;

package/dist/util/validate.js

@@ -1,77 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isValidate = exports.validate = exports.ValidationError = void 0;
-const zod_validation_error_1 = require("../../compiled/zod-validation-error");
-class ValidationError extends Error {
-    constructor(message) {
-        super(message);
-        this.name = "ValidationError";
-    }
-}
-exports.ValidationError = ValidationError;
-function validate(opts, schema) {
-    const res = schema.safeParse(opts);
-    if (!res.success) {
-        const strategy = process.env.RSPACK_CONFIG_VALIDATE ?? "strict";
-        if (strategy === "loose-silent")
-            return;
-        let friendlyErr;
-        const originalIssues = res.error.issues;
-        // Issues with code `unrecognized_keys` are ignored. Other issues are thrown.
-        // This does not work when `zodError.issues` is empty so we need to check the length of `zodError.issues`.
-        // See: https://github.com/causaly/zod-validation-error/blob/62684ba47cba9cbd84e2a75dfd5fd06dcd0e1ad5/lib/fromZodError.ts#L53
-        if (strategy === "loose-unrecognized-keys" && res.error.issues.length > 0) {
-            // This is based on the invariant that `fromZodError` always reads `zodError.errors` first and
-            // `zodError.errors` always returns `zodError.issues`:
-            // See: https://github.com/causaly/zod-validation-error/blob/62684ba47cba9cbd84e2a75dfd5fd06dcd0e1ad5/lib/fromZodError.ts#L55
-            // Also see: https://github.com/colinhacks/zod/blob/8552233c77426f77d3586cc877f7aec1aa0aa45b/src/ZodError.ts#L200
-            const unrecognizedKeys = originalIssues.filter(issue => issue.code === "unrecognized_keys");
-            if (unrecognizedKeys.length > 0) {
-                res.error.issues = unrecognizedKeys;
-                friendlyErr = toValidationError(res.error);
-                console.error(friendlyErr.message);
-                res.error.issues = originalIssues;
-            }
-            res.error.issues = originalIssues.filter(issue => issue.code !== "unrecognized_keys");
-            if (res.error.issues.length > 0) {
-                throw toValidationError(res.error);
-            }
-            return;
-        }
-        if (strategy === "loose-unrecognized-keys" || strategy === "loose") {
-            friendlyErr = toValidationError(res.error);
-            console.error(friendlyErr.message);
-            return;
-        }
-        // strict
-        friendlyErr = toValidationError(res.error);
-        throw friendlyErr;
-    }
-}
-exports.validate = validate;
-function toValidationError(error) {
-    const issueSeparator = "$issue$";
-    const prefixSeparator = "$prefix$";
-    const validationErr = (0, zod_validation_error_1.fromZodError)(error, {
-        prefix: "Invalid configuration object. Rspack has been initialized using a configuration object that does not match the API schema.",
-        prefixSeparator,
-        issueSeparator
-    });
-    // The output validationErr.message looks like
-    // `Configuration error$prefix$xxxx error$issue$yyy error$issue$zzz error`
-    const [prefix, reason] = validationErr.message.split(prefixSeparator);
-    const reasonItem = reason.split(issueSeparator);
-    const message = `${prefix}\n${reasonItem.map(item => `- ${item}`).join("\n")}`;
-    const friendlyErr = new ValidationError(message);
-    return friendlyErr;
-}
-function isValidate(opts, schema) {
-    try {
-        validate(opts, schema);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-exports.isValidate = isValidate;

package/dist/util/webpack.js

@@ -1,27 +0,0 @@
-"use strict";
-// util module that compatible with webpack
-// ```js
-// const { NormalModuleReplacementPlugin, WebpackError, util } = compiler.webpack;
-// ```
-Object.defineProperty(exports, "__esModule", { value: true });
-const createHash_1 = require("./createHash");
-exports.default = {
-    get createHash() {
-        return createHash_1.createHash;
-    }
-    // get comparators() {
-    // 	return require("./comparators");
-    // },
-    // get runtime() {
-    // 	return require("./util/runtime");
-    // },
-    // get serialization() {
-    // 	return require("./util/serialization");
-    // },
-    // get cleverMerge() {
-    // 	return require("./util/cleverMerge").cachedCleverMerge;
-    // },
-    // get LazySet() {
-    // 	return require("./util/LazySet");
-    // }
-};