@utoo/pack 1.2.13 → 1.3.0-alpha.0

package/cjs/core/hmr.js

@@ -30,11 +30,6 @@ async function createHotReloader(bundleOptions, projectPath, rootPath) {
     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,
         },
@@ -256,6 +251,77 @@ async function createHotReloader(bundleOptions, projectPath, rootPath) {
                 })();
             });
         },
+        registerClient(ws) {
+            const subscriptions = new Map();
+            clients.add(ws);
+            clientStates.set(ws, {
+                hmrPayloads: new Map(),
+                turbopackUpdates: [],
+                subscriptions,
+            });
+            const turbopackConnected = {
+                action: pack_shared_1.HMR_ACTIONS_SENT_TO_BROWSER.TURBOPACK_CONNECTED,
+                data: { sessionId },
+            };
+            sendToClient(ws, turbopackConnected);
+            const errors = [];
+            const sync = {
+                action: pack_shared_1.HMR_ACTIONS_SENT_TO_BROWSER.SYNC,
+                errors,
+                warnings: [],
+                hash: "",
+            };
+            sendToClient(ws, sync);
+        },
+        unregisterClient(ws) {
+            var _a;
+            const state = clientStates.get(ws);
+            if (state) {
+                for (const subscription of state.subscriptions.values()) {
+                    (_a = subscription.return) === null || _a === void 0 ? void 0 : _a.call(subscription);
+                }
+            }
+            clientStates.delete(ws);
+            clients.delete(ws);
+        },
+        handleClientMessage(ws, data) {
+            const parsedData = JSON.parse(data);
+            switch (parsedData.event) {
+                case "client-error":
+                case "client-warning":
+                case "client-success":
+                case "client-full-reload": {
+                    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:
+                    if (!parsedData.type) {
+                        throw new Error(`unrecognized HMR message "${data}"`);
+                    }
+            }
+            switch (parsedData.type) {
+                case "turbopack-subscribe":
+                    subscribeToHmrEvents(ws, parsedData.path);
+                    break;
+                case "turbopack-unsubscribe":
+                    unsubscribeFromHmrEvents(ws, parsedData.path);
+                    break;
+                default:
+                    if (!parsedData.event) {
+                        throw new Error(`unrecognized Turbopack HMR message "${data}"`);
+                    }
+            }
+        },
         send(action) {
             const payload = JSON.stringify(action);
             for (const client of clients) {
@@ -274,8 +340,7 @@ async function createHotReloader(bundleOptions, projectPath, rootPath) {
         },
         close() {
             for (const wsClient of clients) {
-                // it's okay to not cleanly close these websocket connections, this is dev
-                wsClient.terminate();
+                wsClient.close();
             }
             clients.clear();
         },

package/cjs/utils/common.d.ts

@@ -1,4 +1,4 @@
-export { createDefineEnv, debounce, isWellKnownError, ModuleBuildError, processIssues, rustifyEnv, } from "@utoo/pack-shared";
+export { debounce, isWellKnownError, ModuleBuildError, processIssues, rustifyEnv, } from "@utoo/pack-shared";
 export declare function blockStdout(): void;
 /**
  * Pack 根目录（pack 包所在目录）。

package/cjs/utils/common.js

@@ -3,12 +3,11 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.rustifyEnv = exports.processIssues = exports.ModuleBuildError = exports.isWellKnownError = exports.debounce = exports.createDefineEnv = void 0;
+exports.rustifyEnv = exports.processIssues = exports.ModuleBuildError = exports.isWellKnownError = exports.debounce = void 0;
 exports.blockStdout = blockStdout;
 exports.getPackPath = getPackPath;
 const path_1 = __importDefault(require("path"));
 var pack_shared_1 = require("@utoo/pack-shared");
-Object.defineProperty(exports, "createDefineEnv", { enumerable: true, get: function () { return pack_shared_1.createDefineEnv; } });
 Object.defineProperty(exports, "debounce", { enumerable: true, get: function () { return pack_shared_1.debounce; } });
 Object.defineProperty(exports, "isWellKnownError", { enumerable: true, get: function () { return pack_shared_1.isWellKnownError; } });
 Object.defineProperty(exports, "ModuleBuildError", { enumerable: true, get: function () { return pack_shared_1.ModuleBuildError; } });

package/esm/binding.d.ts

@@ -9,22 +9,6 @@ export declare class ExternalObject<T> {
     [K: symbol]: T
   }
 }
-/** Arguments for `NapiTurbopackCallbacks::throw_turbopack_internal_error`. */
-export interface TurbopackInternalErrorOpts {
-  message: string
-  anonymizedLocation?: string
-}
-export interface NapiTurbopackCallbacksJsObject {
-  /**
-   * Called when we've encountered a bug in Turbopack and not in the user's code. Constructs and
-   * throws a `TurbopackInternalError` type. Logs to anonymized telemetry.
-   *
-   * As a result of the use of `ErrorStrategy::CalleeHandled`, the first argument is an error if
-   * there's a runtime conversion error. This should never happen, but if it does, the function
-   * can throw it instead.
-   */
-  throwTurbopackInternalError: (conversionError: Error | null, opts: TurbopackInternalErrorOpts) => never
-}
 export declare function registerWorkerScheduler(creator: (arg: NapiWorkerCreation) => any, terminator: (arg: NapiWorkerTermination) => any): void
 export declare function workerCreated(workerId: number): void
 export interface NapiWorkerCreation {
@@ -93,11 +77,6 @@ export interface NapiProjectOptions {
   config: string
   /** A map of environment variables to use when compiling code. */
   processEnv: Array<NapiEnvVar>
-  /**
-   * A map of environment variables which should get injected at compile
-   * time.
-   */
-  defineEnv: NapiDefineEnv
   /** The mode in which Next.js is running. */
   dev: boolean
   /** The build id. */
@@ -119,11 +98,6 @@ export interface NapiPartialProjectOptions {
   config?: string
   /** A map of environment variables to use when compiling code. */
   processEnv?: Array<NapiEnvVar>
-  /**
-   * A map of environment variables which should get injected at compile
-   * time.
-   */
-  defineEnv?: NapiDefineEnv
   /** The mode in which Next.js is running. */
   dev?: boolean
   /** The build id. */
@@ -136,11 +110,6 @@ export interface NapiPartialProjectOptions {
   noMangling?: boolean
   packPath?: string
 }
-export interface NapiDefineEnv {
-  client: Array<NapiEnvVar>
-  edge: Array<NapiEnvVar>
-  nodejs: Array<NapiEnvVar>
-}
 export interface NapiTurboEngineOptions {
   /** Use the new backend with persistent caching enabled. */
   persistentCaching?: boolean
@@ -214,6 +183,11 @@ export declare function projectTraceSource(project: { __napiType: "Project" }, f
 export declare function projectGetSourceForAsset(project: { __napiType: "Project" }, filePath: string): Promise<string | null>
 export declare function projectGetSourceMap(project: { __napiType: "Project" }, filePath: RcStr): Promise<string | null>
 export declare function projectGetSourceMapSync(project: { __napiType: "Project" }, filePath: RcStr): string | null
+/** Arguments for `NapiTurbopackCallbacks::throw_turbopack_internal_error`. */
+export interface TurbopackInternalErrorOpts {
+  message: string
+  anonymizedLocation?: string
+}
 /**
  * A version of [`NapiTurbopackCallbacks`] that can accepted as an argument to a napi function.
  *

package/esm/commands/build.js

@@ -6,7 +6,7 @@ import path from "path";
 import { resolveBundleOptions } from "../config/webpackCompat.js";
 import { projectFactory } from "../core/project.js";
 import { HtmlPlugin } from "../plugins/HtmlPlugin.js";
-import { blockStdout, createDefineEnv, getPackPath } from "../utils/common.js";
+import { blockStdout, getPackPath } from "../utils/common.js";
 import { findRootDir } from "../utils/findRoot.js";
 import { getInitialAssetsFromStats } from "../utils/getInitialAssets.js";
 import { processHtmlEntry } from "../utils/htmlEntry.js";
@@ -22,7 +22,7 @@ export function build(options, projectPath, rootPath) {
     return buildInternal(bundleOptions, projectPath, rootPath);
 }
 async function buildInternal(bundleOptions, projectPath, rootPath) {
-    var _a, _b, _c, _d, _e, _f, _g;
+    var _a, _b, _c, _d, _e, _f;
     blockStdout();
     if (process.env.XCODE_PROFILE) {
         await xcodeProfilingReady();
@@ -33,15 +33,10 @@ async function buildInternal(bundleOptions, projectPath, rootPath) {
     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,
+        dev: (_b = bundleOptions.dev) !== null && _b !== void 0 ? _b : false,
         buildId: bundleOptions.buildId || nanoid(),
         config: {
             ...bundleOptions.config,
@@ -53,7 +48,7 @@ async function buildInternal(bundleOptions, projectPath, rootPath) {
         rootPath: rootPath || projectPath || process.cwd(),
         packPath: getPackPath(),
     }, {
-        persistentCaching: (_d = bundleOptions.config.persistentCaching) !== null && _d !== void 0 ? _d : false,
+        persistentCaching: (_c = bundleOptions.config.persistentCaching) !== null && _c !== void 0 ? _c : false,
     });
     const entrypoints = await project.writeAllEntrypointsToDisk();
     handleIssues(entrypoints.issues);
@@ -69,20 +64,20 @@ async function buildInternal(bundleOptions, projectPath, rootPath) {
     ];
     if (htmlConfigs.length > 0) {
         const assets = { js: [], css: [] };
-        const outputDir = ((_e = bundleOptions.config.output) === null || _e === void 0 ? void 0 : _e.path) || path.join(process.cwd(), "dist");
+        const outputDir = ((_d = bundleOptions.config.output) === null || _d === void 0 ? void 0 : _d.path) || path.join(process.cwd(), "dist");
         if (assets.js.length === 0 && assets.css.length === 0) {
             const discovered = getInitialAssetsFromStats(outputDir);
             assets.js.push(...discovered.js);
             assets.css.push(...discovered.css);
         }
-        const publicPath = (_f = bundleOptions.config.output) === null || _f === void 0 ? void 0 : _f.publicPath;
+        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(((_g = bundleOptions.config.output) === null || _g === void 0 ? void 0 : _g.path) || "dist");
+        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

package/esm/commands/dev-legacy.d.ts

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