@modern-js/app-tools 2.0.0-beta.1 → 2.0.0-beta.3

package/dist/js/treeshaking/config/initial/createHtmlConfig.js

@@ -0,0 +1,31 @@
+export function createHtmlConfig(config) {
+  var _config$output = config.output,
+    disableHtmlFolder = _config$output.disableHtmlFolder,
+    favicon = _config$output.favicon,
+    faviconByEntries = _config$output.faviconByEntries,
+    inject = _config$output.inject,
+    injectByEntries = _config$output.injectByEntries,
+    meta = _config$output.meta,
+    metaByEntries = _config$output.metaByEntries,
+    mountId = _config$output.mountId,
+    title = _config$output.title,
+    titleByEntries = _config$output.titleByEntries,
+    templateParameters = _config$output.templateParameters,
+    templateParametersByEntries = _config$output.templateParametersByEntries,
+    crossorigin = _config$output.crossorigin;
+  return {
+    disableHtmlFolder: disableHtmlFolder,
+    favicon: favicon,
+    faviconByEntries: faviconByEntries,
+    inject: inject,
+    injectByEntries: injectByEntries,
+    meta: meta,
+    metaByEntries: metaByEntries,
+    mountId: mountId,
+    title: title,
+    titleByEntries: titleByEntries,
+    crossorigin: crossorigin,
+    templateParameters: templateParameters,
+    templateParametersByEntries: templateParametersByEntries
+  };
+}

package/dist/js/treeshaking/config/initial/createOutputConfig.js

@@ -0,0 +1,70 @@
+export function createOutputConfig(config) {
+  var _config$output = config.output,
+    assetPrefix = _config$output.assetPrefix,
+    copy = _config$output.copy,
+    cssModuleLocalIdentName = _config$output.cssModuleLocalIdentName,
+    cssPath = _config$output.cssPath,
+    jsPath = _config$output.jsPath,
+    htmlPath = _config$output.htmlPath,
+    mediaPath = _config$output.mediaPath,
+    enableTsLoader = _config$output.enableTsLoader,
+    path = _config$output.path,
+    disableInlineRuntimeChunk = _config$output.disableInlineRuntimeChunk,
+    disableCssExtract = _config$output.disableCssExtract,
+    disableMinimize = _config$output.disableMinimize,
+    disableSourceMap = _config$output.disableSourceMap,
+    disableTsChecker = _config$output.disableTsChecker,
+    enableCssModuleTSDeclaration = _config$output.enableCssModuleTSDeclaration,
+    enableInlineScripts = _config$output.enableInlineScripts,
+    enableInlineStyles = _config$output.enableInlineStyles,
+    polyfill = _config$output.polyfill,
+    dataUriLimit = _config$output.dataUriLimit,
+    disableAssetsCache = _config$output.disableAssetsCache,
+    enableLatestDecorators = _config$output.enableLatestDecorators,
+    disableCssModuleExtension = _config$output.disableCssModuleExtension,
+    ssg = _config$output.ssg,
+    enableModernMode = _config$output.enableModernMode,
+    disableNodePolyfill = _config$output.disableNodePolyfill;
+  return {
+    assetPrefix: assetPrefix,
+    copy: copy,
+    distPath: {
+      root: path,
+      css: cssPath,
+      js: jsPath,
+      html: htmlPath,
+      // `@modern-js/webpack` output all media files to `dist/media` by default
+      svg: mediaPath || 'media',
+      image: mediaPath || 'media',
+      font: mediaPath || 'media',
+      media: mediaPath || 'media'
+    },
+    dataUriLimit: {
+      svg: dataUriLimit,
+      image: dataUriLimit,
+      font: dataUriLimit,
+      media: dataUriLimit
+    },
+    disableCssExtract: disableCssExtract,
+    disableCssModuleExtension: disableCssModuleExtension,
+    disableInlineRuntimeChunk: disableInlineRuntimeChunk,
+    disableMinimize: disableMinimize,
+    disableSourceMap: disableSourceMap,
+    disableTsChecker: disableTsChecker || enableTsLoader,
+    enableCssModuleTSDeclaration: enableCssModuleTSDeclaration,
+    enableInlineScripts: enableInlineScripts,
+    enableInlineStyles: enableInlineStyles,
+    polyfill: polyfill,
+    disableFilenameHash: disableAssetsCache,
+    enableLatestDecorators: enableLatestDecorators,
+    filename: {
+      css: cssModuleLocalIdentName
+    },
+    ssg: ssg,
+    // set `true`, only in legacy config
+    enableAssetFallback: true,
+    enableAssetManifest: true,
+    enableModernMode: enableModernMode,
+    disableNodePolyfill: disableNodePolyfill
+  };
+}

