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

package/cjs/dev.js

@@ -1,362 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DetachedPromise = exports.ResponseAborted = exports.ResponseAbortedName = void 0;
-exports.serve = serve;
-exports.startServer = startServer;
-exports.initialize = initialize;
-exports.pipeToNodeResponse = pipeToNodeResponse;
-exports.createAbortController = createAbortController;
-exports.isAbortError = isAbortError;
-exports.serveStatic = serveStatic;
-exports.formatHostname = formatHostname;
-const fs_1 = __importDefault(require("fs"));
-const http_1 = __importDefault(require("http"));
-const https_1 = __importDefault(require("https"));
-const net_1 = require("net");
-const path_1 = __importDefault(require("path"));
-const send_1 = __importDefault(require("send"));
-const url_1 = __importDefault(require("url"));
-const hmr_1 = require("./hmr");
-const mkcert_1 = require("./mkcert");
-const util_1 = require("./util");
-const webpackCompat_1 = require("./webpackCompat");
-const xcodeProfile_1 = require("./xcodeProfile");
-function serve(options, projectPath, rootPath, serverOptions) {
-    const bundleOptions = options.compatMode
-        ? (0, webpackCompat_1.compatOptionsFromWebpack)(options)
-        : options;
-    return serveInternal(bundleOptions, projectPath, rootPath, serverOptions);
-}
-async function serveInternal(options, projectPath, rootPath, serverOptions) {
-    (0, util_1.blockStdout)();
-    if (process.env.XCODE_PROFILE) {
-        await (0, xcodeProfile_1.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 (0, mkcert_1.createSelfSignedCertificate)((serverOptions === null || serverOptions === void 0 ? void 0 : serverOptions.hostname) || "localhost")
-            : undefined,
-    }, options, projectPath || process.cwd(), rootPath);
-}
-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_1.default.createServer({
-            key: fs_1.default.readFileSync(selfSignedCertificate.key),
-            cert: fs_1.default.readFileSync(selfSignedCertificate.cert),
-        }, requestListener)
-        : http_1.default.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);
-    });
-}
-async function initialize(bundleOptions, projectPath, rootPath) {
-    process.env.NODE_ENV = "development";
-    const hotReloader = await (0, hmr_1.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_1.default.resolve(projectPath, ((_a = bundleOptions.config.output) === null || _a === void 0 ? void 0 : _a.path) || "./dist");
-            try {
-                const reqUrl = req.url || "";
-                const path = url_1.default.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();
-        },
-    };
-}
-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 });
-    }
-}
-function createAbortController(response) {
-    const controller = new AbortController();
-    response.once("close", () => {
-        if (response.writableFinished)
-            return;
-        controller.abort(new ResponseAborted());
-    });
-    return controller;
-}
-function isAbortError(e) {
-    return (e === null || e === void 0 ? void 0 : e.name) === "AbortError" || (e === null || e === void 0 ? void 0 : e.name) === exports.ResponseAbortedName;
-}
-exports.ResponseAbortedName = "ResponseAborted";
-class ResponseAborted extends Error {
-    constructor() {
-        super(...arguments);
-        this.name = exports.ResponseAbortedName;
-    }
-}
-exports.ResponseAborted = ResponseAborted;
-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;
-        },
-    });
-}
-class DetachedPromise {
-    constructor() {
-        let resolve;
-        let reject;
-        this.promise = new Promise((res, rej) => {
-            resolve = res;
-            reject = rej;
-        });
-        this.resolve = resolve;
-        this.reject = reject;
-    }
-}
-exports.DetachedPromise = DetachedPromise;
-function serveStatic(req, res, path, opts) {
-    return new Promise((resolve, reject) => {
-        (0, send_1.default)(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);
-    });
-}
-function formatHostname(hostname) {
-    return (0, net_1.isIPv6)(hostname) ? `[${hostname}]` : hostname;
-}

package/cjs/mkcert.d.ts

@@ -1,7 +0,0 @@
-export interface SelfSignedCertificate {
-    key: string;
-    cert: string;
-    rootCA?: string;
-}
-export declare function createSelfSignedCertificate(host?: string, certDir?: string): Promise<SelfSignedCertificate | undefined>;
-export declare function getCacheDirectory(fileDirectory: string, envPath?: string): string;

