@modern-js/plugin-v2 0.0.0-next-20241113090110

package/dist/esm-node/cli/api.js

@@ -0,0 +1,83 @@
+import { merge } from "@modern-js/utils/lodash";
+function initPluginAPI({ context }) {
+  const { hooks, extendsHooks, plugins } = context;
+  function getAppContext() {
+    if (context) {
+      const { hooks: hooks2, config, normalizedConfig, pluginAPI, ...appContext } = context;
+      return appContext;
+    }
+    throw new Error("Cannot access context");
+  }
+  function getConfig() {
+    if (context.config) {
+      return context.config;
+    }
+    throw new Error("Cannot access config");
+  }
+  function getNormalizedConfig() {
+    if (context.normalizedConfig) {
+      return context.normalizedConfig;
+    }
+    throw new Error("Cannot access normalized config");
+  }
+  function getHooks() {
+    return {
+      ...context.hooks,
+      ...context.extendsHooks
+    };
+  }
+  const extendsPluginApi = {};
+  function updateRegistryApi() {
+    plugins.forEach((plugin) => {
+      const { registryApi } = plugin;
+      if (registryApi) {
+        const apis = registryApi(context, updateAppContext);
+        Object.keys(apis).forEach((apiName) => {
+          extendsPluginApi[apiName] = apis[apiName];
+        });
+      }
+    });
+  }
+  updateRegistryApi();
+  Object.keys(extendsHooks).forEach((hookName) => {
+    extendsPluginApi[hookName] = extendsHooks[hookName].tap;
+  });
+  function updateAppContext(updateContext) {
+    context = merge(context, updateContext);
+    updateRegistryApi();
+  }
+  return {
+    getAppContext,
+    getConfig,
+    getNormalizedConfig,
+    getHooks,
+    updateAppContext,
+    config: hooks.config.tap,
+    modifyConfig: hooks.modifyConfig.tap,
+    modifyResolvedConfig: hooks.modifyResolvedConfig.tap,
+    modifyRsbuildConfig: hooks.modifyRsbuildConfig.tap,
+    modifyBundlerChain: hooks.modifyBundlerChain.tap,
+    modifyRspackConfig: hooks.modifyRspackConfig.tap,
+    modifyWebpackChain: hooks.modifyWebpackChain.tap,
+    modifyWebpackConfig: hooks.modifyWebpackConfig.tap,
+    modifyHtmlPartials: hooks.modifyHtmlPartials.tap,
+    addCommand: hooks.addCommand.tap,
+    onPrepare: hooks.onPrepare.tap,
+    onWatchFiles: hooks.addWatchFiles.tap,
+    onFileChanged: hooks.onFileChanged.tap,
+    onBeforeRestart: hooks.onBeforeRestart.tap,
+    onBeforeCreateCompiler: hooks.onBeforeCreateCompiler.tap,
+    onAfterCreateCompiler: hooks.onAfterCreateCompiler.tap,
+    onBeforeBuild: hooks.onBeforeBuild.tap,
+    onAfterBuild: hooks.onAfterBuild.tap,
+    onBeforeDev: hooks.onBeforeDev.tap,
+    onAfterDev: hooks.onAfterDev.tap,
+    onBeforeDeploy: hooks.onBeforeDeploy.tap,
+    onAfterDeploy: hooks.onAfterDeploy.tap,
+    onBeforeExit: hooks.onBeforeExit.tap,
+    ...extendsPluginApi
+  };
+}
+export {
+  initPluginAPI
+};

package/dist/esm-node/cli/context.js

