@modern-js/utils 2.22.0 → 2.22.1-alpha.1

package/dist/FileSizeReporter.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file at
+ * https://github.com/facebook/create-react-app/blob/master/LICENSE
+ */
+declare function printFileSizesAfterBuild(webpackStats: any, previousSizeMap: {
+  root: string;
+  sizes: Record<string, number[]>;
+}, buildFolder: string, maxBundleGzipSize: number, maxChunkGzipSize: number): void;
+declare function measureFileSizesBeforeBuild(buildFolder: string): Promise<{
+  root: string;
+  sizes: Record<string, number[]>;
+}>;
+export { measureFileSizesBeforeBuild, printFileSizesAfterBuild };

package/dist/FileSizeReporter.js

@@ -0,0 +1,162 @@
+"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 FileSizeReporter_exports = {};
+__export(FileSizeReporter_exports, {
+  measureFileSizesBeforeBuild: () => measureFileSizesBeforeBuild,
+  printFileSizesAfterBuild: () => printFileSizesAfterBuild
+});
+module.exports = __toCommonJS(FileSizeReporter_exports);
+var import_fs = __toESM(require("fs"));
+var import_path = __toESM(require("path"));
+var import_compiled = require("./compiled");
+var import_logger = require("./logger");
+function canReadAsset(asset) {
+  return /\.(js|css)$/.test(asset) && !/service-worker\.js/.test(asset) && !/precache-manifest\.[0-9a-f]+\.js/.test(asset);
+}
+function printFileSizesAfterBuild(webpackStats, previousSizeMap, buildFolder, maxBundleGzipSize, maxChunkGzipSize) {
+  var root = previousSizeMap.root;
+  var sizes = previousSizeMap.sizes;
+  var assets = (webpackStats.stats || [webpackStats]).map(
+    (stats) => stats.toJson({ all: false, assets: true }).assets.filter((asset) => canReadAsset(asset.name)).map((asset) => {
+      var fileContents = import_fs.default.readFileSync(import_path.default.join(root, asset.name));
+      var size = fileContents.length;
+      var gzippedSize = import_compiled.gzipSize.sync(fileContents);
+      var [previousSize, previousGzipSize] = sizes[removeFileNameHash(root, asset.name)] || [];
+      var sizeDifference = getDifferenceLabel(size, previousSize);
+      var gzipSizeDifference = getDifferenceLabel(
+        gzippedSize,
+        previousGzipSize
+      );
+      return {
+        folder: import_path.default.join(
+          import_path.default.basename(buildFolder),
+          import_path.default.dirname(asset.name)
+        ),
+        name: import_path.default.basename(asset.name),
+        gzippedSize,
+        sizeLabel: (0, import_compiled.filesize)(size) + (sizeDifference ? " (" + sizeDifference + ")" : ""),
+        gzipSizeLabel: (0, import_compiled.filesize)(gzippedSize) + (gzipSizeDifference ? " (" + gzipSizeDifference + ")" : "")
+      };
+    })
+  ).reduce((single, all) => all.concat(single), []);
+  assets.sort((a, b) => b.size - a.size);
+  var longestSizeLabelLength = Math.max.apply(
+    null,
+    assets.map((a) => (0, import_compiled.stripAnsi)(a.sizeLabel).length)
+  );
+  var longestFileNameLength = Math.max.apply(
+    null,
+    assets.map((a) => (0, import_compiled.stripAnsi)(a.folder + import_path.default.sep + a.name).length)
+  );
+  printFileSizesHeader(longestFileNameLength, longestSizeLabelLength);
+  var suggestBundleSplitting = false;
+  assets.forEach((asset) => {
+    var { folder, name, sizeLabel, gzipSizeLabel, gzippedSize } = asset;
+    var fileNameLength = (0, import_compiled.stripAnsi)(folder + import_path.default.sep + name).length;
+    var sizeLength = (0, import_compiled.stripAnsi)(sizeLabel).length;
+    if (sizeLength < longestSizeLabelLength) {
+      var rightPadding = " ".repeat(longestSizeLabelLength - sizeLength);
+      sizeLabel += rightPadding;
+    }
+    var fileNameLabel = import_compiled.chalk.dim(asset.folder + import_path.default.sep) + import_compiled.chalk.cyan(asset.name);
+    if (fileNameLength < longestFileNameLength) {
+      var rightPadding = " ".repeat(longestFileNameLength - fileNameLength);
+      fileNameLabel += rightPadding;
+    }
+    var isMainBundle = asset.name.indexOf("main.") === 0;
+    var maxRecommendedSize = isMainBundle ? maxBundleGzipSize : maxChunkGzipSize;
+    var isLarge = maxRecommendedSize && gzippedSize > maxRecommendedSize;
+    if (isLarge && import_path.default.extname(asset.name) === ".js") {
+      suggestBundleSplitting = true;
+    }
+    import_logger.logger.log(
+      "  " + fileNameLabel + "    " + sizeLabel + "    " + (isLarge ? import_compiled.chalk.yellow(gzipSizeLabel) : gzipSizeLabel)
+    );
+  });
+  if (suggestBundleSplitting) {
+    import_logger.logger.log();
+    import_logger.logger.warn("The bundle size is significantly larger than recommended.");
+  }
+}
+function printFileSizesHeader(longestFileNameLength, longestSizeLabelLength) {
+  const longestLengths = [longestFileNameLength, longestSizeLabelLength];
+  const headerRow = ["File", "Size", "Gzipped"].reduce((prev, cur, index) => {
+    const length = longestLengths[index];
+    let curLabel = cur;
+    if (length) {
+      curLabel = cur.length < length ? cur + " ".repeat(length - cur.length) : cur;
+    }
+    return prev + curLabel + "    ";
+  }, "  ");
+  import_logger.logger.log(import_compiled.chalk.bold(import_compiled.chalk.blue(headerRow)));
+}
+function removeFileNameHash(buildFolder, fileName) {
+  return fileName.replace(buildFolder, "").replace(/\\/g, "/").replace(
+    /\/?(.*)(\.[0-9a-f]+)(\.chunk)?(\.js|\.css)/,
+    (match, p1, p2, p3, p4) => p1 + p4
+  );
+}
+function getDifferenceLabel(currentSize, previousSize) {
+  var FIFTY_KILOBYTES = 1024 * 50;
+  var difference = currentSize - previousSize;
+  var fileSize = !Number.isNaN(difference) ? (0, import_compiled.filesize)(difference) : 0;
+  if (difference >= FIFTY_KILOBYTES) {
+    return import_compiled.chalk.red("+" + fileSize);
+  } else if (difference < FIFTY_KILOBYTES && difference > 0) {
+    return import_compiled.chalk.yellow("+" + fileSize);
+  } else if (difference < 0) {
+    return import_compiled.chalk.green(fileSize);
+  } else {
+    return "";
+  }
+}
+function measureFileSizesBeforeBuild(buildFolder) {
+  return new Promise((resolve) => {
+    (0, import_compiled.recursiveReaddir)(buildFolder, (err, fileNames) => {
+      var sizes;
+      if (!err && fileNames) {
+        sizes = fileNames.filter(canReadAsset).reduce((memo, fileName) => {
+          var contents = import_fs.default.readFileSync(fileName);
+          var key = removeFileNameHash(buildFolder, fileName);
+          memo[key] = [contents.length, import_compiled.gzipSize.sync(contents)];
+          return memo;
+        }, {});
+      }
+      resolve({
+        root: buildFolder,
+        sizes: sizes || {}
+      });
+    });
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  measureFileSizesBeforeBuild,
+  printFileSizesAfterBuild
+});

package/dist/alias.d.ts

@@ -0,0 +1,25 @@
+export type Alias = Record<string, string | string[]>;
+export type AliasOption = Alias | ((aliases: Alias) => Alias | void);
+interface NormalizedConfig {
+  source: {
+    alias?: AliasOption | Array<AliasOption>;
+  };
+}
+interface IAliasConfig {
+  absoluteBaseUrl: string;
+  paths?: Record<string, string | string[]>;
+  isTsPath?: boolean;
+  isTsProject?: boolean;
+}
+export declare const validAlias: <T extends NormalizedConfig>(modernConfig: T, {
+  tsconfigPath
+}: {
+  tsconfigPath: string;
+}) => string | null;
+export declare const mergeAlias: (alias: NormalizedConfig['source']['alias']) => Alias;
+export declare const getAliasConfig: (aliasOption: NormalizedConfig['source']['alias'], option: {
+  appDirectory: string;
+  tsconfigPath: string;
+}) => IAliasConfig;
+export declare const getUserAlias: (alias?: Record<string, string | string[]>) => Record<string, string | string[]>;
+export {};

package/dist/alias.js

@@ -0,0 +1,108 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+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 alias_exports = {};
+__export(alias_exports, {
+  getAliasConfig: () => getAliasConfig,
+  getUserAlias: () => getUserAlias,
+  mergeAlias: () => mergeAlias,
+  validAlias: () => validAlias
+});
+module.exports = __toCommonJS(alias_exports);
+var import_fs = __toESM(require("fs"));
+var import_path = __toESM(require("path"));
+var import_compiled = require("./compiled");
+var import_readTsConfig = require("./readTsConfig");
+var import_applyOptionsChain = require("./applyOptionsChain");
+const validAlias = (modernConfig, { tsconfigPath }) => {
+  const {
+    source: { alias }
+  } = modernConfig;
+  if (!alias) {
+    return null;
+  }
+  const isTsProject = import_fs.default.existsSync(tsconfigPath);
+  if (!isTsProject) {
+    return null;
+  }
+  const userAlias = getUserAlias(alias);
+  if (Object.keys(userAlias).length > 0) {
+    return import_compiled.chalk.red(
+      'Note: Please use `compilerOptions.paths` in "tsconfig.json" file replace `source.alias` config in "modern.config.js/ts" when project is typescript'
+    );
+  }
+  return null;
+};
+const mergeAlias = (alias) => (0, import_applyOptionsChain.applyOptionsChain)({}, alias);
+const getAliasConfig = (aliasOption, option) => {
+  var _a, _b;
+  const isTsProject = import_fs.default.existsSync(option.tsconfigPath);
+  const alias = mergeAlias(aliasOption);
+  if (!isTsProject) {
+    return {
+      absoluteBaseUrl: option.appDirectory,
+      paths: alias,
+      isTsPath: false,
+      isTsProject
+    };
+  }
+  const tsconfig = (0, import_readTsConfig.readTsConfigByFile)(option.tsconfigPath);
+  const baseUrl = (_a = tsconfig == null ? void 0 : tsconfig.compilerOptions) == null ? void 0 : _a.baseUrl;
+  return {
+    absoluteBaseUrl: baseUrl ? import_path.default.join(option.appDirectory, baseUrl) : option.appDirectory,
+    paths: __spreadValues(__spreadValues({}, alias), (_b = tsconfig == null ? void 0 : tsconfig.compilerOptions) == null ? void 0 : _b.paths),
+    isTsPath: true,
+    isTsProject
+  };
+};
+const getUserAlias = (alias = {}) => Object.keys(alias).reduce((o, k) => {
+  if (Array.isArray(alias[k])) {
+    o[k] = alias[k];
+  }
+  return o;
+}, {});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getAliasConfig,
+  getUserAlias,
+  mergeAlias,
+  validAlias
+});

