@utoo/pack 1.1.2 → 1.1.3

package/esm/dev.d.ts

@@ -1,43 +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(options: BundleOptions | 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;

package/esm/dev.js

@@ -1,360 +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 { findRootDir } from "./find-root";
-import { createHotReloader } from "./hmr";
-import { createSelfSignedCertificate } from "./mkcert";
-import { blockStdout, getPackPath } from "./util";
-import { compatOptionsFromWebpack } from "./webpackCompat";
-import { xcodeProfilingReady } from "./xcodeProfile";
-export function serve(options, projectPath, rootPath, serverOptions) {
-    const bundleOptions = options.webpackMode
-        ? compatOptionsFromWebpack(options, projectPath, rootPath)
-        : options;
-    if (!rootPath) {
-        // help user to find the rootDir automatically
-        rootPath = findRootDir(projectPath || process.cwd());
-    }
-    return serveInternal(bundleOptions, projectPath, rootPath, serverOptions);
-}
-async function serveInternal(options, projectPath, rootPath, serverOptions) {
-    blockStdout();
-    if (process.env.XCODE_PROFILE) {
-        await xcodeProfilingReady();
-    }
-    await startServer({
-        hostname: (serverOptions === null || serverOptions === void 0 ? void 0 : serverOptions.hostname) || "localhost",
-        port: (serverOptions === null || serverOptions === void 0 ? void 0 : serverOptions.port) || 3000,
-        https: serverOptions === null || serverOptions === void 0 ? void 0 : serverOptions.https,
-        selfSignedCertificate: (serverOptions === null || serverOptions === void 0 ? void 0 : serverOptions.https)
-            ? await createSelfSignedCertificate((serverOptions === null || serverOptions === void 0 ? void 0 : serverOptions.hostname) || "localhost")
-            : undefined,
-    }, {
-        ...options,
-        config: {
-            ...options.config,
-            devServer: { hot: true },
-        },
-        packPath: getPackPath(),
-    }, projectPath || process.cwd(), rootPath);
-}
-export async function startServer(serverOptions, bundleOptions, projectPath, rootPath) {
-    let { port, hostname, selfSignedCertificate } = serverOptions;
-    process.title = "utoo-pack-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 (process.env.TURBOPACK_DEBUG_JS) {
-                console.log(`Listening on ${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;
-            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");
-            try {
-                const reqUrl = req.url || "";
-                const path = url.parse(reqUrl).pathname || "";
-                return await serveStatic(req, res, path, { 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/find-root.d.ts

@@ -1,4 +0,0 @@
-export declare function findRootLockFile(cwd: string): string | undefined;
-export declare function findPackageJson(cwd: string): string | undefined;
-export declare function findWorkspacesRoot(cwd: string): string;
-export declare function findRootDir(cwd: string): string;

package/esm/find-root.js

@@ -1,66 +0,0 @@
-import findUp from "find-up";
-import { readFileSync } from "fs";
-import { dirname } from "path";
-export function findRootLockFile(cwd) {
-    return findUp.sync([
-        "pnpm-lock.yaml",
-        "package-lock.json",
-        "yarn.lock",
-        "bun.lock",
-        "bun.lockb",
-    ], {
-        cwd,
-    });
-}
-// compatible with tnpm
-export function findPackageJson(cwd) {
-    return findUp.sync(["package.json"], {
-        cwd,
-    });
-}
-function isWorkspaceRoot(pkgPath) {
-    const pkgJson = readFileSync(pkgPath, "utf-8");
-    const pkgJsonContent = JSON.parse(pkgJson);
-    return Boolean(pkgJsonContent.workspaces);
-}
-// refer from: https://github.com/umijs/mako/blob/next/crates/pm/src/helper/workspace.rs#L153
-// TODO: 这块逻辑后续跟 utoo-pkg 使用一套方法
-export function findWorkspacesRoot(cwd) {
-    const pkgJson = findPackageJson(cwd);
-    if (!pkgJson)
-        return cwd;
-    const pkgJsonFiles = [pkgJson];
-    while (true) {
-        const lastPkgJson = pkgJsonFiles[pkgJsonFiles.length - 1];
-        const currentDir = dirname(lastPkgJson);
-        const parentDir = dirname(currentDir);
-        if (parentDir === currentDir)
-            break;
-        if (isWorkspaceRoot(lastPkgJson))
-            break;
-        const newPkgJson = findPackageJson(parentDir);
-        if (!newPkgJson)
-            break;
-        pkgJsonFiles.push(newPkgJson);
-    }
-    return dirname(pkgJsonFiles[pkgJsonFiles.length - 1]);
-}
-export function findRootDir(cwd) {
-    const lockFile = findRootLockFile(cwd);
-    if (!lockFile)
-        return findWorkspacesRoot(cwd);
-    const lockFiles = [lockFile];
-    while (true) {
-        const lastLockFile = lockFiles[lockFiles.length - 1];
-        const currentDir = dirname(lastLockFile);
-        const parentDir = dirname(currentDir);
-        // dirname('/')==='/' so if we happen to reach the FS root (as might happen in a container we need to quit to avoid looping forever
-        if (parentDir === currentDir)
-            break;
-        const newLockFile = findRootLockFile(parentDir);
-        if (!newLockFile)
-            break;
-        lockFiles.push(newLockFile);
-    }
-    return dirname(lockFiles[lockFiles.length - 1]);
-}

package/esm/hmr.d.ts

@@ -1,80 +0,0 @@
-import { IncomingMessage } from "http";
-import { Duplex } from "stream";
-import type webpack from "webpack";
-import { BundleOptions, Project, Update as TurbopackUpdate } from "./types";
-export declare const enum HMR_ACTIONS_SENT_TO_BROWSER {
-    RELOAD = "reload",
-    CLIENT_CHANGES = "clientChanges",
-    SERVER_ONLY_CHANGES = "serverOnlyChanges",
-    SYNC = "sync",
-    BUILT = "built",
-    BUILDING = "building",
-    TURBOPACK_MESSAGE = "turbopack-message",
-    TURBOPACK_CONNECTED = "turbopack-connected"
-}
-export interface TurbopackMessageAction {
-    action: HMR_ACTIONS_SENT_TO_BROWSER.TURBOPACK_MESSAGE;
-    data: TurbopackUpdate | TurbopackUpdate[];
-}
-export interface TurbopackConnectedAction {
-    action: HMR_ACTIONS_SENT_TO_BROWSER.TURBOPACK_CONNECTED;
-    data: {
-        sessionId: number;
-    };
-}
-interface BuildingAction {
-    action: HMR_ACTIONS_SENT_TO_BROWSER.BUILDING;
-}
-export interface CompilationError {
-    moduleName?: string;
-    message: string;
-    details?: string;
-    moduleTrace?: Array<{
-        moduleName?: string;
-    }>;
-    stack?: string;
-}
-export interface SyncAction {
-    action: HMR_ACTIONS_SENT_TO_BROWSER.SYNC;
-    hash: string;
-    errors: ReadonlyArray<CompilationError>;
-    warnings: ReadonlyArray<CompilationError>;
-    updatedModules?: ReadonlyArray<string>;
-}
-export interface BuiltAction {
-    action: HMR_ACTIONS_SENT_TO_BROWSER.BUILT;
-    hash: string;
-    errors: ReadonlyArray<CompilationError>;
-    warnings: ReadonlyArray<CompilationError>;
-    updatedModules?: ReadonlyArray<string>;
-}
-export interface ReloadAction {
-    action: HMR_ACTIONS_SENT_TO_BROWSER.RELOAD;
-    data: string;
-}
-export type HMR_ACTION_TYPES = TurbopackMessageAction | TurbopackConnectedAction | BuildingAction | SyncAction | BuiltAction | ReloadAction;
-export interface HotReloaderInterface {
-    turbopackProject?: Project;
-    serverStats: webpack.Stats | null;
-    setHmrServerError(error: Error | null): void;
-    clearHmrServerError(): void;
-    start(): Promise<void>;
-    send(action: HMR_ACTION_TYPES): void;
-    onHMR(req: IncomingMessage, socket: Duplex, head: Buffer, onUpgrade?: (client: {
-        send(data: string): void;
-    }) => void): void;
-    buildFallbackError(): Promise<void>;
-    close(): void;
-}
-export type ChangeSubscriptions = Map<string, Promise<AsyncIterableIterator<TurbopackResult>>>;
-export type ReadyIds = Set<string>;
-export type StartBuilding = (id: string, forceRebuild: boolean) => () => void;
-export type ClientState = {
-    hmrPayloads: Map<string, HMR_ACTION_TYPES>;
-    turbopackUpdates: TurbopackUpdate[];
-    subscriptions: Map<string, AsyncIterator<any>>;
-};
-export type SendHmr = (id: string, payload: HMR_ACTION_TYPES) => void;
-export declare const FAST_REFRESH_RUNTIME_RELOAD = "Fast Refresh had to perform a full reload due to a runtime error.";
-export declare function createHotReloader(bundleOptions: BundleOptions, projectPath?: string, rootPath?: string): Promise<HotReloaderInterface>;
-export {};