@unpackjs/core 1.6.4 → 1.7.1

package/dist/prebundleDeps.cjs

@@ -0,0 +1,349 @@
+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 `window ${getExternalLibraryName(pkgName)}`;
+};
+const bundleDep = ({
+  root,
+  name,
+  entry,
+  version
+}) => {
+  return new Promise((resolve) => {
+    const pkgDir = import_node_path.default.resolve(root, import_constants.TEMP_DIR, CACHE_DIR, name);
+    const outDir = import_node_path.default.resolve(pkgDir, 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)) {
+      resolve(getResult());
+      return;
+    }
+    (0, import_utils.removeDir)(pkgDir);
+    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: false,
+      module: {
+        rules: [
+          {
+            test: /\.(j|t)s$/,
+            use: [
+              {
+                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) => {
+      let isFailed = false;
+      if (stats?.hasErrors()) {
+        isFailed = true;
+        failedDeps.push(name);
+        (0, import_utils.removeDir)(outDir);
+      } else {
+        count.bundled++;
+      }
+      updateProgress();
+      compiler.close(() => {
+        resolve(!isFailed ? getResult() : 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 };
+  const HtmlPlugin = unpackConfig.bundler === "rspack" ? import_core.rspack.HtmlRspackPlugin : import_html_webpack_plugin.default;
+  unpackConfig.plugins.push({
+    name: "unpack:prebundle",
+    bundlerConfig: (config) => {
+      const PLUGIN_NAME = "PluginInjectAssets";
+      config.plugins.push({
+        apply: (compiler) => {
+          compiler.hooks.compilation.tap(PLUGIN_NAME, (compilation) => {
+            HtmlPlugin.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;AA+N3C,eAAO,MAAM,aAAa,sBAEvB;IACD,YAAY,EAAE,YAAY,CAAA;CAC3B,KAAG,OAAO,CAAC,YAAY,CA0GvB,CAAA"}

package/dist/prebundleDeps.js

@@ -0,0 +1,334 @@
+import { createRequire } from 'node:module';
+var require = createRequire(import.meta['url']);
+
+import path from "path";
+import { fileURLToPath } from "url";
+var getFilename = () => fileURLToPath(import.meta.url);
+var getDirname = () => path.dirname(getFilename());
+var __dirname = /* @__PURE__ */ getDirname();
+var __filename = /* @__PURE__ */ getFilename();
+import fs from "node:fs";
+import path2 from "node:path";
+import { rspack } from "@rspack/core";
+import cors from "cors";
+import express from "express";
+import HtmlWebpackPlugin from "html-webpack-plugin";
+import { globSync } from "tinyglobby";
+import colors from "./colors.js";
+import { TEMP_DIR } from "./constants.js";
+import { logger } from "./logger.js";
+import {
+  getCompiledPkgPath,
+  getIpv4Interfaces,
+  getPort,
+  getUserDepPath,
+  isPlainObject,
+  isString,
+  logUpdate,
+  removeDir
+} from "./utils.js";
+const app = express();
+app.use(cors());
+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 = () => {
+  logUpdate(
+    `${colors.magenta(colors.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 `window ${getExternalLibraryName(pkgName)}`;
+};
+const bundleDep = ({
+  root,
+  name,
+  entry,
+  version
+}) => {
+  return new Promise((resolve) => {
+    const pkgDir = path2.resolve(root, TEMP_DIR, CACHE_DIR, name);
+    const outDir = path2.resolve(pkgDir, version);
+    const getResult = () => {
+      const assets = globSync("**/index.{js,css}", {
+        cwd: outDir,
+        absolute: true
+      });
+      return {
+        name,
+        assets
+      };
+    };
+    if (fs.existsSync(outDir)) {
+      resolve(getResult());
+      return;
+    }
+    removeDir(pkgDir);
+    count.total++;
+    updateProgress();
+    const getSwcOptions = ({ tsx }) => {
+      return {
+        jsc: {
+          parser: {
+            tsx,
+            syntax: "typescript",
+            dynamicImport: true,
+            decorators: true
+          },
+          transform: {
+            react: {
+              runtime: "automatic"
+            }
+          }
+        }
+      };
+    };
+    const compiler = 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: false,
+      module: {
+        rules: [
+          {
+            test: /\.(j|t)s$/,
+            use: [
+              {
+                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: getCompiledPkgPath("less-loader"),
+                options: {
+                  lessOptions: {
+                    javascriptEnabled: true
+                  },
+                  implementation: getUserDepPath(root, "less")
+                }
+              }
+            ]
+          },
+          {
+            test: /\.s[ac]ss$/i,
+            type: "css/auto",
+            use: [
+              {
+                loader: getCompiledPkgPath("sass-loader"),
+                options: {
+                  api: "modern-compiler",
+                  implementation: 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) => {
+      let isFailed = false;
+      if (stats?.hasErrors()) {
+        isFailed = true;
+        failedDeps.push(name);
+        removeDir(outDir);
+      } else {
+        count.bundled++;
+      }
+      updateProgress();
+      compiler.close(() => {
+        resolve(!isFailed ? getResult() : void 0);
+      });
+    });
+  });
+};
+const getExistExternals = (externals) => {
+  const existExternals = /* @__PURE__ */ new Set();
+  if (Array.isArray(externals)) {
+    externals.forEach((item) => {
+      if (isPlainObject(item)) {
+        Object.keys(item).forEach((key) => existExternals.add(key));
+      }
+    });
+  } else if (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 (isString(packageJson.exports))
+      return packageJson.exports;
+    const defaultExport = packageJson.exports["."];
+    if (defaultExport) {
+      if (isString(defaultExport))
+        return defaultExport;
+      if (isString(defaultExport.import))
+        return defaultExport.import;
+      if (isString(defaultExport.browser))
+        return defaultExport.browser;
+      if (isString(defaultExport.default))
+        return defaultExport.default;
+    }
+  }
+  if (packageJson.main)
+    return packageJson.main;
+};
+const prebundleDeps = async ({
+  unpackConfig
+}) => {
+  const userOptions = isPlainObject(unpackConfig.dev?.prebundle) ? unpackConfig.dev.prebundle : {};
+  const { root } = unpackConfig;
+  const packageJson = JSON.parse(fs.readFileSync(path2.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(
+      fs.readFileSync(path2.resolve(root, "node_modules", pkgName, "package.json"), "utf-8")
+    );
+    const entry = getPkgEntry(packageJson2);
+    if (!entry) {
+      noEntryDeps.push(pkgName);
+      return;
+    }
+    return {
+      name: pkgName,
+      entry: path2.resolve(root, "node_modules", pkgName, entry),
+      version: packageJson2.version
+    };
+  }).filter(Boolean);
+  if (noEntryDeps[0]) {
+    logger.warn(`Could not find entry for "${colors.bold(noEntryDeps.join(", "))}"`);
+  }
+  const bundledDeps = await Promise.all(
+    needBundleDeps.map((depInfo) => bundleDep({ root, ...depInfo }))
+  );
+  if (failedDeps[0]) {
+    logger.warn(`Something went wrong while optimizing "${colors.bold(failedDeps.join(", "))}"`);
+  }
+  const cachePath = path2.resolve(root, TEMP_DIR, CACHE_DIR);
+  app.use(`/${CACHE_DIR}`, express.static(cachePath));
+  const port = await getPort(3200);
+  app.listen(port, () => {
+  });
+  const externals = {};
+  const jsAssets = [];
+  const cssAssets = [];
+  const preJsAssets = [];
+  const ipv4Interfaces = getIpv4Interfaces();
+  bundledDeps.filter(Boolean).forEach((dep) => {
+    externals[dep.name] = getExternalValue(dep.name);
+    dep.assets.forEach((absPath) => {
+      const relativePath = path2.relative(cachePath, absPath);
+      const preDeps = ["react", "react-dom", "react-router", "react-router-dom"];
+      const serverPath = `//${ipv4Interfaces[1].address}:${port}/${CACHE_DIR}/${relativePath}`;
+      switch (path2.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 };
+  const HtmlPlugin = unpackConfig.bundler === "rspack" ? rspack.HtmlRspackPlugin : HtmlWebpackPlugin;
+  unpackConfig.plugins.push({
+    name: "unpack:prebundle",
+    bundlerConfig: (config) => {
+      const PLUGIN_NAME = "PluginInjectAssets";
+      config.plugins.push({
+        apply: (compiler) => {
+          compiler.hooks.compilation.tap(PLUGIN_NAME, (compilation) => {
+            HtmlPlugin.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;
+};
+export {
+  prebundleDeps
+};