@utoo/pack-shared 0.0.7 → 1.1.8-rc.2

package/esm/issue.js

@@ -1,13 +1,9 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.formatIssue = formatIssue;
-exports.handleIssues = handleIssues;
-const code_frame_1 = require("@babel/code-frame");
-const styledString_1 = require("./styledString");
-function formatIssue(issue, forceColor = true) {
+import { codeFrameColumns } from "@babel/code-frame";
+import { renderStyledStringToErrorAnsi } from "./styledString";
+export function formatIssue(issue, forceColor = true) {
     const { filePath, title, description, source } = issue;
     let { documentationLink } = issue;
-    let formattedTitle = (0, styledString_1.renderStyledStringToErrorAnsi)(title).replace(/\n/g, "\n    ");
+    let formattedTitle = renderStyledStringToErrorAnsi(title).replace(/\n/g, "\n    ");
     let formattedFilePath = filePath
         .replace("[project]/", "./")
         .replaceAll("/./", "/")
@@ -27,7 +23,7 @@ function formatIssue(issue, forceColor = true) {
     if ((source === null || source === void 0 ? void 0 : source.range) && source.source.content) {
         const { start, end } = source.range;
         message +=
-            (0, code_frame_1.codeFrameColumns)(source.source.content, {
+            codeFrameColumns(source.source.content, {
                 start: {
                     line: start.line + 1,
                     column: start.column + 1,
@@ -41,7 +37,7 @@ function formatIssue(issue, forceColor = true) {
             { forceColor }).trim() + "\n\n";
     }
     if (description) {
-        message += (0, styledString_1.renderStyledStringToErrorAnsi)(description) + "\n\n";
+        message += renderStyledStringToErrorAnsi(description) + "\n\n";
     }
     // TODO: make it possible to enable this for debugging, but not in tests.
     // if (detail) {
@@ -53,7 +49,7 @@ function formatIssue(issue, forceColor = true) {
     }
     return message;
 }
-function handleIssues(issues, throwErrors = true, forceColor = true) {
+export function handleIssues(issues, throwErrors = true, forceColor = true) {
     const topLevelErrors = new Set();
     const topLevelWarnings = new Set();
     for (const issue of issues) {
@@ -85,7 +81,7 @@ function isNodeModulesIssue(issue) {
     if (issue.severity === "warning" && issue.stage === "config") {
         // Override for the externalize issue
         // `Package foo (serverExternalPackages or default list) can't be external`
-        if ((0, styledString_1.renderStyledStringToErrorAnsi)(issue.title).includes("can't be external")) {
+        if (renderStyledStringToErrorAnsi(issue.title).includes("can't be external")) {
             return false;
         }
     }

package/esm/magicIdentifier.js

@@ -1,7 +1,3 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MAGIC_IDENTIFIER_REGEX = void 0;
-exports.decodeMagicIdentifier = decodeMagicIdentifier;
 function decodeHex(hexStr) {
     if (hexStr.trim() === "") {
         throw new Error("can't decode empty hex");
@@ -13,7 +9,7 @@ function decodeHex(hexStr) {
     return String.fromCodePoint(num);
 }
 const DECODE_REGEX = /^__TURBOPACK__([a-zA-Z0-9_$]+)__$/;
-function decodeMagicIdentifier(identifier) {
+export function decodeMagicIdentifier(identifier) {
     const matches = identifier.match(DECODE_REGEX);
     if (!matches) {
         return identifier;
@@ -86,4 +82,4 @@ function decodeMagicIdentifier(identifier) {
     }
     return output;
 }
-exports.MAGIC_IDENTIFIER_REGEX = /__TURBOPACK__[a-zA-Z0-9_$]+__/g;
+export const MAGIC_IDENTIFIER_REGEX = /__TURBOPACK__[a-zA-Z0-9_$]+__/g;

package/esm/styledString.js

@@ -1,16 +1,13 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.renderStyledStringToErrorAnsi = renderStyledStringToErrorAnsi;
-const picocolors_1 = require("picocolors");
-const magicIdentifier_1 = require("./magicIdentifier");
-function renderStyledStringToErrorAnsi(string) {
+import { bold, green, magenta, red } from "picocolors";
+import { decodeMagicIdentifier, MAGIC_IDENTIFIER_REGEX, } from "./magicIdentifier";
+export function renderStyledStringToErrorAnsi(string) {
     function decodeMagicIdentifiers(str) {
-        return str.replaceAll(magicIdentifier_1.MAGIC_IDENTIFIER_REGEX, (ident) => {
+        return str.replaceAll(MAGIC_IDENTIFIER_REGEX, (ident) => {
             try {
-                return (0, picocolors_1.magenta)(`{${(0, magicIdentifier_1.decodeMagicIdentifier)(ident)}}`);
+                return magenta(`{${decodeMagicIdentifier(ident)}}`);
             }
             catch (e) {
-                return (0, picocolors_1.magenta)(`{${ident} (decoding failed: ${e})}`);
+                return magenta(`{${ident} (decoding failed: ${e})}`);
             }
         });
     }
@@ -18,9 +15,9 @@ function renderStyledStringToErrorAnsi(string) {
         case "text":
             return decodeMagicIdentifiers(string.value);
         case "strong":
-            return (0, picocolors_1.bold)((0, picocolors_1.red)(decodeMagicIdentifiers(string.value)));
+            return bold(red(decodeMagicIdentifiers(string.value)));
         case "code":
-            return (0, picocolors_1.green)(decodeMagicIdentifiers(string.value));
+            return green(decodeMagicIdentifiers(string.value));
         case "line":
             return string.value.map(renderStyledStringToErrorAnsi).join("");
         case "stack":

package/esm/utils.d.ts

@@ -0,0 +1,20 @@
+import { ConfigComplete, DefineEnv, RustifiedEnv } from "./config";
+import { Issue } from "./issue";
+export declare class ModuleBuildError extends Error {
+    name: string;
+}
+export interface ResultWithIssues {
+    issues: Issue[];
+}
+export declare function processIssues(result: ResultWithIssues, throwIssue: boolean, logErrors: boolean): void;
+export declare function isWellKnownError(issue: Issue): boolean;
+export declare function rustifyEnv(env: Record<string, string>): RustifiedEnv;
+interface DefineEnvOptions {
+    config: ConfigComplete;
+    dev: boolean;
+    optionDefineEnv?: DefineEnv;
+}
+export declare function createDefineEnv(options: DefineEnvOptions): DefineEnv;
+type AnyFunc<T> = (this: T, ...args: any) => any;
+export declare function debounce<T, F extends AnyFunc<T>>(fn: F, ms: number, maxWait?: number): (this: T, ...passedArgs: Parameters<F>) => void;
+export {};

package/esm/utils.js

@@ -0,0 +1,125 @@
+import { formatIssue } from "./issue";
+import { renderStyledStringToErrorAnsi } from "./styledString";
+export class ModuleBuildError extends Error {
+    constructor() {
+        super(...arguments);
+        this.name = "ModuleBuildError";
+    }
+}
+export function processIssues(result, throwIssue, logErrors) {
+    const relevantIssues = new Set();
+    for (const issue of result.issues) {
+        if (issue.severity !== "error" &&
+            issue.severity !== "fatal" &&
+            issue.severity !== "warning")
+            continue;
+        if (issue.severity !== "warning") {
+            if (throwIssue) {
+                const formatted = formatIssue(issue);
+                relevantIssues.add(formatted);
+            }
+            // if we throw the issue it will most likely get handed and logged elsewhere
+            else if (logErrors && isWellKnownError(issue)) {
+                const formatted = formatIssue(issue);
+                console.error(formatted);
+            }
+        }
+    }
+    if (relevantIssues.size && throwIssue) {
+        throw new ModuleBuildError([...relevantIssues].join("\n\n"));
+    }
+}
+export function isWellKnownError(issue) {
+    const { title } = issue;
+    const formattedTitle = renderStyledStringToErrorAnsi(title);
+    // TODO: add more well known errors
+    if (formattedTitle.includes("Module not found") ||
+        formattedTitle.includes("Unknown module type")) {
+        return true;
+    }
+    return false;
+}
+export function rustifyEnv(env) {
+    return Object.entries(env)
+        .filter(([_, value]) => value != null)
+        .map(([name, value]) => ({
+        name,
+        value,
+    }));
+}
+export function createDefineEnv(options) {
+    var _a;
+    let defineEnv = (_a = options.optionDefineEnv) !== null && _a !== void 0 ? _a : {
+        client: [],
+        edge: [],
+        nodejs: [],
+    };
+    function getDefineEnv() {
+        var _a;
+        const envs = {
+            "process.env.NODE_ENV": options.dev ? "development" : "production",
+        };
+        const userDefines = (_a = options.config.define) !== null && _a !== void 0 ? _a : {};
+        for (const key in userDefines) {
+            envs[key] = userDefines[key];
+        }
+        // serialize
+        const defineEnvStringified = {};
+        for (const key in defineEnv) {
+            const value = envs[key];
+            defineEnvStringified[key] = JSON.stringify(value);
+        }
+        return defineEnvStringified;
+    }
+    // TODO: future define envs need to extends for more compiler like server or edge.
+    for (const variant of Object.keys(defineEnv)) {
+        defineEnv[variant] = rustifyEnv(getDefineEnv());
+    }
+    return defineEnv;
+}
+export function debounce(fn, ms, maxWait = Infinity) {
+    let timeoutId;
+    // The time the debouncing function was first called during this debounce queue.
+    let startTime = 0;
+    // The time the debouncing function was last called.
+    let lastCall = 0;
+    // The arguments and this context of the last call to the debouncing function.
+    let args, context;
+    // A helper used to that either invokes the debounced function, or
+    // reschedules the timer if a more recent call was made.
+    function run() {
+        const now = Date.now();
+        const diff = lastCall + ms - now;
+        // If the diff is non-positive, then we've waited at least `ms`
+        // milliseconds since the last call. Or if we've waited for longer than the
+        // max wait time, we must call the debounced function.
+        if (diff <= 0 || startTime + maxWait >= now) {
+            // It's important to clear the timeout id before invoking the debounced
+            // function, in case the function calls the debouncing function again.
+            timeoutId = undefined;
+            fn.apply(context, args);
+        }
+        else {
+            // Else, a new call was made after the original timer was scheduled. We
+            // didn't clear the timeout (doing so is very slow), so now we need to
+            // reschedule the timer for the time difference.
+            timeoutId = setTimeout(run, diff);
+        }
+    }
+    return function (...passedArgs) {
+        // The arguments and this context of the most recent call are saved so the
+        // debounced function can be invoked with them later.
+        args = passedArgs;
+        context = this;
+        // Instead of constantly clearing and scheduling a timer, we record the
+        // time of the last call. If a second call comes in before the timer fires,
+        // then we'll reschedule in the run function. Doing this is considerably
+        // faster.
+        lastCall = Date.now();
+        // Only schedule a new timer if we're not currently waiting.
+        if (timeoutId === undefined) {
+            startTime = lastCall;
+            timeoutId = setTimeout(run, ms);
+        }
+    };
+}

package/esm/webpackCompat.d.ts

@@ -0,0 +1,6 @@
+import type webpack from "webpack";
+import { BundleOptions } from "./config";
+export type WebpackConfig = Partial<Pick<webpack.Configuration, "name" | "entry" | "mode" | "module" | "resolve" | "externals" | "output" | "target" | "devtool" | "optimization" | "plugins" | "stats">> & {
+    webpackMode: true;
+};
+export declare function compatOptionsFromWebpack(webpackConfig: WebpackConfig): BundleOptions;

package/esm/webpackCompat.js

@@ -0,0 +1,410 @@
+export function compatOptionsFromWebpack(webpackConfig) {
+    const { entry, mode, module, resolve, externals, output, target, devtool, optimization, plugins, stats, } = webpackConfig;
+    return {
+        config: {
+            entry: compatEntry(entry),
+            mode: compatMode(mode),
+            module: compatModule(module),
+            resolve: compatResolve(resolve),
+            externals: compatExternals(externals),
+            output: compatOutput(output),
+            target: compatTarget(target),
+            sourceMaps: compatSourceMaps(devtool),
+            optimization: compatOptimization(optimization),
+            define: compatFromWebpackPlugin(plugins, compatDefine),
+            provider: compatFromWebpackPlugin(plugins, compatProvider),
+            stats: compatStats(stats),
+            html: compatFromWebpackPlugins(plugins, compatHtml),
+        },
+        buildId: webpackConfig.name,
+    };
+}
+function compatMode(webpackMode) {
+    return webpackMode
+        ? webpackMode === "none"
+            ? "production"
+            : webpackMode
+        : "production";
+}
+function compatEntry(webpackEntry) {
+    const entry = [];
+    switch (typeof webpackEntry) {
+        case "string":
+            entry.push({ import: webpackEntry });
+            break;
+        case "object":
+            if (Array.isArray(webpackEntry)) {
+                webpackEntry.forEach((e) => entry.push({
+                    import: e,
+                }));
+            }
+            else {
+                Object.entries(webpackEntry).forEach(([k, v]) => {
+                    var _a;
+                    switch (typeof v) {
+                        case "string":
+                            entry.push({ name: k, import: v });
+                            break;
+                        case "object":
+                            if (!Array.isArray(v)) {
+                                switch (typeof v.import) {
+                                    case "string":
+                                        entry.push({
+                                            name: k,
+                                            import: v.import,
+                                            library: ((_a = v.library) === null || _a === void 0 ? void 0 : _a.type) === "umd"
+                                                ? {
+                                                    name: typeof v.library.name === "string"
+                                                        ? v.library.name
+                                                        : undefined,
+                                                    export: typeof v.library.export === "string"
+                                                        ? [v.library.export]
+                                                        : v.library.export,
+                                                }
+                                                : undefined,
+                                        });
+                                        break;
+                                    default:
+                                        break;
+                                }
+                            }
+                            else {
+                                if (v.length === 0) {
+                                    throw "entry value items is empty";
+                                }
+                                else if (v.length === 1) {
+                                    entry.push({ name: k, import: v[0] });
+                                }
+                                else {
+                                    throw "multi entry items for one entry not supported yet";
+                                }
+                            }
+                            break;
+                        default:
+                            throw "non string and non object entry path not supported yet";
+                    }
+                });
+            }
+            break;
+        case "function":
+            throw "functional entry not supported yet";
+        default:
+            throw "entry config not compatible now";
+    }
+    return entry;
+}
+function compatFromWebpackPlugin(webpackPlugins, picker) {
+    const plugin = webpackPlugins === null || webpackPlugins === void 0 ? void 0 : webpackPlugins.find((p) => p && typeof p === "object" && p.constructor.name === picker.pluginName);
+    return picker(plugin);
+}
+function compatFromWebpackPlugins(webpackPlugins, picker) {
+    const plugins = webpackPlugins === null || webpackPlugins === void 0 ? void 0 : webpackPlugins.filter((p) => p && typeof p === "object" && p.constructor.name === picker.pluginName);
+    if (!plugins || plugins.length === 0) {
+        return undefined;
+    }
+    const results = plugins.map(picker).filter((r) => r !== undefined);
+    if (results.length === 0)
+        return undefined;
+    return results.length === 1 ? results[0] : results;
+}
+compatHtml.pluginName = "HtmlWebpackPlugin";
+function compatHtml(maybeWebpackPluginInstance) {
+    if (!maybeWebpackPluginInstance) {
+        return undefined;
+    }
+    return (maybeWebpackPluginInstance.userOptions ||
+        maybeWebpackPluginInstance.options);
+}
+compatDefine.pluginName = "DefinePlugin";
+function compatDefine(maybeWebpackPluginInstance) {
+    const definitions = maybeWebpackPluginInstance === null || maybeWebpackPluginInstance === void 0 ? void 0 : maybeWebpackPluginInstance.definitions;
+    if (!definitions || typeof definitions !== "object") {
+        return definitions;
+    }
+    const processedDefinitions = {};
+    for (const [key, value] of Object.entries(definitions)) {
+        if (typeof value === "object" && value !== null) {
+            processedDefinitions[key] = JSON.stringify(value);
+        }
+        else {
+            processedDefinitions[key] = value;
+        }
+    }
+    return processedDefinitions;
+}
+compatProvider.pluginName = "ProvidePlugin";
+function compatProvider(maybeWebpackPluginInstance) {
+    const definitions = maybeWebpackPluginInstance === null || maybeWebpackPluginInstance === void 0 ? void 0 : maybeWebpackPluginInstance.definitions;
+    if (!definitions || typeof definitions !== "object") {
+        return undefined;
+    }
+    const provider = {};
+    for (const [key, value] of Object.entries(definitions)) {
+        if (typeof value === "string") {
+            // Simple module import: { $: 'jquery' }
+            provider[key] = value;
+        }
+        else if (Array.isArray(value)) {
+            if (value.length === 1) {
+                // e.g. { process: ['process/browser'] } for default import
+                provider[key] = value[0];
+            }
+            else if (value.length >= 2) {
+                // Named export import: { Buffer: ['buffer', 'Buffer'] }
+                provider[key] = [value[0], value[1]];
+            }
+        }
+    }
+    return Object.keys(provider).length > 0 ? provider : undefined;
+}
+function compatExternals(webpackExternals) {
+    if (!webpackExternals) {
+        return undefined;
+    }
+    let externals = {};
+    switch (typeof webpackExternals) {
+        case "string": {
+            // Single string external: "lodash" -> { "lodash": "lodash" }
+            externals[webpackExternals] = webpackExternals;
+            break;
+        }
+        case "object": {
+            if (Array.isArray(webpackExternals)) {
+                // Array of externals: ["lodash", "react"] -> { "lodash": "lodash", "react": "react" }
+                externals = webpackExternals.reduce((acc, external) => {
+                    if (typeof external === "string") {
+                        acc[external] = external;
+                    }
+                    else if (typeof external === "object" && external !== null) {
+                        Object.assign(acc, compatExternals(external));
+                    }
+                    return acc;
+                }, {});
+            }
+            else if (webpackExternals instanceof RegExp) {
+                throw "regex external not supported yet";
+            }
+            else {
+                if ("byLayer" in webpackExternals) {
+                    throw "by layer external item not supported yet";
+                }
+                Object.entries(webpackExternals).forEach(([key, value]) => {
+                    if (typeof value === "string") {
+                        // Check if it's a script type with shorthand syntax: "global@https://example.com/script.js"
+                        if (value.includes("@") &&
+                            (value.startsWith("script ") || value.includes("://"))) {
+                            const match = value.match(/^(?:script\s+)?(.+?)@(.+)$/);
+                            if (match) {
+                                const [, globalName, scriptUrl] = match;
+                                // Use utoopack string format: "script globalName@url"
+                                externals[key] = `script ${globalName}@${scriptUrl}`;
+                            }
+                            else {
+                                externals[key] = value;
+                            }
+                        }
+                        else {
+                            // Simple string mapping: { "react": "React" }
+                            externals[key] = value;
+                        }
+                    }
+                    else if (Array.isArray(value)) {
+                        // Array format handling
+                        if (value.length >= 2) {
+                            const [first, second] = value;
+                            // Check if it's a script type array: ["https://example.com/script.js", "GlobalName"]
+                            if (typeof first === "string" &&
+                                first.includes("://") &&
+                                typeof second === "string") {
+                                // Use utoopack object format for script
+                                externals[key] = {
+                                    root: second,
+                                    type: "script",
+                                    script: first,
+                                };
+                            }
+                            else if (typeof first === "string" &&
+                                typeof second === "string") {
+                                // Handle type prefix formats
+                                if (first.startsWith("commonjs")) {
+                                    externals[key] = `commonjs ${second}`;
+                                }
+                                else if (first === "module") {
+                                    externals[key] = `esm ${second}`;
+                                }
+                                else if (first === "var" ||
+                                    first === "global" ||
+                                    first === "window") {
+                                    externals[key] = second;
+                                }
+                                else if (first === "script") {
+                                    // Script type without URL in array format - treat as regular script prefix
+                                    externals[key] = `script ${second}`;
+                                }
+                                else {
+                                    externals[key] = `${first} ${second}`;
+                                }
+                            }
+                            else {
+                                externals[key] = value[0] || key;
+                            }
+                        }
+                        else {
+                            externals[key] = value[0] || key;
+                        }
+                    }
+                    else if (typeof value === "object" && value !== null) {
+                        // Object format: handle complex configurations
+                        if ("root" in value || "commonjs" in value || "amd" in value) {
+                            // Standard webpack externals object format
+                            if (value.commonjs) {
+                                externals[key] = `commonjs ${value.commonjs}`;
+                            }
+                            else if (value.root) {
+                                externals[key] = value.root;
+                            }
+                            else if (value.amd) {
+                                externals[key] = value.amd;
+                            }
+                            else {
+                                externals[key] = key;
+                            }
+                        }
+                        else {
+                            // Treat as utoopack specific configuration (might already be in correct format)
+                            externals[key] = value;
+                        }
+                    }
+                    else {
+                        // Fallback to key name
+                        externals[key] = key;
+                    }
+                });
+            }
+            break;
+        }
+        case "function": {
+            throw "functional external not supported yet";
+        }
+        default:
+            break;
+    }
+    return externals;
+}
+function compatModule(webpackModule) {
+    if (!Array.isArray(webpackModule === null || webpackModule === void 0 ? void 0 : webpackModule.rules)) {
+        return;
+    }
+    const moduleRules = {
+        rules: webpackModule.rules.reduce((acc, cur) => {
+            var _a, _b;
+            switch (typeof cur) {
+                case "object":
+                    if (cur) {
+                        let condition = (_b = (_a = cur.test) === null || _a === void 0 ? void 0 : _a.toString().match(/(\.\w+)/)) === null || _b === void 0 ? void 0 : _b[1];
+                        if (condition) {
+                            Object.assign(acc, {
+                                ["*" + condition]: {
+                                    loaders: typeof cur.use === "string"
+                                        ? [cur.use]
+                                        : typeof (cur === null || cur === void 0 ? void 0 : cur.use) === "object"
+                                            ? Array.isArray(cur.use)
+                                                ? cur.use.map((use) => typeof use === "string"
+                                                    ? { loader: use, options: {} }
+                                                    : {
+                                                        loader: use.loader,
+                                                        options: use.options || {},
+                                                    })
+                                                : [
+                                                    {
+                                                        loader: cur.loader,
+                                                        options: cur.options || {},
+                                                    },
+                                                ]
+                                            : [],
+                                    as: "*.js",
+                                },
+                            });
+                        }
+                    }
+                    break;
+                default:
+                    break;
+            }
+            return acc;
+        }, {}),
+    };
+    return moduleRules;
+}
+function compatResolve(webpackResolve) {
+    if (!webpackResolve) {
+        return;
+    }
+    const { alias, extensions } = webpackResolve;
+    return {
+        alias: alias
+            ? Array.isArray(alias)
+                ? alias.reduce((acc, cur) => Object.assign(acc, { [cur.name]: cur.alias }), {})
+                : Object.entries(alias).reduce((acc, [k, v]) => {
+                    if (typeof v === "string") {
+                        // Handle alias keys ending with $ by removing the $
+                        const aliasKey = k.endsWith("$") ? k.slice(0, -1) : k;
+                        Object.assign(acc, { [aliasKey]: v });
+                    }
+                    else {
+                        throw "non string alias value not supported yet";
+                    }
+                    return acc;
+                }, {})
+            : undefined,
+        extensions,
+    };
+}
+function compatOutput(webpackOutput) {
+    if ((webpackOutput === null || webpackOutput === void 0 ? void 0 : webpackOutput.filename) && typeof webpackOutput.filename !== "string") {
+        throw "non string output filename not supported yet";
+    }
+    if ((webpackOutput === null || webpackOutput === void 0 ? void 0 : webpackOutput.chunkFilename) &&
+        typeof webpackOutput.chunkFilename !== "string") {
+        throw "non string output chunkFilename not supported yet";
+    }
+    if ((webpackOutput === null || webpackOutput === void 0 ? void 0 : webpackOutput.publicPath) &&
+        typeof webpackOutput.publicPath !== "string") {
+        throw "non string output publicPath not supported yet";
+    }
+    return {
+        path: webpackOutput === null || webpackOutput === void 0 ? void 0 : webpackOutput.path,
+        filename: webpackOutput === null || webpackOutput === void 0 ? void 0 : webpackOutput.filename,
+        chunkFilename: webpackOutput === null || webpackOutput === void 0 ? void 0 : webpackOutput.chunkFilename,
+        clean: !!(webpackOutput === null || webpackOutput === void 0 ? void 0 : webpackOutput.clean),
+        publicPath: webpackOutput === null || webpackOutput === void 0 ? void 0 : webpackOutput.publicPath,
+    };
+}
+function compatTarget(webpackTarget) {
+    return webpackTarget
+        ? Array.isArray(webpackTarget)
+            ? webpackTarget.join(" ")
+            : webpackTarget
+        : undefined;
+}
+function compatSourceMaps(webpackSourceMaps) {
+    return !!webpackSourceMaps;
+}
+function compatOptimization(webpackOptimization) {
+    if (!webpackOptimization) {
+        return;
+    }
+    const { moduleIds, minimize, concatenateModules } = webpackOptimization;
+    return {
+        moduleIds: moduleIds === "named"
+            ? "named"
+            : moduleIds === "deterministic"
+                ? "deterministic"
+                : undefined,
+        minify: minimize,
+        concatenateModules,
+    };
+}
+function compatStats(webpackStats) {
+    return !!webpackStats;
+}