package/dist/analyzeProject.d.ts

@@ -0,0 +1,2 @@
+export declare const isApiOnly: (appDirectory: string, entryDir?: string) => Promise<boolean>;
+export declare const isWebOnly: () => Promise<boolean>;

package/dist/analyzeProject.js

@@ -0,0 +1,71 @@
+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 __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+var analyzeProject_exports = {};
+__export(analyzeProject_exports, {
+  isApiOnly: () => isApiOnly,
+  isWebOnly: () => isWebOnly
+});
+module.exports = __toCommonJS(analyzeProject_exports);
+var path = __toESM(require("path"));
+var import_commands = require("./commands");
+var import_compiled = require("./compiled");
+const isApiOnly = (appDirectory, entryDir) => __async(void 0, null, function* () {
+  const srcDir = path.join(appDirectory, entryDir != null ? entryDir : "src");
+  const existSrc = yield import_compiled.fs.pathExists(srcDir);
+  const options = (0, import_compiled.minimist)((0, import_commands.getArgv)());
+  return !existSrc || Boolean(options["api-only"]);
+});
+const isWebOnly = () => __async(void 0, null, function* () {
+  const options = (0, import_compiled.minimist)((0, import_commands.getArgv)());
+  return Boolean(options["web-only"]);
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  isApiOnly,
+  isWebOnly
+});