package/dist/js/treeshaking/config/initial/createSourceConfig.js

@@ -0,0 +1,41 @@
+import _createForOfIteratorHelper from "@babel/runtime/helpers/esm/createForOfIteratorHelper";
+export function createSourceConfig(config) {
+  var _config$source = config.source,
+    alias = _config$source.alias,
+    envVars = _config$source.envVars,
+    globalVars = _config$source.globalVars,
+    include = _config$source.include,
+    moduleScopes = _config$source.moduleScopes,
+    preEntry = _config$source.preEntry,
+    entries = _config$source.entries,
+    enableAsyncEntry = _config$source.enableAsyncEntry,
+    disableDefaultEntries = _config$source.disableDefaultEntries,
+    entriesDir = _config$source.entriesDir,
+    configDir = _config$source.configDir;
+  var builderGlobalVars = globalVars || {};
+  var _iterator = _createForOfIteratorHelper(envVars || []),
+    _step;
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var envVar = _step.value;
+      var envVarValue = process.env[envVar];
+      envVarValue && (builderGlobalVars["process.env.".concat(envVar)] = envVarValue);
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+  return {
+    alias: alias,
+    moduleScopes: moduleScopes,
+    globalVars: builderGlobalVars,
+    include: include,
+    preEntry: preEntry,
+    entries: entries,
+    enableAsyncEntry: enableAsyncEntry,
+    disableDefaultEntries: disableDefaultEntries,
+    entriesDir: entriesDir,
+    configDir: configDir
+  };
+}

package/dist/js/treeshaking/config/initial/createToolsConfig.js

@@ -0,0 +1,38 @@
+export function createToolsConfig(config) {
+  var _config$tools = config.tools,
+    autoprefixer = _config$tools.autoprefixer,
+    babel = _config$tools.babel,
+    minifyCss = _config$tools.minifyCss,
+    terser = _config$tools.terser,
+    webpack = _config$tools.webpack,
+    webpackChain = _config$tools.webpackChain,
+    tsLoader = _config$tools.tsLoader,
+    styledComponents = _config$tools.styledComponents,
+    sass = _config$tools.sass,
+    postcss = _config$tools.postcss,
+    less = _config$tools.less,
+    htmlPlugin = _config$tools.htmlPlugin,
+    devServer = _config$tools.devServer,
+    tailwindcss = _config$tools.tailwindcss,
+    jest = _config$tools.jest,
+    esbuild = _config$tools.esbuild;
+  var enableTsLoader = config.output.enableTsLoader;
+  return {
+    tsLoader: enableTsLoader ? tsLoader : undefined,
+    autoprefixer: autoprefixer,
+    babel: babel,
+    minifyCss: minifyCss,
+    terser: terser,
+    webpack: webpack,
+    webpackChain: webpackChain,
+    styledComponents: styledComponents,
+    sass: sass,
+    postcss: postcss,
+    less: less,
+    htmlPlugin: htmlPlugin,
+    devServer: devServer,
+    tailwindcss: tailwindcss,
+    jest: jest,
+    esbuild: esbuild
+  };
+}

package/dist/js/treeshaking/config/initial/index.js

