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

package/dist/js/node/builder/createSourceConfig.js

@@ -0,0 +1,82 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createBuilderInclude = createBuilderInclude;
+exports.createBuilderModuleScope = createBuilderModuleScope;
+exports.createSourceConfig = createSourceConfig;
+var _path = require("path");
+var _utils = require("@modern-js/utils");
+function createSourceConfig(normalizedConfig, appContext) {
+  const {
+    alias,
+    envVars,
+    globalVars,
+    include,
+    moduleScopes,
+    preEntry
+  } = normalizedConfig.source;
+  const builderGlobalVars = globalVars || {};
+  for (const envVar of envVars || []) {
+    const envVarValue = process.env[envVar];
+    envVarValue && (builderGlobalVars[`process.env.${envVar}`] = envVarValue);
+  }
+  const builderModuleScope = createBuilderModuleScope(moduleScopes);
+  const builderInclude = createBuilderInclude(include, appContext);
+  return {
+    alias: (0, _utils.mergeAlias)(alias),
+    moduleScopes: builderModuleScope,
+    globalVars: builderGlobalVars,
+    include: builderInclude,
+    preEntry,
+    // ensure resolve.extensions same as before
+    resolveExtensionPrefix: '.web'
+  };
+}
+function createBuilderInclude(include, appContext) {
+  const defaultInclude = [appContext.internalDirectory];
+  const transformInclude = (include || []).map(include => {
+    if (typeof include === 'string') {
+      if ((0, _path.isAbsolute)(include)) {
+        return include;
+      }
+      return new RegExp(include);
+    }
+    return include;
+  }).concat(defaultInclude); // concat default Include
+
+  const root = (0, _utils.findMonorepoRoot)(appContext.appDirectory);
+  if (!root) {
+    return transformInclude;
+  }
+  const modernjsMonorepo = (0, _utils.isModernjsMonorepo)(root);
+  if (modernjsMonorepo) {
+    const paths = _utils.globby.sync(_path.posix.join(root, 'features', '**', 'package.json'), {
+      ignore: ['**/node_modules/**/*']
+    }).map(pathname => (0, _path.dirname)(pathname) + _path.sep);
+    return [...paths, ...transformInclude];
+  }
+  return transformInclude;
+}
+function createBuilderModuleScope(moduleScopes) {
+  if (moduleScopes) {
+    let builderModuleScope = [];
+    const DEFAULT_SCOPES = ['./src', './shared', /node_modules/];
+    if (Array.isArray(moduleScopes)) {
+      if (isPrimitiveScope(moduleScopes)) {
+        builderModuleScope = DEFAULT_SCOPES.concat(moduleScopes);
+      } else {
+        builderModuleScope = [DEFAULT_SCOPES, ...moduleScopes];
+      }
+    } else {
+      builderModuleScope = [DEFAULT_SCOPES, moduleScopes];
+    }
+    return builderModuleScope;
+  } else {
+    return undefined;
+  }
+  function isPrimitiveScope(items) {
+    return items.every(item => typeof item === 'string' || Object.prototype.toString.call(item) === '[object RegExp]');
+  }
+}

package/dist/js/node/builder/createToolsConfig.js

@@ -0,0 +1,94 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createBuilderTsChecker = createBuilderTsChecker;
+exports.createToolsConfig = createToolsConfig;
+var _utils = require("@modern-js/utils");
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function createToolsConfig(normalizedConfig) {
+  const {
+    disableCssExtract,
+    enableTsLoader
+  } = normalizedConfig.output;
+  const {
+    autoprefixer,
+    babel,
+    minifyCss,
+    terser,
+    webpack,
+    webpackChain,
+    tsLoader,
+    styledComponents,
+    sass,
+    postcss,
+    less,
+    htmlPlugin,
+    // TODO: remove modernjs tools.lodash config
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    lodash
+  } = normalizedConfig.tools;
+  const builderTsLoader = createBuilderTsLoader(tsLoader, enableTsLoader);
+  const builderTsChecker = createBuilderTsChecker(normalizedConfig.output);
+  return {
+    tsChecker: builderTsChecker,
+    styleLoader: disableCssExtract ? {} : undefined,
+    cssExtract: disableCssExtract ? false : undefined,
+    autoprefixer,
+    babel,
+    minifyCss,
+    terser,
+    webpack,
+    webpackChain: webpackChain,
+    tsLoader: builderTsLoader,
+    styledComponents: styledComponents,
+    sass: sass,
+    postcss: postcss,
+    less: less,
+    // can't remove comment in html minify.
+    // some html template insert by using those comments.
+    htmlPlugin: [config => _objectSpread(_objectSpread({}, config), {}, {
+      minify: typeof config.minify === 'object' ? _objectSpread(_objectSpread({}, config.minify), {}, {
+        removeComments: false
+      }) : config.minify
+    }),
+    // eslint-disable-next-line no-nested-ternary
+    ...(Array.isArray(htmlPlugin) ? htmlPlugin : htmlPlugin ? [htmlPlugin] : [])]
+  };
+}
+function createBuilderTsLoader(tsLoader, enableTsLoader) {
+  const useTsLoader = Boolean(enableTsLoader);
+  if (!useTsLoader) {
+    return undefined;
+  }
+  const defaultTsLoader = {
+    compilerOptions: {
+      target: 'es5',
+      module: 'ESNext'
+    },
+    transpileOnly: false,
+    allowTsInNodeModules: true
+  };
+  return (_, utils) => (0, _utils.applyOptionsChain)(defaultTsLoader, tsLoader, utils);
+}
+function createBuilderTsChecker(output) {
+  if (output.enableTsLoader) {
+    return false;
+  }
+  const defaultTsChecker = {
+    issue: {
+      include: [{
+        file: '**/src/**/*'
+      }],
+      exclude: [{
+        file: '**/*.(spec|test).ts'
+      }, {
+        file: '**/node_modules/**/*'
+      }]
+    }
+  };
+  return defaultTsChecker;
+}

