@umijs/bundler-webpack 4.2.6-alpha.6 → 4.2.6

package/dist/build.d.ts

@@ -0,0 +1,22 @@
+import webpack from '../compiled/webpack';
+import type { IOpts as IConfigOpts } from './config/config';
+import { IConfig } from './types';
+declare type IOpts = {
+    cwd: string;
+    rootDir?: string;
+    entry: Record<string, string>;
+    config: IConfig;
+    onBuildComplete?: Function;
+    babelPreset?: any;
+    chainWebpack?: Function;
+    modifyWebpackConfig?: Function;
+    beforeBabelPlugins?: any[];
+    beforeBabelPresets?: any[];
+    extraBabelPlugins?: any[];
+    extraBabelPresets?: any[];
+    clean?: boolean;
+    watch?: boolean;
+    disableCopy?: boolean;
+} & Pick<IConfigOpts, 'cache' | 'pkg'>;
+export declare function build(opts: IOpts): Promise<webpack.Stats>;
+export {};

package/dist/build.js

@@ -0,0 +1,151 @@
+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);
+
+// src/build.ts
+var build_exports = {};
+__export(build_exports, {
+  build: () => build
+});
+module.exports = __toCommonJS(build_exports);
+var import_utils = require("@umijs/utils");
+var import_path = require("path");
+var import_webpack = __toESM(require("../compiled/webpack"));
+var import_types = require("./types");
+var configModule = (0, import_utils.importLazy)(
+  require.resolve("./config/config")
+);
+async function build(opts) {
+  const cacheDirectoryPath = (0, import_path.resolve)(
+    opts.rootDir || opts.cwd,
+    opts.config.cacheDirectoryPath || "node_modules/.cache"
+  );
+  const webpackConfig = await configModule.getConfig({
+    cwd: opts.cwd,
+    rootDir: opts.rootDir,
+    env: import_types.Env.production,
+    entry: opts.entry,
+    userConfig: opts.config,
+    analyze: process.env.ANALYZE,
+    babelPreset: opts.babelPreset,
+    extraBabelPlugins: [
+      ...opts.beforeBabelPlugins || [],
+      ...opts.extraBabelPlugins || []
+    ],
+    extraBabelPresets: [
+      ...opts.beforeBabelPresets || [],
+      ...opts.extraBabelPresets || []
+    ],
+    extraBabelIncludes: opts.config.extraBabelIncludes,
+    chainWebpack: opts.chainWebpack,
+    modifyWebpackConfig: opts.modifyWebpackConfig,
+    cache: opts.cache ? {
+      ...opts.cache,
+      cacheDirectory: (0, import_path.join)(cacheDirectoryPath, "bundler-webpack")
+    } : void 0,
+    pkg: opts.pkg,
+    disableCopy: opts.disableCopy
+  });
+  let isFirstCompile = true;
+  return new Promise((resolve2, reject) => {
+    if (opts.clean) {
+      import_utils.rimraf.sync(webpackConfig.output.path);
+    }
+    const compiler = (0, import_webpack.default)(webpackConfig);
+    let closeWatching;
+    const handler = async (err, stats) => {
+      var _a;
+      const validErr = err || ((stats == null ? void 0 : stats.hasErrors()) ? new Error(stats.toString("errors-only")) : null);
+      await ((_a = opts.onBuildComplete) == null ? void 0 : _a.call(opts, {
+        err: validErr,
+        stats,
+        isFirstCompile,
+        time: stats ? stats.endTime - stats.startTime : null,
+        // pass close function to close watching
+        ...opts.watch ? { close: closeWatching } : {}
+      }));
+      isFirstCompile = false;
+      if (validErr) {
+        (stats == null ? void 0 : stats.hasErrors()) && esbuildCompressErrorHelper(validErr.toString());
+        reject(validErr);
+      } else {
+        resolve2(stats);
+      }
+      if (!opts.watch)
+        compiler.close(() => {
+        });
+    };
+    if (opts.watch) {
+      const watching = compiler.watch(
+        webpackConfig.watchOptions || {},
+        handler
+      );
+      closeWatching = watching.close.bind(watching);
+    } else {
+      compiler.run(handler);
+    }
+  });
+}
+function esbuildCompressErrorHelper(errorMsg) {
+  if (typeof errorMsg !== "string")
+    return;
+  if (
+    // https://github.com/evanw/esbuild/blob/a5f781ecd5edeb3fb6ae8d1045507ab850462614/internal/js_parser/js_parser_lower.go#L18
+    errorMsg.includes("configured target environment") && errorMsg.includes("es2015")
+  ) {
+    const terserRecommend = {
+      label: import_utils.chalk.green("change jsMinifier"),
+      details: import_utils.chalk.cyan(`  jsMinifier: 'terser'`)
+    };
+    const upgradeTargetRecommend = {
+      label: import_utils.chalk.green("upgrade target"),
+      details: import_utils.chalk.cyan(`  jsMinifierOptions: {
+    target: ['chrome80', 'es2020']
+  }`)
+    };
+    const ieRecommend = {
+      details: `P.S. compatible with legacy browsers: https://umijs.org/blog/legacy-browser`
+    };
+    console.log();
+    console.log(import_utils.chalk.bgRed(" COMPRESSION ERROR "));
+    console.log(
+      import_utils.chalk.yellow(
+        `esbuild minify failed, please ${terserRecommend.label} or ${upgradeTargetRecommend.label}:`
+      )
+    );
+    console.log("e.g. ");
+    console.log(terserRecommend.details);
+    console.log("   or");
+    console.log(upgradeTargetRecommend.details);
+    console.log(ieRecommend.details);
+    console.log();
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  build
+});

