@utoo/pack 1.1.3 → 1.1.4

package/cjs/utils/mkcert.d.ts

@@ -0,0 +1,7 @@
+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/utils/mkcert.js

@@ -0,0 +1,183 @@
+"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/utils/print-server-info.d.ts

@@ -0,0 +1 @@
+export declare function printServerInfo(protocol: "http" | "https", hostname: string, port: number): void;

package/cjs/utils/print-server-info.js

@@ -0,0 +1,50 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.printServerInfo = printServerInfo;
+const os_1 = __importDefault(require("os"));
+const picocolors_1 = __importDefault(require("picocolors"));
+function printServerInfo(protocol, hostname, port) {
+    const localUrl = `${protocol}://localhost:${port}`;
+    const networkAddress = getNetworkAddress();
+    const networkUrl = networkAddress
+        ? `${protocol}://${networkAddress}:${port}`
+        : null;
+    console.log();
+    console.log(picocolors_1.default.green("  ┌──────────────────────────────────────────────────┐"));
+    console.log(picocolors_1.default.green("  │                                                  │"));
+    console.log(picocolors_1.default.green("  │   ") +
+        picocolors_1.default.bold("Serving!") +
+        picocolors_1.default.green("                                       │"));
+    console.log(picocolors_1.default.green("  │                                                  │"));
+    const localLabel = "  │   - Local:    ";
+    const localPadding = 50 - 15 - localUrl.length; // 15 is "   - Local:    ".length
+    console.log(picocolors_1.default.green(localLabel) +
+        picocolors_1.default.cyan(localUrl) +
+        picocolors_1.default.green(" ".repeat(Math.max(0, localPadding)) + "│"));
+    if (networkUrl) {
+        const netLabel = "  │   - Network:  ";
+        const netPadding = 50 - 17 - networkUrl.length; // 17 is "   - Network:  ".length
+        console.log(picocolors_1.default.green(netLabel) +
+            picocolors_1.default.cyan(networkUrl) +
+            picocolors_1.default.green(" ".repeat(Math.max(0, netPadding)) + "│"));
+    }
+    console.log(picocolors_1.default.green("  │                                                  │"));
+    console.log(picocolors_1.default.green("  │   Copied local address to clipboard!             │"));
+    console.log(picocolors_1.default.green("  │                                                  │"));
+    console.log(picocolors_1.default.green("  └──────────────────────────────────────────────────┘"));
+    console.log();
+}
+function getNetworkAddress() {
+    const interfaces = os_1.default.networkInterfaces();
+    for (const name of Object.keys(interfaces)) {
+        for (const iface of interfaces[name]) {
+            if (iface.family === "IPv4" && !iface.internal) {
+                return iface.address;
+            }
+        }
+    }
+    return undefined;
+}

package/cjs/utils/xcodeProfile.d.ts

@@ -0,0 +1 @@
+export declare function xcodeProfilingReady(): Promise<void>;

package/cjs/utils/xcodeProfile.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.xcodeProfilingReady = xcodeProfilingReady;
+async function xcodeProfilingReady() {
+    await new Promise((resolve) => {
+        const readline = require("readline");
+        const rl = readline.createInterface({
+            input: process.stdin,
+            output: process.stdout,
+        });
+        rl.question(`Xcode profile enabled. Current process ${process.title} (${process.pid}) . Press Enter to continue...\n`, () => {
+            rl.close();
+            resolve();
+        });
+    });
+}

package/esm/commands/build.d.ts

@@ -0,0 +1,3 @@
+import { WebpackConfig } from "../config/webpackCompat";
+import { BundleOptions } from "../core/types";
+export declare function build(options: BundleOptions | WebpackConfig, projectPath?: string, rootPath?: string): Promise<void>;

package/esm/commands/build.js

