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

package/dist/cjs/cli/run/create.js

@@ -0,0 +1,125 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var create_exports = {};
+__export(create_exports, {
+  createCli: () => createCli
+});
+module.exports = __toCommonJS(create_exports);
+var import_utils = require("@modern-js/utils");
+var import_commander = require("@modern-js/utils/commander");
+var import_manager = require("../../manager");
+var import_api = require("../api");
+var import_context = require("../context");
+var import_createLoadedConfig = require("./config/createLoadedConfig");
+var import_createResolvedConfig = require("./config/createResolvedConfig");
+var import_checkIsDuplicationPlugin = require("./utils/checkIsDuplicationPlugin");
+var import_commander2 = require("./utils/commander");
+var import_createFileWatcher = require("./utils/createFileWatcher");
+var import_initAppDir = require("./utils/initAppDir");
+var import_loadEnv = require("./utils/loadEnv");
+const createCli = () => {
+  const pluginManager = (0, import_manager.createPluginManager)();
+  async function init(options) {
+    const { metaName = "MODERN", configFile, command, version, packageJsonConfig, loadedConfig, internalPlugins, handleSetupResult } = options;
+    const appDirectory = await (0, import_initAppDir.initAppDir)(options === null || options === void 0 ? void 0 : options.cwd);
+    (0, import_commander2.initCommandsMap)();
+    (0, import_commander2.setProgramVersion)(version);
+    (0, import_loadEnv.loadEnv)(appDirectory, process.env[`${metaName.toUpperCase()}_ENV`]);
+    const loaded = await (0, import_createLoadedConfig.createLoadedConfig)(appDirectory, configFile, packageJsonConfig, loadedConfig);
+    const allPlugins = [
+      ...internalPlugins || [],
+      ...loaded.config.plugins || []
+    ];
+    (0, import_checkIsDuplicationPlugin.checkIsDuplicationPlugin)(allPlugins.map((plugin) => plugin.name), loaded.config.autoLoadPlugins);
+    pluginManager.addPlugins(allPlugins);
+    const plugins = await pluginManager.getPlugins();
+    const context = await (0, import_context.createContext)({
+      appContext: (0, import_context.initAppContext)({
+        packageName: loaded.packageName,
+        configFile: loaded.configFile,
+        command,
+        appDirectory,
+        plugins
+      }),
+      config: loaded.config,
+      normalizedConfig: {}
+    });
+    const pluginAPI = (0, import_api.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) {
+          import_utils.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 (0, import_createResolvedConfig.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: import_commander.program
+    });
+    await (0, import_createFileWatcher.createFileWatcher)(appContext);
+    import_commander.program.parse(process.argv);
+    if (!((_program_commands = import_commander.program.commands) === null || _program_commands === void 0 ? void 0 : _program_commands.length)) {
+      import_utils.logger.warn("No command found, please make sure you have registered plugins correctly.");
+    }
+  }
+  return {
+    init,
+    run
+  };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createCli
+});

package/dist/cjs/cli/run/index.js

@@ -0,0 +1,29 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var run_exports = {};
+__export(run_exports, {
+  cli: () => cli
+});
+module.exports = __toCommonJS(run_exports);
+var import_create = require("./create");
+const cli = (0, import_create.createCli)();
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  cli
+});

package/dist/cjs/cli/run/run.js

@@ -0,0 +1,58 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var run_exports = {};
+__export(run_exports, {
+  run: () => run
+});
+module.exports = __toCommonJS(run_exports);
+var import_utils = require("@modern-js/utils");
+var import__ = require(".");
+const run = async (options) => {
+  const { initialLog, version, cwd, configFile, ...params } = options;
+  if (initialLog) {
+    import_utils.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 import__.cli.run({
+    version,
+    cwd,
+    command,
+    configFile,
+    ...params
+  });
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  run
+});

package/dist/cjs/cli/run/types.js

@@ -0,0 +1,16 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var types_exports = {};
+module.exports = __toCommonJS(types_exports);

package/dist/cjs/cli/run/utils/checkIsDuplicationPlugin.js

@@ -0,0 +1,45 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var checkIsDuplicationPlugin_exports = {};
+__export(checkIsDuplicationPlugin_exports, {
+  checkIsDuplicationPlugin: () => checkIsDuplicationPlugin
+});
+module.exports = __toCommonJS(checkIsDuplicationPlugin_exports);
+var import_utils = require("@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) {
+    import_utils.logger.warn(`Duplicate registration plugins: ${duplicationPlugins.join(",")}.`);
+    if (autoLoadPlugin) {
+      import_utils.logger.warn("This is probably because you enabled `autoLoadPlugin` configuration and also registered these plugins manually");
+    }
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  checkIsDuplicationPlugin
+});

package/dist/cjs/cli/run/utils/commander.js

@@ -0,0 +1,50 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var commander_exports = {};
+__export(commander_exports, {
+  initCommandsMap: () => initCommandsMap,
+  program: () => import_utils.program,
+  setProgramVersion: () => setProgramVersion
+});
+module.exports = __toCommonJS(commander_exports);
+var import_utils = require("@modern-js/utils");
+const setProgramVersion = (version = "unknown") => {
+  const name = process.argv[1];
+  import_utils.program.name(name).usage("<command> [options]").version(version);
+};
+function initCommandsMap() {
+  if (!import_utils.program.hasOwnProperty("commandsMap")) {
+    Object.defineProperty(import_utils.program, "commandsMap", {
+      get() {
+        const map = /* @__PURE__ */ new Map();
+        for (const command of import_utils.program.commands) {
+          map.set(command._name, command);
+        }
+        return map;
+      },
+      configurable: false
+    });
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  initCommandsMap,
+  program,
+  setProgramVersion
+});