package/dist/applyOptionsChain.d.ts

@@ -0,0 +1,3 @@
+import type { Falsy } from './types';
+export declare function applyOptionsChain<T, U>(defaults: T, options?: T | ((config: T, utils?: U) => T | void) | Array<T | ((config: T, utils?: U) => T | void)> | Falsy, utils?: U, mergeFn?: typeof Object.assign): T;
+export declare function applyOptionsChain<T, U>(defaults: T, options: T | ((config: T, utils: U) => T | void) | Array<T | ((config: T, utils: U) => T | void)> | Falsy, utils: U, mergeFn?: typeof Object.assign): T;

package/dist/applyOptionsChain.js

@@ -0,0 +1,58 @@
+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 applyOptionsChain_exports = {};
+__export(applyOptionsChain_exports, {
+  applyOptionsChain: () => applyOptionsChain
+});
+module.exports = __toCommonJS(applyOptionsChain_exports);
+var import_index = require("./index");
+function applyOptionsChain(defaults, options, utils, mergeFn = Object.assign) {
+  if (!options) {
+    return defaults;
+  }
+  if ((0, import_index.isPlainObject)(options)) {
+    return mergeFn(defaults, options);
+  } else if ((0, import_index.isFunction)(options)) {
+    const ret = options(defaults, utils);
+    if (ret) {
+      if (!(0, import_index.isPlainObject)(ret)) {
+        import_index.logger.warn(
+          `${options.name}: Function should mutate the config and return nothing, Or return a cloned or merged version of config object.`
+        );
+      }
+      return ret;
+    }
+  } else if (Array.isArray(options)) {
+    return options.reduce(
+      (memo, cur) => applyOptionsChain(memo, cur, utils, mergeFn),
+      defaults
+    );
+  } else {
+    throw new Error(
+      `applyOptionsChain error:
+default options is: ${JSON.stringify(
+        defaults
+      )}`
+    );
+  }
+  return defaults;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  applyOptionsChain
+});