@@ -0,0 +1,11 @@
+import { initHtmlConfig, initSourceConfig, initToolsConfig } from "./inits";
+export { transformNormalizedConfig } from "./transformNormalizedConfig";
+export function checkIsLegacyConfig(config) {
+  return Boolean(config.legacy);
+}
+export function initialNormalizedConfig(config, appContext) {
+  initHtmlConfig(config, appContext);
+  initSourceConfig(config, appContext);
+  initToolsConfig(config);
+  return config;
+}

package/dist/js/treeshaking/config/initial/inits.js

@@ -0,0 +1,114 @@
+import _typeof from "@babel/runtime/helpers/esm/typeof";
+import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
+import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
+import path, { dirname, isAbsolute, posix, sep } from 'path';
+import { applyOptionsChain, findExists, findMonorepoRoot, globby, isModernjsMonorepo } from '@modern-js/utils';
+export function initHtmlConfig(config, appContext) {
+  var ICON_EXTENSIONS = ['png', 'jpg', 'jpeg', 'svg', 'ico'];
+  config.html.appIcon = createBuilderAppIcon(config, appContext);
+  config.html.favicon = createBuilderFavicon(config, appContext);
+  return config.html;
+  function createBuilderAppIcon(config, appContext) {
+    var configDir = config.source.configDir;
+    var appIcon = findExists(ICON_EXTENSIONS.map(function (ext) {
+      return path.resolve(appContext.appDirectory, configDir || './config', "icon.".concat(ext));
+    }));
+    return typeof appIcon === 'string' ? appIcon : undefined;
+  }
+  function createBuilderFavicon(config, appContext) {
+    var configDir = config.source.configDir;
+    var favicon = config.html.favicon;
+    var defaultFavicon = findExists(ICON_EXTENSIONS.map(function (ext) {
+      return path.resolve(appContext.appDirectory, configDir || './config', "favicon.".concat(ext));
+    }));
+    return favicon || defaultFavicon || undefined;
+  }
+}
+export function initSourceConfig(config, appContext) {
+  config.source.include = createBuilderInclude(config, appContext);
+  config.source.moduleScopes = createBuilderModuleScope(config);
+  function createBuilderInclude(config, appContext) {
+    var include = config.source.include;
+    var defaultInclude = [appContext.internalDirectory];
+    var transformInclude = (include || []).map(function (include) {
+      if (typeof include === 'string') {
+        if (isAbsolute(include)) {
+          return include;
+        }
+        return new RegExp(include);
+      }
+      return include;
+    }).concat(defaultInclude); // concat default Include
+
+    var root = findMonorepoRoot(appContext.appDirectory);
+    if (!root) {
+      return transformInclude;
+    }
+    var modernjsMonorepo = isModernjsMonorepo(root);
+    if (modernjsMonorepo) {
+      var paths = globby.sync(posix.join(root, 'features', '**', 'package.json'), {
+        ignore: ['**/node_modules/**/*']
+      }).map(function (pathname) {
+        return dirname(pathname) + sep;
+      });
+      return [].concat(_toConsumableArray(paths), _toConsumableArray(transformInclude));
+    }
+    return transformInclude;
+  }
+  function createBuilderModuleScope(config) {
+    var moduleScopes = config.source.moduleScopes;
+    if (moduleScopes) {
+      var builderModuleScope = [];
+      var DEFAULT_SCOPES = ['./src', './shared', /node_modules/];
+      if (Array.isArray(moduleScopes)) {
+        if (isPrimitiveScope(moduleScopes)) {
+          builderModuleScope = DEFAULT_SCOPES.concat(moduleScopes);
+        } else {
+          builderModuleScope = [DEFAULT_SCOPES].concat(_toConsumableArray(moduleScopes));
+        }
+      } else {
+        builderModuleScope = [DEFAULT_SCOPES, moduleScopes];
+      }
+      return builderModuleScope;
+    } else {
+      return undefined;
+    }
+    function isPrimitiveScope(items) {
+      return items.every(function (item) {
+        return typeof item === 'string' || Object.prototype.toString.call(item) === '[object RegExp]';
+      });
+    }
+  }
+}
+export function initToolsConfig(config) {
+  var defaultTsChecker = {
+    issue: {
+      include: [{
+        file: '**/src/**/*'
+      }],
+      exclude: [{
+        file: '**/*.(spec|test).ts'
+      }, {
+        file: '**/node_modules/**/*'
+      }]
+    }
+  };
+  var _config$tools = config.tools,
+    tsChecker = _config$tools.tsChecker,
+    tsLoader = _config$tools.tsLoader,
+    htmlPlugin = _config$tools.htmlPlugin;
+  config.tools.tsChecker = applyOptionsChain(defaultTsChecker, tsChecker);
+  tsLoader && (config.tools.tsLoader = function (tsLoaderConfig, utils) {
+    applyOptionsChain(_objectSpread(_objectSpread({}, tsLoaderConfig), {}, {
+      transpileOnly: false,
+      allowTsInNodeModules: true
+    }), tsLoader || {}, utils);
+  });
+  config.tools.htmlPlugin = [function (config) {
+    return _objectSpread(_objectSpread({}, config), {}, {
+      minify: _typeof(config.minify) === 'object' ? _objectSpread(_objectSpread({}, config.minify), {}, {
+        removeComments: false
+      }) : config.minify
+    });
+  }].concat(_toConsumableArray(Array.isArray(htmlPlugin) ? htmlPlugin : htmlPlugin ? [htmlPlugin] : []));
+}

