@utoo/pack 1.3.2-alpha.0 → 1.3.3-alpha.0

package/esm/commands/dev-legacy.js

@@ -1,442 +0,0 @@
-import fs from "fs";
-import http from "http";
-import https from "https";
-import { isIPv6 } from "net";
-import path from "path";
-import send from "send";
-import url from "url";
-import { resolveBundleOptions } from "../config/webpackCompat.js";
-import { createHotReloader } from "../core/hmr.js";
-import { blockStdout, getPackPath } from "../utils/common.js";
-import { findRootDir } from "../utils/findRoot.js";
-import { createSelfSignedCertificate } from "../utils/mkcert.js";
-import { printServerInfo } from "../utils/printServerInfo.js";
-import { xcodeProfilingReady } from "../utils/xcodeProfile.js";
-function parsePath(pathStr) {
-    const hashIndex = pathStr.indexOf("#");
-    const queryIndex = pathStr.indexOf("?");
-    const hasQuery = queryIndex > -1 && (hashIndex < 0 || queryIndex < hashIndex);
-    if (hasQuery || hashIndex > -1) {
-        return {
-            pathname: pathStr.substring(0, hasQuery ? queryIndex : hashIndex),
-            query: hasQuery
-                ? pathStr.substring(queryIndex, hashIndex > -1 ? hashIndex : undefined)
-                : "",
-            hash: hashIndex > -1 ? pathStr.slice(hashIndex) : "",
-        };
-    }
-    return { pathname: pathStr, query: "", hash: "" };
-}
-function pathHasPrefix(pathStr, prefix) {
-    if (typeof pathStr !== "string") {
-        return false;
-    }
-    const { pathname } = parsePath(pathStr);
-    return pathname === prefix || pathname.startsWith(prefix + "/");
-}
-function removePathPrefix(pathStr, prefix) {
-    // If the path doesn't start with the prefix we can return it as is.
-    if (!pathHasPrefix(pathStr, prefix)) {
-        return pathStr;
-    }
-    // Remove the prefix from the path via slicing.
-    const withoutPrefix = pathStr.slice(prefix.length);
-    // If the path without the prefix starts with a `/` we can return it as is.
-    if (withoutPrefix.startsWith("/")) {
-        return withoutPrefix;
-    }
-    // If the path without the prefix doesn't start with a `/` we need to add it
-    // back to the path to make sure it's a valid path.
-    return `/${withoutPrefix}`;
-}
-function normalizedPublicPath(publicPath) {
-    const escapedPublicPath = (publicPath === null || publicPath === void 0 ? void 0 : publicPath.replace(/^\/+|\/+$/g, "")) || false;
-    if (!escapedPublicPath) {
-        return "";
-    }
-    try {
-        if (URL.canParse(escapedPublicPath)) {
-            const url = new URL(escapedPublicPath).toString();
-            return url.endsWith("/") ? url.slice(0, -1) : url;
-        }
-    }
-    catch (_a) { }
-    return `/${escapedPublicPath}`;
-}
-export function serve(options, projectPath, rootPath, serverOptions) {
-    const bundleOptions = resolveBundleOptions(options, projectPath, rootPath);
-    if (!rootPath) {
-        rootPath = findRootDir(projectPath || process.cwd());
-    }
-    return serveInternal(bundleOptions, projectPath, rootPath, serverOptions);
-}
-async function serveInternal(options, projectPath, rootPath, serverOptions) {
-    var _a;
-    blockStdout();
-    if (process.env.XCODE_PROFILE) {
-        await xcodeProfilingReady();
-    }
-    // FIXME: fix any type
-    const cfgDevServer = (((_a = options.config) === null || _a === void 0 ? void 0 : _a.devServer) || {});
-    const serverOpts = {
-        hostname: (serverOptions === null || serverOptions === void 0 ? void 0 : serverOptions.hostname) || cfgDevServer.host || "localhost",
-        port: typeof (serverOptions === null || serverOptions === void 0 ? void 0 : serverOptions.port) !== "undefined"
-            ? serverOptions.port
-            : cfgDevServer.port || 3000,
-        https: typeof (serverOptions === null || serverOptions === void 0 ? void 0 : serverOptions.https) !== "undefined"
-            ? serverOptions.https
-            : cfgDevServer.https,
-        logServerInfo: serverOptions === null || serverOptions === void 0 ? void 0 : serverOptions.logServerInfo,
-        selfSignedCertificate: serverOptions === null || serverOptions === void 0 ? void 0 : serverOptions.selfSignedCertificate,
-    };
-    // If HTTPS is requested and no certificate provided, attempt to generate one.
-    if (serverOpts.https && !serverOpts.selfSignedCertificate) {
-        try {
-            // createSelfSignedCertificate may return undefined on failure
-            const cert = await createSelfSignedCertificate(serverOpts.hostname);
-            if (cert)
-                serverOpts.selfSignedCertificate = cert;
-        }
-        catch (e) {
-            // ignore and fall back to http if certificate generation fails
-        }
-    }
-    await startServer(serverOpts, {
-        ...options,
-        config: {
-            ...options.config,
-            devServer: {
-                hot: true,
-                ...(options.config.devServer || {}),
-            },
-        },
-        packPath: getPackPath(),
-    }, projectPath || process.cwd(), rootPath);
-}
-export async function startServer(serverOptions, bundleOptions, projectPath, rootPath) {
-    let { port, hostname, selfSignedCertificate } = serverOptions;
-    process.title = "utoopack-dev-server";
-    let handlersReady = () => { };
-    let handlersError = () => { };
-    let handlersPromise = new Promise((resolve, reject) => {
-        handlersReady = resolve;
-        handlersError = reject;
-    });
-    let requestHandler = async (req, res) => {
-        if (handlersPromise) {
-            await handlersPromise;
-            return requestHandler(req, res);
-        }
-        throw new Error("Invariant request handler was not setup");
-    };
-    let upgradeHandler = async (req, socket, head) => {
-        if (handlersPromise) {
-            await handlersPromise;
-            return upgradeHandler(req, socket, head);
-        }
-        throw new Error("Invariant upgrade handler was not setup");
-    };
-    async function requestListener(req, res) {
-        try {
-            if (handlersPromise) {
-                await handlersPromise;
-                handlersPromise = undefined;
-            }
-            await requestHandler(req, res);
-        }
-        catch (err) {
-            res.statusCode = 500;
-            res.end("Internal Server Error");
-            console.error(`Failed to handle request for ${req.url}`);
-            console.error(err);
-        }
-    }
-    const server = selfSignedCertificate
-        ? https.createServer({
-            key: fs.readFileSync(selfSignedCertificate.key),
-            cert: fs.readFileSync(selfSignedCertificate.cert),
-        }, requestListener)
-        : http.createServer(requestListener);
-    server.on("upgrade", async (req, socket, head) => {
-        try {
-            await upgradeHandler(req, socket, head);
-        }
-        catch (err) {
-            socket.destroy();
-            console.error(`Failed to handle request for ${req.url}`);
-            console.error(err);
-        }
-    });
-    let portRetryCount = 0;
-    const originalPort = port;
-    server.on("error", (err) => {
-        if (port && err.code === "EADDRINUSE" && portRetryCount < 10) {
-            port += 1;
-            portRetryCount += 1;
-            server.listen(port, hostname);
-        }
-        else {
-            console.error(`Failed to start server`);
-            console.error(err);
-            process.exit(1);
-        }
-    });
-    await new Promise((resolve) => {
-        server.on("listening", async () => {
-            const addr = server.address();
-            const actualHostname = formatHostname(typeof addr === "object"
-                ? (addr === null || addr === void 0 ? void 0 : addr.address) || hostname || "localhost"
-                : addr);
-            const formattedHostname = !hostname || actualHostname === "0.0.0.0"
-                ? "localhost"
-                : actualHostname === "[::]"
-                    ? "[::1]"
-                    : formatHostname(hostname);
-            port = typeof addr === "object" ? (addr === null || addr === void 0 ? void 0 : addr.port) || port : port;
-            if (portRetryCount) {
-                console.warn(`Port ${originalPort} is in use, using available port ${port} instead.`);
-            }
-            if (serverOptions.logServerInfo !== false) {
-                printServerInfo(serverOptions.https ? "https" : "http", formattedHostname, port);
-            }
-            try {
-                let cleanupStarted = false;
-                let closeUpgraded = null;
-                const cleanup = () => {
-                    if (cleanupStarted) {
-                        return;
-                    }
-                    cleanupStarted = true;
-                    (async () => {
-                        console.debug("start-server process cleanup");
-                        await new Promise((res) => {
-                            server.close((err) => {
-                                if (err)
-                                    console.error(err);
-                                res();
-                            });
-                            server.closeAllConnections();
-                            closeUpgraded === null || closeUpgraded === void 0 ? void 0 : closeUpgraded();
-                        });
-                        console.debug("start-server process cleanup finished");
-                        process.exit(0);
-                    })();
-                };
-                const exception = (err) => {
-                    console.error(err);
-                };
-                process.on("SIGINT", cleanup);
-                process.on("SIGTERM", cleanup);
-                process.on("rejectionHandled", () => { });
-                process.on("uncaughtException", exception);
-                process.on("unhandledRejection", exception);
-                const initResult = await initialize(bundleOptions, projectPath, rootPath);
-                requestHandler = initResult.requestHandler;
-                upgradeHandler = initResult.upgradeHandler;
-                closeUpgraded = initResult.closeUpgraded;
-                handlersReady();
-            }
-            catch (err) {
-                handlersError();
-                console.error(err);
-                process.exit(1);
-            }
-            resolve();
-        });
-        server.listen(port, hostname);
-    });
-}
-export async function initialize(bundleOptions, projectPath, rootPath) {
-    process.env.NODE_ENV = "development";
-    const hotReloader = await createHotReloader(bundleOptions, projectPath, rootPath);
-    await hotReloader.start();
-    const requestHandlerImpl = async (req, res) => {
-        req.on("error", console.error);
-        res.on("error", console.error);
-        const handleRequest = async () => {
-            var _a, _b;
-            if (!(req.method === "GET" || req.method === "HEAD")) {
-                res.setHeader("Allow", ["GET", "HEAD"]);
-                res.statusCode = 405;
-                res.end();
-            }
-            const distRoot = path.resolve(projectPath, ((_a = bundleOptions.config.output) === null || _a === void 0 ? void 0 : _a.path) || "./dist");
-            const publicPath = (_b = bundleOptions.config.output) === null || _b === void 0 ? void 0 : _b.publicPath;
-            try {
-                const reqUrl = req.url || "";
-                let requestPath = url.parse(reqUrl).pathname || "";
-                if (publicPath && publicPath !== "runtime") {
-                    const normalizedPrefix = normalizedPublicPath(publicPath);
-                    const isAbsoluteUrl = normalizedPrefix.startsWith("http://") ||
-                        normalizedPrefix.startsWith("https://");
-                    if (!isAbsoluteUrl && normalizedPrefix) {
-                        if (pathHasPrefix(requestPath, normalizedPrefix)) {
-                            requestPath = removePathPrefix(requestPath, normalizedPrefix);
-                        }
-                    }
-                }
-                return await serveStatic(req, res, requestPath, { root: distRoot });
-            }
-            catch (err) {
-                res.setHeader("Cache-Control", "private, no-cache, no-store, max-age=0, must-revalidate");
-                res.statusCode = 404;
-                res.end();
-            }
-        };
-        try {
-            await handleRequest();
-        }
-        catch (err) {
-            res.statusCode = 500;
-            res.end("Internal Server Error");
-        }
-    };
-    let requestHandler = requestHandlerImpl;
-    const logError = async (type, err) => {
-        if (type === "unhandledRejection") {
-            console.error("unhandledRejection: ", err);
-        }
-        else if (type === "uncaughtException") {
-            console.error("uncaughtException: ", err);
-        }
-    };
-    process.on("uncaughtException", logError.bind(null, "uncaughtException"));
-    process.on("unhandledRejection", logError.bind(null, "unhandledRejection"));
-    const upgradeHandler = async (req, socket, head) => {
-        var _a;
-        try {
-            const isHMRRequest = (_a = req.url) === null || _a === void 0 ? void 0 : _a.includes("turbopack-hmr");
-            if (isHMRRequest) {
-                hotReloader.onHMR(req, socket, head);
-            }
-            else {
-                socket.end();
-            }
-        }
-        catch (err) {
-            console.error("Error handling upgrade request", err);
-            socket.end();
-        }
-    };
-    return {
-        requestHandler,
-        upgradeHandler,
-        closeUpgraded() {
-            hotReloader.close();
-        },
-    };
-}
-export async function pipeToNodeResponse(readable, res, waitUntilForEnd) {
-    try {
-        const { errored, destroyed } = res;
-        if (errored || destroyed)
-            return;
-        const controller = createAbortController(res);
-        const writer = createWriterFromResponse(res, waitUntilForEnd);
-        await readable.pipeTo(writer, { signal: controller.signal });
-    }
-    catch (err) {
-        if (isAbortError(err))
-            return;
-        throw new Error("failed to pipe response", { cause: err });
-    }
-}
-export function createAbortController(response) {
-    const controller = new AbortController();
-    response.once("close", () => {
-        if (response.writableFinished)
-            return;
-        controller.abort(new ResponseAborted());
-    });
-    return controller;
-}
-export function isAbortError(e) {
-    return (e === null || e === void 0 ? void 0 : e.name) === "AbortError" || (e === null || e === void 0 ? void 0 : e.name) === ResponseAbortedName;
-}
-export const ResponseAbortedName = "ResponseAborted";
-export class ResponseAborted extends Error {
-    constructor() {
-        super(...arguments);
-        this.name = ResponseAbortedName;
-    }
-}
-function createWriterFromResponse(res, waitUntilForEnd) {
-    let started = false;
-    let drained = new DetachedPromise();
-    function onDrain() {
-        drained.resolve();
-    }
-    res.on("drain", onDrain);
-    res.once("close", () => {
-        res.off("drain", onDrain);
-        drained.resolve();
-    });
-    const finished = new DetachedPromise();
-    res.once("finish", () => {
-        finished.resolve();
-    });
-    return new WritableStream({
-        write: async (chunk) => {
-            if (!started) {
-                started = true;
-                res.flushHeaders();
-            }
-            try {
-                const ok = res.write(chunk);
-                if ("flush" in res && typeof res.flush === "function") {
-                    res.flush();
-                }
-                if (!ok) {
-                    await drained.promise;
-                    drained = new DetachedPromise();
-                }
-            }
-            catch (err) {
-                res.end();
-                throw new Error("failed to write chunk to response", { cause: err });
-            }
-        },
-        abort: (err) => {
-            if (res.writableFinished)
-                return;
-            res.destroy(err);
-        },
-        close: async () => {
-            if (waitUntilForEnd) {
-                await waitUntilForEnd;
-            }
-            if (res.writableFinished)
-                return;
-            res.end();
-            return finished.promise;
-        },
-    });
-}
-export class DetachedPromise {
-    constructor() {
-        let resolve;
-        let reject;
-        this.promise = new Promise((res, rej) => {
-            resolve = res;
-            reject = rej;
-        });
-        this.resolve = resolve;
-        this.reject = reject;
-    }
-}
-export function serveStatic(req, res, path, opts) {
-    return new Promise((resolve, reject) => {
-        send(req, path, opts)
-            .on("directory", () => {
-            const err = new Error("No directory access");
-            err.code = "ENOENT";
-            reject(err);
-        })
-            .on("error", reject)
-            .pipe(res)
-            .on("finish", resolve);
-    });
-}
-export function formatHostname(hostname) {
-    return isIPv6(hostname) ? `[${hostname}]` : hostname;
-}

