@utoo/pack 1.1.3 → 1.1.4-lingguang.0

package/cjs/core/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/cjs/core/hmr.js

@@ -0,0 +1,341 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FAST_REFRESH_RUNTIME_RELOAD = void 0;
+exports.createHotReloader = createHotReloader;
+const fs_1 = __importDefault(require("fs"));
+const nanoid_1 = require("nanoid");
+const path_1 = require("path");
+const ws_1 = __importDefault(require("ws"));
+const HtmlPlugin_1 = require("../plugins/HtmlPlugin");
+const common_1 = require("../utils/common");
+const html_entry_1 = require("../utils/html-entry");
+const project_1 = require("./project");
+const wsServer = new ws_1.default.Server({ noServer: true });
+const sessionId = Math.floor(Number.MAX_SAFE_INTEGER * Math.random());
+exports.FAST_REFRESH_RUNTIME_RELOAD = "Fast Refresh had to perform a full reload due to a runtime error.";
+async function createHotReloader(bundleOptions, projectPath, rootPath) {
+    var _a;
+    (0, html_entry_1.processHtmlEntry)(bundleOptions.config, projectPath || process.cwd());
+    const createProject = (0, project_1.projectFactory)();
+    const project = await createProject({
+        processEnv: (_a = bundleOptions.processEnv) !== null && _a !== void 0 ? _a : {},
+        defineEnv: (0, common_1.createDefineEnv)({
+            config: bundleOptions.config,
+            dev: true,
+            optionDefineEnv: bundleOptions.defineEnv,
+        }),
+        watch: {
+            enable: true,
+        },
+        dev: true,
+        buildId: bundleOptions.buildId || (0, nanoid_1.nanoid)(),
+        config: {
+            ...bundleOptions.config,
+            mode: "development",
+            stats: Boolean(process.env.ANALYZE) ||
+                bundleOptions.config.stats ||
+                bundleOptions.config.entry.some((e) => !!e.html),
+            optimization: {
+                ...bundleOptions.config.optimization,
+                minify: false,
+                moduleIds: "named",
+            },
+        },
+        projectPath: projectPath || process.cwd(),
+        rootPath: rootPath || projectPath || process.cwd(),
+        packPath: (0, common_1.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 = (0, common_1.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) {
+                (0, common_1.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() {
+        var _a, _b;
+        for await (const entrypoints of entrypointsSubscription) {
+            if (!currentEntriesHandlingResolve) {
+                currentEntriesHandling = new Promise(
+                // eslint-disable-next-line no-loop-func
+                (resolve) => (currentEntriesHandlingResolve = resolve));
+            }
+            const assets = { js: [], css: [] };
+            await Promise.all(entrypoints.apps.map((l) => l.writeToDisk().then((res) => {
+                (0, common_1.processIssues)(res, true, true);
+                res.clientPaths.forEach((p) => {
+                    if (p.endsWith(".js"))
+                        assets.js.push(p);
+                    if (p.endsWith(".css"))
+                        assets.css.push(p);
+                });
+            })));
+            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 outputDir = ((_a = bundleOptions.config.output) === null || _a === void 0 ? void 0 : _a.path) || (0, path_1.join)(process.cwd(), "dist");
+                const publicPath = (_b = bundleOptions.config.output) === null || _b === void 0 ? void 0 : _b.publicPath;
+                if (assets.js.length === 0 && assets.css.length === 0) {
+                    const statsPath = (0, path_1.join)(outputDir, "stats.json");
+                    if (fs_1.default.existsSync(statsPath)) {
+                        try {
+                            const stats = JSON.parse(fs_1.default.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);
+                        }
+                    }
+                }
+                for (const config of htmlConfigs) {
+                    const plugin = new HtmlPlugin_1.HtmlPlugin(config);
+                    await plugin.generate(outputDir, assets, publicPath);
+                }
+            }
+            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(exports.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/cjs/core/loaderWorkerPool.d.ts

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

package/cjs/core/loaderWorkerPool.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runLoaderWorkerPool = runLoaderWorkerPool;
+const worker_threads_1 = require("worker_threads");
+const loaderWorkers = {};
+function getPoolId(cwd, filename) {
+    return `${cwd}:${filename}`;
+}
+let workerSchedulerRegistered = false;
+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_threads_1.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/cjs/core/project.d.ts

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