package/dist/js/treeshaking/config/initial/transformNormalizedConfig.js

@@ -0,0 +1,38 @@
+import { createToolsConfig } from "./createToolsConfig";
+import { createSourceConfig } from "./createSourceConfig";
+import { createOutputConfig } from "./createOutputConfig";
+import { createHtmlConfig } from "./createHtmlConfig";
+export function transformNormalizedConfig(config) {
+  var html = createHtmlConfig(config);
+  var output = createOutputConfig(config);
+  var source = createSourceConfig(config);
+  var tools = createToolsConfig(config);
+  var bff = config.bff,
+    dev = config.dev,
+    deploy = config.deploy,
+    runtime = config.runtime,
+    runtimeByEntries = config.runtimeByEntries,
+    server = config.server,
+    cliOptions = config.cliOptions,
+    plugins = config.plugins,
+    testing = config.testing;
+  return {
+    source: source,
+    html: html,
+    output: output,
+    tools: tools,
+    bff: bff,
+    dev: dev,
+    deploy: deploy,
+    runtime: runtime,
+    runtimeByEntries: runtimeByEntries,
+    server: server,
+    cliOptions: cliOptions,
+    testing: testing,
+    plugins: plugins,
+    security: {},
+    _raw: {},
+    experiments: {},
+    performance: {}
+  };
+}

package/dist/js/treeshaking/defineConfig.js

@@ -0,0 +1,14 @@
+import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
+export var defineConfig = function defineConfig(config) {
+  return config;
+};
+
+/**
+ * @deprecated
+ * Using defineConfig first.
+ */
+export var defineLegacyConfig = function defineLegacyConfig(config) {
+  return _objectSpread(_objectSpread({}, config), {}, {
+    legacy: true
+  });
+};

package/dist/js/treeshaking/hooks.js

