@utoo/pack 0.0.1-alpha.1 → 0.0.1-alpha.12

package/esm/dev.js

@@ -0,0 +1,339 @@
+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 { createHotReloader } from "./hmr";
+import { createSelfSignedCertificate } from "./mkcert";
+import { blockStdout } from "./util";
+import { xcodeProfilingReady } from "./xcodeProfile";
+export async function serve(options, projectPath, rootPath, serverOptions) {
+    blockStdout();
+    if (process.env.XCODE_PROFILE) {
+        await xcodeProfilingReady();
+    }
+    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, projectPath, 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.`);
+            }
+            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/hmr.d.ts

@@ -0,0 +1,80 @@
+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 {};

package/esm/hmr.js

@@ -0,0 +1,278 @@
+import { nanoid } from "nanoid";
+import ws from "ws";
+import { projectFactory } from "./project";
+import { createDefineEnv, debounce, processIssues } from "./util";
+const wsServer = new ws.Server({ noServer: true });
+const sessionId = Math.floor(Number.MAX_SAFE_INTEGER * Math.random());
+export const FAST_REFRESH_RUNTIME_RELOAD = "Fast Refresh had to perform a full reload due to a runtime error.";
+export async function createHotReloader(bundleOptions, projectPath, rootPath) {
+    var _a;
+    const createProject = projectFactory();
+    const project = await createProject({
+        processEnv: (_a = bundleOptions.processEnv) !== null && _a !== void 0 ? _a : {},
+        processDefineEnv: createDefineEnv({
+            config: bundleOptions.config,
+            dev: true,
+            optionDefineEnv: bundleOptions.processDefineEnv,
+        }),
+        watch: {
+            enable: true,
+        },
+        dev: true,
+        buildId: nanoid(),
+        config: {
+            ...bundleOptions.config,
+            mode: "development",
+            optimization: {
+                ...bundleOptions.config.optimization,
+                minify: false,
+                moduleIds: "named",
+            },
+        },
+        projectPath: projectPath || process.cwd(),
+        rootPath: rootPath || projectPath || process.cwd(),
+    }, {
+        persistentCaching: true,
+    });
+    const entrypointsSubscription = project.entrypointsSubscribe();
+    let currentEntriesHandlingResolve;
+    let currentEntriesHandling = new Promise((resolve) => (currentEntriesHandlingResolve = resolve));
+    let hmrEventHappened = false;
+    let hmrHash = 0;
+    const clients = new Set();
+    const clientStates = new WeakMap();
+    function sendToClient(client, payload) {
+        client.send(JSON.stringify(payload));
+    }
+    function sendEnqueuedMessages() {
+        for (const client of clients) {
+            const state = clientStates.get(client);
+            if (!state) {
+                continue;
+            }
+            for (const payload of state.hmrPayloads.values()) {
+                sendToClient(client, payload);
+            }
+            state.hmrPayloads.clear();
+            if (state.turbopackUpdates.length > 0) {
+                sendToClient(client, {
+                    action: "turbopack-message" /* HMR_ACTIONS_SENT_TO_BROWSER.TURBOPACK_MESSAGE */,
+                    data: state.turbopackUpdates,
+                });
+                state.turbopackUpdates.length = 0;
+            }
+        }
+    }
+    const sendEnqueuedMessagesDebounce = debounce(sendEnqueuedMessages, 2);
+    function sendTurbopackMessage(payload) {
+        var _a;
+        payload.diagnostics = [];
+        payload.issues = [];
+        for (const client of clients) {
+            (_a = clientStates.get(client)) === null || _a === void 0 ? void 0 : _a.turbopackUpdates.push(payload);
+        }
+        hmrEventHappened = true;
+        sendEnqueuedMessagesDebounce();
+    }
+    async function subscribeToHmrEvents(client, id) {
+        const state = clientStates.get(client);
+        if (!state || state.subscriptions.has(id)) {
+            return;
+        }
+        const subscription = project.hmrEvents(id);
+        state.subscriptions.set(id, subscription);
+        // The subscription will always emit once, which is the initial
+        // computation. This is not a change, so swallow it.
+        try {
+            await subscription.next();
+            for await (const data of subscription) {
+                processIssues(data, true, true);
+                if (data.type !== "issues") {
+                    sendTurbopackMessage(data);
+                }
+            }
+        }
+        catch (e) {
+            // The client might be using an HMR session from a previous server, tell them
+            // to fully reload the page to resolve the issue. We can't use
+            // `hotReloader.send` since that would force every connected client to
+            // reload, only this client is out of date.
+            const reloadAction = {
+                action: "reload" /* HMR_ACTIONS_SENT_TO_BROWSER.RELOAD */,
+                data: `error in HMR event subscription for ${id}: ${e}`,
+            };
+            sendToClient(client, reloadAction);
+            client.close();
+            return;
+        }
+    }
+    function unsubscribeFromHmrEvents(client, id) {
+        const state = clientStates.get(client);
+        if (!state) {
+            return;
+        }
+        const subscription = state.subscriptions.get(id);
+        subscription === null || subscription === void 0 ? void 0 : subscription.return();
+    }
+    async function handleEntrypointsSubscription() {
+        for await (const entrypoints of entrypointsSubscription) {
+            if (!currentEntriesHandlingResolve) {
+                currentEntriesHandling = new Promise(
+                // eslint-disable-next-line no-loop-func
+                (resolve) => (currentEntriesHandlingResolve = resolve));
+            }
+            await Promise.all(entrypoints.apps.map((l) => l.writeToDisk().then((res) => processIssues(res, true, true))));
+            currentEntriesHandlingResolve();
+            currentEntriesHandlingResolve = undefined;
+        }
+    }
+    const hotReloader = {
+        turbopackProject: project,
+        serverStats: null,
+        onHMR(req, socket, head, onUpgrade) {
+            wsServer.handleUpgrade(req, socket, head, (client) => {
+                onUpgrade === null || onUpgrade === void 0 ? void 0 : onUpgrade(client);
+                const subscriptions = new Map();
+                clients.add(client);
+                clientStates.set(client, {
+                    hmrPayloads: new Map(),
+                    turbopackUpdates: [],
+                    subscriptions,
+                });
+                client.on("close", () => {
+                    var _a;
+                    // Remove active subscriptions
+                    for (const subscription of subscriptions.values()) {
+                        (_a = subscription.return) === null || _a === void 0 ? void 0 : _a.call(subscription);
+                    }
+                    clientStates.delete(client);
+                    clients.delete(client);
+                });
+                client.addEventListener("message", ({ data }) => {
+                    const parsedData = JSON.parse(typeof data !== "string" ? data.toString() : data);
+                    // messages
+                    switch (parsedData.event) {
+                        case "client-error": // { errorCount, clientId }
+                        case "client-warning": // { warningCount, clientId }
+                        case "client-success": // { clientId }
+                        case "client-full-reload": // { stackTrace, hadRuntimeError }
+                            const { hadRuntimeError, dependencyChain } = parsedData;
+                            if (hadRuntimeError) {
+                                console.warn(FAST_REFRESH_RUNTIME_RELOAD);
+                            }
+                            if (Array.isArray(dependencyChain) &&
+                                typeof dependencyChain[0] === "string") {
+                                const cleanedModulePath = dependencyChain[0]
+                                    .replace(/^\[project\]/, ".")
+                                    .replace(/ \[.*\] \(.*\)$/, "");
+                                console.warn(`Fast Refresh had to perform a full reload when ${cleanedModulePath} changed.`);
+                            }
+                            break;
+                        default:
+                            // Might be a Turbopack message...
+                            if (!parsedData.type) {
+                                throw new Error(`unrecognized HMR message "${data}"`);
+                            }
+                    }
+                    // Turbopack messages
+                    switch (parsedData.type) {
+                        case "turbopack-subscribe":
+                            subscribeToHmrEvents(client, parsedData.path);
+                            break;
+                        case "turbopack-unsubscribe":
+                            unsubscribeFromHmrEvents(client, parsedData.path);
+                            break;
+                        default:
+                            if (!parsedData.event) {
+                                throw new Error(`unrecognized Turbopack HMR message "${data}"`);
+                            }
+                    }
+                });
+                const turbopackConnected = {
+                    action: "turbopack-connected" /* HMR_ACTIONS_SENT_TO_BROWSER.TURBOPACK_CONNECTED */,
+                    data: { sessionId },
+                };
+                sendToClient(client, turbopackConnected);
+                const errors = [];
+                (async function () {
+                    const sync = {
+                        action: "sync" /* HMR_ACTIONS_SENT_TO_BROWSER.SYNC */,
+                        errors,
+                        warnings: [],
+                        hash: "",
+                    };
+                    sendToClient(client, sync);
+                })();
+            });
+        },
+        send(action) {
+            const payload = JSON.stringify(action);
+            for (const client of clients) {
+                client.send(payload);
+            }
+        },
+        setHmrServerError(_error) {
+            // Not implemented yet.
+        },
+        clearHmrServerError() {
+            // Not implemented yet.
+        },
+        async start() { },
+        async buildFallbackError() {
+            // Not implemented yet.
+        },
+        close() {
+            for (const wsClient of clients) {
+                // it's okay to not cleanly close these websocket connections, this is dev
+                wsClient.terminate();
+            }
+            clients.clear();
+        },
+    };
+    handleEntrypointsSubscription().catch((err) => {
+        console.error(err);
+        process.exit(1);
+    });
+    // Write empty manifests
+    await currentEntriesHandling;
+    async function handleProjectUpdates() {
+        for await (const updateMessage of project.updateInfoSubscribe(30)) {
+            switch (updateMessage.updateType) {
+                case "start": {
+                    hotReloader.send({ action: "building" /* HMR_ACTIONS_SENT_TO_BROWSER.BUILDING */ });
+                    break;
+                }
+                case "end": {
+                    sendEnqueuedMessages();
+                    const errors = new Map();
+                    for (const client of clients) {
+                        const state = clientStates.get(client);
+                        if (!state) {
+                            continue;
+                        }
+                        const clientErrors = new Map(errors);
+                        sendToClient(client, {
+                            action: "built" /* HMR_ACTIONS_SENT_TO_BROWSER.BUILT */,
+                            hash: String(++hmrHash),
+                            errors: [...clientErrors.values()],
+                            warnings: [],
+                        });
+                    }
+                    if (hmrEventHappened) {
+                        const time = updateMessage.value.duration;
+                        const timeMessage = time > 2000 ? `${Math.round(time / 100) / 10}s` : `${time}ms`;
+                        console.log(`Compiled in ${timeMessage}`);
+                        hmrEventHappened = false;
+                    }
+                    break;
+                }
+                default:
+            }
+        }
+    }
+    handleProjectUpdates().catch((err) => {
+        console.error(err);
+        process.exit(1);
+    });
+    return hotReloader;
+}