package/dist/js/node/builder/index.js

@@ -0,0 +1,117 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createBuilderForEdenX = createBuilderForEdenX;
+exports.createBuilderOptions = createBuilderOptions;
+var _builder = require("@modern-js/builder");
+var _builderWebpackProvider = require("@modern-js/builder-webpack-provider");
+var _utils = require("@modern-js/utils");
+var _compatModern = require("./builderPlugins/compatModern");
+var _createHtmlConfig = require("./createHtmlConfig");
+var _createOutputConfig = require("./createOutputConfig");
+var _createSourceConfig = require("./createSourceConfig");
+var _createToolsConfig = require("./createToolsConfig");
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+function getBuilderTargets(normalizedConfig) {
+  const targets = ['web'];
+  if (normalizedConfig.output.enableModernMode && !targets.includes('modern-web')) {
+    targets.push('modern-web');
+  }
+  if ((0, _utils.isUseSSRBundle)(normalizedConfig)) {
+    targets.push('node');
+  }
+  return targets;
+}
+async function createBuilderForEdenX({
+  normalizedConfig,
+  appContext,
+  compatPluginConfig
+}) {
+  const builderConfig = createBuilderProviderConfig(normalizedConfig, appContext);
+  // create webpack provider
+  const webpackProvider = (0, _builderWebpackProvider.builderWebpackProvider)({
+    builderConfig
+  });
+  const target = getBuilderTargets(normalizedConfig);
+  const builderOptions = createBuilderOptions(target, appContext);
+  const builder = await (0, _builder.createBuilder)(webpackProvider, builderOptions);
+  await applyBuilderPlugins(builder, normalizedConfig, appContext, compatPluginConfig);
+  return builder;
+}
+function createBuilderProviderConfig(normalizedConfig, appContext) {
+  const source = (0, _createSourceConfig.createSourceConfig)(normalizedConfig, appContext);
+  const html = (0, _createHtmlConfig.createHtmlConfig)(normalizedConfig, appContext);
+  const output = (0, _createOutputConfig.createOutputConfig)(normalizedConfig, appContext);
+  const tools = (0, _createToolsConfig.createToolsConfig)(normalizedConfig);
+  return {
+    source,
+    html,
+    output,
+    tools,
+    dev: {
+      https: normalizedConfig.dev.https,
+      assetPrefix: normalizedConfig.dev.assetPrefix
+    },
+    performance: {
+      // `@modern-js/webpack` used to remove moment locale by default
+      removeMomentLocale: true
+    }
+  };
+}
+function createBuilderOptions(target, appContext) {
+  // create entries
+
+  const entries = {};
+  const {
+    entrypoints = [],
+    checkedEntries
+  } = appContext;
+  for (const {
+    entryName,
+    entry
+  } of entrypoints) {
+    if (checkedEntries && !checkedEntries.includes(entryName)) {
+      continue;
+    }
+    if (entryName in entries) {
+      entries[entryName].push(entry);
+    } else {
+      entries[entryName] = [entry];
+    }
+  }
+  return {
+    cwd: appContext.appDirectory,
+    target,
+    configPath: appContext.configFile || undefined,
+    entry: entries,
+    framework: appContext.metaName
+  };
+}
+
+/**
+ * register builder Plugin by condition
+ */
+async function applyBuilderPlugins(builder, normalizedConfig, appContext, compatPluginConfig) {
+  if (!normalizedConfig.output.disableNodePolyfill) {
+    const {
+      PluginNodePolyfill
+    } = await Promise.resolve().then(() => _interopRequireWildcard(require('@modern-js/builder-plugin-node-polyfill')));
+    builder.addPlugins([PluginNodePolyfill()]);
+  }
+  if (normalizedConfig.tools.esbuild) {
+    const {
+      esbuild: esbuildOptions
+    } = normalizedConfig.tools;
+    const {
+      PluginEsbuild
+    } = await Promise.resolve().then(() => _interopRequireWildcard(require('@modern-js/builder-plugin-esbuild')));
+    builder.addPlugins([PluginEsbuild({
+      loader: false,
+      minimize: (0, _utils.applyOptionsChain)({}, esbuildOptions)
+    })]);
+  }
+  builder.addPlugins([(0, _compatModern.PluginCompatModern)(appContext, normalizedConfig, compatPluginConfig)]);
+}

