@utoo/pack 1.1.2 → 1.1.3

package/esm/hmr.js

@@ -1,279 +0,0 @@
-import { nanoid } from "nanoid";
-import ws from "ws";
-import { projectFactory } from "./project";
-import { createDefineEnv, debounce, getPackPath, 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 : {},
-        defineEnv: createDefineEnv({
-            config: bundleOptions.config,
-            dev: true,
-            optionDefineEnv: bundleOptions.defineEnv,
-        }),
-        watch: {
-            enable: true,
-        },
-        dev: true,
-        buildId: bundleOptions.buildId || nanoid(),
-        config: {
-            ...bundleOptions.config,
-            mode: "development",
-            optimization: {
-                ...bundleOptions.config.optimization,
-                minify: false,
-                moduleIds: "named",
-            },
-        },
-        projectPath: projectPath || process.cwd(),
-        rootPath: rootPath || projectPath || process.cwd(),
-        packPath: getPackPath(),
-    }, {
-        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;
-}

package/esm/loaderWorkerPool.d.ts

@@ -1 +0,0 @@
-export declare function runLoaderWorkerPool(binding: typeof import("./binding"), bindingPath: string): Promise<void>;

package/esm/loaderWorkerPool.js

@@ -1,32 +0,0 @@
-import { Worker } from "worker_threads";
-const loaderWorkers = {};
-function getPoolId(cwd, filename) {
-    return `${cwd}:${filename}`;
-}
-let workerSchedulerRegistered = false;
-export async function runLoaderWorkerPool(binding, bindingPath) {
-    if (workerSchedulerRegistered) {
-        return;
-    }
-    binding.registerWorkerScheduler((creation) => {
-        const { options: { filename, cwd }, } = creation;
-        let poolId = getPoolId(cwd, filename);
-        const worker = new Worker(filename, {
-            workerData: {
-                bindingPath,
-                cwd,
-            },
-        });
-        worker.unref();
-        const workers = loaderWorkers[poolId] || (loaderWorkers[poolId] = new Map());
-        workers.set(worker.threadId, worker);
-    }, (termination) => {
-        var _a;
-        const { options: { filename, cwd }, workerId, } = termination;
-        let poolId = getPoolId(cwd, filename);
-        const workers = loaderWorkers[poolId];
-        (_a = workers.get(workerId)) === null || _a === void 0 ? void 0 : _a.terminate();
-        workers.delete(workerId);
-    });
-    workerSchedulerRegistered = true;
-}

package/esm/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/esm/mkcert.js

