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

package/esm/mkcert.js

@@ -0,0 +1,176 @@
+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,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/esm/project.js

@@ -1,6 +1,5 @@
 import { isDeepStrictEqual } from "util";
 import * as binding from "./binding";
-import { nanoid } from "nanoid";
 import { rustifyEnv } from "./util";
 export class TurbopackInternalError extends Error {
     constructor(cause) {
@@ -53,7 +52,6 @@ function ensureLoadersHaveSerializableOptions(turbopackRules) {
 async function serializeConfig(config) {
     var _a, _b;
     let configSerializable = { ...config };
-    configSerializable.generateBuildId = () => nanoid();
     if ((_a = configSerializable.module) === null || _a === void 0 ? void 0 : _a.rules) {
         ensureLoadersHaveSerializableOptions(configSerializable.module.rules);
     }

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

@@ -1,5 +1,5 @@
-import { bold, green, magenta, red } from "picocolors";
 import { codeFrameColumns } from "@babel/code-frame";
+import { bold, green, magenta, red } from "picocolors";
 import { decodeMagicIdentifier, MAGIC_IDENTIFIER_REGEX, } from "./magicIdentifier";
 export class ModuleBuildError extends Error {
     constructor() {

package/esm/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;

package/esm/webpackCompat.js

@@ -0,0 +1,338 @@
+export function compatOptionsFromWebpack(webpackConfig) {
+    const { entry, mode, module, resolve, externals, output, target, devtool, optimization, plugins, stats, } = webpackConfig;
+    return {
+        config: {
+            entry: compatEntry(entry),
+            mode: compatMode(mode),
+            module: compatModule(module),
+            resolve: compatResolve(resolve),
+            externals: compatExternals(externals),
+            output: compatOutput(output),
+            target: compatTarget(target),
+            sourceMaps: compatSourceMaps(devtool),
+            optimization: compatOptimization(optimization),
+            define: compatFromWebpackPlugin(plugins, compatDefine),
+            stats: compatStats(stats),
+        },
+        buildId: webpackConfig.name,
+    };
+}
+function compatMode(webpackMode) {
+    return webpackMode
+        ? webpackMode === "none"
+            ? "production"
+            : webpackMode
+        : "production";
+}
+function compatEntry(webpackEntry) {
+    const entry = [];
+    switch (typeof webpackEntry) {
+        case "string":
+            entry.push({ import: webpackEntry });
+            break;
+        case "object":
+            if (Array.isArray(webpackEntry)) {
+                webpackEntry.forEach((e) => entry.push({
+                    import: e,
+                }));
+            }
+            else {
+                Object.entries(webpackEntry).forEach(([k, v]) => {
+                    var _a;
+                    switch (typeof v) {
+                        case "string":
+                            entry.push({ name: k, import: v });
+                            break;
+                        case "object":
+                            if (!Array.isArray(v)) {
+                                switch (typeof v.import) {
+                                    case "string":
+                                        entry.push({
+                                            name: k,
+                                            import: v.import,
+                                            library: ((_a = v.library) === null || _a === void 0 ? void 0 : _a.type) === "umd"
+                                                ? {
+                                                    name: typeof v.library.name === "string"
+                                                        ? v.library.name
+                                                        : undefined,
+                                                    export: typeof v.library.export === "string"
+                                                        ? [v.library.export]
+                                                        : v.library.export,
+                                                }
+                                                : undefined,
+                                        });
+                                        break;
+                                    default:
+                                        break;
+                                }
+                            }
+                            else {
+                                throw "multi entry items for one entry not supported yet";
+                            }
+                            break;
+                        default:
+                            throw "non string and non object entry path not supported yet";
+                    }
+                });
+            }
+            break;
+        case "function":
+            throw "functional entry not supported yet";
+        default:
+            throw "entry config not compatible now";
+    }
+    return entry;
+}
+function compatFromWebpackPlugin(webpackPlugins, picker) {
+    const plugin = webpackPlugins === null || webpackPlugins === void 0 ? void 0 : webpackPlugins.find((p) => p && typeof p === "object" && p.constructor.name === picker.pluginName);
+    return picker(plugin);
+}
+compatDefine.pluginName = "DefinePlugin";
+function compatDefine(maybeWebpackPluginInstance) {
+    return maybeWebpackPluginInstance === null || maybeWebpackPluginInstance === void 0 ? void 0 : maybeWebpackPluginInstance.definitions;
+}
+function compatExternals(webpackExternals) {
+    if (!webpackExternals) {
+        return undefined;
+    }
+    let externals = {};
+    switch (typeof webpackExternals) {
+        case "string": {
+            // Single string external: "lodash" -> { "lodash": "lodash" }
+            externals[webpackExternals] = webpackExternals;
+            break;
+        }
+        case "object": {
+            if (Array.isArray(webpackExternals)) {
+                // Array of externals: ["lodash", "react"] -> { "lodash": "lodash", "react": "react" }
+                externals = webpackExternals.reduce((acc, external) => {
+                    if (typeof external === "string") {
+                        acc[external] = external;
+                    }
+                    else if (typeof external === "object" && external !== null) {
+                        Object.assign(acc, compatExternals(external));
+                    }
+                    return acc;
+                }, {});
+            }
+            else if (webpackExternals instanceof RegExp) {
+                throw "regex external not supported yet";
+            }
+            else {
+                if ("byLayer" in webpackExternals) {
+                    throw "by layer external item not supported yet";
+                }
+                Object.entries(webpackExternals).forEach(([key, value]) => {
+                    if (typeof value === "string") {
+                        // Check if it's a script type with shorthand syntax: "global@https://example.com/script.js"
+                        if (value.includes("@") &&
+                            (value.startsWith("script ") || value.includes("://"))) {
+                            const match = value.match(/^(?:script\s+)?(.+?)@(.+)$/);
+                            if (match) {
+                                const [, globalName, scriptUrl] = match;
+                                // Use utoo-pack string format: "script globalName@url"
+                                externals[key] = `script ${globalName}@${scriptUrl}`;
+                            }
+                            else {
+                                externals[key] = value;
+                            }
+                        }
+                        else {
+                            // Simple string mapping: { "react": "React" }
+                            externals[key] = value;
+                        }
+                    }
+                    else if (Array.isArray(value)) {
+                        // Array format handling
+                        if (value.length >= 2) {
+                            const [first, second] = value;
+                            // Check if it's a script type array: ["https://example.com/script.js", "GlobalName"]
+                            if (typeof first === "string" &&
+                                first.includes("://") &&
+                                typeof second === "string") {
+                                // Use utoo-pack object format for script
+                                externals[key] = {
+                                    root: second,
+                                    type: "script",
+                                    script: first,
+                                };
+                            }
+                            else if (typeof first === "string" &&
+                                typeof second === "string") {
+                                // Handle type prefix formats
+                                if (first.startsWith("commonjs")) {
+                                    externals[key] = `commonjs ${second}`;
+                                }
+                                else if (first === "module") {
+                                    externals[key] = `esm ${second}`;
+                                }
+                                else if (first === "var" ||
+                                    first === "global" ||
+                                    first === "window") {
+                                    externals[key] = second;
+                                }
+                                else if (first === "script") {
+                                    // Script type without URL in array format - treat as regular script prefix
+                                    externals[key] = `script ${second}`;
+                                }
+                                else {
+                                    externals[key] = `${first} ${second}`;
+                                }
+                            }
+                            else {
+                                externals[key] = value[0] || key;
+                            }
+                        }
+                        else {
+                            externals[key] = value[0] || key;
+                        }
+                    }
+                    else if (typeof value === "object" && value !== null) {
+                        // Object format: handle complex configurations
+                        if ("root" in value || "commonjs" in value || "amd" in value) {
+                            // Standard webpack externals object format
+                            if (value.commonjs) {
+                                externals[key] = `commonjs ${value.commonjs}`;
+                            }
+                            else if (value.root) {
+                                externals[key] = value.root;
+                            }
+                            else if (value.amd) {
+                                externals[key] = value.amd;
+                            }
+                            else {
+                                externals[key] = key;
+                            }
+                        }
+                        else {
+                            // Treat as utoo-pack specific configuration (might already be in correct format)
+                            externals[key] = value;
+                        }
+                    }
+                    else {
+                        // Fallback to key name
+                        externals[key] = key;
+                    }
+                });
+            }
+            break;
+        }
+        case "function": {
+            throw "functional external not supported yet";
+        }
+        default:
+            break;
+    }
+    return externals;
+}
+function compatModule(webpackModule) {
+    if (!Array.isArray(webpackModule === null || webpackModule === void 0 ? void 0 : webpackModule.rules)) {
+        return;
+    }
+    const moduleRules = {
+        rules: webpackModule.rules.reduce((acc, cur) => {
+            var _a, _b;
+            switch (typeof cur) {
+                case "object":
+                    if (cur) {
+                        let condition = (_b = (_a = cur.test) === null || _a === void 0 ? void 0 : _a.toString().match(/(\.\w+)/)) === null || _b === void 0 ? void 0 : _b[1];
+                        if (condition) {
+                            Object.assign(acc, {
+                                ["*" + condition]: {
+                                    loaders: typeof cur.use === "string"
+                                        ? [cur.use]
+                                        : typeof (cur === null || cur === void 0 ? void 0 : cur.use) === "object"
+                                            ? Array.isArray(cur.use)
+                                                ? cur.use.map((use) => typeof use === "string"
+                                                    ? { loader: use, options: {} }
+                                                    : {
+                                                        loader: use.loader,
+                                                        options: use.options || {},
+                                                    })
+                                                : [
+                                                    {
+                                                        loader: cur.loader,
+                                                        options: cur.options || {},
+                                                    },
+                                                ]
+                                            : [],
+                                    as: "*.js",
+                                },
+                            });
+                        }
+                    }
+                    break;
+                default:
+                    break;
+            }
+            return acc;
+        }, {}),
+    };
+    return moduleRules;
+}
+function compatResolve(webpackResolve) {
+    if (!webpackResolve) {
+        return;
+    }
+    const { alias, extensions } = webpackResolve;
+    return {
+        alias: alias
+            ? Array.isArray(alias)
+                ? alias.reduce((acc, cur) => Object.assign(acc, { [cur.name]: cur.alias }), {})
+                : Object.entries(alias).reduce((acc, [k, v]) => {
+                    if (typeof v === "string") {
+                        Object.assign(acc, { [k]: v });
+                    }
+                    else {
+                        throw "non string alias value not supported yet";
+                    }
+                    return acc;
+                }, {})
+            : undefined,
+        extensions,
+    };
+}
+function compatOutput(webpackOutput) {
+    if ((webpackOutput === null || webpackOutput === void 0 ? void 0 : webpackOutput.filename) && typeof webpackOutput.filename !== "string") {
+        throw "non string output filename not supported yet";
+    }
+    if ((webpackOutput === null || webpackOutput === void 0 ? void 0 : webpackOutput.chunkFilename) &&
+        typeof webpackOutput.chunkFilename !== "string") {
+        throw "non string output chunkFilename not supported yet";
+    }
+    return {
+        path: webpackOutput === null || webpackOutput === void 0 ? void 0 : webpackOutput.path,
+        filename: webpackOutput === null || webpackOutput === void 0 ? void 0 : webpackOutput.filename,
+        chunkFilename: webpackOutput === null || webpackOutput === void 0 ? void 0 : webpackOutput.chunkFilename,
+        clean: !!(webpackOutput === null || webpackOutput === void 0 ? void 0 : webpackOutput.clean),
+    };
+}
+function compatTarget(webpackTarget) {
+    return webpackTarget
+        ? Array.isArray(webpackTarget)
+            ? webpackTarget.join(" ")
+            : webpackTarget
+        : undefined;
+}
+function compatSourceMaps(webpackSourceMaps) {
+    return !!webpackSourceMaps;
+}
+function compatOptimization(webpackOptimization) {
+    if (!webpackOptimization) {
+        return;
+    }
+    const { moduleIds, minimize,
+    // TODO: concatenateModules to be supported, need to upgrade to next.js@15.4
+     } = webpackOptimization;
+    return {
+        moduleIds: moduleIds === "named"
+            ? "named"
+            : moduleIds === "deterministic"
+                ? "deterministic"
+                : undefined,
+        minify: minimize,
+    };
+}
+function compatStats(webpackStats) {
+    return !!webpackStats;
+}