package/dist/cli.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/cli.js

@@ -0,0 +1,96 @@
+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 __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
+));
+
+// src/cli.ts
+var import_esbuild = __toESM(require("@umijs/bundler-utils/compiled/esbuild"));
+var import_utils = require("@umijs/utils");
+var import_assert = __toESM(require("assert"));
+var import_fs = require("fs");
+var import_path = require("path");
+var import_build = require("./build");
+var import_dev = require("./dev");
+var args = (0, import_utils.yParser)(process.argv.slice(2), {});
+var command = args._[0];
+var cwd = process.cwd();
+var entry = (0, import_utils.tryPaths)([
+  (0, import_path.join)(cwd, "src/index.tsx"),
+  (0, import_path.join)(cwd, "src/index.ts"),
+  (0, import_path.join)(cwd, "index.tsx"),
+  (0, import_path.join)(cwd, "index.ts")
+]);
+var config = {};
+var configFile = (0, import_path.resolve)(cwd, args.config || "config.ts");
+import_utils.register.register({
+  implementor: import_esbuild.default
+});
+import_utils.register.clearFiles();
+if ((0, import_fs.existsSync)(configFile)) {
+  require("./requireHook");
+  config = require(configFile).default;
+}
+Object.assign(config, args);
+if (command === "build") {
+  (async () => {
+    process.env.NODE_ENV = "production";
+    (0, import_assert.default)(entry, `Build failed: entry not found.`);
+    try {
+      await (0, import_build.build)({
+        config,
+        cwd,
+        entry: {
+          [getEntryKey(entry)]: entry
+        }
+      });
+    } catch (e) {
+      console.error(e);
+    }
+  })();
+} else if (command === "dev") {
+  (async () => {
+    process.env.NODE_ENV = "development";
+    try {
+      (0, import_assert.default)(entry, `Build failed: entry not found.`);
+      await (0, import_dev.dev)({
+        config,
+        cwd,
+        port: process.env.PORT,
+        entry: {
+          [getEntryKey(entry)]: entry
+        },
+        cache: {
+          buildDependencies: [].filter(Boolean)
+        }
+      });
+    } catch (e) {
+      console.error(e);
+    }
+  })();
+} else {
+  error(`Unsupported command ${command}.`);
+}
+function error(msg) {
+  console.error(import_utils.chalk.red(msg));
+}
+function getEntryKey(path) {
+  return (0, import_path.basename)(path, (0, import_path.extname)(path));
+}

package/dist/config/_sampleFeature.d.ts

@@ -0,0 +1,10 @@
+import Config from '@umijs/bundler-webpack/compiled/webpack-5-chain';
+import { Env, IConfig } from '../types';
+interface IOpts {
+    config: Config;
+    userConfig: IConfig;
+    cwd: string;
+    env: Env;
+}
+export declare function addSampleFeature(opts: IOpts): Promise<void>;
+export {};

package/dist/config/_sampleFeature.js

@@ -0,0 +1,35 @@
+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);
+
+// src/config/_sampleFeature.ts
+var sampleFeature_exports = {};
+__export(sampleFeature_exports, {
+  addSampleFeature: () => addSampleFeature
+});
+module.exports = __toCommonJS(sampleFeature_exports);
+async function addSampleFeature(opts) {
+  const { config, userConfig, cwd, env } = opts;
+  config;
+  userConfig;
+  cwd;
+  env;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  addSampleFeature
+});

package/dist/config/assetRules.d.ts