package/dist/js/node/builder/share.js

@@ -0,0 +1,51 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createCopyPattern = createCopyPattern;
+var _path = _interopRequireDefault(require("path"));
+var _lodash = require("@modern-js/utils/lodash");
+var _utils = require("@modern-js/utils");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function createCopyPattern(appContext, config, patternsType, chain) {
+  const configDir = _path.default.resolve(appContext.appDirectory, config.source.configDir);
+  const uploadDir = _path.default.posix.join(configDir.replace(/\\/g, '/'), 'upload');
+  const publicDir = _path.default.posix.join(configDir.replace(/\\/g, '/'), 'public');
+  const minifiedJsRexExp = /\.min\.js/;
+  const info = file => ({
+    // If the file name ends with `.min.js`, we assume it's a compressed file.
+    // So we don't want copy-webpack-plugin to minify it.
+    // ref: https://github.com/webpack-contrib/copy-webpack-plugin#info
+    minimized: minifiedJsRexExp.test(file.sourceFilename)
+  });
+  if (patternsType === 'public') {
+    if (!chain) {
+      throw new Error("expect get a webpackChain, but receive 'undefined'");
+    }
+    return {
+      info,
+      from: '**/*',
+      to: 'public',
+      context: publicDir,
+      noErrorOnMissing: true,
+      // eslint-disable-next-line node/prefer-global/buffer
+      transform: (content, absoluteFrom) => {
+        if (!/\.html?$/.test(absoluteFrom)) {
+          return content;
+        }
+        return (0, _lodash.template)(content.toString('utf8'))({
+          assetPrefix: (0, _utils.removeTailSlash)(chain.output.get('publicPath'))
+        });
+      }
+    };
+  } else {
+    return {
+      info,
+      from: '**/*',
+      to: 'upload',
+      context: uploadDir,
+      noErrorOnMissing: true
+    };
+  }
+}

package/dist/js/node/builder/webpackPlugins/htmlAsyncChunkPlugin.js

@@ -0,0 +1,36 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.HtmlAsyncChunkPlugin = void 0;
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+class HtmlAsyncChunkPlugin {
+  constructor(htmlWebpackPlugin) {
+    _defineProperty(this, "name", void 0);
+    _defineProperty(this, "htmlWebpackPlugin", void 0);
+    this.name = 'HtmlAsyncChunkPlugin';
+    this.htmlWebpackPlugin = htmlWebpackPlugin;
+  }
+  apply(compiler) {
+    compiler.hooks.compilation.tap(this.name, compilation => {
+      const hooks = this.htmlWebpackPlugin.getHooks(compilation);
+      hooks.alterAssetTagGroups.tap(this.name, assets => {
+        const tags = [...assets.headTags, ...assets.bodyTags];
+        for (const tag of tags) {
+          if (tag.tagName === 'script') {
+            const {
+              attributes
+            } = tag;
+            if (attributes && attributes.defer === true) {
+              attributes.async = true;
+              delete attributes.defer;
+            }
+          }
+        }
+        return assets;
+      });
+    });
+  }
+}
+exports.HtmlAsyncChunkPlugin = HtmlAsyncChunkPlugin;

package/dist/js/node/builder/webpackPlugins/htmlBottomTemplate.js