package/dist/babel.d.ts

@@ -0,0 +1,3 @@
+import { BabelConfig, BabelConfigUtils, BabelTransformOptions } from '@modern-js/types';
+export declare const getBabelUtils: (config: BabelTransformOptions) => BabelConfigUtils;
+export declare const applyUserBabelConfig: (defaultOptions: BabelTransformOptions, userBabelConfig?: BabelConfig | BabelConfig[], extraBabelUtils?: Partial<BabelConfigUtils>) => BabelTransformOptions;

package/dist/babel.js

@@ -0,0 +1,136 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+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 babel_exports = {};
+__export(babel_exports, {
+  applyUserBabelConfig: () => applyUserBabelConfig,
+  getBabelUtils: () => getBabelUtils
+});
+module.exports = __toCommonJS(babel_exports);
+var import_path = require("path");
+var import_applyOptionsChain = require("./applyOptionsChain");
+var import_ensureArray = require("./ensureArray");
+var import_path2 = require("./path");
+const formatPath = (originPath) => {
+  if ((0, import_path.isAbsolute)(originPath)) {
+    return originPath.split(import_path.sep).join("/");
+  }
+  return originPath;
+};
+const getPluginItemName = (item) => {
+  if (typeof item === "string") {
+    return formatPath(item);
+  }
+  if (Array.isArray(item) && typeof item[0] === "string") {
+    return formatPath(item[0]);
+  }
+  return null;
+};
+const addPlugins = (plugins, config) => {
+  if (config.plugins) {
+    config.plugins.push(...plugins);
+  } else {
+    config.plugins = plugins;
+  }
+};
+const addPresets = (presets, config) => {
+  if (config.presets) {
+    config.presets.push(...presets);
+  } else {
+    config.presets = presets;
+  }
+};
+const removePlugins = (plugins, config) => {
+  if (!config.plugins) {
+    return;
+  }
+  const removeList = (0, import_ensureArray.ensureArray)(plugins);
+  config.plugins = config.plugins.filter((item) => {
+    const name = getPluginItemName(item);
+    if (name) {
+      return !removeList.find((removeItem) => name.includes(removeItem));
+    }
+    return true;
+  });
+};
+const removePresets = (presets, config) => {
+  if (!config.presets) {
+    return;
+  }
+  const removeList = (0, import_ensureArray.ensureArray)(presets);
+  config.presets = config.presets.filter((item) => {
+    const name = getPluginItemName(item);
+    if (name) {
+      return !removeList.find((removeItem) => name.includes(removeItem));
+    }
+    return true;
+  });
+};
+const modifyPresetOptions = (presetName, options, presets = []) => {
+  presets.forEach((preset, index) => {
+    if (Array.isArray(preset)) {
+      if (typeof preset[0] === "string" && (0, import_path2.normalizeToPosixPath)(preset[0]).includes(presetName)) {
+        preset[1] = __spreadValues(__spreadValues({}, preset[1] || {}), options);
+      }
+    } else if (typeof preset === "string" && (0, import_path2.normalizeToPosixPath)(preset).includes(presetName)) {
+      presets[index] = [preset, options];
+    }
+  });
+};
+const getBabelUtils = (config) => {
+  const noop = () => {
+  };
+  return {
+    addPlugins: (plugins) => addPlugins(plugins, config),
+    addPresets: (presets) => addPresets(presets, config),
+    removePlugins: (plugins) => removePlugins(plugins, config),
+    removePresets: (presets) => removePresets(presets, config),
+    // `addIncludes` and `addExcludes` are noop functions by default,
+    // It can be overridden by `extraBabelUtils`.
+    addIncludes: noop,
+    addExcludes: noop,
+    // Compat `presetEnvOptions` and `presetReactOptions` in Eden.
+    modifyPresetEnvOptions: (options) => modifyPresetOptions("@babel/preset-env", options, config.presets || []),
+    modifyPresetReactOptions: (options) => modifyPresetOptions("@babel/preset-react", options, config.presets || [])
+  };
+};
+const applyUserBabelConfig = (defaultOptions, userBabelConfig, extraBabelUtils) => {
+  if (userBabelConfig) {
+    const babelUtils = __spreadValues(__spreadValues({}, getBabelUtils(defaultOptions)), extraBabelUtils);
+    return (0, import_applyOptionsChain.applyOptionsChain)(defaultOptions, userBabelConfig || {}, babelUtils);
+  }
+  return defaultOptions;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  applyUserBabelConfig,
+  getBabelUtils
+});