@@ -0,0 +1,11 @@
+import Config from '@umijs/bundler-webpack/compiled/webpack-5-chain';
+import { Env, IConfig } from '../types';
+interface IOpts {
+    config: Config;
+    userConfig: IConfig;
+    cwd: string;
+    env: Env;
+    staticPathPrefix: string;
+}
+export declare function addAssetRules(opts: IOpts): Promise<void>;
+export {};

package/dist/config/assetRules.js

@@ -0,0 +1,48 @@
+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);
+
+// src/config/assetRules.ts
+var assetRules_exports = {};
+__export(assetRules_exports, {
+  addAssetRules: () => addAssetRules
+});
+module.exports = __toCommonJS(assetRules_exports);
+async function addAssetRules(opts) {
+  const { config, userConfig } = opts;
+  const inlineLimit = userConfig.inlineLimit;
+  const rule = config.module.rule("asset");
+  rule.oneOf("avif").test(/\.avif$/).type("asset").mimetype("image/avif").parser({
+    dataUrlCondition: {
+      maxSize: inlineLimit
+    }
+  });
+  rule.oneOf("image").test(/\.(bmp|gif|jpg|jpeg|png)$/).type("asset").parser({
+    dataUrlCondition: {
+      maxSize: inlineLimit
+    }
+  });
+  const fallback = rule.oneOf("fallback").exclude.add(/^$/).add(/\.(js|mjs|cjs|jsx|ts|tsx)$/).add(/\.(css|less|sass|scss|styl|stylus)$/).add(/\.html$/).add(/\.json$/);
+  if (userConfig.mdx) {
+    fallback.add(/\.mdx?$/);
+  }
+  fallback.end().type("asset/resource");
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  addAssetRules
+});

package/dist/config/bundleAnalyzerPlugin.d.ts

@@ -0,0 +1,10 @@
+import Config from '@umijs/bundler-webpack/compiled/webpack-5-chain';
+import { Env, IConfig } from '../types';
+interface IOpts {
+    config: Config;
+    userConfig: IConfig;
+    cwd: string;
+    env: Env;
+}
+export declare function addBundleAnalyzerPlugin(opts: IOpts): Promise<void>;
+export {};

package/dist/config/bundleAnalyzerPlugin.js

@@ -0,0 +1,43 @@
+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);
+
+// src/config/bundleAnalyzerPlugin.ts
+var bundleAnalyzerPlugin_exports = {};
+__export(bundleAnalyzerPlugin_exports, {
+  addBundleAnalyzerPlugin: () => addBundleAnalyzerPlugin
+});
+module.exports = __toCommonJS(bundleAnalyzerPlugin_exports);
+var import_webpack_bundle_analyzer = require("@umijs/bundler-webpack/compiled/webpack-bundle-analyzer");
+async function addBundleAnalyzerPlugin(opts) {
+  const { config } = opts;
+  config.plugin("webpack-bundle-analyzer").use(import_webpack_bundle_analyzer.BundleAnalyzerPlugin, [
+    // https://github.com/webpack-contrib/webpack-bundle-analyzer
+    {
+      analyzerMode: "server",
+      analyzerPort: process.env.ANALYZE_PORT || 8888,
+      openAnalyzer: false,
+      logLevel: "info",
+      defaultSizes: "parsed",
+      ...opts.userConfig.analyze
+    }
+  ]);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  addBundleAnalyzerPlugin
+});

package/dist/config/compressPlugin.d.ts

@@ -0,0 +1,10 @@
+import Config from '../../compiled/webpack-5-chain';
+import { Env, IConfig } from '../types';
+interface IOpts {
+    config: Config;
+    userConfig: IConfig;
+    cwd: string;
+    env: Env;
+}
+export declare function addCompressPlugin(opts: IOpts): Promise<void>;
+export {};

package/dist/config/compressPlugin.js