package/cjs/mkcert.js

@@ -1,183 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createSelfSignedCertificate = createSelfSignedCertificate;
-exports.getCacheDirectory = getCacheDirectory;
-const node_child_process_1 = require("node:child_process");
-const node_crypto_1 = require("node:crypto");
-const node_fs_1 = __importDefault(require("node:fs"));
-const node_path_1 = __importDefault(require("node:path"));
-const os_1 = __importDefault(require("os"));
-const { WritableStream } = require("node:stream/web");
-const MKCERT_VERSION = "v1.4.4";
-function getBinaryName() {
-    const platform = process.platform;
-    const arch = process.arch === "x64" ? "amd64" : process.arch;
-    if (platform === "win32") {
-        return `mkcert-${MKCERT_VERSION}-windows-${arch}.exe`;
-    }
-    if (platform === "darwin") {
-        return `mkcert-${MKCERT_VERSION}-darwin-${arch}`;
-    }
-    if (platform === "linux") {
-        return `mkcert-${MKCERT_VERSION}-linux-${arch}`;
-    }
-    throw new Error(`Unsupported platform: ${platform}`);
-}
-async function downloadBinary() {
-    try {
-        const binaryName = getBinaryName();
-        const cacheDirectory = getCacheDirectory("mkcert");
-        const binaryPath = node_path_1.default.join(cacheDirectory, binaryName);
-        if (node_fs_1.default.existsSync(binaryPath)) {
-            return binaryPath;
-        }
-        const downloadUrl = `https://github.com/FiloSottile/mkcert/releases/download/${MKCERT_VERSION}/${binaryName}`;
-        await node_fs_1.default.promises.mkdir(cacheDirectory, { recursive: true });
-        console.log(`Downloading mkcert package...`);
-        const response = await fetch(downloadUrl);
-        if (!response.ok || !response.body) {
-            throw new Error(`request failed with status ${response.status}`);
-        }
-        console.log(`Download response was successful, writing to disk`);
-        const binaryWriteStream = node_fs_1.default.createWriteStream(binaryPath);
-        await response.body.pipeTo(new WritableStream({
-            write(chunk) {
-                return new Promise((resolve, reject) => {
-                    binaryWriteStream.write(chunk, (error) => {
-                        if (error) {
-                            reject(error);
-                            return;
-                        }
-                        resolve();
-                    });
-                });
-            },
-            close() {
-                return new Promise((resolve, reject) => {
-                    binaryWriteStream.close((error) => {
-                        if (error) {
-                            reject(error);
-                            return;
-                        }
-                        resolve();
-                    });
-                });
-            },
-        }));
-        await node_fs_1.default.promises.chmod(binaryPath, 0o755);
-        return binaryPath;
-    }
-    catch (err) {
-        console.error("Error downloading mkcert:", err);
-    }
-}
-async function createSelfSignedCertificate(host, certDir = "certificates") {
-    try {
-        const binaryPath = await downloadBinary();
-        if (!binaryPath)
-            throw new Error("missing mkcert binary");
-        const resolvedCertDir = node_path_1.default.resolve(process.cwd(), `./${certDir}`);
-        await node_fs_1.default.promises.mkdir(resolvedCertDir, {
-            recursive: true,
-        });
-        const keyPath = node_path_1.default.resolve(resolvedCertDir, "localhost-key.pem");
-        const certPath = node_path_1.default.resolve(resolvedCertDir, "localhost.pem");
-        if (node_fs_1.default.existsSync(keyPath) && node_fs_1.default.existsSync(certPath)) {
-            const cert = new node_crypto_1.X509Certificate(node_fs_1.default.readFileSync(certPath));
-            const key = node_fs_1.default.readFileSync(keyPath);
-            if (cert.checkHost(host !== null && host !== void 0 ? host : "localhost") &&
-                cert.checkPrivateKey((0, node_crypto_1.createPrivateKey)(key))) {
-                console.log("Using already generated self signed certificate");
-                const caLocation = (0, node_child_process_1.execSync)(`"${binaryPath}" -CAROOT`)
-                    .toString()
-                    .trim();
-                return {
-                    key: keyPath,
-                    cert: certPath,
-                    rootCA: `${caLocation}/rootCA.pem`,
-                };
-            }
-        }
-        console.log("Attempting to generate self signed certificate. This may prompt for your password");
-        const defaultHosts = ["localhost", "127.0.0.1", "::1"];
-        const hosts = host && !defaultHosts.includes(host)
-            ? [...defaultHosts, host]
-            : defaultHosts;
-        (0, node_child_process_1.execSync)(`"${binaryPath}" -install -key-file "${keyPath}" -cert-file "${certPath}" ${hosts.join(" ")}`, { stdio: "ignore" });
-        const caLocation = (0, node_child_process_1.execSync)(`"${binaryPath}" -CAROOT`).toString().trim();
-        if (!node_fs_1.default.existsSync(keyPath) || !node_fs_1.default.existsSync(certPath)) {
-            throw new Error("Certificate files not found");
-        }
-        console.log(`CA Root certificate created in ${caLocation}`);
-        console.log(`Certificates created in ${resolvedCertDir}`);
-        const gitignorePath = node_path_1.default.resolve(process.cwd(), "./.gitignore");
-        if (node_fs_1.default.existsSync(gitignorePath)) {
-            const gitignore = await node_fs_1.default.promises.readFile(gitignorePath, "utf8");
-            if (!gitignore.includes(certDir)) {
-                console.log("Adding certificates to .gitignore");
-                await node_fs_1.default.promises.appendFile(gitignorePath, `\n${certDir}`);
-            }
-        }
-        return {
-            key: keyPath,
-            cert: certPath,
-            rootCA: `${caLocation}/rootCA.pem`,
-        };
-    }
-    catch (err) {
-        console.error("Failed to generate self-signed certificate. Falling back to http.", err);
-    }
-}
-// get platform specific cache directory adapted from playwright's handling
-// https://github.com/microsoft/playwright/blob/7d924470d397975a74a19184c136b3573a974e13/packages/playwright-core/src/utils/registry.ts#L141
-function getCacheDirectory(fileDirectory, envPath) {
-    let result;
-    if (envPath) {
-        result = envPath;
-    }
-    else {
-        let systemCacheDirectory;
-        if (process.platform === "linux") {
-            systemCacheDirectory =
-                process.env.XDG_CACHE_HOME || node_path_1.default.join(os_1.default.homedir(), ".cache");
-        }
-        else if (process.platform === "darwin") {
-            systemCacheDirectory = node_path_1.default.join(os_1.default.homedir(), "Library", "Caches");
-        }
-        else if (process.platform === "win32") {
-            systemCacheDirectory =
-                process.env.LOCALAPPDATA || node_path_1.default.join(os_1.default.homedir(), "AppData", "Local");
-        }
-        else {
-            /// Attempt to use generic tmp location for un-handled platform
-            if (!systemCacheDirectory) {
-                for (const dir of [
-                    node_path_1.default.join(os_1.default.homedir(), ".cache"),
-                    node_path_1.default.join(os_1.default.tmpdir()),
-                ]) {
-                    if (node_fs_1.default.existsSync(dir)) {
-                        systemCacheDirectory = dir;
-                        break;
-                    }
-                }
-            }
-            if (!systemCacheDirectory) {
-                console.error(new Error("Unsupported platform: " + process.platform));
-                process.exit(0);
-            }
-        }
-        result = node_path_1.default.join(systemCacheDirectory, fileDirectory);
-    }
-    if (!node_path_1.default.isAbsolute(result)) {
-        // It is important to resolve to the absolute path:
-        //   - for unzipping to work correctly;
-        //   - so that registry directory matches between installation and execution.
-        // INIT_CWD points to the root of `npm/yarn install` and is probably what
-        // the user meant when typing the relative path.
-        result = node_path_1.default.resolve(process.env["INIT_CWD"] || process.cwd(), result);
-    }
-    return result;
-}

package/cjs/webpackCompat.d.ts

@@ -1,6 +0,0 @@
-import type webpack from "webpack";
-import { BundleOptions } from "./types";
-export type WebpackConfig = Pick<webpack.Configuration, "name" | "entry" | "mode" | "module" | "resolve" | "externals" | "output" | "target" | "devtool" | "optimization" | "plugins" | "stats"> & {
-    compatMode: true;
-};
-export declare function compatOptionsFromWebpack(webpackConfig: WebpackConfig): BundleOptions;