@modern-js/app-tools 2.0.0-beta.0 → 2.0.0-beta.2

package/dist/js/treeshaking/analyze/getServerRoutes.js

@@ -2,18 +2,18 @@ import _objectWithoutProperties from "@babel/runtime/helpers/esm/objectWithoutPr
 import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
 import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
 var _excluded = ["path"],
-    _excluded2 = ["path"];
+  _excluded2 = ["path"];
 import path from 'path';
 import fs from 'fs';
 import { urlJoin, isPlainObject, removeLeadingSlash, getEntryOptions, SERVER_BUNDLE_DIRECTORY, MAIN_ENTRY_NAME, removeTailSlash } from '@modern-js/utils';
 import { walkDirectory } from "./utils";
+
 /**
  * Add base url for each server route.
  * @param baseUrl - Base url from server.baseUrl
  * @param routes - Server routes.
  * @returns Server routes with baseUrl prefixed.
  */
-
 var applyBaseUrl = function applyBaseUrl(baseUrl, routes) {
   if (baseUrl) {
     if (Array.isArray(baseUrl)) {
@@ -29,33 +29,30 @@ var applyBaseUrl = function applyBaseUrl(baseUrl, routes) {
       });
     }
   }
-
   return routes;
 };
+
 /**
  *
  * @param original - Original entrypoint route info.
  * @param routeOptions - Custom entrypoint route config from server.routes.
  * @returns
  */
