@utoo/pack 1.1.2-alpha.5 → 1.1.2-lingguang

package/esm/webpackCompat.js

@@ -1,375 +0,0 @@
-import path from "path";
-export function readWebpackConfig(projectPath, rootPath) {
-    const projectPathOutOfRoot = projectPath === undefined
-        ? process.cwd()
-        : path.join(rootPath !== null && rootPath !== void 0 ? rootPath : "", projectPath);
-    const configPath = path.join(projectPathOutOfRoot, "webpack.config.js");
-    return require(configPath);
-}
-export function compatOptionsFromWebpack(webpackConfig, projectPath, rootPath) {
-    const { entry, mode, module, resolve, externals, output, target, devtool, optimization, plugins, stats, } = webpackConfig.entry
-        ? webpackConfig
-        : readWebpackConfig(projectPath, rootPath);
-    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),
-            stats: compatStats(stats),
-        },
-        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);
-}
-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;
-}
-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 utoo-pack 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 utoo-pack 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 utoo-pack 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;
-}

package/esm/xcodeProfile.d.ts

@@ -1 +0,0 @@
-export declare function xcodeProfilingReady(): Promise<void>;

package/esm/xcodeProfile.js

@@ -1,13 +0,0 @@
-export async function xcodeProfilingReady() {
-    await new Promise((resolve) => {
-        const readline = require("readline");
-        const rl = readline.createInterface({
-            input: process.stdin,
-            output: process.stdout,
-        });
-        rl.question(`Xcode profile enabled. Current process ${process.title} (${process.pid}) . Press Enter to continue...\n`, () => {
-            rl.close();
-            resolve();
-        });
-    });
-}