@@ -1,21 +1,25 @@
-import { createAsyncWaterfall, createAsyncWorkflow } from '@modern-js/plugin';
-export var beforeDev = createAsyncWorkflow();
-export var afterDev = createAsyncWorkflow();
-export var beforeCreateCompiler = createAsyncWorkflow();
-export var afterCreateCompiler = createAsyncWorkflow();
-export var beforePrintInstructions = createAsyncWaterfall();
-export var beforeBuild = createAsyncWorkflow();
-export var afterBuild = createAsyncWorkflow();
-export var beforeDeploy = createAsyncWorkflow();
-export var afterDeploy = createAsyncWorkflow();
+import { createAsyncWaterfall, createAsyncWorkflow, createParallelWorkflow } from '@modern-js/plugin';
 export var hooks = {
-  beforeDev: beforeDev,
-  afterDev: afterDev,
-  beforeCreateCompiler: beforeCreateCompiler,
-  afterCreateCompiler: afterCreateCompiler,
-  beforePrintInstructions: beforePrintInstructions,
-  beforeBuild: beforeBuild,
-  afterBuild: afterBuild,
-  beforeDeploy: beforeDeploy,
-  afterDeploy: afterDeploy
+  modifyEntryExport: createAsyncWaterfall(),
+  modifyEntryImports: createAsyncWaterfall(),
+  modifyEntryRuntimePlugins: createAsyncWaterfall(),
+  modifyEntryRenderFunction: createAsyncWaterfall(),
+  modifyAsyncEntry: createAsyncWaterfall(),
+  modifyFileSystemRoutes: createAsyncWaterfall(),
+  modifyServerRoutes: createAsyncWaterfall(),
+  htmlPartials: createAsyncWaterfall(),
+  beforeGenerateRoutes: createAsyncWaterfall(),
+  addDefineTypes: createAsyncWaterfall(),
+  beforeDev: createAsyncWorkflow(),
+  afterDev: createAsyncWorkflow(),
+  beforeCreateCompiler: createAsyncWorkflow(),
+  afterCreateCompiler: createAsyncWorkflow(),
+  beforePrintInstructions: createAsyncWaterfall(),
+  beforeBuild: createAsyncWorkflow(),
+  afterBuild: createAsyncWorkflow(),
+  beforeDeploy: createAsyncWorkflow(),
+  afterDeploy: createAsyncWorkflow(),
+  watchFiles: createParallelWorkflow(),
+  fileChange: createAsyncWorkflow(),
+  beforeRestart: createAsyncWorkflow()
 };

package/dist/js/treeshaking/index.js

@@ -2,22 +2,24 @@ import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
 import _regeneratorRuntime from "@babel/runtime/helpers/esm/regeneratorRuntime";
 import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
 import path from 'path';
-import { defineConfig, cli } from '@modern-js/core';
 import LintPlugin from '@modern-js/plugin-lint';
 import { cleanRequireCache, emptyDir, Import } from '@modern-js/utils';
 import AnalyzePlugin from "./analyze";
+import InitializePlugin from "./initialize";
 import { hooks } from "./hooks";
 import { i18n, localeKeys } from "./locale";
 import { getLocaleLanguage } from "./utils/language";
 import { getCommand } from "./utils/commands";