-
-
 var applyRouteOptions = function applyRouteOptions(original, routeOptions) {
   var route = routeOptions.route,
-      disableSpa = routeOptions.disableSpa;
-  original.isSPA = !disableSpa; // set entryPath as dir
+    disableSpa = routeOptions.disableSpa;
+  original.isSPA = !disableSpa;
 
+  // set entryPath as dir
   !original.isSPA && (original.entryPath = path.dirname(original.entryPath));
   var routes;
-
   if (route) {
     if (Array.isArray(route)) {
       routes = route.map(function (url) {
         if (isPlainObject(url)) {
           var _ref = url,
-              urlPath = _ref.path,
-              other = _objectWithoutProperties(_ref, _excluded);
-
+            urlPath = _ref.path,
+            other = _objectWithoutProperties(_ref, _excluded);
           return _objectSpread(_objectSpread(_objectSpread({}, original), other), {}, {
             urlPath: urlPath
           });
@@ -67,9 +64,8 @@ var applyRouteOptions = function applyRouteOptions(original, routeOptions) {
       });
     } else if (isPlainObject(route)) {
       var _ref2 = route,
-          urlPath = _ref2.path,
-          other = _objectWithoutProperties(_ref2, _excluded2);
-
+        urlPath = _ref2.path,
+        other = _objectWithoutProperties(_ref2, _excluded2);
       routes = [_objectSpread(_objectSpread(_objectSpread({}, original), other), {}, {
         urlPath: urlPath
       })];
@@ -81,36 +77,32 @@ var applyRouteOptions = function applyRouteOptions(original, routeOptions) {
   } else {
     routes = [original];
   }
-
   return routes;
 };
+
 /**
  * Collect routes from entrypoints.
  * @param entrypoints - Bundle entrypoints.
  * @param config - Normalized user config.
  * @returns entrypoint Routes
  */
-
-
 var collectHtmlRoutes = function collectHtmlRoutes(entrypoints, appContext, config) {
-  var _config$output = config.output,
-      htmlPath = _config$output.htmlPath,
-      disableHtmlFolder = _config$output.disableHtmlFolder,
-      enableModernMode = _config$output.enableModernMode,
-      _config$server = config.server,
-      baseUrl = _config$server.baseUrl,
-      routes = _config$server.routes,
-      ssr = _config$server.ssr,
-      ssrByEntries = _config$server.ssrByEntries;
+  var disableHtmlFolder = config.html.disableHtmlFolder,
+    _config$output$distPa = config.output.distPath;
+  _config$output$distPa = _config$output$distPa === void 0 ? {} : _config$output$distPa;
+  var htmlPath = _config$output$distPa.html,
+    _config$server = config.server,
+    baseUrl = _config$server.baseUrl,
+    routes = _config$server.routes,
+    ssr = _config$server.ssr,
+    ssrByEntries = _config$server.ssrByEntries;
   var packageName = appContext.packageName;
   var htmlRoutes = entrypoints.reduce(function (previous, _ref3) {
     var entryName = _ref3.entryName;
     var entryOptions = getEntryOptions(entryName, ssr, ssrByEntries, packageName);
     var isSSR = Boolean(entryOptions);
-
     var _ref4 = (routes === null || routes === void 0 ? void 0 : routes[entryName]) || {},
-        resHeaders = _ref4.resHeaders;
-
+      resHeaders = _ref4.resHeaders;
     var route = {
       urlPath: "/".concat(entryName === MAIN_ENTRY_NAME ? '' : entryName),
       entryName: entryName,
@@ -118,53 +110,49 @@ var collectHtmlRoutes = function collectHtmlRoutes(entrypoints, appContext, conf
       isSPA: true,
       isSSR: isSSR,
       responseHeaders: resHeaders,
-      enableModernMode: Boolean(enableModernMode),
+      // FIXME: remove the config.enableModernMode
+      // enableModernMode: Boolean(enableModernMode),
       bundle: isSSR ? "".concat(SERVER_BUNDLE_DIRECTORY, "/").concat(entryName, ".js") : undefined
     };
-
     if (routes !== null && routes !== void 0 && routes.hasOwnProperty(entryName)) {
       var routeOptions = isPlainObject(routes[entryName]) ? routes[entryName] : {
         route: routes[entryName]
       };
       route = applyRouteOptions(route, routeOptions);
     }
-
     return Array.isArray(route) ? [].concat(_toConsumableArray(previous), _toConsumableArray(route)) : [].concat(_toConsumableArray(previous), [route]);
   }, []);
   htmlRoutes = applyBaseUrl(baseUrl, htmlRoutes);
   return htmlRoutes;
 };
+
 /**
  * Collect static public file routes from config/public folder.
  * @param appContext - App context info.
  * @param config - normalized user config.
  * @returns Static public file routes.
  */
-
-
 var collectStaticRoutes = function collectStaticRoutes(appContext, config) {
   var appDirectory = appContext.appDirectory;
   var configDir = config.source.configDir,
-      _config$server$public = config.server.publicRoutes,
-      publicRoutes = _config$server$public === void 0 ? {} : _config$server$public;
-  var publicFolder = path.resolve(appDirectory, configDir, 'public');
+    _config$server$public = config.server.publicRoutes,
+    publicRoutes = _config$server$public === void 0 ? {} : _config$server$public;
+  var publicFolder = path.resolve(appDirectory, configDir || '', 'public');
   return fs.existsSync(publicFolder) ? walkDirectory(publicFolder).map(function (filePath) {
     var urlPath = "".concat(urlJoin(toPosix(filePath).slice(toPosix(publicFolder).length)));
     return {
       urlPath: publicRoutes[removeLeadingSlash(urlPath)] || urlPath,
       isSPA: true,
       isSSR: false,
-      entryPath: toPosix(path.relative(path.resolve(appDirectory, configDir), filePath))
+      entryPath: toPosix(path.relative(path.resolve(appDirectory, configDir || ''), filePath))
     };
   }) : [];
 };
-
 export var getServerRoutes = function getServerRoutes(entrypoints, _ref5) {
   var appContext = _ref5.appContext,
-      config = _ref5.config;
+    config = _ref5.config;
   return [].concat(_toConsumableArray(collectHtmlRoutes(entrypoints, appContext, config)), _toConsumableArray(collectStaticRoutes(appContext, config)));
 };
-
 var toPosix = function toPosix(pathStr) {
   return pathStr.split(path.sep).join(path.posix.sep);
 };

package/dist/js/treeshaking/analyze/index.js

@@ -3,96 +3,69 @@ import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
 import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
 import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
 import * as path from 'path';
-import { createAsyncWaterfall } from '@modern-js/plugin';
 import { createDebugger, fs, isApiOnly } from '@modern-js/utils';
 import { cloneDeep } from '@modern-js/utils/lodash';
+import { createBuilderForEdenX } from "../builder";
+import { printInstructions } from "../utils/printInstructions";
+import { generateRoutes } from "../utils/routes";
+import { emitResolvedConfig } from "../utils/config";
+import { getCommand } from "../utils/commands";
+import { initialNormalizedConfig } from "../config";
 import { isRouteComponentFile } from "./utils";
 var debug = createDebugger('plugin-analyze');
-export var modifyEntryImports = createAsyncWaterfall();
-export var modifyEntryExport = createAsyncWaterfall();
-export var addRuntimeExports = createAsyncWaterfall();
-export var modifyEntryRuntimePlugins = createAsyncWaterfall();
-export var modifyEntryRenderFunction = createAsyncWaterfall();
-export var modifyAsyncEntry = createAsyncWaterfall();
-export var modifyFileSystemRoutes = createAsyncWaterfall();
-export var modifyServerRoutes = createAsyncWaterfall();
-export var htmlPartials = createAsyncWaterfall();
-export var beforeGenerateRoutes = createAsyncWaterfall();
-export var addDefineTypes = createAsyncWaterfall();
 export default (function () {
   return {
     name: '@modern-js/plugin-analyze',
-    registerHook: {
-      modifyAsyncEntry: modifyAsyncEntry,
-      modifyEntryImports: modifyEntryImports,
-      modifyEntryExport: modifyEntryExport,
-      modifyEntryRuntimePlugins: modifyEntryRuntimePlugins,
-      modifyEntryRenderFunction: modifyEntryRenderFunction,
-      modifyFileSystemRoutes: modifyFileSystemRoutes,
-      modifyServerRoutes: modifyServerRoutes,
-      htmlPartials: htmlPartials,
-      addRuntimeExports: addRuntimeExports,
-      beforeGenerateRoutes: beforeGenerateRoutes,
-      addDefineTypes: addDefineTypes
-    },
     setup: function setup(api) {
       var pagesDir = [];
       var originEntrypoints = [];
       return {
         prepare: function prepare() {
-          return _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee() {
+          return _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee6() {
             var _resolvedConfig$sourc;
-
-            var appContext, resolvedConfig, hookRunners, apiOnly, _yield$hookRunners$mo, _routes, _yield$Promise$all, _yield$Promise$all2, getBundleEntry, getServerRoutes, generateCode, getHtmlTemplate, entrypoints, defaultChecked, initialRoutes, _yield$hookRunners$mo2, routes, nestedRouteEntries, htmlTemplates;
-
-            return _regeneratorRuntime().wrap(function _callee$(_context) {
+            var appContext, resolvedConfig, hookRunners, apiOnly, _yield$hookRunners$mo, _routes, _yield$Promise$all, _yield$Promise$all2, getBundleEntry, getServerRoutes, generateCode, getHtmlTemplate, entrypoints, defaultChecked, initialRoutes, _yield$hookRunners$mo2, routes, nestedRouteEntries, htmlTemplates, command, buildCommands, normalizedConfig, builder;
+            return _regeneratorRuntime().wrap(function _callee6$(_context6) {
               while (1) {
-                switch (_context.prev = _context.next) {
+                switch (_context6.prev = _context6.next) {
                   case 0:
                     appContext = api.useAppContext();
                     resolvedConfig = api.useResolvedConfigContext();
                     hookRunners = api.useHookRunners();
-
                     try {
                       fs.emptydirSync(appContext.internalDirectory);
-                    } catch (_unused) {// FIXME:
+                    } catch (_unused) {
+                      // FIXME:
                     }
-
-                    _context.next = 6;
-                    return isApiOnly(appContext.appDirectory, resolvedConfig === null || resolvedConfig === void 0 ? void 0 : (_resolvedConfig$sourc = resolvedConfig.source) === null || _resolvedConfig$sourc === void 0 ? void 0 : _resolvedConfig$sourc.entriesDir);
-
+                    _context6.next = 6;
+                    return isApiOnly(appContext.appDirectory, (_resolvedConfig$sourc = resolvedConfig.source) === null || _resolvedConfig$sourc === void 0 ? void 0 : _resolvedConfig$sourc.entriesDir);
                   case 6:
-                    apiOnly = _context.sent;
-                    _context.next = 9;
+                    apiOnly = _context6.sent;
+                    _context6.next = 9;
                     return hookRunners.addRuntimeExports();
-
                   case 9:
                     if (!apiOnly) {
-                      _context.next = 17;
+                      _context6.next = 18;
                       break;
                     }
-
-                    _context.next = 12;
+                    _context6.next = 12;
                     return hookRunners.modifyServerRoutes({
                       routes: []
                     });
-
                   case 12:
-                    _yield$hookRunners$mo = _context.sent;
+                    _yield$hookRunners$mo = _context6.sent;
                     _routes = _yield$hookRunners$mo.routes;
                     debug("server routes: %o", _routes);
-                    api.setAppContext(_objectSpread(_objectSpread({}, appContext), {}, {
+                    appContext = _objectSpread(_objectSpread({}, appContext), {}, {
                       apiOnly: apiOnly,
                       serverRoutes: _routes
-                    }));
-                    return _context.abrupt("return");
-
-                  case 17:
-                    _context.next = 19;
+                    });
+                    api.setAppContext(appContext);
+                    return _context6.abrupt("return");
+                  case 18:
+                    _context6.next = 20;
                     return Promise.all([import("./getBundleEntry"), import("./getServerRoutes"), import("./generateCode"), import("./getHtmlTemplate")]);
-
-                  case 19:
-                    _yield$Promise$all = _context.sent;
+                  case 20:
+                    _yield$Promise$all = _context6.sent;
                     _yield$Promise$all2 = _slicedToArray(_yield$Promise$all, 4);
                     getBundleEntry = _yield$Promise$all2[0].getBundleEntry;
                     getServerRoutes = _yield$Promise$all2[1].getServerRoutes;
@@ -107,19 +80,19 @@ export default (function () {
                       appContext: appContext,
                       config: resolvedConfig
                     });
-                    _context.next = 31;
+                    _context6.next = 32;
                     return hookRunners.modifyServerRoutes({
                       routes: initialRoutes
                     });
-
-                  case 31:
-                    _yield$hookRunners$mo2 = _context.sent;
+                  case 32:
+                    _yield$hookRunners$mo2 = _context6.sent;
                     routes = _yield$hookRunners$mo2.routes;
                     debug("server routes: %o", routes);
-                    api.setAppContext(_objectSpread(_objectSpread({}, appContext), {}, {
+                    appContext = _objectSpread(_objectSpread({}, appContext), {}, {
                       entrypoints: entrypoints,
                       serverRoutes: routes
-                    }));
+                    });
+                    api.setAppContext(appContext);
                     nestedRouteEntries = entrypoints.map(function (point) {
                       return point.nestedRoutesEntry;
                     }).filter(Boolean);
@@ -127,85 +100,216 @@ export default (function () {
                       return point.entry;
                     }).filter(Boolean).concat(nestedRouteEntries);
                     originEntrypoints = cloneDeep(entrypoints);
-                    _context.next = 40;
+                    _context6.next = 42;
                     return generateCode(appContext, resolvedConfig, entrypoints, api);
-
-                  case 40:
-                    _context.next = 42;
+                  case 42:
+                    _context6.next = 44;
                     return getHtmlTemplate(entrypoints, api, {
                       appContext: appContext,
                       config: resolvedConfig
                     });
-
-                  case 42:
-                    htmlTemplates = _context.sent;
+                  case 44:
+                    htmlTemplates = _context6.sent;
                     debug("html templates: %o", htmlTemplates);
-                    _context.next = 46;
+                    _context6.next = 48;
                     return hookRunners.addDefineTypes();
-
-                  case 46:
+                  case 48:
                     debug("add Define Types");
-                    api.setAppContext(_objectSpread(_objectSpread({}, appContext), {}, {
+                    appContext = _objectSpread(_objectSpread({}, appContext), {}, {
                       entrypoints: entrypoints,
                       checkedEntries: defaultChecked,
                       apiOnly: apiOnly,
                       serverRoutes: routes,
                       htmlTemplates: htmlTemplates
-                    }));
-
-                  case 48:
+                    });
+                    api.setAppContext(appContext);
+                    command = getCommand();
+                    buildCommands = ['dev', 'build', 'inspect', 'deploy'];
+                    if (!buildCommands.includes(command)) {
+                      _context6.next = 60;
+                      break;
+                    }
+                    normalizedConfig = api.useResolvedConfigContext();
+                    _context6.next = 57;
+                    return createBuilderForEdenX({
+                      normalizedConfig: normalizedConfig,
+                      appContext: appContext,
+                      compatPluginConfig: {
+                        onBeforeBuild: function onBeforeBuild(_ref) {
+                          return _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee() {
+                            var bundlerConfigs, hookRunners;
+                            return _regeneratorRuntime().wrap(function _callee$(_context) {
+                              while (1) {
+                                switch (_context.prev = _context.next) {
+                                  case 0:
+                                    bundlerConfigs = _ref.bundlerConfigs;
+                                    hookRunners = api.useHookRunners();
+                                    _context.next = 4;
+                                    return generateRoutes(appContext);
+                                  case 4:
+                                    _context.next = 6;
+                                    return hookRunners.beforeBuild({
+                                      bundlerConfigs: bundlerConfigs
+                                    });
+                                  case 6:
+                                  case "end":
+                                    return _context.stop();
+                                }
+                              }
+                            }, _callee);
+                          }))();
+                        },
+                        onAfterBuild: function onAfterBuild(_ref2) {
+                          return _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee2() {
+                            var stats, hookRunners;
+                            return _regeneratorRuntime().wrap(function _callee2$(_context2) {
+                              while (1) {
+                                switch (_context2.prev = _context2.next) {
+                                  case 0:
+                                    stats = _ref2.stats;
+                                    hookRunners = api.useHookRunners();
+                                    _context2.next = 4;
+                                    return hookRunners.afterBuild({
+                                      stats: stats
+                                    });
+                                  case 4:
+                                    _context2.next = 6;
+                                    return emitResolvedConfig(appContext.appDirectory, normalizedConfig);
+                                  case 6:
+                                  case "end":
+                                    return _context2.stop();
+                                }
+                              }
+                            }, _callee2);
+                          }))();
+                        },
+                        onDevCompileDone: function onDevCompileDone(_ref3) {
+                          return _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee3() {
+                            var isFirstCompile, hookRunners;
+                            return _regeneratorRuntime().wrap(function _callee3$(_context3) {
+                              while (1) {
+                                switch (_context3.prev = _context3.next) {
+                                  case 0:
+                                    isFirstCompile = _ref3.isFirstCompile;
+                                    hookRunners = api.useHookRunners();
+                                    if (process.stdout.isTTY || isFirstCompile) {
+                                      hookRunners.afterDev();
+                                      if (isFirstCompile) {
+                                        printInstructions(hookRunners, appContext, normalizedConfig);
+                                      }
+                                    }
+                                  case 3:
+                                  case "end":
+                                    return _context3.stop();
+                                }
+                              }
+                            }, _callee3);
+                          }))();
+                        },
+                        onBeforeCreateCompiler: function onBeforeCreateCompiler(_ref4) {
+                          return _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee4() {
+                            var bundlerConfigs, hookRunners;
+                            return _regeneratorRuntime().wrap(function _callee4$(_context4) {
+                              while (1) {
+                                switch (_context4.prev = _context4.next) {
+                                  case 0:
+                                    bundlerConfigs = _ref4.bundlerConfigs;
+                                    hookRunners = api.useHookRunners(); // run modernjs framework `beforeCreateCompiler` hook
+                                    _context4.next = 4;
+                                    return hookRunners.beforeCreateCompiler({
+                                      bundlerConfigs: bundlerConfigs
+                                    });
+                                  case 4:
+                                  case "end":
+                                    return _context4.stop();
+                                }
+                              }
+                            }, _callee4);
+                          }))();
+                        },
+                        onAfterCreateCompiler: function onAfterCreateCompiler(_ref5) {
+                          return _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee5() {
+                            var compiler, hookRunners;
+                            return _regeneratorRuntime().wrap(function _callee5$(_context5) {
+                              while (1) {
+                                switch (_context5.prev = _context5.next) {
+                                  case 0:
+                                    compiler = _ref5.compiler;
+                                    hookRunners = api.useHookRunners(); // run modernjs framework afterCreateCompiler hooks
+                                    _context5.next = 4;
+                                    return hookRunners.afterCreateCompiler({
+                                      compiler: compiler
+                                    });
+                                  case 4:
+                                  case "end":
+                                    return _context5.stop();
+                                }
+                              }
+                            }, _callee5);
+                          }))();
+                        }
+                      }
+                    });
+                  case 57:
+                    builder = _context6.sent;
+                    appContext = _objectSpread(_objectSpread({}, appContext), {}, {
+                      builder: builder
+                    });
+                    api.setAppContext(appContext);
+                  case 60:
                   case "end":
-                    return _context.stop();
+                    return _context6.stop();
                 }
               }
-            }, _callee);
+            }, _callee6);
           }))();
         },
         watchFiles: function watchFiles() {
           return pagesDir;
         },
