@unpackjs/core 1.6.4 → 1.7.0

package/dist/createUnpack.js

@@ -10,7 +10,7 @@ var __filename = /* @__PURE__ */ getFilename();
 import colors from "./colors.js";
 import { getNormalizedPluginsByHook } from "./plugin.js";
 import { bundlerBuild, bundlerDev } from "./run/index.js";
-import { isDev, isDevServer, isProd, mergeConfig, setDevServer, setNodeEnv } from "./utils.js";
+import { isDevServer, isProd, mergeConfig, setDevServer, setNodeEnv } from "./utils.js";
 function createUnpack() {
   const resolveConfig = async (unpackConfig) => {
     const defaultConfig = {
@@ -22,7 +22,10 @@ function createUnpack() {
         sourceMap: isProd() ? false : "cheap-module-source-map",
         parallel: !isDevServer(),
         filenameHash: true,
-        cache: isDev()
+        typeCheck: true
+      },
+      dev: {
+        lazyCompilation: true
       },
       server: {
         port: 3e3
@@ -50,7 +53,7 @@ function createUnpack() {
     build: async (unpackConfig) => {
       setNodeEnv("production");
       console.log(
-        colors.rainbow(`unpack v${"1.6.4"}`),
+        colors.rainbow(`unpack v${"1.7.0"}`),
         colors.green("building for production...")
       );
       const config = await resolveConfig(unpackConfig);
@@ -66,7 +69,7 @@ function createUnpack() {
     watch: async (unpackConfig) => {
       setNodeEnv("development");
       console.log(
-        colors.rainbow(`unpack v${"1.6.4"}`),
+        colors.rainbow(`unpack v${"1.7.0"}`),
         colors.green("building for development...")
       );
       const config = await resolveConfig(unpackConfig);

package/dist/index.cjs

@@ -28,6 +28,7 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var src_exports = {};
 __export(src_exports, {
+  HtmlPlugin: () => import_html_webpack_plugin.default,
   colors: () => import_colors.default
 });
 module.exports = __toCommonJS(src_exports);
@@ -38,8 +39,10 @@ __reExport(src_exports, require("./constants.cjs"), module.exports);
 __reExport(src_exports, require("./createUnpack.cjs"), module.exports);
 __reExport(src_exports, require("./config.cjs"), module.exports);
 var import_colors = __toESM(require("./colors.cjs"));
+var import_html_webpack_plugin = __toESM(require("html-webpack-plugin"));
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  HtmlPlugin,
   colors,
   ...require("./logger.cjs"),
   ...require("./types/index.cjs"),

package/dist/index.d.ts

@@ -5,4 +5,5 @@ export * from './constants';
 export * from './createUnpack';
 export * from './config';
 export { default as colors } from './colors';
+export { default as HtmlPlugin } from 'html-webpack-plugin';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,UAAU,CAAA;AACxB,cAAc,eAAe,CAAA;AAC7B,cAAc,SAAS,CAAA;AACvB,cAAc,aAAa,CAAA;AAC3B,cAAc,gBAAgB,CAAA;AAC9B,cAAc,UAAU,CAAA;AACxB,OAAO,EAAE,OAAO,IAAI,MAAM,EAAE,MAAM,UAAU,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,UAAU,CAAA;AACxB,cAAc,eAAe,CAAA;AAC7B,cAAc,SAAS,CAAA;AACvB,cAAc,aAAa,CAAA;AAC3B,cAAc,gBAAgB,CAAA;AAC9B,cAAc,UAAU,CAAA;AACxB,OAAO,EAAE,OAAO,IAAI,MAAM,EAAE,MAAM,UAAU,CAAA;AAC5C,OAAO,EAAE,OAAO,IAAI,UAAU,EAAE,MAAM,qBAAqB,CAAA"}

package/dist/index.js

@@ -14,6 +14,8 @@ export * from "./constants.js";
 export * from "./createUnpack.js";
 export * from "./config.js";
 import { default as default2 } from "./colors.js";
+import { default as default3 } from "html-webpack-plugin";
 export {
+  default3 as HtmlPlugin,
   default2 as colors
 };

package/dist/plugin-progress/rspack.cjs

@@ -63,7 +63,9 @@ class RspackPluginProgress extends import_core.rspack.ProgressPlugin {
           await (0, import_reporter.printFileSize)({ root: compiler.options.context, stats });
           console.log(import_colors.default.green(`✓ built in ${import_colors.default.bold((0, import_utils.prettyTime)(compileTime))}`));
         } else {
-          import_logger.logger.ready(`built in ${import_colors.default.bold((0, import_utils.prettyTime)(compileTime))}`);
+          import_logger.logger.ready(
+            `built in ${(0, import_utils.prettyTime)(compileTime)} (${stats.compilation.modules.size} modules)`
+          );
         }
       }
     });

package/dist/plugin-progress/rspack.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"rspack.d.ts","sourceRoot":"","sources":["../../src/plugin-progress/rspack.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,QAAQ,EAAE,MAAM,EAAE,MAAM,cAAc,CAAA;AAGpD,OAAO,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAA;AAK7C,qBAAa,oBAAqB,SAAQ,MAAM,CAAC,cAAc;IAC7D,SAAS,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAY;IACxC,WAAW,cAAoB;;IAO/B,KAAK,CAAC,QAAQ,EAAE,QAAQ,GAAG,IAAI;CAsBhC"}
+{"version":3,"file":"rspack.d.ts","sourceRoot":"","sources":["../../src/plugin-progress/rspack.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,QAAQ,EAAE,MAAM,EAAE,MAAM,cAAc,CAAA;AAGpD,OAAO,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAA;AAK7C,qBAAa,oBAAqB,SAAQ,MAAM,CAAC,cAAc;IAC7D,SAAS,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAY;IACxC,WAAW,cAAoB;;IAO/B,KAAK,CAAC,QAAQ,EAAE,QAAQ,GAAG,IAAI;CAwBhC"}

package/dist/plugin-progress/rspack.js

@@ -40,7 +40,9 @@ class RspackPluginProgress extends rspack.ProgressPlugin {
           await printFileSize({ root: compiler.options.context, stats });
           console.log(colors.green(`✓ built in ${colors.bold(prettyTime(compileTime))}`));
         } else {
-          logger.ready(`built in ${colors.bold(prettyTime(compileTime))}`);
+          logger.ready(
+            `built in ${prettyTime(compileTime)} (${stats.compilation.modules.size} modules)`
+          );
         }
       }
     });

package/dist/plugin-progress/webpack.cjs

@@ -73,7 +73,9 @@ class WebpackPluginProgress extends import_webpack.default.ProgressPlugin {
           await (0, import_reporter.printFileSize)({ root: compiler.options.context, stats });
           console.log(import_colors.default.green(`✓ built in ${import_colors.default.bold((0, import_utils.prettyTime)(compileTime))}`));
         } else {
-          import_logger.logger.ready(`built in ${import_colors.default.bold((0, import_utils.prettyTime)(compileTime))}`);
+          import_logger.logger.ready(
+            `built in ${(0, import_utils.prettyTime)(compileTime)} (${stats.compilation.modules.size} modules)`
+          );
         }
       }
     });

