@utoo/pack 0.0.1-alpha.15 → 0.0.1-alpha.17

package/esm/binding.d.ts

@@ -9,12 +9,6 @@ export declare class ExternalObject<T> {
     [K: symbol]: T
   }
 }
-export interface TransformOutput {
-  code: string
-  map?: string
-  output?: string
-  diagnostics: Array<string>
-}
 export interface NapiEndpointConfig {
   
 }
@@ -63,7 +57,7 @@ export interface NapiProjectOptions {
    * A map of environment variables which should get injected at compile
    * time.
    */
-  processDefineEnv: NapiDefineEnv
+  defineEnv: NapiDefineEnv
   /** The mode in which Next.js is running. */
   dev: boolean
   /** The build id. */
@@ -88,7 +82,7 @@ export interface NapiPartialProjectOptions {
    * A map of environment variables which should get injected at compile
    * time.
    */
-  processDefineEnv?: NapiDefineEnv
+  defineEnv?: NapiDefineEnv
   /** The mode in which Next.js is running. */
   dev?: boolean
   /** The build id. */
@@ -136,7 +130,7 @@ export interface NapiEntrypoints {
 }
 export declare function projectWriteAllEntrypointsToDisk(project: { __napiType: "Project" }): Promise<TurbopackResult>
 export declare function projectEntrypointsSubscribe(project: { __napiType: "Project" }, func: (...args: any[]) => any): { __napiType: "RootTask" }
-export declare function projectHmrEvents(project: { __napiType: "Project" }, identifier: string, func: (...args: any[]) => any): { __napiType: "RootTask" }
+export declare function projectHmrEvents(project: { __napiType: "Project" }, identifier: RcStr, func: (...args: any[]) => any): { __napiType: "RootTask" }
 export interface HmrIdentifiers {
   identifiers: Array<string>
 }
@@ -166,16 +160,18 @@ export declare function projectUpdateInfoSubscribe(project: { __napiType: "Proje
 export interface StackFrame {
   isServer: boolean
   isInternal?: boolean
-  originalFile?: string
-  file: string
+  originalFile?: RcStr
+  file: RcStr
+  /** 1-indexed, unlike source map tokens */
   line?: number
+  /** 1-indexed, unlike source map tokens */
   column?: number
-  methodName?: string
+  methodName?: RcStr
 }
 export declare function projectTraceSource(project: { __napiType: "Project" }, frame: StackFrame, currentDirectoryFileUrl: string): Promise<StackFrame | null>
 export declare function projectGetSourceForAsset(project: { __napiType: "Project" }, filePath: string): Promise<string | null>
-export declare function projectGetSourceMap(project: { __napiType: "Project" }, filePath: string): Promise<string | null>
-export declare function projectGetSourceMapSync(project: { __napiType: "Project" }, filePath: string): 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
 export declare function rootTaskDispose(rootTask: { __napiType: "RootTask" }): void
 export interface NapiIssue {
   severity: string
@@ -186,7 +182,7 @@ export interface NapiIssue {
   detail?: any
   source?: NapiIssueSource
   documentationLink: string
-  subIssues: Array<NapiIssue>
+  importTraces: any
 }
 export interface NapiIssueSource {
   source: NapiSource

package/esm/build.d.ts

@@ -1,2 +1,4 @@
 import { BundleOptions } from "./types";
-export declare function build(projectOptions: BundleOptions, projectPath?: string, rootPath?: string): Promise<void>;
+import { WebpackConfig } from "./webpackCompat";
+export declare function build(bundleOptions: BundleOptions, projectPath?: string, rootPath?: string): Promise<void>;
+export declare function build(webpackConfig: WebpackConfig, projectPath?: string, rootPath?: string): Promise<void>;

package/esm/build.js

@@ -1,27 +1,34 @@
 import { nanoid } from "nanoid";
 import { projectFactory } from "./project";
 import { blockStdout, createDefineEnv, formatIssue, isRelevantWarning, } from "./util";
+import { compatOptionsFromWebpack } from "./webpackCompat";
 import { xcodeProfilingReady } from "./xcodeProfile";
-export async function build(projectOptions, projectPath, rootPath) {
-    var _a, _b, _c, _d;
+export function build(options, projectPath, rootPath) {
+    const bundleOptions = options.compatMode
+        ? compatOptionsFromWebpack(options)
+        : options;
+    return buildInternal(bundleOptions, projectPath, rootPath);
+}
+async function buildInternal(bundleOptions, projectPath, rootPath) {
+    var _a, _b, _c;
     blockStdout();
     if (process.env.XCODE_PROFILE) {
         await xcodeProfilingReady();
     }
     const createProject = projectFactory();
     const project = await createProject({
-        processEnv: (_a = projectOptions.processEnv) !== null && _a !== void 0 ? _a : {},
-        processDefineEnv: createDefineEnv({
-            config: projectOptions.config,
-            dev: (_b = projectOptions.dev) !== null && _b !== void 0 ? _b : false,
-            optionDefineEnv: projectOptions.processDefineEnv,
+        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: (_c = projectOptions.watch) !== null && _c !== void 0 ? _c : {
+        watch: {
             enable: false,
         },
-        dev: (_d = projectOptions.dev) !== null && _d !== void 0 ? _d : false,
-        buildId: nanoid(),
-        config: projectOptions.config,
+        dev: (_c = bundleOptions.dev) !== null && _c !== void 0 ? _c : false,
+        buildId: bundleOptions.buildId || nanoid(),
+        config: bundleOptions.config,
         projectPath: projectPath || process.cwd(),
         rootPath: rootPath || projectPath || process.cwd(),
     }, {

package/esm/dev.d.ts

@@ -2,7 +2,9 @@ import { IncomingMessage, ServerResponse } from "http";
 import send from "send";
 import { Duplex, Writable } from "stream";
 import { BundleOptions } from "./types";
-export declare function serve(options: BundleOptions, projectPath: string, rootPath?: string, serverOptions?: StartServerOptions): Promise<void>;
+import { WebpackConfig } from "./webpackCompat";
+export declare function serve(bundleOptions: BundleOptions, projectPath?: string, rootPath?: string, serverOptions?: StartServerOptions): Promise<void>;
+export declare function serve(webpackConfig: WebpackConfig, projectPath?: string, rootPath?: string, serverOptions?: StartServerOptions): Promise<void>;
 export interface SelfSignedCertificate {
     key: string;
     cert: string;

package/esm/dev.js

@@ -8,8 +8,15 @@ import url from "url";
 import { createHotReloader } from "./hmr";
 import { createSelfSignedCertificate } from "./mkcert";
 import { blockStdout } from "./util";
+import { compatOptionsFromWebpack } from "./webpackCompat";
 import { xcodeProfilingReady } from "./xcodeProfile";
-export async function serve(options, projectPath, rootPath, serverOptions) {
+export function serve(options, projectPath, rootPath, serverOptions) {
+    const bundleOptions = options.compatMode
+        ? compatOptionsFromWebpack(options)
+        : options;
+    return serveInternal(bundleOptions, projectPath, rootPath, serverOptions);
+}
+async function serveInternal(options, projectPath, rootPath, serverOptions) {
     blockStdout();
     if (process.env.XCODE_PROFILE) {
         await xcodeProfilingReady();
@@ -21,7 +28,7 @@ export async function serve(options, projectPath, rootPath, serverOptions) {
         selfSignedCertificate: (serverOptions === null || serverOptions === void 0 ? void 0 : serverOptions.https)
             ? await createSelfSignedCertificate((serverOptions === null || serverOptions === void 0 ? void 0 : serverOptions.hostname) || "localhost")
             : undefined,
-    }, options, projectPath, rootPath);
+    }, options, projectPath || process.cwd(), rootPath);
 }
 export async function startServer(serverOptions, bundleOptions, projectPath, rootPath) {
     let { port, hostname, selfSignedCertificate } = serverOptions;

package/esm/hmr.js

@@ -10,16 +10,16 @@ export async function createHotReloader(bundleOptions, projectPath, rootPath) {
     const createProject = projectFactory();
     const project = await createProject({
         processEnv: (_a = bundleOptions.processEnv) !== null && _a !== void 0 ? _a : {},
-        processDefineEnv: createDefineEnv({
+        defineEnv: createDefineEnv({
             config: bundleOptions.config,
             dev: true,
-            optionDefineEnv: bundleOptions.processDefineEnv,
+            optionDefineEnv: bundleOptions.defineEnv,
         }),
         watch: {
             enable: true,
         },
         dev: true,
-        buildId: nanoid(),
+        buildId: bundleOptions.buildId || nanoid(),
         config: {
             ...bundleOptions.config,
             mode: "development",

package/esm/index.d.ts

@@ -1,2 +1,14 @@
-export { build } from "./build";
-export { serve } from "./dev";
+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/esm/index.js

@@ -1,2 +1,6 @@
-export { build } from "./build";
-export { serve } from "./dev";
+import { build } from "./build";
+import { serve } from "./dev";
+export { build };
+export { serve };
+const utoopack = { build, serve };
+export default utoopack;

package/esm/project.d.ts

@@ -5,7 +5,7 @@ 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";
     };

package/esm/project.js

@@ -1,4 +1,3 @@
-import { nanoid } from "nanoid";
 import { isDeepStrictEqual } from "util";
 import * as binding from "./binding";
 import { rustifyEnv } from "./util";
@@ -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

@@ -65,7 +65,6 @@ export interface DefineEnv {
 }
 export interface ExperimentalConfig {
 }
-export type TurbopackRuleConfigItemOrShortcut = TurbopackRuleConfigItem;
 export type TurbopackRuleConfigItem = TurbopackRuleConfigItemOptions | {
     [condition: string]: TurbopackRuleConfigItem;
 } | false;
@@ -81,7 +80,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[]>>;
@@ -152,6 +151,7 @@ export interface ConfigComplete {
     images?: {
         inlineLimit?: number;
     };
+    stats?: boolean;
     experimental?: ExperimentalConfig;
     persistentCaching?: boolean;
     cacheHandler?: string;
@@ -205,23 +205,23 @@ 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 BundleOptions = Omit<ProjectOptions, "rootPath" | "projectPath">;
 export interface Project {

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;
+}