@@ -0,0 +1,40 @@
+import path from "path";
+import { initHooks } from "./hooks";
+function initAppContext(params) {
+  const { appDirectory, srcDir = "src", distDir = "dist" } = params;
+  return {
+    packageName: params.packageName,
+    configFile: params.configFile,
+    command: params.command,
+    isProd: process.env.NODE_ENV === "production",
+    appDirectory,
+    srcDirectory: path.resolve(appDirectory, srcDir),
+    distDirectory: path.resolve(appDirectory, distDir),
+    nodeModulesDirectory: path.resolve(appDirectory, "node_modules"),
+    plugins: params.plugins
+  };
+}
+async function createContext({ appContext, config, normalizedConfig }) {
+  const { plugins } = appContext;
+  const extendsHooks = {};
+  plugins.forEach((plugin) => {
+    const { registryHooks = {} } = plugin;
+    Object.keys(registryHooks).forEach((hookName) => {
+      extendsHooks[hookName] = registryHooks[hookName];
+    });
+  });
+  return {
+    ...appContext,
+    hooks: {
+      ...initHooks(),
+      ...extendsHooks
+    },
+    extendsHooks,
+    config,
+    normalizedConfig
+  };
+}
+export {
+  createContext,
+  initAppContext
+};

package/dist/esm-node/cli/hooks.js

@@ -0,0 +1,41 @@
+import { createAsyncHook, createCollectAsyncHook } from "../hooks";
+function initHooks() {
+  return {
+    /**
+    * add config for this cli plugin
+    */
+    config: createCollectAsyncHook(),
+    /**
+    * @private
+    * modify config for this cli plugin
+    */
+    modifyConfig: createAsyncHook(),
+    /**
+    * modify final config
+    */
+    modifyResolvedConfig: createAsyncHook(),
+    modifyRsbuildConfig: createAsyncHook(),
+    modifyBundlerChain: createAsyncHook(),
+    modifyRspackConfig: createAsyncHook(),
+    modifyWebpackChain: createAsyncHook(),
+    modifyWebpackConfig: createAsyncHook(),
+    modifyHtmlPartials: createAsyncHook(),
+    addCommand: createAsyncHook(),
+    addWatchFiles: createCollectAsyncHook(),
+    onPrepare: createAsyncHook(),
+    onFileChanged: createAsyncHook(),
+    onBeforeRestart: createAsyncHook(),
+    onBeforeCreateCompiler: createAsyncHook(),
+    onAfterCreateCompiler: createAsyncHook(),
+    onBeforeBuild: createAsyncHook(),
+    onAfterBuild: createAsyncHook(),
+    onBeforeDev: createAsyncHook(),
+    onAfterDev: createAsyncHook(),
+    onBeforeDeploy: createAsyncHook(),
+    onAfterDeploy: createAsyncHook(),
+    onBeforeExit: createAsyncHook()
+  };
+}
+export {
+  initHooks
+};

package/dist/esm-node/cli/index.js

@@ -0,0 +1,14 @@
+import { initPluginAPI } from "./api";
+import { initAppContext } from "./context";
+import { initHooks } from "./hooks";
+import { cli } from "./run";
+import { initAppDir } from "./run/utils/initAppDir";
+import { createLoadedConfig } from "../cli/run/config/createLoadedConfig";
+export {
+  cli,
+  createLoadedConfig,
+  initAppContext,
+  initAppDir,
+  initHooks,
+  initPluginAPI
+};

package/dist/esm-node/cli/run/config/createLoadedConfig.js