package/esm/core/proxy-hono.d.ts

@@ -1,29 +0,0 @@
-/**
- * HTTP proxy middleware for Hono dev server.
- * Matches ProxyRule by path, applies pathRewrite, and forwards via Hono proxy().
- * No generic WS proxying in this module.
- */
-import type { DevServerProxy, PathRewrite, ProxyRule } from "@utoo/pack-shared";
-import type { Context, Next } from "hono";
-/** Path prefix or ^-prefixed regex match (regex tests full path). */
-export declare function doesContextMatchUrl(context: string, pathOrUrl: string): boolean;
-export declare function ruleMatchesUrl(rule: ProxyRule, pathOrUrl: string): boolean;
-/**
- * Apply pathRewrite (http-proxy-middleware style).
- * Object: first matching regex → replace, then stop. Function: (path) => new path.
- */
-export declare function applyPathRewrite(path: string, pathRewrite?: PathRewrite): string;
-export interface PreparedProxyRequest {
-    url: URL;
-    headers: Headers;
-}
-/**
- * Build target URL and headers for the proxy request from current context and rule.
- */
-export declare function prepareProxyRequest(c: Context, rule: ProxyRule): PreparedProxyRequest;
-/**
- * Hono middleware: on match, proxy to rule.target with pathRewrite and changeOrigin;
- * on error return 502; otherwise next().
- * Caller (e.g. dev.ts) must pass a non-empty array; empty array means no rule matches.
- */
-export declare function createHttpProxyMiddleware(rules: DevServerProxy): (c: Context, next: Next) => Promise<void | Response>;