package/dist/cjs/cli/run/utils/createFileWatcher.js

@@ -0,0 +1,114 @@
+"use strict";
+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 createFileWatcher_exports = {};
+__export(createFileWatcher_exports, {
+  createFileWatcher: () => createFileWatcher
+});
+module.exports = __toCommonJS(createFileWatcher_exports);
+var import_crypto = __toESM(require("crypto"));
+var fs = __toESM(require("fs"));
+var path = __toESM(require("path"));
+var import_utils = require("@modern-js/utils");
+const debug = (0, import_utils.createDebugger)("watch-files");
+const hashMap = /* @__PURE__ */ new Map();
+const md5 = (data) => import_crypto.default.createHash("md5").update(data).digest("hex");
+const createFileWatcher = async (appContext) => {
+  if ((0, import_utils.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 = import_utils.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;
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createFileWatcher
+});

package/dist/cjs/cli/run/utils/initAppDir.js

@@ -0,0 +1,49 @@
+"use strict";
+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 initAppDir_exports = {};
+__export(initAppDir_exports, {
+  initAppDir: () => initAppDir
+});
+module.exports = __toCommonJS(initAppDir_exports);
+var import_path = __toESM(require("path"));
+var import_utils = require("@modern-js/utils");
+const initAppDir = async (currentDir) => {
+  const cwd = currentDir || process.cwd();
+  const pkg = await (0, import_utils.pkgUp)({
+    cwd
+  });
+  if (!pkg) {
+    throw new Error(`no package.json found in current work dir: ${cwd}`);
+  }
+  return import_path.default.dirname(pkg);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  initAppDir
+});

package/dist/cjs/cli/run/utils/loadEnv.js

@@ -0,0 +1,53 @@
+"use strict";
+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 loadEnv_exports = {};
+__export(loadEnv_exports, {
+  loadEnv: () => loadEnv
+});
+module.exports = __toCommonJS(loadEnv_exports);
+var import_fs = __toESM(require("fs"));
+var import_path = __toESM(require("path"));
+var import_utils = require("@modern-js/utils");
+const loadEnv = (appDirectory, mode = process.env.NODE_ENV) => {
+  [
+    `.env.${mode}.local`,
+    ".env.local",
+    `.env.${mode}`,
+    ".env"
+  ].map((name) => import_path.default.resolve(appDirectory, name)).filter((filePath) => import_fs.default.existsSync(filePath) && !import_fs.default.statSync(filePath).isDirectory()).forEach((filePath) => {
+    const envConfig = import_utils.dotenv.config({
+      path: filePath
+    });
+    (0, import_utils.dotenvExpand)(envConfig);
+  });
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  loadEnv
+});

package/dist/cjs/cli/run/utils/mergeConfig.js

@@ -0,0 +1,62 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var mergeConfig_exports = {};
+__export(mergeConfig_exports, {
+  mergeConfig: () => mergeConfig
+});
+module.exports = __toCommonJS(mergeConfig_exports);
+var import_utils = require("@modern-js/utils");
+var import_lodash = require("@modern-js/utils/lodash");
+const mergeConfig = (configs) => (0, import_lodash.mergeWith)({}, ...configs, (target, source, key) => {
+  if (key === "designSystem" || key === "tailwindcss" && typeof source === "object") {
+    return (0, import_lodash.mergeWith)({}, target !== null && target !== void 0 ? target : {}, source !== null && source !== void 0 ? source : {});
+  }
+  if ((0, import_utils.isOverriddenConfigKey)(key)) {
+    return source !== null && source !== void 0 ? source : target;
+  }
+  if (Array.isArray(target) || Array.isArray(source)) {
+    if (target === void 0) {
+      return source;
+    }
+    if (source === void 0) {
+      return target;
+    }
+    return [
+      ...(0, import_utils.ensureArray)(target),
+      ...(0, import_utils.ensureArray)(source)
+    ];
+  }
+  if ((0, import_lodash.isFunction)(target) || (0, import_lodash.isFunction)(source)) {
+    if (source === void 0) {
+      return target;
+    }
+    if (target === void 0) {
+      return source;
+    }
+    return [
+      target,
+      source
+    ];
+  }
+  return void 0;
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  mergeConfig
+});

package/dist/cjs/hooks.js

@@ -0,0 +1,69 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var hooks_exports = {};
+__export(hooks_exports, {
+  createAsyncHook: () => createAsyncHook,
+  createCollectAsyncHook: () => createCollectAsyncHook
+});
+module.exports = __toCommonJS(hooks_exports);
+function createAsyncHook() {
+  const callbacks = [];
+  const tap = (cb) => {
+    callbacks.push(cb);
+  };
+  const call = async (...params) => {
+    for (const callback of callbacks) {
+      const result = await callback(...params);
+      if (result !== void 0) {
+        params[0] = result;
+      }
+    }
+    return params[0] || [];
+  };
+  return {
+    tap,
+    call
+  };
+}
+function createCollectAsyncHook() {
+  const callbacks = [];
+  const tap = (cb) => {
+    callbacks.push(cb);
+  };
+  const call = async (...params) => {
+    const results = [];
+    for (const callback of callbacks) {
+      const result = await callback(...params);
+      if (result !== void 0) {
+        params[0] = result;
+        results.push(result);
+      }
+    }
+    return results;
+  };
+  return {
+    tap,
+    call
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createAsyncHook,
+  createCollectAsyncHook
+});