@@ -0,0 +1,74 @@
+import { fs, CONFIG_FILE_EXTENSIONS, chalk, getCommand, getNodeEnv, isDevCommand, isPlainObject, logger } from "@modern-js/utils";
+import { mergeWith } from "@modern-js/utils/lodash";
+import { mergeConfig } from "../utils/mergeConfig";
+import { getConfigFilePath, loadConfig } from "./loadConfig";
+async function getConfigObject(config) {
+  if (typeof config === "function") {
+    return await config({
+      env: getNodeEnv(),
+      command: getCommand()
+    }) || {};
+  }
+  return config || {};
+}
+async function loadLocalConfig(appDirectory, configFile) {
+  let localConfigFile = false;
+  if (typeof configFile === "string") {
+    for (const ext of CONFIG_FILE_EXTENSIONS) {
+      if (configFile.endsWith(ext)) {
+        const replacedPath = configFile.replace(ext, `.local${ext}`);
+        if (fs.existsSync(replacedPath)) {
+          localConfigFile = replacedPath;
+        }
+      }
+    }
+  }
+  if (localConfigFile) {
+    const loaded = await loadConfig(appDirectory, localConfigFile);
+    return getConfigObject(loaded.config);
+  }
+  return null;
+}
+function assignPkgConfig(userConfig, pkgConfig) {
+  return mergeWith({}, userConfig, pkgConfig, (objValue, srcValue) => {
+    if (objValue === void 0 && isPlainObject(srcValue)) {
+      return {
+        ...srcValue
+      };
+    }
+    return void 0;
+  });
+}
+async function createLoadedConfig(appDirectory, configFilePath, packageJsonConfig, loadedConfig) {
+  const configFile = getConfigFilePath(appDirectory, configFilePath);
+  const loaded = await loadConfig(appDirectory, configFile, packageJsonConfig, loadedConfig);
+  if (!loaded.config && !loaded.pkgConfig) {
+    logger.warn(`Can not find any config file in the current project, please check if you have a correct config file.`);
+    logger.warn(`Current project path: ${chalk.yellow(appDirectory)}`);
+  }
+  const config = await getConfigObject(loaded.config);
+  let mergedConfig = config;
+  if (loaded.pkgConfig) {
+    mergedConfig = assignPkgConfig(config, loaded === null || loaded === void 0 ? void 0 : loaded.pkgConfig);
+  }
+  if (isDevCommand()) {
+    const localConfig = await loadLocalConfig(appDirectory, configFile);
+    if (localConfig) {
+      mergedConfig = mergeConfig([
+        mergedConfig,
+        localConfig
+      ]);
+    }
+  }
+  return {
+    packageName: loaded.packageName,
+    config: mergedConfig,
+    configFile: loaded.configFile,
+    pkgConfig: loaded.pkgConfig,
+    jsConfig: loaded.config
+  };
+}
+export {
+  assignPkgConfig,
+  createLoadedConfig
+};

package/dist/esm-node/cli/run/config/createResolvedConfig.js

@@ -0,0 +1,16 @@
+import { createDebugger } from "@modern-js/utils";
+import { mergeConfig } from "../utils/mergeConfig";
+const debug = createDebugger("resolve-config");
+const createResolveConfig = async (loaded, configs) => {
+  const { config: userConfig } = loaded;
+  const resolved = mergeConfig([
+    {},
+    ...configs,
+    userConfig
+  ]);
+  debug("resolved %o", resolved);
+  return resolved;
+};
+export {
+  createResolveConfig
+};

package/dist/esm-node/cli/run/config/loadConfig.js

@@ -0,0 +1,80 @@
+import path from "path";
+import { bundleRequire, defaultGetOutputFile } from "@modern-js/node-bundle-require";
+import { fs, CONFIG_CACHE_DIR, globby } from "@modern-js/utils";
+const getPackageConfig = (appDirectory, packageJsonConfig) => {
+  const json = JSON.parse(fs.readFileSync(path.resolve(appDirectory, "./package.json"), "utf8"));
+  return json[packageJsonConfig];
+};
+const getConfigFilePath = (appDirectory, configFilePath) => {
+  if (path.isAbsolute(configFilePath)) {
+    return configFilePath;
+  }
+  return path.resolve(appDirectory, configFilePath);
+};
+const clearFilesOverTime = async (targetDir, overtime) => {
+  try {
+    const files = await globby(`${targetDir}/**/*`, {
+      stats: true,
+      absolute: true
+    });
+    const currentTime = Date.now();
+    if (files.length > 0) {
+      for (const file of files) {
+        if (currentTime - file.stats.birthtimeMs >= overtime * 1e3) {
+          fs.unlinkSync(file.path);
+        }
+      }
+    }
+  } catch (err) {
+  }
+};
+const bundleRequireWithCatch = async (configFile, { appDirectory }) => {
+  try {
+    const mod = await bundleRequire(configFile, {
+      autoClear: false,
+      getOutputFile: async (filePath) => {
+        const defaultOutputFileName = path.basename(await defaultGetOutputFile(filePath));
+        const outputPath = path.join(appDirectory, CONFIG_CACHE_DIR);
+        const timeLimit = 10 * 60;
+        await clearFilesOverTime(outputPath, timeLimit);
+        return path.join(outputPath, defaultOutputFileName);
+      }
+    });
+    return mod;
+  } catch (e) {
+    if (e instanceof Error) {
+      e.message = `Get Error while loading config file: ${configFile}, please check it and retry.
+${e.message || ""}`;
+    }
+    throw e;
+  }
+};
+const loadConfig = async (appDirectory, configFile, packageJsonConfig, loadedConfig) => {
+  let pkgConfig;
+  if (packageJsonConfig) {
+    pkgConfig = getPackageConfig(appDirectory, packageJsonConfig);
+  }
+  const packageName = require(path.resolve(appDirectory, "./package.json")).name;
+  let config;
+  if (loadedConfig) {
+    config = loadedConfig;
+  } else if (configFile) {
+    delete require.cache[configFile];
+    const mod = await bundleRequireWithCatch(configFile, {
+      appDirectory
+    });
+    config = mod.default || mod;
+  }
+  return {
+    packageName,
+    configFile,
+    config,
+    pkgConfig
+  };
+};
+export {
+  clearFilesOverTime,
+  getConfigFilePath,
+  getPackageConfig,
+  loadConfig
+};