+        resolvedConfig: function resolvedConfig(_ref6) {
+          var resolved = _ref6.resolved;
+          var appContext = api.useAppContext();
+          var config = initialNormalizedConfig(resolved, appContext);
+          return {
+            resolved: config
+          };
+        },
         fileChange: function fileChange(e) {
-          return _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee2() {
+          return _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee7() {
             var appContext, appDirectory, filename, eventType, isPageFile, absoluteFilePath, isRouteComponent, resolvedConfig, _yield$import, generateCode, entrypoints;
-
-            return _regeneratorRuntime().wrap(function _callee2$(_context2) {
+            return _regeneratorRuntime().wrap(function _callee7$(_context7) {
               while (1) {
-                switch (_context2.prev = _context2.next) {
+                switch (_context7.prev = _context7.next) {
                   case 0:
                     appContext = api.useAppContext();
                     appDirectory = appContext.appDirectory;
                     filename = e.filename, eventType = e.eventType;
-
                     isPageFile = function isPageFile(name) {
                       return pagesDir.some(function (pageDir) {
                         return name.includes(pageDir);
                       });
                     };
-
                     absoluteFilePath = path.resolve(appDirectory, filename);
                     isRouteComponent = isPageFile(absoluteFilePath) && isRouteComponentFile(absoluteFilePath);
-
                     if (!(isRouteComponent && (eventType === 'add' || eventType === 'unlink'))) {
-                      _context2.next = 14;
+                      _context7.next = 14;
                       break;
                     }
-
                     resolvedConfig = api.useResolvedConfigContext();
-                    _context2.next = 10;
+                    _context7.next = 10;
                     return import("./generateCode");
-
                   case 10:
-                    _yield$import = _context2.sent;
+                    _yield$import = _context7.sent;
                     generateCode = _yield$import.generateCode;
                     entrypoints = cloneDeep(originEntrypoints);
                     generateCode(appContext, resolvedConfig, entrypoints, api);
-
                   case 14:
                   case "end":
-                    return _context2.stop();
+                    return _context7.stop();
                 }
               }
-            }, _callee2);
+            }, _callee7);
           }))();
         }
       };