package/esm/core/proxy-hono.js

@@ -1,89 +0,0 @@
-/**
- * HTTP proxy middleware for Hono dev server.
- * Matches ProxyRule by path, applies pathRewrite, and forwards via Hono proxy().
- * No generic WS proxying in this module.
- */
-import { proxy } from "hono/proxy";
-/** Path prefix or ^-prefixed regex match (regex tests full path). */
-export function doesContextMatchUrl(context, pathOrUrl) {
-    if (context[0] === "^") {
-        try {
-            return new RegExp(context).test(pathOrUrl);
-        }
-        catch (_a) {
-            return false;
-        }
-    }
-    return pathOrUrl === context || pathOrUrl.startsWith(context + "/");
-}
-export function ruleMatchesUrl(rule, pathOrUrl) {
-    const contexts = Array.isArray(rule.context) ? rule.context : [rule.context];
-    return contexts.some((ctx) => doesContextMatchUrl(ctx, pathOrUrl));
-}
-/**
- * Apply pathRewrite (http-proxy-middleware style).
- * Object: first matching regex → replace, then stop. Function: (path) => new path.
- */
-export function applyPathRewrite(path, pathRewrite) {
-    if (!pathRewrite)
-        return path;
-    if (typeof pathRewrite === "function") {
-        return pathRewrite(path);
-    }
-    for (const [pattern, value] of Object.entries(pathRewrite)) {
-        try {
-            const regex = new RegExp(pattern);
-            if (regex.test(path)) {
-                return path.replace(regex, value);
-            }
-        }
-        catch (_a) {
-            // invalid regex, skip
-        }
-    }
-    return path;
-}
-/**
- * Build target URL and headers for the proxy request from current context and rule.
- */
-export function prepareProxyRequest(c, rule) {
-    const origUrl = new URL(c.req.url);
-    const targetUrl = new URL(rule.target);
-    const origPath = c.req.path;
-    const rewrittenPath = applyPathRewrite(origPath, rule.pathRewrite);
-    targetUrl.pathname = rewrittenPath;
-    targetUrl.search = origUrl.search;
-    const headers = new Headers(c.req.header());
-    if (rule.changeOrigin !== false) {
-        headers.set("host", targetUrl.host);
-    }
-    return { url: targetUrl, headers };
-}
-/**
- * Hono middleware: on match, proxy to rule.target with pathRewrite and changeOrigin;
- * on error return 502; otherwise next().
- * Caller (e.g. dev.ts) must pass a non-empty array; empty array means no rule matches.
- */
-export function createHttpProxyMiddleware(rules) {
-    return async (c, next) => {
-        const rule = rules.find((r) => ruleMatchesUrl(r, c.req.path));
-        if (!rule) {
-            return next();
-        }
-        try {
-            const prepared = prepareProxyRequest(c, rule);
-            const init = {
-                method: c.req.method,
-                headers: prepared.headers,
-            };
-            if (c.req.method !== "GET" && c.req.method !== "HEAD") {
-                init.body = c.req.raw.body;
-            }
-            return proxy(prepared.url.toString(), init);
-        }
-        catch (err) {
-            console.error("[dev proxy] error", c.req.method, c.req.url, err);
-            return c.text("Bad Gateway", 502);
-        }
-    };
-}