package/dist/esm-node/cli/run/create.js

@@ -0,0 +1,101 @@
+import { logger } from "@modern-js/utils";
+import { program } from "@modern-js/utils/commander";
+import { createPluginManager } from "../../manager";
+import { initPluginAPI } from "../api";
+import { createContext, initAppContext } from "../context";
+import { createLoadedConfig } from "./config/createLoadedConfig";
+import { createResolveConfig } from "./config/createResolvedConfig";
+import { checkIsDuplicationPlugin } from "./utils/checkIsDuplicationPlugin";
+import { initCommandsMap, setProgramVersion } from "./utils/commander";
+import { createFileWatcher } from "./utils/createFileWatcher";
+import { initAppDir } from "./utils/initAppDir";
+import { loadEnv } from "./utils/loadEnv";
+const createCli = () => {
+  const pluginManager = createPluginManager();
+  async function init(options) {
+    const { metaName = "MODERN", configFile, command, version, packageJsonConfig, loadedConfig, internalPlugins, handleSetupResult } = options;
+    const appDirectory = await initAppDir(options === null || options === void 0 ? void 0 : options.cwd);
+    initCommandsMap();
+    setProgramVersion(version);
+    loadEnv(appDirectory, process.env[`${metaName.toUpperCase()}_ENV`]);
+    const loaded = await createLoadedConfig(appDirectory, configFile, packageJsonConfig, loadedConfig);
+    const allPlugins = [
+      ...internalPlugins || [],
+      ...loaded.config.plugins || []
+    ];
+    checkIsDuplicationPlugin(allPlugins.map((plugin) => plugin.name), loaded.config.autoLoadPlugins);
+    pluginManager.addPlugins(allPlugins);
+    const plugins = await pluginManager.getPlugins();
+    const context = await createContext({
+      appContext: initAppContext({
+        packageName: loaded.packageName,
+        configFile: loaded.configFile,
+        command,
+        appDirectory,
+        plugins
+      }),
+      config: loaded.config,
+      normalizedConfig: {}
+    });
+    const pluginAPI = initPluginAPI({
+      context,
+      pluginManager
+    });
+    context.pluginAPI = pluginAPI;
+    for (const plugin of plugins) {
+      const setupResult = await plugin.setup(pluginAPI);
+      if (handleSetupResult) {
+        await handleSetupResult(setupResult, pluginAPI);
+      }
+    }
+    [
+      "SIGINT",
+      "SIGTERM",
+      "unhandledRejection",
+      "uncaughtException"
+    ].forEach((event) => {
+      process.on(event, async (err) => {
+        await context.hooks.onBeforeExit.call();
+        let hasError = false;
+        if (err instanceof Error) {
+          logger.error(err.stack);
+          hasError = true;
+        } else if (err && (event === "unhandledRejection" || event === "uncaughtException")) {
+          console.trace("Unknown Error", err);
+          hasError = true;
+        }
+        process.nextTick(() => {
+          process.exit(hasError ? 1 : 0);
+        });
+      });
+    });
+    const extraConfigs = await context.hooks.config.call();
+    const normalizedConfig = await createResolveConfig(loaded, extraConfigs);
+    const resolved = await context.hooks.modifyResolvedConfig.call(normalizedConfig);
+    context.normalizedConfig = resolved[0] || normalizedConfig;
+    await pluginAPI.updateAppContext(context);
+    await context.hooks.onPrepare.call();
+    return {
+      appContext: context
+    };
+  }
+  async function run(options) {
+    var _program_commands;
+    const { appContext } = await init(options);
+    await appContext.hooks.addCommand.call({
+      program
+    });
+    await createFileWatcher(appContext);
+    program.parse(process.argv);
+    if (!((_program_commands = program.commands) === null || _program_commands === void 0 ? void 0 : _program_commands.length)) {
+      logger.warn("No command found, please make sure you have registered plugins correctly.");
+    }
+  }
+  return {
+    init,
+    run
+  };
+};
+export {
+  createCli
+};