-export { defineConfig, hooks };
+import { restart } from "./utils/restart";
+export * from "./defineConfig";
+export * from "./types";
 var upgradeModel = Import.lazy('@modern-js/upgrade', require);
 export default (function () {
   return {
     name: '@modern-js/app-tools',
-    post: ['@modern-js/plugin-analyze', '@modern-js/plugin-ssr', '@modern-js/plugin-document', '@modern-js/plugin-state', '@modern-js/plugin-router', '@modern-js/plugin-router-legacy', '@modern-js/plugin-polyfill'],
+    post: ['@modern-js/plugin-initialize', '@modern-js/plugin-analyze', '@modern-js/plugin-ssr', '@modern-js/plugin-document', '@modern-js/plugin-state', '@modern-js/plugin-router', '@modern-js/plugin-router-legacy', '@modern-js/plugin-polyfill'],
     registerHook: hooks,
-    usePlugins: [AnalyzePlugin(), LintPlugin()],
+    usePlugins: [InitializePlugin(), AnalyzePlugin(), LintPlugin()],
     setup: function setup(api) {
       var locale = getLocaleLanguage();
       i18n.changeLanguage({
@@ -237,7 +239,7 @@ export default (function () {
                     return closeServer();
                   case 11:
                     _context8.next = 13;
-                    return cli.restart();
+                    return restart(api.useHookRunners());
                   case 13:
                   case "end":
                     return _context8.stop();

package/dist/js/treeshaking/initialize/index.js

@@ -0,0 +1,121 @@
+import _regeneratorRuntime from "@babel/runtime/helpers/esm/regeneratorRuntime";
+import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
+import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
+import { ensureAbsolutePath, getPort, isDev } from '@modern-js/utils';
+import { legacySchema, schema } from "../schema";
+import { getCommand } from "../utils/commands";
+import { transformNormalizedConfig } from "../config/initial/transformNormalizedConfig";
+import { checkIsLegacyConfig, createDefaultConfig, createLegacyDefaultConfig } from "../config";
+export default (function () {
+  return {
+    name: '@modern-js/plugin-initialize',
+    setup: function setup(api) {
+      var config = function config() {
+        var appContext = api.useAppContext();
+        var userConfig = api.useConfigContext();
+        return checkIsLegacyConfig(userConfig) ? createLegacyDefaultConfig(appContext) : createDefaultConfig(appContext);
+      };
+      var validateSchema = function validateSchema() {
+        var userConfig = api.useConfigContext();
+        var schemas = checkIsLegacyConfig(userConfig) ? legacySchema : schema;
+        return schemas.generate();
+      };
+      return {
+        config: config,
+        validateSchema: validateSchema,
+        resolvedConfig: function resolvedConfig(_ref) {
+          return _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee() {
+            var _resolved$output$dist, _normalizedConfig$ser;
+            var resolved, appContext, userConfig, port, normalizedConfig;
+            return _regeneratorRuntime().wrap(function _callee$(_context) {
+              while (1) {
+                switch (_context.prev = _context.next) {
+                  case 0:
+                    resolved = _ref.resolved;
+                    appContext = api.useAppContext();
+                    userConfig = api.useConfigContext();
+                    _context.next = 5;
+                    return getDevServerPort(appContext, resolved);
+                  case 5:
+                    port = _context.sent;
+                    appContext = _objectSpread(_objectSpread({}, appContext), {}, {
+                      port: port,
+                      distDirectory: ensureAbsolutePath(appContext.distDirectory, ((_resolved$output$dist = resolved.output.distPath) === null || _resolved$output$dist === void 0 ? void 0 : _resolved$output$dist.root) || 'dist')
+                    });
+                    api.setAppContext(appContext);
+                    normalizedConfig = checkIsLegacyConfig(resolved) ? transformNormalizedConfig(resolved) : resolved;
+                    return _context.abrupt("return", {
+                      resolved: {
+                        // FIXME: the userConfig mayby legacy userConfig
+                        _raw: userConfig,
+                        source: normalizedConfig.source || {},
+                        server: _objectSpread(_objectSpread({}, normalizedConfig.server || {}), {}, {
+                          port: port || ((_normalizedConfig$ser = normalizedConfig.server) === null || _normalizedConfig$ser === void 0 ? void 0 : _normalizedConfig$ser.port)
+                        }),
+                        bff: normalizedConfig.bff || {},
+                        dev: normalizedConfig.dev || {},
+                        html: normalizedConfig.html || {},
+                        output: normalizedConfig.output || {},
+                        security: normalizedConfig.security || {},
+                        tools: normalizedConfig.tools || {},
+                        testing: normalizedConfig.testing || {},
+                        plugins: normalizedConfig.plugins || [],
+                        runtime: normalizedConfig.runtime || {},
+                        runtimeByEntries: normalizedConfig.runtimeByEntries || {},
+                        deploy: normalizedConfig.deploy || {},
+                        performance: normalizedConfig.performance || {},
+                        experiments: normalizedConfig.experiments || {}
+                      }
+                    });
+                  case 10:
+                  case "end":
+                    return _context.stop();
+                }
+              }
+            }, _callee);
+          }))();
+        }
+      };
+    }
+  };
+});
+function getDevServerPort(_x, _x2) {
+  return _getDevServerPort.apply(this, arguments);
+}
+function _getDevServerPort() {
+  _getDevServerPort = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee2(appContext, resolved) {
+    var command, _appContext$port;
+    return _regeneratorRuntime().wrap(function _callee2$(_context2) {
+      while (1) {
+        switch (_context2.prev = _context2.next) {
+          case 0:
+            command = getCommand();
+            if (!(isDev() && command === 'dev')) {
+              _context2.next = 10;
+              break;
+            }
+            if (!(((_appContext$port = appContext.port) !== null && _appContext$port !== void 0 ? _appContext$port : 0) > 0)) {
+              _context2.next = 6;
+              break;
+            }
+            _context2.t0 = appContext.port;
+            _context2.next = 9;
+            break;
+          case 6:
+            _context2.next = 8;
+            return getPort(resolved.server.port || 8080);
+          case 8:
+            _context2.t0 = _context2.sent;
+          case 9:
+            return _context2.abrupt("return", _context2.t0);
+          case 10:
+            return _context2.abrupt("return", resolved.server.port);
+          case 11:
+          case "end":
+            return _context2.stop();
+        }
+      }
+    }, _callee2);
+  }));
+  return _getDevServerPort.apply(this, arguments);
+}

package/dist/js/treeshaking/schema/Schema.js

@@ -0,0 +1,75 @@
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+import _classCallCheck from "@babel/runtime/helpers/esm/classCallCheck";
+import _createClass from "@babel/runtime/helpers/esm/createClass";
+import _assertThisInitialized from "@babel/runtime/helpers/esm/assertThisInitialized";
+import _inherits from "@babel/runtime/helpers/esm/inherits";
+import _createSuper from "@babel/runtime/helpers/esm/createSuper";
+import _wrapNativeSuper from "@babel/runtime/helpers/esm/wrapNativeSuper";
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+import { merge } from '@modern-js/utils/lodash';
+export var Schema = /*#__PURE__*/function (_Map) {
+  _inherits(Schema, _Map);
+  var _super = _createSuper(Schema);
+  function Schema() {
+    var _this;
+    var baseSchema = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    _classCallCheck(this, Schema);
+    _this = _super.call(this);
+    _defineProperty(_assertThisInitialized(_this), "schema", void 0);
+    _this.schema = baseSchema;
+    return _this;
+  }
+  _createClass(Schema, [{
+    key: "setSchema",
+    value: function setSchema(key, object) {
+      var _this2 = this;
+      Object.entries(object).forEach(function (_ref) {
+        var _ref2 = _slicedToArray(_ref, 2),
+          k = _ref2[0],
+          v = _ref2[1];
+        var target = "".concat(key, ".").concat(k);
+        _this2.set(target, v);
+      });
+      return this;
+    }
+  }, {
+    key: "set",
+    value: function set(key, value) {
+      if (this.has(key)) {
+        merge(this.schema[key], value);
+      } else {
+        this.schema[key] = value;
+      }
+      return this;
+    }
+  }, {
+    key: "has",
+    value: function has(key) {
+      return key in this.schema;
+    }
+  }, {
+    key: "get",
+    value: function get(key) {
+      return this.schema[key];
+    }
+  }, {
+    key: "delete",
+    value: function _delete(key) {
+      return delete this.schema[key];
+    }
+  }, {
+    key: "generate",
+    value: function generate() {
+      return Object.entries(this.schema).map(function (_ref3) {
+        var _ref4 = _slicedToArray(_ref3, 2),
+          target = _ref4[0],
+          schema = _ref4[1];
+        return {
+          target: target,
+          schema: schema
+        };
+      });
+    }
+  }]);
+  return Schema;
+}( /*#__PURE__*/_wrapNativeSuper(Map));