@@ -0,0 +1,129 @@
+import { handleIssues } from "@utoo/pack-shared";
+import { spawn } from "child_process";
+import fs, { existsSync } from "fs";
+import { nanoid } from "nanoid";
+import { join } from "path";
+import { compatOptionsFromWebpack, readWebpackConfig, } from "../config/webpackCompat";
+import { projectFactory } from "../core/project";
+import { HtmlPlugin } from "../plugins/HtmlPlugin";
+import { blockStdout, createDefineEnv, getPackPath } from "../utils/common";
+import { findRootDir } from "../utils/find-root";
+import { processHtmlEntry } from "../utils/html-entry";
+import { xcodeProfilingReady } from "../utils/xcodeProfile";
+export function build(options, projectPath, rootPath) {
+    let bundleOptions;
+    if (options.webpackMode) {
+        let webpackConfig = options;
+        if (!webpackConfig.entry) {
+            const loadedConfig = readWebpackConfig(projectPath, rootPath);
+            webpackConfig = { ...webpackConfig, ...loadedConfig };
+        }
+        bundleOptions = compatOptionsFromWebpack(webpackConfig);
+    }
+    else {
+        bundleOptions = options;
+    }
+    if (!rootPath) {
+        // help user to find the rootDir automatically.
+        rootPath = findRootDir(projectPath || process.cwd());
+    }
+    return buildInternal(bundleOptions, projectPath, rootPath);
+}
+async function buildInternal(bundleOptions, projectPath, rootPath) {
+    var _a, _b, _c, _d, _e, _f;
+    blockStdout();
+    if (process.env.XCODE_PROFILE) {
+        await xcodeProfilingReady();
+    }
+    processHtmlEntry(bundleOptions.config, projectPath || process.cwd());
+    const createProject = projectFactory();
+    const project = await createProject({
+        processEnv: (_a = bundleOptions.processEnv) !== null && _a !== void 0 ? _a : {},
+        defineEnv: createDefineEnv({
+            config: bundleOptions.config,
+            dev: (_b = bundleOptions.dev) !== null && _b !== void 0 ? _b : false,
+            optionDefineEnv: bundleOptions.defineEnv,
+        }),
+        watch: {
+            enable: false,
+        },
+        dev: (_c = bundleOptions.dev) !== null && _c !== void 0 ? _c : false,
+        buildId: bundleOptions.buildId || nanoid(),
+        config: {
+            ...bundleOptions.config,
+            stats: Boolean(process.env.ANALYZE) ||
+                bundleOptions.config.stats ||
+                bundleOptions.config.entry.some((e) => !!e.html),
+        },
+        projectPath: projectPath || process.cwd(),
+        rootPath: rootPath || projectPath || process.cwd(),
+        packPath: getPackPath(),
+    }, {
+        persistentCaching: false,
+    });
+    const entrypoints = await project.writeAllEntrypointsToDisk();
+    handleIssues(entrypoints.issues);
+    const htmlConfigs = [
+        ...(Array.isArray(bundleOptions.config.html)
+            ? bundleOptions.config.html
+            : bundleOptions.config.html
+                ? [bundleOptions.config.html]
+                : []),
+        ...bundleOptions.config.entry.filter((e) => !!e.html).map((e) => e.html),
+    ];
+    if (htmlConfigs.length > 0) {
+        const assets = { js: [], css: [] };
+        const outputDir = ((_d = bundleOptions.config.output) === null || _d === void 0 ? void 0 : _d.path) || join(process.cwd(), "dist");
+        if (assets.js.length === 0 && assets.css.length === 0) {
+            const statsPath = join(outputDir, "stats.json");
+            if (existsSync(statsPath)) {
+                try {
+                    const stats = JSON.parse(fs.readFileSync(statsPath, "utf-8"));
+                    if (stats.assets) {
+                        stats.assets.forEach((asset) => {
+                            if (asset.name.endsWith(".js"))
+                                assets.js.push(asset.name);
+                            if (asset.name.endsWith(".css"))
+                                assets.css.push(asset.name);
+                        });
+                    }
+                }
+                catch (e) {
+                    console.warn("Failed to read stats.json for assets discovery", e);
+                }
+            }
+        }
+        const publicPath = (_e = bundleOptions.config.output) === null || _e === void 0 ? void 0 : _e.publicPath;
+        for (const config of htmlConfigs) {
+            const plugin = new HtmlPlugin(config);
+            await plugin.generate(outputDir, assets, publicPath);
+        }
+    }
+    if (process.env.ANALYZE) {
+        await analyzeBundle(((_f = bundleOptions.config.output) === null || _f === void 0 ? void 0 : _f.path) || "dist");
+    }
+    await project.shutdown();
+    // TODO: Maybe run tasks in worker is a better way, see
+    // https://github.com/vercel/next.js/blob/512d8283054407ab92b2583ecce3b253c3be7b85/packages/next/src/lib/worker.ts
+}
+async function analyzeBundle(outputPath) {
+    const statsPath = join(outputPath, "stats.json");
+    if (!existsSync(statsPath)) {
+        console.warn(`Stats file not found at ${statsPath}. Make sure to enable stats in your configuration.`);
+        return;
+    }
+    return new Promise((resolve, reject) => {
+        const analyzer = spawn("npx", ["webpack-bundle-analyzer", statsPath], {
+            stdio: "inherit",
+            shell: true,
+        });
+        analyzer.on("error", (error) => {
+            reject(new Error(`Failed to start bundle analyzer: ${error.message}`));
+        });
+        analyzer.on("close", () => {
+            // The analyzer process has finished, so we can resolve the promise
+            // to allow the build process to exit gracefully.
+            resolve();
+        });
+    });
+}

package/esm/commands/dev.d.ts

@@ -0,0 +1,44 @@
+import { IncomingMessage, ServerResponse } from "http";
+import send from "send";
+import { Duplex, Writable } from "stream";
+import { WebpackConfig } from "../config/webpackCompat";
+import { BundleOptions } from "../core/types";
+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;
+    logServerInfo?: boolean;
+    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;