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

package/cjs/{hotReloader.js → hmr.js}

@@ -4,76 +4,34 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FAST_REFRESH_RUNTIME_RELOAD = void 0;
-exports.setBundlerFindSourceMapImplementation = setBundlerFindSourceMapImplementation;
 exports.createHotReloader = createHotReloader;
+const nanoid_1 = require("nanoid");
 const ws_1 = __importDefault(require("ws"));
-const path_1 = require("path");
-const url_1 = require("url");
 const project_1 = require("./project");
 const util_1 = require("./util");
-const nanoid_1 = require("nanoid");
 const wsServer = new ws_1.default.Server({ noServer: true });
 const sessionId = Math.floor(Number.MAX_SAFE_INTEGER * Math.random());
-/**
- * Replaces turbopack:///[project] with the specified project in the `source` field.
- */
-function rewriteTurbopackSources(projectRoot, sourceMap) {
-    if ("sections" in sourceMap) {
-        for (const section of sourceMap.sections) {
-            rewriteTurbopackSources(projectRoot, section.map);
-        }
-    }
-    else {
-        for (let i = 0; i < sourceMap.sources.length; i++) {
-            sourceMap.sources[i] = (0, url_1.pathToFileURL)((0, path_1.join)(projectRoot, sourceMap.sources[i].replace(/turbopack:\/\/\/\[project\]/, ""))).toString();
-        }
-    }
-}
-function getSourceMapFromTurbopack(project, projectRoot, sourceURL) {
-    let sourceMapJson = null;
-    try {
-        sourceMapJson = project.getSourceMapSync(sourceURL);
-    }
-    catch (err) { }
-    if (sourceMapJson === null) {
-        return undefined;
-    }
-    else {
-        const payload = JSON.parse(sourceMapJson);
-        // The sourcemap from Turbopack is not yet written to disk so its `sources`
-        // are not absolute paths yet. We need to rewrite them to be absolute paths.
-        rewriteTurbopackSources(projectRoot, payload);
-        return payload;
-    }
-}
-// Find a source map using the bundler's API.
-// This is only a fallback for when Node.js fails to due to bugs e.g. https://github.com/nodejs/node/issues/52102
-// TODO: Remove once all supported Node.js versions are fixed.
-// TODO(veil): Set from Webpack as well
-let bundlerFindSourceMapPayload = () => undefined;
-function setBundlerFindSourceMapImplementation(findSourceMapImplementation) {
-    bundlerFindSourceMapPayload = findSourceMapImplementation;
-}
 exports.FAST_REFRESH_RUNTIME_RELOAD = "Fast Refresh had to perform a full reload due to a runtime error.";