package/dist/plugin-progress/webpack.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"webpack.d.ts","sourceRoot":"","sources":["../../src/plugin-progress/webpack.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAA;AAG7C,OAAO,OAAO,MAAM,SAAS,CAAA;AAG7B,qBAAa,qBAAsB,SAAQ,OAAO,CAAC,cAAc;IAC/D,SAAS,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAY;IACxC,WAAW,cAAoB;;IAiB/B,KAAK,CAAC,QAAQ,EAAE,OAAO,CAAC,QAAQ,GAAG,IAAI;CAsBxC"}
+{"version":3,"file":"webpack.d.ts","sourceRoot":"","sources":["../../src/plugin-progress/webpack.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAA;AAG7C,OAAO,OAAO,MAAM,SAAS,CAAA;AAG7B,qBAAa,qBAAsB,SAAQ,OAAO,CAAC,cAAc;IAC/D,SAAS,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAY;IACxC,WAAW,cAAoB;;IAiB/B,KAAK,CAAC,QAAQ,EAAE,OAAO,CAAC,QAAQ,GAAG,IAAI;CAwBxC"}

package/dist/plugin-progress/webpack.js

@@ -50,7 +50,9 @@ class WebpackPluginProgress extends webpack.ProgressPlugin {
           await printFileSize({ root: compiler.options.context, stats });
           console.log(colors.green(`✓ built in ${colors.bold(prettyTime(compileTime))}`));
         } else {
-          logger.ready(`built in ${colors.bold(prettyTime(compileTime))}`);
+          logger.ready(
+            `built in ${prettyTime(compileTime)} (${stats.compilation.modules.size} modules)`
+          );
         }
       }
     });