package/dist/js/treeshaking/analyze/isDefaultExportFunction.js

@@ -2,16 +2,13 @@ import fs from 'fs';
 import { parse } from '@babel/parser';
 import traverse from '@babel/traverse';
 import * as t from '@babel/types';
-
 var isFunction = function isFunction(node) {
   return t.isFunctionDeclaration(node) || t.isFunctionExpression(node) || t.isArrowFunctionExpression(node);
 };
-
 export var isDefaultExportFunction = function isDefaultExportFunction(file) {
   if (!file || !fs.existsSync(file)) {
     return false;
   }
-
   var ast = parse(fs.readFileSync(file, 'utf8'), {
     sourceType: 'unambiguous',
     plugins: ['jsx', 'typescript', 'classProperties', 'dynamicImport', 'exportDefaultFrom', 'exportNamespaceFrom', 'decorators-legacy', 'functionBind', 'classPrivateMethods', ['pipelineOperator', {
@@ -22,7 +19,6 @@ export var isDefaultExportFunction = function isDefaultExportFunction(file) {
   traverse(ast, {
     ExportDefaultDeclaration: function ExportDefaultDeclaration(path) {
       var declaration = path.node.declaration;
-
       if (isFunction(declaration)) {
         isExportFunction = true;
       }

package/dist/js/treeshaking/analyze/makeLegalIdentifier.js

@@ -9,10 +9,8 @@ export function makeLegalIdentifier(str) {
   var identifier = str.replace(/-(\w)/g, function (_, letter) {
     return letter.toUpperCase();
   }).replace(/[^$_a-zA-Z0-9]/g, '_');
-
   if (/\d/.test(identifier[0]) || forbidList.has(identifier)) {
     return "_".concat(identifier);
   }
-
   return identifier || '_';
 }