package/dist/esm-node/cli/run/index.js

@@ -0,0 +1,5 @@
+import { createCli } from "./create";
+const cli = createCli();
+export {
+  cli
+};

package/dist/esm-node/cli/run/run.js

@@ -0,0 +1,34 @@
+import { logger } from "@modern-js/utils";
+import { cli } from ".";
+const run = async (options) => {
+  const { initialLog, version, cwd, configFile, ...params } = options;
+  if (initialLog) {
+    logger.greet(`  ${initialLog}
+`);
+  }
+  const command = process.argv[2];
+  if (!process.env.NODE_ENV) {
+    if ([
+      "build",
+      "serve",
+      "deploy",
+      "analyze"
+    ].includes(command)) {
+      process.env.NODE_ENV = "production";
+    } else if (command === "test") {
+      process.env.NODE_ENV = "test";
+    } else {
+      process.env.NODE_ENV = "development";
+    }
+  }
+  await cli.run({
+    version,
+    cwd,
+    command,
+    configFile,
+    ...params
+  });
+};
+export {
+  run
+};

package/dist/esm-node/cli/run/utils/checkIsDuplicationPlugin.js

@@ -0,0 +1,21 @@
+import { logger } from "@modern-js/utils";
+function checkIsDuplicationPlugin(plugins, autoLoadPlugin = false) {
+  const set = /* @__PURE__ */ new Set();
+  const duplicationPlugins = [];
+  plugins.filter((plugin) => typeof plugin === "string").forEach((plugin) => {
+    if (set.has(plugin)) {
+      duplicationPlugins.push(plugin);
+    } else {
+      set.add(plugin);
+    }
+  });
+  if (duplicationPlugins.length > 0) {
+    logger.warn(`Duplicate registration plugins: ${duplicationPlugins.join(",")}.`);
+    if (autoLoadPlugin) {
+      logger.warn("This is probably because you enabled `autoLoadPlugin` configuration and also registered these plugins manually");
+    }
+  }
+}
+export {
+  checkIsDuplicationPlugin
+};

package/dist/esm-node/cli/run/utils/commander.js

@@ -0,0 +1,24 @@
+import { program } from "@modern-js/utils";
+const setProgramVersion = (version = "unknown") => {
+  const name = process.argv[1];
+  program.name(name).usage("<command> [options]").version(version);
+};
+function initCommandsMap() {
+  if (!program.hasOwnProperty("commandsMap")) {
+    Object.defineProperty(program, "commandsMap", {
+      get() {
+        const map = /* @__PURE__ */ new Map();
+        for (const command of program.commands) {
+          map.set(command._name, command);
+        }
+        return map;
+      },
+      configurable: false
+    });
+  }
+}
+export {
+  initCommandsMap,
+  program,
+  setProgramVersion
+};

package/dist/esm-node/cli/run/utils/createFileWatcher.js