@@ -1,176 +0,0 @@
-import { execSync } from "node:child_process";
-import { createPrivateKey, X509Certificate } from "node:crypto";
-import fs from "node:fs";
-import path from "node:path";
-import os from "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 = path.join(cacheDirectory, binaryName);
-        if (fs.existsSync(binaryPath)) {
-            return binaryPath;
-        }
-        const downloadUrl = `https://github.com/FiloSottile/mkcert/releases/download/${MKCERT_VERSION}/${binaryName}`;
-        await fs.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 = fs.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 fs.promises.chmod(binaryPath, 0o755);
-        return binaryPath;
-    }
-    catch (err) {
-        console.error("Error downloading mkcert:", err);
-    }
-}
-export async function createSelfSignedCertificate(host, certDir = "certificates") {
-    try {
-        const binaryPath = await downloadBinary();
-        if (!binaryPath)
-            throw new Error("missing mkcert binary");
-        const resolvedCertDir = path.resolve(process.cwd(), `./${certDir}`);
-        await fs.promises.mkdir(resolvedCertDir, {
-            recursive: true,
-        });
-        const keyPath = path.resolve(resolvedCertDir, "localhost-key.pem");
-        const certPath = path.resolve(resolvedCertDir, "localhost.pem");
-        if (fs.existsSync(keyPath) && fs.existsSync(certPath)) {
-            const cert = new X509Certificate(fs.readFileSync(certPath));
-            const key = fs.readFileSync(keyPath);
-            if (cert.checkHost(host !== null && host !== void 0 ? host : "localhost") &&
-                cert.checkPrivateKey(createPrivateKey(key))) {
-                console.log("Using already generated self signed certificate");
-                const caLocation = 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;
-        execSync(`"${binaryPath}" -install -key-file "${keyPath}" -cert-file "${certPath}" ${hosts.join(" ")}`, { stdio: "ignore" });
-        const caLocation = execSync(`"${binaryPath}" -CAROOT`).toString().trim();
-        if (!fs.existsSync(keyPath) || !fs.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 = path.resolve(process.cwd(), "./.gitignore");
-        if (fs.existsSync(gitignorePath)) {
-            const gitignore = await fs.promises.readFile(gitignorePath, "utf8");
-            if (!gitignore.includes(certDir)) {
-                console.log("Adding certificates to .gitignore");
-                await fs.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
-export function getCacheDirectory(fileDirectory, envPath) {
-    let result;
-    if (envPath) {
-        result = envPath;
-    }
-    else {
-        let systemCacheDirectory;
-        if (process.platform === "linux") {
-            systemCacheDirectory =
-                process.env.XDG_CACHE_HOME || path.join(os.homedir(), ".cache");
-        }
-        else if (process.platform === "darwin") {
-            systemCacheDirectory = path.join(os.homedir(), "Library", "Caches");
-        }
-        else if (process.platform === "win32") {
-            systemCacheDirectory =
-                process.env.LOCALAPPDATA || path.join(os.homedir(), "AppData", "Local");
-        }
-        else {
-            /// Attempt to use generic tmp location for un-handled platform
-            if (!systemCacheDirectory) {
-                for (const dir of [
-                    path.join(os.homedir(), ".cache"),
-                    path.join(os.tmpdir()),
-                ]) {
-                    if (fs.existsSync(dir)) {
-                        systemCacheDirectory = dir;
-                        break;
-                    }
-                }
-            }
-            if (!systemCacheDirectory) {
-                console.error(new Error("Unsupported platform: " + process.platform));
-                process.exit(0);
-            }
-        }
-        result = path.join(systemCacheDirectory, fileDirectory);
-    }
-    if (!path.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 = path.resolve(process.env["INIT_CWD"] || process.cwd(), result);
-    }
-    return result;
-}

package/esm/project.d.ts

@@ -1,43 +0,0 @@
-import type { HmrIdentifiers, NapiUpdateMessage, NapiWrittenEndpoint, StackFrame } from "./binding";
-import * as binding from "./binding";
-import { ProjectOptions, RawEntrypoints, Update } from "./types";
-export declare class TurbopackInternalError extends Error {
-    name: string;
-    constructor(cause: Error);
-}
-export declare function projectFactory(): (options: Required<ProjectOptions>, turboEngineOptions: binding.NapiTurboEngineOptions) => Promise<{
-    readonly _nativeProject: {
-        __napiType: "Project";
-    };
-    update(options: Partial<ProjectOptions>): Promise<void>;
-    writeAllEntrypointsToDisk(): Promise<TurbopackResult<RawEntrypoints>>;
-    entrypointsSubscribe(): AsyncGenerator<{
-        apps: {
-            readonly _nativeEndpoint: {
-                __napiType: "Endpoint";
-            };
-            writeToDisk(): Promise<TurbopackResult<NapiWrittenEndpoint>>;
-            clientChanged(): Promise<AsyncIterableIterator<TurbopackResult<{}>>>;
-            serverChanged(includeIssues: boolean): Promise<AsyncIterableIterator<TurbopackResult<{}>>>;
-        }[];
-        libraries: {
-            readonly _nativeEndpoint: {
-                __napiType: "Endpoint";
-            };
-            writeToDisk(): Promise<TurbopackResult<NapiWrittenEndpoint>>;
-            clientChanged(): Promise<AsyncIterableIterator<TurbopackResult<{}>>>;
-            serverChanged(includeIssues: boolean): Promise<AsyncIterableIterator<TurbopackResult<{}>>>;
-        }[];
-        issues: binding.NapiIssue[];
-        diagnostics: binding.NapiDiagnostic[];
-    }, void, unknown>;
-    hmrEvents(identifier: string): AsyncIterableIterator<TurbopackResult<Update>>;
-    hmrIdentifiersSubscribe(): AsyncIterableIterator<TurbopackResult<HmrIdentifiers>>;
-    traceSource(stackFrame: StackFrame, currentDirectoryFileUrl: string): Promise<StackFrame | null>;
-    getSourceForAsset(filePath: string): Promise<string | null>;
-    getSourceMap(filePath: string): Promise<string | null>;
-    getSourceMapSync(filePath: string): string | null;
-    updateInfoSubscribe(aggregationMs: number): AsyncIterableIterator<TurbopackResult<NapiUpdateMessage>>;
-    shutdown(): Promise<void>;
-    onExit(): Promise<void>;
-}>;