@utoo/pack 0.0.1-alpha.14 → 0.0.1-alpha.16

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,247 @@
+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(webpackExternal) {
+    let externals = {};
+    switch (typeof webpackExternal) {
+        case "string":
+            externals[webpackExternal] = webpackExternal;
+            break;
+        case "object":
+            if (webpackExternal instanceof RegExp) {
+                throw "regex enternal not supported yet";
+            }
+            else if (Array.isArray(webpackExternal)) {
+                webpackExternal.forEach((k) => {
+                    switch (typeof k) {
+                        case "string":
+                            externals[k] = k;
+                            break;
+                        default:
+                            throw "non string external item not supported yet";
+                    }
+                });
+            }
+            else {
+                if ("byLayer" in webpackExternal) {
+                    throw "by layer external item not supported yet";
+                }
+                Object.entries(webpackExternal).forEach(([k, v]) => {
+                    switch (typeof v) {
+                        case "string":
+                            externals[k] = v;
+                            break;
+                        default:
+                            throw "non string external item not supported yet";
+                    }
+                });
+            }
+            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;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@utoo/pack",
-  "version": "0.0.1-alpha.14",
+  "version": "0.0.1-alpha.16",
   "main": "cjs/index.js",
   "module": "esm/index.js",
   "exports": {
@@ -60,10 +60,12 @@
     "styled-jsx": "^5.1.6",
     "typescript": "^5.8.3",
     "@types/ws": "^8.18.1",
-    "@types/webpack": "^5.28.5",
     "@types/send": "0.14.4",
     "@types/mime-types": "3.0.1"
   },
+  "peerDependencies": {
+    "@types/webpack": "^5.28.5"
+  },
   "engines": {
     "node": ">= 10"
   },
@@ -79,12 +81,12 @@
   },
   "repository": "git@github.com:umijs/mako.git",
   "optionalDependencies": {
-    "@utoo/pack-darwin-arm64": "0.0.1-alpha.14",
-    "@utoo/pack-darwin-x64": "0.0.1-alpha.14",
-    "@utoo/pack-linux-arm64-gnu": "0.0.1-alpha.14",
-    "@utoo/pack-linux-arm64-musl": "0.0.1-alpha.14",
-    "@utoo/pack-linux-x64-gnu": "0.0.1-alpha.14",
-    "@utoo/pack-linux-x64-musl": "0.0.1-alpha.14",
-    "@utoo/pack-win32-x64-msvc": "0.0.1-alpha.14"
+    "@utoo/pack-darwin-arm64": "0.0.1-alpha.16",
+    "@utoo/pack-darwin-x64": "0.0.1-alpha.16",
+    "@utoo/pack-linux-arm64-gnu": "0.0.1-alpha.16",
+    "@utoo/pack-linux-arm64-musl": "0.0.1-alpha.16",
+    "@utoo/pack-linux-x64-gnu": "0.0.1-alpha.16",
+    "@utoo/pack-linux-x64-musl": "0.0.1-alpha.16",
+    "@utoo/pack-win32-x64-msvc": "0.0.1-alpha.16"
   }
 }