@@ -0,0 +1,40 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.BottomTemplatePlugin = void 0;
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+class BottomTemplatePlugin {
+  constructor(htmlWebpackPlugin) {
+    _defineProperty(this, "htmlWebpackPlugin", void 0);
+    _defineProperty(this, "bottomTemplateReg", /<!--<\?-\s*bottomTemplate\s*\?>-->/);
+    _defineProperty(this, "bodyRegExp", /(<\/\s*body\s*>)/i);
+    _defineProperty(this, "name", void 0);
+    this.htmlWebpackPlugin = htmlWebpackPlugin;
+    this.name = 'bottom-template';
+  }
+  apply(compiler) {
+    compiler.hooks.compilation.tap(this.name, compilation => {
+      this.htmlWebpackPlugin.getHooks(compilation).beforeEmit.tap(this.name, data => {
+        var _data$plugin$options;
+        if (!((_data$plugin$options = data.plugin.options) !== null && _data$plugin$options !== void 0 && _data$plugin$options.__internal__)) {
+          return data;
+        }
+        // 含有 <!--<?- bottomTemplate ?>--> 占位符时才需要注入 bottom.html
+        if (this.bottomTemplateReg.test(data.html)) {
+          // 清空占位符
+          data.html = data.html.replace(this.bottomTemplateReg, '');
+          const {
+            bottomTemplate
+          } = data.plugin.options;
+          if (bottomTemplate) {
+            data.html = data.html.replace(this.bodyRegExp, match => `\n${bottomTemplate}\n${match}`);
+          }
+        }
+        return data;
+      });
+    });
+  }
+}
+exports.BottomTemplatePlugin = BottomTemplatePlugin;

package/dist/js/node/builder/webpackPlugins/routerPlugin.js

@@ -0,0 +1,105 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _path = _interopRequireDefault(require("path"));
+var _utils = require("@modern-js/utils");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+const PLUGIN_NAME = 'ModernjsRoutePlugin';
+class RouterPlugin {
+  constructor(options) {
+    _defineProperty(this, "existNestedRoutes", void 0);
+    this.existNestedRoutes = options.existNestedRoutes;
+  }
+  apply(compiler) {
+    const {
+      existNestedRoutes
+    } = this;
+    const {
+      target
+    } = compiler.options;
+    if (target === 'node' || Array.isArray(target) && target.includes('node')) {
+      return;
+    }
+    if (!existNestedRoutes) {
+      return;
+    }
+    const {
+      webpack
+    } = compiler;
+    const {
+      Compilation,
+      sources
+    } = webpack;
+    const {
+      RawSource
+    } = sources;
+    const {
+      PROCESS_ASSETS_STAGE_REPORT
+    } = Compilation;
+    const outputPath = compiler.options.output.path;
+    const newAssetsMap = new Map();
+    const normalizePath = path => {
+      if (!path.endsWith('/')) {
+        return `${path}/`;
+      }
+      return path;
+    };
+    compiler.hooks.thisCompilation.tap(PLUGIN_NAME, compilation => {
+      compilation.hooks.processAssets.tapPromise({
+        name: PLUGIN_NAME,
+        stage: PROCESS_ASSETS_STAGE_REPORT
+      }, async () => {
+        const stats = compilation.getStats().toJson({
+          chunkGroups: true,
+          chunks: true
+        });
+        const {
+          publicPath
+        } = stats;
+        const routeAssets = {};
+        const {
+          namedChunkGroups,
+          assetsByChunkName
+        } = stats;
+        if (!namedChunkGroups || !assetsByChunkName) {
+          _utils.logger.warn('Route manifest does not exist, performance will be affected');
+          return;
+        }
+        for (const [name, chunkGroup] of Object.entries(namedChunkGroups)) {
+          routeAssets[name] = {
+            chunkIds: chunkGroup.chunks,
+            assets: assetsByChunkName[name].map(item => publicPath ? normalizePath(publicPath) + item : item)
+          };
+        }
+        const manifest = {
+          routeAssets
+        };
+        const injectedContent = `
+            ;(function(){
+              window.${_utils.ROUTE_MANIFEST} = ${JSON.stringify(manifest)};
+            })();
+          `;
+        const entrypointsArray = Array.from(compilation.entrypoints.entries());
+        const entryChunkIds = entrypointsArray.map(entrypoint => entrypoint[0]);
+        const entryChunks = [...compilation.chunks].filter(chunk => {
+          return entryChunkIds.includes(chunk.name);
+        });
+        const entryChunkFiles = entryChunks.map(chunk => [...chunk.files][0]);
+        for (const file of entryChunkFiles) {
+          const asset = compilation.assets[file];
+          const newContent = `${injectedContent}${asset.source().toString()}`;
+          newAssetsMap.set(_path.default.join(outputPath, file), newContent);
+          compilation.updateAsset(file, new RawSource(newContent));
+        }
+        const filename = _path.default.join(outputPath, _utils.ROUTE_MINIFEST_FILE);
+        await _utils.fs.ensureFile(filename);
+        await _utils.fs.writeFile(filename, JSON.stringify(manifest, null, 2));
+      });
+    });
+  }
+}
+exports.default = RouterPlugin;