@utoo/pack 0.0.1-alpha.18 → 0.0.1-alpha.2

package/cjs/webpackCompat.js

@@ -1,341 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.compatOptionsFromWebpack = compatOptionsFromWebpack;
-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),
-            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 {
-                                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) {
-    return maybeWebpackPluginInstance === null || maybeWebpackPluginInstance === void 0 ? void 0 : maybeWebpackPluginInstance.definitions;
-}
-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") {
-                        Object.assign(acc, { [k]: 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";
-    }
-    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),
-    };
-}
-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,
-    // TODO: concatenateModules to be supported, need to upgrade to next.js@15.4
-     } = webpackOptimization;
-    return {
-        moduleIds: moduleIds === "named"
-            ? "named"
-            : moduleIds === "deterministic"
-                ? "deterministic"
-                : undefined,
-        minify: minimize,
-    };
-}
-function compatStats(webpackStats) {
-    return !!webpackStats;
-}

package/esm/dev.d.ts

@@ -1,44 +0,0 @@
-import { IncomingMessage, ServerResponse } from "http";
-import send from "send";
-import { Duplex, Writable } from "stream";
-import { BundleOptions } from "./types";
-import { WebpackConfig } from "./webpackCompat";
-export declare function serve(bundleOptions: BundleOptions, projectPath?: string, rootPath?: string, serverOptions?: StartServerOptions): Promise<void>;
-export declare function serve(webpackConfig: WebpackConfig, projectPath?: string, rootPath?: string, serverOptions?: StartServerOptions): Promise<void>;
-export interface SelfSignedCertificate {
-    key: string;
-    cert: string;
-    rootCA?: string;
-}
-export interface StartServerOptions {
-    port: number;
-    https?: boolean;
-    hostname?: string;
-    selfSignedCertificate?: SelfSignedCertificate;
-}
-export type RequestHandler = (req: IncomingMessage, res: ServerResponse) => Promise<void>;
-export type UpgradeHandler = (req: IncomingMessage, socket: Duplex, head: Buffer) => Promise<void>;
-export type ServerInitResult = {
-    requestHandler: RequestHandler;
-    upgradeHandler: UpgradeHandler;
-    closeUpgraded: () => void;
-};
-export declare function startServer(serverOptions: StartServerOptions, bundleOptions: BundleOptions, projectPath: string, rootPath?: string): Promise<void>;
-export declare function initialize(bundleOptions: BundleOptions, projectPath: string, rootPath?: string): Promise<ServerInitResult>;
-export declare function pipeToNodeResponse(readable: ReadableStream<Uint8Array>, res: ServerResponse, waitUntilForEnd?: Promise<unknown>): Promise<void>;
-export declare function createAbortController(response: Writable): AbortController;
-export declare function isAbortError(e: any): e is Error & {
-    name: "AbortError";
-};
-export declare const ResponseAbortedName = "ResponseAborted";
-export declare class ResponseAborted extends Error {
-    readonly name = "ResponseAborted";
-}
-export declare class DetachedPromise<T = any> {
-    readonly resolve: (value: T | PromiseLike<T>) => void;
-    readonly reject: (reason: any) => void;
-    readonly promise: Promise<T>;
-    constructor();
-}
-export declare function serveStatic(req: IncomingMessage, res: ServerResponse, path: string, opts?: Parameters<typeof send>[2]): Promise<void>;
-export declare function formatHostname(hostname: string): string;