@@ -0,0 +1,80 @@
+import crypto from "crypto";
+import * as fs from "fs";
+import * as path from "path";
+import { chokidar, createDebugger, isDevCommand } from "@modern-js/utils";
+const debug = createDebugger("watch-files");
+const hashMap = /* @__PURE__ */ new Map();
+const md5 = (data) => crypto.createHash("md5").update(data).digest("hex");
+const createFileWatcher = async (appContext) => {
+  if (isDevCommand()) {
+    const { appDirectory } = appContext;
+    const extraFiles = await appContext.hooks.addWatchFiles.call();
+    const watched = extraFiles.filter((extra) => {
+      return Array.isArray(extra);
+    }).flat();
+    const privateWatched = extraFiles.filter((extra) => {
+      return !Array.isArray(extra) && extra.isPrivate;
+    }).map((extra) => {
+      return extra.files;
+    }).flat();
+    const isPrivate = (filename) => privateWatched.some((ff) => {
+      return path.resolve(appDirectory, filename).startsWith(ff);
+    });
+    debug(`watched: %o`, watched);
+    const watcher = chokidar.watch([
+      ...watched,
+      ...privateWatched
+    ], {
+      cwd: appDirectory,
+      ignoreInitial: true,
+      ignorePermissionErrors: true,
+      ignored: [
+        "**/__test__/**",
+        "**/*.test.(js|jsx|ts|tsx)",
+        "**/*.spec.(js|jsx|ts|tsx)",
+        "**/*.stories.(js|jsx|ts|tsx)"
+      ]
+    });
+    watcher.on("change", (changed) => {
+      const lastHash = hashMap.get(changed);
+      const currentHash = md5(fs.readFileSync(path.join(appDirectory, changed), "utf8"));
+      if (currentHash !== lastHash) {
+        debug(`file change: %s`, changed);
+        hashMap.set(changed, currentHash);
+        appContext.hooks.onFileChanged.call({
+          filename: changed,
+          eventType: "change",
+          isPrivate: isPrivate(changed)
+        });
+      }
+    });
+    watcher.on("add", (changed) => {
+      debug(`add file: %s`, changed);
+      const currentHash = md5(fs.readFileSync(path.join(appDirectory, changed), "utf8"));
+      hashMap.set(changed, currentHash);
+      appContext.hooks.onFileChanged.call({
+        filename: changed,
+        eventType: "add",
+        isPrivate: isPrivate(changed)
+      });
+    });
+    watcher.on("unlink", (changed) => {
+      debug(`remove file: %s`, changed);
+      if (hashMap.has(changed)) {
+        hashMap.delete(changed);
+      }
+      appContext.hooks.onFileChanged.call({
+        filename: changed,
+        eventType: "unlink",
+        isPrivate: isPrivate(changed)
+      });
+    });
+    watcher.on("error", (err) => {
+      throw err;
+    });
+    return watcher;
+  }
+};
+export {
+  createFileWatcher
+};

package/dist/esm-node/cli/run/utils/initAppDir.js

@@ -0,0 +1,15 @@
+import path from "path";
+import { pkgUp } from "@modern-js/utils";
+const initAppDir = async (currentDir) => {
+  const cwd = currentDir || process.cwd();
+  const pkg = await pkgUp({
+    cwd
+  });
+  if (!pkg) {
+    throw new Error(`no package.json found in current work dir: ${cwd}`);
+  }
+  return path.dirname(pkg);
+};
+export {
+  initAppDir
+};

package/dist/esm-node/cli/run/utils/loadEnv.js

@@ -0,0 +1,19 @@
+import fs from "fs";
+import path from "path";
+import { dotenv, dotenvExpand } from "@modern-js/utils";
+const loadEnv = (appDirectory, mode = process.env.NODE_ENV) => {
+  [
+    `.env.${mode}.local`,
+    ".env.local",
+    `.env.${mode}`,
+    ".env"
+  ].map((name) => path.resolve(appDirectory, name)).filter((filePath) => fs.existsSync(filePath) && !fs.statSync(filePath).isDirectory()).forEach((filePath) => {
+    const envConfig = dotenv.config({
+      path: filePath
+    });
+    dotenvExpand(envConfig);
+  });
+};
+export {
+  loadEnv
+};