-async function createHotReloader(projectOptions, projectPath, rootPath) {
-    var _a, _b;
+async function createHotReloader(bundleOptions, projectPath, rootPath) {
+    var _a;
     const createProject = (0, project_1.projectFactory)();
     const project = await createProject({
-        processEnv: (_a = projectOptions.processEnv) !== null && _a !== void 0 ? _a : {},
-        processDefineEnv: (0, util_1.createDefineEnv)({
-            config: projectOptions.config,
+        processEnv: (_a = bundleOptions.processEnv) !== null && _a !== void 0 ? _a : {},
+        defineEnv: (0, util_1.createDefineEnv)({
+            config: bundleOptions.config,
             dev: true,
-            optionDefineEnv: projectOptions.processDefineEnv,
+            optionDefineEnv: bundleOptions.defineEnv,
         }),
-        watch: (_b = projectOptions.watch) !== null && _b !== void 0 ? _b : {
-            enable: false,
+        watch: {
+            enable: true,
         },
         dev: true,
-        buildId: (0, nanoid_1.nanoid)(),
+        buildId: bundleOptions.buildId || (0, nanoid_1.nanoid)(),
         config: {
-            ...projectOptions.config,
+            ...bundleOptions.config,
+            mode: "development",
             optimization: {
-                ...projectOptions.config.optimization,
+                ...bundleOptions.config.optimization,
                 minify: false,
                 moduleIds: "named",
             },
@@ -83,7 +41,6 @@ async function createHotReloader(projectOptions, projectPath, rootPath) {
     }, {
         persistentCaching: true,
     });
-    setBundlerFindSourceMapImplementation(getSourceMapFromTurbopack.bind(null, project, projectOptions.projectPath));
     const entrypointsSubscription = project.entrypointsSubscribe();
     let currentEntriesHandlingResolve;
     let currentEntriesHandling = new Promise((resolve) => (currentEntriesHandlingResolve = resolve));
@@ -116,9 +73,6 @@ async function createHotReloader(projectOptions, projectPath, rootPath) {
     const sendEnqueuedMessagesDebounce = (0, util_1.debounce)(sendEnqueuedMessages, 2);
     function sendTurbopackMessage(payload) {
         var _a;
-        // TODO(PACK-2049): For some reason we end up emitting hundreds of issues messages on bigger apps,
-        //   a lot of which are duplicates.
-        //   They are currently not handled on the client at all, so might as well not send them for now.
         payload.diagnostics = [];
         payload.issues = [];
         for (const client of clients) {
@@ -182,10 +136,9 @@ async function createHotReloader(projectOptions, projectPath, rootPath) {
     const hotReloader = {
         turbopackProject: project,
         serverStats: null,
-        // TODO: Figure out if socket type can match the HotReloaderInterface
         onHMR(req, socket, head, onUpgrade) {
             wsServer.handleUpgrade(req, socket, head, (client) => {
-                onUpgrade(client);
+                onUpgrade === null || onUpgrade === void 0 ? void 0 : onUpgrade(client);
                 const subscriptions = new Map();
                 clients.add(client);
                 clientStates.set(client, {

package/cjs/index.d.ts

@@ -1,15 +1,14 @@
-import { NapiDiagnostic, NapiIssue } from "./binding";
-export { build } from "./build";
-export { watch } from "./watch";
-declare global {
-    export type TurbopackResult<T = {}> = T & {
-        issues: NapiIssue[];
-        diagnostics: NapiDiagnostic[];
-    };
-    export type RefCell = {
-        readonly __tag: unique symbol;
-    };
-    export type ExternalEndpoint = {
-        readonly __tag: unique symbol;
-    };
+import { build } from "./build";
+import { serve } from "./dev";
+import * as webpackCompat from "./webpackCompat";
+export { build };
+export { serve };
+declare const utoopack: {
+    build: typeof build;
+    serve: typeof serve;
+};
+export default utoopack;
+export type WebpackConfig = webpackCompat.WebpackConfig;
+declare namespace utoopack {
+    type WebpackConfig = webpackCompat.WebpackConfig;
 }

package/cjs/index.js

@@ -1,7 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.watch = exports.build = void 0;
-var build_1 = require("./build");
+exports.serve = exports.build = void 0;
+const build_1 = require("./build");
 Object.defineProperty(exports, "build", { enumerable: true, get: function () { return build_1.build; } });
-var watch_1 = require("./watch");
-Object.defineProperty(exports, "watch", { enumerable: true, get: function () { return watch_1.watch; } });
+const dev_1 = require("./dev");
+Object.defineProperty(exports, "serve", { enumerable: true, get: function () { return dev_1.serve; } });
+const utoopack = { build: build_1.build, serve: dev_1.serve };
+exports.default = utoopack;

package/cjs/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/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/project.d.ts

@@ -1,11 +1,11 @@
+import type { HmrIdentifiers, NapiUpdateMessage, NapiWrittenEndpoint, StackFrame } from "./binding";
 import * as binding from "./binding";
-import type { NapiWrittenEndpoint, StackFrame } from "./binding";
 import { ProjectOptions, RawEntrypoints, Update } from "./types";
 export declare class TurbopackInternalError extends Error {
     name: string;
     constructor(cause: Error);
 }
-export declare function projectFactory(): (options: ProjectOptions, turboEngineOptions: binding.NapiTurboEngineOptions) => Promise<{
+export declare function projectFactory(): (options: Required<ProjectOptions>, turboEngineOptions: binding.NapiTurboEngineOptions) => Promise<{
     readonly _nativeProject: {
         __napiType: "Project";
     };
@@ -32,12 +32,12 @@ export declare function projectFactory(): (options: ProjectOptions, turboEngineO
         diagnostics: binding.NapiDiagnostic[];
     }, void, unknown>;
     hmrEvents(identifier: string): AsyncIterableIterator<TurbopackResult<Update>>;
-    hmrIdentifiersSubscribe(): AsyncIterableIterator<TurbopackResult<binding.HmrIdentifiers>>;
+    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<binding.NapiUpdateMessage>>;
+    updateInfoSubscribe(aggregationMs: number): AsyncIterableIterator<TurbopackResult<NapiUpdateMessage>>;
     shutdown(): Promise<void>;
     onExit(): Promise<void>;
 }>;

package/cjs/project.js

@@ -37,7 +37,6 @@ exports.TurbopackInternalError = void 0;
 exports.projectFactory = projectFactory;
 const util_1 = require("util");
 const binding = __importStar(require("./binding"));
-const nanoid_1 = require("nanoid");
 const util_2 = require("./util");
 class TurbopackInternalError extends Error {
     constructor(cause) {
@@ -91,7 +90,6 @@ function ensureLoadersHaveSerializableOptions(turbopackRules) {
 async function serializeConfig(config) {
     var _a, _b;
     let configSerializable = { ...config };
-    configSerializable.generateBuildId = () => (0, nanoid_1.nanoid)();
     if ((_a = configSerializable.module) === null || _a === void 0 ? void 0 : _a.rules) {
         ensureLoadersHaveSerializableOptions(configSerializable.module.rules);
     }

package/cjs/types.d.ts

@@ -1,4 +1,17 @@
-import { HmrIdentifiers, NapiIssue, NapiUpdateMessage, NapiWrittenEndpoint, StackFrame } from "./binding";
+import { HmrIdentifiers, NapiDiagnostic, NapiIssue, NapiUpdateMessage, NapiWrittenEndpoint, StackFrame } from "./binding";
+declare global {
+    export type TurbopackResult<T = {}> = T & {
+        issues: NapiIssue[];
+        diagnostics: NapiDiagnostic[];
+    };
+    export type RefCell = {
+        readonly __tag: unique symbol;
+    };
+    export type ExternalEndpoint = {
+        readonly __tag: unique symbol;
+    };
+    export type RcStr = string;
+}
 export interface BaseUpdate {
     resource: {
         headers: unknown;
@@ -53,7 +66,6 @@ export interface DefineEnv {
 }
 export interface ExperimentalConfig {
 }
-export type TurbopackRuleConfigItemOrShortcut = TurbopackRuleConfigItem;
 export type TurbopackRuleConfigItem = TurbopackRuleConfigItemOptions | {
     [condition: string]: TurbopackRuleConfigItem;
 } | false;
@@ -69,7 +81,7 @@ export type TurbopackRuleConfigItemOptions = {
     as?: string;
 };
 export interface ModuleOptions {
-    rules?: Record<string, TurbopackRuleConfigItemOrShortcut>;
+    rules?: Record<string, TurbopackRuleConfigItem>;
 }
 export interface ResolveOptions {
     alias?: Record<string, string | string[] | Record<string, string | string[]>>;
@@ -140,6 +152,7 @@ export interface ConfigComplete {
     images?: {
         inlineLimit?: number;
     };
+    stats?: boolean;
     experimental?: ExperimentalConfig;
     persistentCaching?: boolean;
     cacheHandler?: string;
@@ -193,25 +206,25 @@ export interface ProjectOptions {
     /**
      * A map of environment variables to use when compiling code.
      */
-    processEnv: Record<string, string>;
-    processDefineEnv: DefineEnv;
+    processEnv?: Record<string, string>;
+    defineEnv?: DefineEnv;
     /**
      * Whether to watch the filesystem for file changes.
      */
-    watch: {
+    watch?: {
         enable: boolean;
         pollIntervalMs?: number;
     };
     /**
      * The mode of utoo-pack.
      */
-    dev: boolean;
+    dev?: boolean;
     /**
      * The build id.
      */
-    buildId: string;
+    buildId?: string;
 }
-export type BuildOptions = Omit<ProjectOptions, "rootPath" | "projectPath">;
+export type BundleOptions = Omit<ProjectOptions, "rootPath" | "projectPath">;
 export interface Project {
     update(options: Partial<ProjectOptions>): Promise<void>;
     entrypointsSubscribe(): AsyncIterableIterator<TurbopackResult<RawEntrypoints>>;

package/cjs/util.d.ts

@@ -1,5 +1,5 @@
 import { NapiIssue } from "./binding";
-import { DefineEnv, StyledString, RustifiedEnv, ConfigComplete } from "./types";
+import { ConfigComplete, DefineEnv, RustifiedEnv, StyledString } from "./types";
 export declare class ModuleBuildError extends Error {
     name: string;
 }

package/cjs/util.js

@@ -10,8 +10,8 @@ exports.rustifyEnv = rustifyEnv;
 exports.createDefineEnv = createDefineEnv;
 exports.debounce = debounce;
 exports.blockStdout = blockStdout;
-const picocolors_1 = require("picocolors");
 const code_frame_1 = require("@babel/code-frame");
+const picocolors_1 = require("picocolors");
 const magicIdentifier_1 = require("./magicIdentifier");
 class ModuleBuildError extends Error {
     constructor() {

package/cjs/webpackCompat.d.ts

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