package/dist/prebundleDeps.cjs

@@ -0,0 +1,340 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var prebundleDeps_exports = {};
+__export(prebundleDeps_exports, {
+  prebundleDeps: () => prebundleDeps
+});
+module.exports = __toCommonJS(prebundleDeps_exports);
+var import_node_fs = __toESM(require("node:fs"));
+var import_node_path = __toESM(require("node:path"));
+var import_core = require("@rspack/core");
+var import_cors = __toESM(require("cors"));
+var import_express = __toESM(require("express"));
+var import_html_webpack_plugin = __toESM(require("html-webpack-plugin"));
+var import_tinyglobby = require("tinyglobby");
+var import_colors = __toESM(require("./colors.cjs"));
+var import_constants = require("./constants.cjs");
+var import_logger = require("./logger.cjs");
+var import_utils = require("./utils.cjs");
+const app = (0, import_express.default)();
+app.use((0, import_cors.default)());
+const CACHE_DIR = "umd";
+const externalAlias = {
+  react: "React",
+  "react-dom": "ReactDOM",
+  "react-router": "ReactRouter",
+  "react-router-dom": "ReactRouterDOM"
+};
+const count = {
+  total: 0,
+  bundled: 0
+};
+const failedDeps = [];
+const noEntryDeps = [];
+const updateProgress = () => {
+  (0, import_utils.logUpdate)(
+    `${import_colors.default.magenta(import_colors.default.bold("»"))} Optimizing dependencies (${count.bundled}/${count.total})`
+  );
+  if (count.total === count.bundled + failedDeps.length) {
+    console.log();
+  }
+};
+const getExternalLibraryName = (pkgName) => {
+  return externalAlias[pkgName] || pkgName;
+};
+const getExternalValue = (pkgName) => {
+  return `var window['${getExternalLibraryName(pkgName)}']`;
+};
+const bundleDep = ({
+  root,
+  name,
+  entry,
+  version
+}) => {
+  return new Promise((resolve) => {
+    const outDir = import_node_path.default.resolve(root, import_constants.TEMP_DIR, CACHE_DIR, name, version);
+    const getResult = () => {
+      const assets = (0, import_tinyglobby.globSync)("**/index.{js,css}", {
+        cwd: outDir,
+        absolute: true
+      });
+      return {
+        name,
+        assets
+      };
+    };
+    if (import_node_fs.default.existsSync(outDir)) {
+      return resolve(getResult());
+    }
+    count.total++;
+    updateProgress();
+    const getSwcOptions = ({ tsx }) => {
+      return {
+        jsc: {
+          parser: {
+            tsx,
+            syntax: "typescript",
+            dynamicImport: true,
+            decorators: true
+          },
+          transform: {
+            react: {
+              runtime: "automatic"
+            }
+          }
+        }
+      };
+    };
+    const compiler = (0, import_core.rspack)({
+      entry: {
+        index: entry
+      },
+      context: root,
+      mode: "development",
+      output: {
+        clean: true,
+        path: outDir,
+        pathinfo: false,
+        library: {
+          name: getExternalLibraryName(name),
+          type: "umd",
+          umdNamedDefine: true
+        },
+        globalObject: "this"
+      },
+      devtool: "cheap-module-source-map",
+      module: {
+        rules: [
+          {
+            test: /\.(j|t)s$/,
+            loader: "builtin:swc-loader",
+            options: getSwcOptions({ tsx: false })
+          },
+          {
+            test: /\.(j|t)sx$/,
+            use: [
+              {
+                loader: "builtin:swc-loader",
+                options: getSwcOptions({ tsx: true })
+              }
+            ]
+          },
+          {
+            test: /\.less$/,
+            type: "css/auto",
+            use: [
+              {
+                loader: (0, import_utils.getCompiledPkgPath)("less-loader"),
+                options: {
+                  lessOptions: {
+                    javascriptEnabled: true
+                  },
+                  implementation: (0, import_utils.getUserDepPath)(root, "less")
+                }
+              }
+            ]
+          },
+          {
+            test: /\.s[ac]ss$/i,
+            type: "css/auto",
+            use: [
+              {
+                loader: (0, import_utils.getCompiledPkgPath)("sass-loader"),
+                options: {
+                  api: "modern-compiler",
+                  implementation: (0, import_utils.getUserDepPath)(root, ["sass-embedded", "sass"])
+                }
+              }
+            ]
+          }
+        ]
+      },
+      optimization: {
+        splitChunks: false
+      },
+      experiments: {
+        css: true
+      },
+      externals: {
+        react: getExternalValue("react"),
+        "react-dom": getExternalValue("react-dom"),
+        "react-router": getExternalValue("react-router"),
+        "react-router-dom": getExternalValue("react-router-dom")
+      }
+    });
+    compiler.run((_, stats) => {
+      if (stats?.hasErrors()) {
+        failedDeps.push(name);
+        import_node_fs.default.rmSync(outDir, { recursive: true, force: true });
+      } else {
+        count.bundled++;
+      }
+      updateProgress();
+      compiler.close(() => {
+        const res = getResult();
+        resolve(!failedDeps.includes(res.name) ? res : void 0);
+      });
+    });
+  });
+};
+const getExistExternals = (externals) => {
+  const existExternals = /* @__PURE__ */ new Set();
+  if (Array.isArray(externals)) {
+    externals.forEach((item) => {
+      if ((0, import_utils.isPlainObject)(item)) {
+        Object.keys(item).forEach((key) => existExternals.add(key));
+      }
+    });
+  } else if ((0, import_utils.isPlainObject)(externals)) {
+    Object.keys(externals).forEach((key) => existExternals.add(key));
+  }
+  return Array.from(existExternals);
+};
+const getPkgEntry = (packageJson) => {
+  if (packageJson.module)
+    return packageJson.module;
+  if (packageJson.exports) {
+    if ((0, import_utils.isString)(packageJson.exports))
+      return packageJson.exports;
+    const defaultExport = packageJson.exports["."];
+    if (defaultExport) {
+      if ((0, import_utils.isString)(defaultExport))
+        return defaultExport;
+      if ((0, import_utils.isString)(defaultExport.import))
+        return defaultExport.import;
+      if ((0, import_utils.isString)(defaultExport.browser))
+        return defaultExport.browser;
+      if ((0, import_utils.isString)(defaultExport.default))
+        return defaultExport.default;
+    }
+  }
+  if (packageJson.main)
+    return packageJson.main;
+};
+const prebundleDeps = async ({
+  unpackConfig
+}) => {
+  const userOptions = (0, import_utils.isPlainObject)(unpackConfig.dev?.prebundle) ? unpackConfig.dev.prebundle : {};
+  const { root } = unpackConfig;
+  const packageJson = JSON.parse(import_node_fs.default.readFileSync(import_node_path.default.resolve(root, "package.json"), "utf-8"));
+  const existExternals = getExistExternals(unpackConfig.externals);
+  const shouldIncludeDeps = Object.keys(packageJson.dependencies).filter(
+    (pkgName) => !existExternals.includes(pkgName) && !userOptions.exclude?.includes(pkgName)
+  );
+  const needBundleDeps = shouldIncludeDeps.map((pkgName) => {
+    const packageJson2 = JSON.parse(
+      import_node_fs.default.readFileSync(import_node_path.default.resolve(root, "node_modules", pkgName, "package.json"), "utf-8")
+    );
+    const entry = getPkgEntry(packageJson2);
+    if (!entry) {
+      noEntryDeps.push(pkgName);
+      return;
+    }
+    return {
+      name: pkgName,
+      entry: import_node_path.default.resolve(root, "node_modules", pkgName, entry),
+      version: packageJson2.version
+    };
+  }).filter(Boolean);
+  if (noEntryDeps[0]) {
+    import_logger.logger.warn(`Could not find entry for "${import_colors.default.bold(noEntryDeps.join(", "))}"`);
+  }
+  const bundledDeps = await Promise.all(
+    needBundleDeps.map((depInfo) => bundleDep({ root, ...depInfo }))
+  );
+  if (failedDeps[0]) {
+    import_logger.logger.warn(`Something went wrong while optimizing "${import_colors.default.bold(failedDeps.join(", "))}"`);
+  }
+  const cachePath = import_node_path.default.resolve(root, import_constants.TEMP_DIR, CACHE_DIR);
+  app.use(`/${CACHE_DIR}`, import_express.default.static(cachePath));
+  const port = await (0, import_utils.getPort)(3200);
+  app.listen(port, () => {
+  });
+  const externals = {};
+  const jsAssets = [];
+  const cssAssets = [];
+  const preJsAssets = [];
+  const ipv4Interfaces = (0, import_utils.getIpv4Interfaces)();
+  bundledDeps.filter(Boolean).forEach((dep) => {
+    externals[dep.name] = getExternalValue(dep.name);
+    dep.assets.forEach((absPath) => {
+      const relativePath = import_node_path.default.relative(cachePath, absPath);
+      const preDeps = ["react", "react-dom", "react-router", "react-router-dom"];
+      const serverPath = `//${ipv4Interfaces[1].address}:${port}/${CACHE_DIR}/${relativePath}`;
+      switch (import_node_path.default.extname(relativePath)) {
+        case ".js":
+          if (preDeps.includes(dep.name)) {
+            preJsAssets.push({
+              path: serverPath,
+              order: preDeps.indexOf(dep.name)
+            });
+          } else {
+            jsAssets.push(serverPath);
+          }
+          break;
+        case ".css":
+          cssAssets.push(serverPath);
+          break;
+        default:
+          break;
+      }
+    });
+  });
+  unpackConfig.externals = Array.isArray(unpackConfig.externals) ? [externals, ...unpackConfig.externals] : { ...externals, ...unpackConfig.externals };
+  unpackConfig.plugins.push({
+    name: "unpack:prebundle",
+    bundlerConfig: (config) => {
+      const PLUGIN_NAME = "PluginInjectAssets";
+      config.plugins.push({
+        apply: (compiler) => {
+          compiler.hooks.compilation.tap(PLUGIN_NAME, (compilation) => {
+            import_html_webpack_plugin.default.getCompilationHooks(compilation).beforeAssetTagGeneration.tapPromise(
+              PLUGIN_NAME,
+              async (args) => {
+                args.assets.js.unshift(
+                  ...[
+                    ...preJsAssets.sort((a, b) => a.order - b.order).map((item) => item.path),
+                    ...jsAssets
+                  ]
+                );
+                args.assets.css.unshift(...cssAssets);
+                return args;
+              }
+            );
+          });
+        }
+      });
+      return config;
+    }
+  });
+  return unpackConfig;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  prebundleDeps
+});

package/dist/prebundleDeps.d.ts

@@ -0,0 +1,5 @@
+import type { UnpackConfig } from './types';
+export declare const prebundleDeps: ({ unpackConfig, }: {
+    unpackConfig: UnpackConfig;
+}) => Promise<UnpackConfig>;
+//# sourceMappingURL=prebundleDeps.d.ts.map

package/dist/prebundleDeps.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prebundleDeps.d.ts","sourceRoot":"","sources":["../src/prebundleDeps.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,SAAS,CAAA;AAsN3C,eAAO,MAAM,aAAa,sBAEvB;IACD,YAAY,EAAE,YAAY,CAAA;CAC3B,KAAG,OAAO,CAAC,YAAY,CA0GvB,CAAA"}