@@ -0,0 +1,128 @@
+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);
+
+// src/config/compressPlugin.ts
+var compressPlugin_exports = {};
+__export(compressPlugin_exports, {
+  addCompressPlugin: () => addCompressPlugin
+});
+module.exports = __toCommonJS(compressPlugin_exports);
+var import_css_minimizer_webpack_plugin = __toESM(require("@umijs/bundler-webpack/compiled/css-minimizer-webpack-plugin"));
+var import_terser_webpack_plugin = __toESM(require("../../compiled/terser-webpack-plugin"));
+var import_EsbuildMinifyFix = require("../plugins/EsbuildMinifyFix");
+var import_types = require("../types");
+var import_getEsBuildTarget = require("../utils/getEsBuildTarget");
+async function addCompressPlugin(opts) {
+  const { config, userConfig, env } = opts;
+  const jsMinifier = userConfig.jsMinifier || import_types.JSMinifier.esbuild;
+  const cssMinifier = userConfig.cssMinifier || import_types.CSSMinifier.esbuild;
+  if (env === import_types.Env.development || process.env.COMPRESS === "none" || jsMinifier === import_types.JSMinifier.none && cssMinifier === import_types.CSSMinifier.none) {
+    config.optimization.minimize(false);
+    return;
+  }
+  config.optimization.minimize(true);
+  const esbuildTarget = (0, import_getEsBuildTarget.getEsBuildTarget)({
+    targets: userConfig.targets || {},
+    jsMinifier
+  });
+  if (!esbuildTarget.includes("es2015")) {
+    esbuildTarget.push("es2015");
+  }
+  let minify;
+  let terserOptions;
+  if (jsMinifier === import_types.JSMinifier.esbuild) {
+    minify = import_terser_webpack_plugin.default.esbuildMinify;
+    terserOptions = {
+      target: esbuildTarget,
+      // remove all comments
+      legalComments: "none"
+    };
+    if (userConfig.esbuildMinifyIIFE) {
+      config.plugin("EsbuildMinifyFix").use(import_EsbuildMinifyFix.EsbuildMinifyFix);
+    }
+  } else if (jsMinifier === import_types.JSMinifier.terser) {
+    minify = import_terser_webpack_plugin.default.terserMinify;
+    terserOptions = {
+      format: {
+        comments: false
+      }
+    };
+  } else if (jsMinifier === import_types.JSMinifier.swc) {
+    minify = import_terser_webpack_plugin.default.swcMinify;
+  } else if (jsMinifier === import_types.JSMinifier.uglifyJs) {
+    minify = import_terser_webpack_plugin.default.uglifyJsMinify;
+    terserOptions = {
+      output: {
+        comments: false
+      }
+    };
+  } else if (jsMinifier !== import_types.JSMinifier.none) {
+    throw new Error(`Unsupported jsMinifier ${userConfig.jsMinifier}.`);
+  }
+  terserOptions = {
+    ...terserOptions,
+    ...userConfig.jsMinifierOptions
+  };
+  if (jsMinifier !== import_types.JSMinifier.none) {
+    config.optimization.minimizer(`js-${jsMinifier}`).use(import_terser_webpack_plugin.default, [
+      {
+        extractComments: false,
+        minify,
+        terserOptions
+      }
+    ]);
+  }
+  let cssMinify;
+  let minimizerOptions;
+  if (cssMinifier === import_types.CSSMinifier.esbuild) {
+    cssMinify = import_css_minimizer_webpack_plugin.default.esbuildMinify;
+    minimizerOptions = {
+      target: esbuildTarget
+    };
+  } else if (cssMinifier === import_types.CSSMinifier.cssnano) {
+    cssMinify = import_css_minimizer_webpack_plugin.default.cssnanoMinify;
+  } else if (cssMinifier === import_types.CSSMinifier.parcelCSS) {
+    cssMinify = import_css_minimizer_webpack_plugin.default.lightningCssMinify;
+  } else if (cssMinifier !== import_types.CSSMinifier.none) {
+    throw new Error(`Unsupported cssMinifier ${userConfig.cssMinifier}.`);
+  }
+  minimizerOptions = {
+    ...minimizerOptions,
+    ...userConfig.cssMinifierOptions
+  };
+  config.optimization.minimizer(`css-${cssMinifier}`).use(import_css_minimizer_webpack_plugin.default, [
+    {
+      minify: cssMinify,
+      minimizerOptions
+    }
+  ]);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  addCompressPlugin
+});

package/dist/config/config.d.ts

@@ -0,0 +1,31 @@
+import { Configuration } from '../../compiled/webpack';
+import { Env, IConfig } from '../types';
+export interface IOpts {
+    cwd: string;
+    rootDir?: string;
+    env: Env;
+    entry: Record<string, string>;
+    extraBabelPresets?: any[];
+    extraBabelPlugins?: any[];
+    extraBabelIncludes?: Array<string | RegExp>;
+    extraEsbuildLoaderHandler?: any[];
+    babelPreset?: any;
+    chainWebpack?: Function;
+    modifyWebpackConfig?: Function;
+    hash?: boolean;
+    hmr?: boolean;
+    staticPathPrefix?: string;
+    userConfig: IConfig;
+    analyze?: any;
+    name?: string;
+    cache?: {
+        absNodeModulesPath?: string;
+        buildDependencies?: string[];
+        cacheDirectory?: string;
+    };
+    pkg?: Record<string, any>;
+    disableCopy?: boolean;
+    host?: string;
+    port?: number;
+}
+export declare function getConfig(opts: IOpts): Promise<Configuration>;