@utoo/pack 1.1.2 → 1.1.3

package/esm/util.js

@@ -1,141 +0,0 @@
-import { formatIssue, renderStyledStringToErrorAnsi } from "@utoo/pack-shared";
-import path from "path";
-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);
-        }
-    };
-}
-// ref:
-// https://github.com/vercel/next.js/pull/51883
-export function blockStdout() {
-    // rust needs stdout to be blocking, otherwise it will throw an error (on macOS at least) when writing a lot of data (logs) to it
-    // see https://github.com/napi-rs/napi-rs/issues/1630
-    // and https://github.com/nodejs/node/blob/main/doc/api/process.md#a-note-on-process-io
-    if (process.stdout._handle != null) {
-        process.stdout._handle.setBlocking(true);
-    }
-    if (process.stderr._handle != null) {
-        process.stderr._handle.setBlocking(true);
-    }
-}
-export function getPackPath() {
-    return path.resolve(__dirname, "..");
-}

package/esm/webpackCompat.d.ts

@@ -1,7 +0,0 @@
-import type webpack from "webpack";
-import { BundleOptions } from "./types";
-export declare function readWebpackConfig(projectPath?: string, rootPath?: string): any;
-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, projectPath?: string, rootPath?: string): BundleOptions;

package/esm/webpackCompat.js

@@ -1,401 +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),
-            provider: compatFromWebpackPlugin(plugins, compatProvider),
-            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;
-}
-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 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();
-        });
-    });
-}