@modern-js/app-tools 2.52.0 → 2.53.1-alpha.0

package/dist/js/modern/utils/config.js

@@ -0,0 +1,78 @@
+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; }
+
+import * as path from 'path';
+import { bundle } from '@modern-js/node-bundle-require';
+import { CONFIG_FILE_EXTENSIONS, fs, getServerConfig, OUTPUT_CONFIG_FILE } from '@modern-js/utils';
+export const defineServerConfig = config => config;
+export const buildServerConfig = async ({
+  appDirectory,
+  distDirectory,
+  configFile,
+  options
+}) => {
+  const configFilePath = await getServerConfig(appDirectory, configFile);
+
+  const getOutputFile = async filepath => path.resolve(distDirectory, `${filepath.replace(new RegExp(CONFIG_FILE_EXTENSIONS.join('|')), '')}.js`);
+
+  if (configFilePath) {
+    const configHelperFilePath = path.normalize(path.join(distDirectory, './config-helper.js'));
+    const helperCode = `
+      export const defineConfig = (config) => config;
+    `;
+    await fs.ensureDir(distDirectory);
+    await fs.writeFile(configHelperFilePath, helperCode);
+    await bundle(configFilePath, _objectSpread(_objectSpread({}, options), {}, {
+      getOutputFile,
+      esbuildPlugins: [{
+        name: 'native-build-config',
+
+        setup(ctx) {
+          ctx.onResolve({
+            filter: /app-tools\/server/
+          }, () => {
+            return {
+              path: configHelperFilePath
+            };
+          });
+        }
+
+      }]
+    }));
+  }
+};
+/**
+ *
+ * 处理循环引用的 replacer
+ */
+
+export const safeReplacer = () => {
+  const cache = [];
+  const keyCache = [];
+  return function (key, value) {
+    if (typeof value === 'object' && value !== null) {
+      const index = cache.indexOf(value);
+
+      if (index !== -1) {
+        return `[Circular ${keyCache[index]}]`;
+      }
+
+      cache.push(value);
+      keyCache.push(key || 'root');
+    }
+
+    return value;
+  };
+};
+export const emitResolvedConfig = async (appDirectory, resolvedConfig) => {
+  var _resolvedConfig$outpu;
+
+  const outputPath = path.join(appDirectory, (resolvedConfig === null || resolvedConfig === void 0 ? void 0 : (_resolvedConfig$outpu = resolvedConfig.output) === null || _resolvedConfig$outpu === void 0 ? void 0 : _resolvedConfig$outpu.path) || './dist', OUTPUT_CONFIG_FILE);
+  await fs.writeJSON(outputPath, resolvedConfig, {
+    spaces: 2,
+    replacer: safeReplacer()
+  });
+};

package/dist/js/modern/utils/createCompiler.js

@@ -0,0 +1,61 @@
+import { webpack } from '@modern-js/webpack';
+import { chalk, logger, formatWebpackMessages, clearConsole } from '@modern-js/utils';
+import { printInstructions } from "./printInstructions";
+export const createCompiler = async ({
+  api,
+  webpackConfigs,
+  // TODO: params
+  userConfig,
+  appContext
+}) => {
+  try {
+    const hookRunners = api.useHookRunners();
+    await hookRunners.beforeCreateCompiler({
+      webpackConfigs
+    });
+    const compiler = webpack(webpackConfigs);
+    await hookRunners.afterCreateCompiler({
+      compiler
+    });
+    let isFirstCompile = true;
+    compiler.hooks.invalid.tap('invalid', () => {
+      clearConsole();
+      logger.log('Compiling...');
+    });
+    compiler.hooks.done.tap('done', async stats => {
+      const statsData = stats.toJson({
+        preset: 'errors-warnings'
+      });
+      const {
+        errors,
+        warnings
+      } = formatWebpackMessages(statsData);
+
+      if (errors.length) {
+        logger.log(chalk.red(`Failed to compile.\n`));
+        logger.log(errors.join('\n\n'));
+        logger.log();
+      } else if (process.stdout.isTTY || isFirstCompile) {
+        await hookRunners.afterDev();
+
+        if (warnings.length) {
+          logger.log(chalk.yellow(`Compiled with warnings.\n`));
+          logger.log(warnings.join('\n\n'));
+          logger.log();
+        }
+
+        await printInstructions(hookRunners, appContext, userConfig);
+      }
+
+      isFirstCompile = false;
+    });
+    return compiler;
+  } catch (err) {
+    logger.log(chalk.red(`Failed to compile.`));
+    logger.log();
+    logger.log(err); // FIXME: 这里最好抛出异常，执行 process.exit 的地方尽可能少或者控制在几个统一的地方比较合适
+    // eslint-disable-next-line no-process-exit
+
+    process.exit(1);
+  }
+};

package/dist/js/modern/utils/createServer.js

@@ -0,0 +1,18 @@
+import { Server } from '@modern-js/server';
+let server = null;
+export const getServer = () => server;
+export const closeServer = async () => {
+  if (server) {
+    await server.close();
+    server = null;
+  }
+};
+export const createServer = async options => {
+  if (server) {
+    await server.close();
+  }
+
+  server = new Server(options);
+  const app = await server.init();
+  return app;
+};

package/dist/js/modern/utils/getSpecifiedEntries.js

@@ -0,0 +1,36 @@
+import { inquirer } from '@modern-js/utils';
+export const getSpecifiedEntries = async (entry, entrypoints) => {
+  const entryNames = entrypoints.map(e => e.entryName);
+
+  if (!entry) {
+    return entryNames;
+  }
+
+  if (typeof entry === 'boolean') {
+    const {
+      selected
+    } = await inquirer.prompt([{
+      type: 'checkbox',
+      name: 'selected',
+      choices: entryNames,
+      message: '请选择需要构建的入口',
+
+      validate(answer) {
+        if (answer.length < 1) {
+          return 'You must choose at least one topping.';
+        }
+
+        return true;
+      }
+
+    }]);
+    return selected;
+  }
+
+  entry.forEach(name => {
+    if (!entryNames.includes(name)) {
+      throw new Error(`can not found entry ${name}, compiler entry should in ${entryNames.join(', ')}`);
+    }
+  });
+  return entry;
+};

package/dist/js/modern/utils/language.js

@@ -0,0 +1,5 @@
+import { I18CLILanguageDetector } from '@modern-js/plugin-i18n/language-detector';
+export function getLocaleLanguage() {
+  const detector = new I18CLILanguageDetector();
+  return detector.detect();
+}

package/dist/js/modern/utils/printInstructions.js

@@ -0,0 +1,11 @@
+import { prettyInstructions, logger } from '@modern-js/utils';
+export const printInstructions = async (hookRunners, appContext, config) => {
+  const message = prettyInstructions(appContext, config); // call beforePrintInstructions hook.
+
+  const {
+    instructions
+  } = await hookRunners.beforePrintInstructions({
+    instructions: message
+  });
+  logger.log(instructions);
+};

package/dist/js/modern/utils/routes.js

@@ -0,0 +1,15 @@
+import path from 'path';
+import { fs, ROUTE_SPEC_FILE } from '@modern-js/utils';
+
+const generateRoutes = async appContext => {
+  const {
+    serverRoutes,
+    distDirectory
+  } = appContext;
+  const output = JSON.stringify({
+    routes: serverRoutes
+  }, null, 2);
+  await fs.outputFile(path.join(distDirectory, ROUTE_SPEC_FILE), output);
+};
+
+export { generateRoutes };

package/dist/js/node/analyze/constants.js

@@ -0,0 +1,36 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.PAGES_DIR_NAME = exports.JS_EXTENSIONS = exports.INDEX_FILE_NAME = exports.HTML_PARTIALS_FOLDER = exports.HTML_PARTIALS_EXTENSIONS = exports.FILE_SYSTEM_ROUTES_LAYOUT = exports.FILE_SYSTEM_ROUTES_INDEX = exports.FILE_SYSTEM_ROUTES_IGNORED_REGEX = exports.FILE_SYSTEM_ROUTES_GLOBAL_LAYOUT = exports.FILE_SYSTEM_ROUTES_FILE_NAME = exports.FILE_SYSTEM_ROUTES_DYNAMIC_REGEXP = exports.FILE_SYSTEM_ROUTES_COMPONENTS_DIR = exports.ENTRY_POINT_FILE_NAME = exports.ENTRY_BOOTSTRAP_FILE_NAME = exports.APP_FILE_NAME = void 0;
+const JS_EXTENSIONS = ['.js', '.ts', '.jsx', '.tsx'];
+exports.JS_EXTENSIONS = JS_EXTENSIONS;
+const INDEX_FILE_NAME = 'index';
+exports.INDEX_FILE_NAME = INDEX_FILE_NAME;
+const APP_FILE_NAME = 'App';
+exports.APP_FILE_NAME = APP_FILE_NAME;
+const PAGES_DIR_NAME = 'pages';
+exports.PAGES_DIR_NAME = PAGES_DIR_NAME;
+const FILE_SYSTEM_ROUTES_FILE_NAME = 'routes.js';
+exports.FILE_SYSTEM_ROUTES_FILE_NAME = FILE_SYSTEM_ROUTES_FILE_NAME;
+const ENTRY_POINT_FILE_NAME = 'index.js';
+exports.ENTRY_POINT_FILE_NAME = ENTRY_POINT_FILE_NAME;
+const ENTRY_BOOTSTRAP_FILE_NAME = 'bootstrap.js';
+exports.ENTRY_BOOTSTRAP_FILE_NAME = ENTRY_BOOTSTRAP_FILE_NAME;
+const FILE_SYSTEM_ROUTES_DYNAMIC_REGEXP = /^\[(\S+)\]([*+?]?)$/;
+exports.FILE_SYSTEM_ROUTES_DYNAMIC_REGEXP = FILE_SYSTEM_ROUTES_DYNAMIC_REGEXP;
+const FILE_SYSTEM_ROUTES_LAYOUT = '_layout';
+exports.FILE_SYSTEM_ROUTES_LAYOUT = FILE_SYSTEM_ROUTES_LAYOUT;
+const FILE_SYSTEM_ROUTES_GLOBAL_LAYOUT = '_app';
+exports.FILE_SYSTEM_ROUTES_GLOBAL_LAYOUT = FILE_SYSTEM_ROUTES_GLOBAL_LAYOUT;
+const FILE_SYSTEM_ROUTES_INDEX = 'index';
+exports.FILE_SYSTEM_ROUTES_INDEX = FILE_SYSTEM_ROUTES_INDEX;
+const FILE_SYSTEM_ROUTES_IGNORED_REGEX = /\.(d|test|spec|e2e)\.(js|jsx|ts|tsx)$/;
+exports.FILE_SYSTEM_ROUTES_IGNORED_REGEX = FILE_SYSTEM_ROUTES_IGNORED_REGEX;
+const HTML_PARTIALS_FOLDER = 'html';
+exports.HTML_PARTIALS_FOLDER = HTML_PARTIALS_FOLDER;
+const HTML_PARTIALS_EXTENSIONS = ['.htm', '.html', '.ejs'];
+exports.HTML_PARTIALS_EXTENSIONS = HTML_PARTIALS_EXTENSIONS;
+const FILE_SYSTEM_ROUTES_COMPONENTS_DIR = 'internal_components';
+exports.FILE_SYSTEM_ROUTES_COMPONENTS_DIR = FILE_SYSTEM_ROUTES_COMPONENTS_DIR;

package/dist/js/node/analyze/generateCode.js

@@ -0,0 +1,208 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.generateCode = exports.createImportStatements = void 0;
+
+var _path = _interopRequireDefault(require("path"));
+
+var _utils = require("@modern-js/utils");
+
+var templates = _interopRequireWildcard(require("./templates"));
+
+var _getClientRoutes = require("./getClientRoutes");
+
+var _constants = require("./constants");
+
+var _utils2 = require("./utils");
+
+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 _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+const createImportSpecifier = specifiers => {
+  let defaults = '';
+  const named = [];
+
+  for (const {
+    local,
+    imported
+  } of specifiers) {
+    if (local && imported) {
+      named.push(`${imported} as ${local}`);
+    } else if (local) {
+      defaults = local;
+    } else {
+      named.push(imported);
+    }
+  }
+
+  if (defaults && named.length) {
+    return `${defaults}, { ${named.join(', ')} }`;
+  } else if (defaults) {
+    return defaults;
+  } else {
+    return `{ ${named.join(', ')} }`;
+  }
+};
+
+const createImportStatements = statements => {
+  // merge import statements with the same value.
+  const deDuplicated = [];
+  const seen = new Map();
+
+  for (const {
+    value,
+    specifiers,
+    initialize
+  } of statements) {
+    if (!seen.has(value)) {
+      deDuplicated.push({
+        value,
+        specifiers,
+        initialize
+      });
+      seen.set(value, specifiers);
+    } else {
+      var _deDuplicated$modifyI, _deDuplicated$modifyI2;
+
+      seen.get(value).push(...specifiers); // make "initialize" param can be connected when multiple plugins were imported from same package
+
+      const modifyIndex = deDuplicated.findIndex(v => v.value === value);
+      const originInitialize = (_deDuplicated$modifyI = (_deDuplicated$modifyI2 = deDuplicated[modifyIndex]) === null || _deDuplicated$modifyI2 === void 0 ? void 0 : _deDuplicated$modifyI2.initialize) !== null && _deDuplicated$modifyI !== void 0 ? _deDuplicated$modifyI : '';
+      deDuplicated[modifyIndex].initialize = originInitialize.concat(`\n${initialize || ''}`);
+    }
+  }
+
+  return deDuplicated.map(({
+    value,
+    specifiers,
+    initialize
+  }) => `import ${createImportSpecifier(specifiers)} from '${value}';\n${initialize || ''}`).join('\n');
+};
+
+exports.createImportStatements = createImportStatements;
+
+const generateCode = async (appContext, config, entrypoints, api) => {
+  const {
+    internalDirectory,
+    srcDirectory,
+    internalDirAlias,
+    internalSrcAlias
+  } = appContext;
+  const hookRunners = api.useHookRunners();
+  const {
+    output: {
+      mountId
+    }
+  } = config;
+
+  for (const entrypoint of entrypoints) {
+    const {
+      entryName,
+      isAutoMount,
+      customBootstrap,
+      fileSystemRoutes
+    } = entrypoint;
+
+    if (isAutoMount) {
+      // generate routes file for file system routes entrypoint.
+      if (fileSystemRoutes) {
+        const initialRoutes = (0, _getClientRoutes.getClientRoutes)({
+          entrypoint,
+          srcDirectory,
+          srcAlias: internalSrcAlias,
+          internalDirectory,
+          internalDirAlias
+        });
+        const {
+          routes
+        } = await hookRunners.modifyFileSystemRoutes({
+          entrypoint,
+          routes: initialRoutes
+        });
+        const {
+          code
+        } = await hookRunners.beforeGenerateRoutes({
+          entrypoint,
+          code: templates.fileSystemRoutes({
+            routes
+          })
+        });
+
+        _utils.fs.outputFileSync(_path.default.resolve(internalDirectory, `./${entryName}/${_constants.FILE_SYSTEM_ROUTES_FILE_NAME}`), code, 'utf8');
+      } // call modifyEntryImports hook
+
+
+      const {
+        imports: importStatements
+      } = await hookRunners.modifyEntryImports({
+        entrypoint,
+        imports: (0, _utils2.getDefaultImports)({
+          entrypoint,
+          srcDirectory,
+          internalSrcAlias,
+          internalDirAlias,
+          internalDirectory
+        })
+      }); // call modifyEntryRuntimePlugins hook
+
+      const {
+        plugins
+      } = await hookRunners.modifyEntryRuntimePlugins({
+        entrypoint,
+        plugins: []
+      }); // call modifyEntryRenderFunction hook
+
+      const {
+        code: renderFunction
+      } = await hookRunners.modifyEntryRenderFunction({
+        entrypoint,
+        code: templates.renderFunction({
+          plugins,
+          customBootstrap,
+          fileSystemRoutes
+        })
+      }); // call modifyEntryExport hook
+
+      const {
+        exportStatement
+      } = await hookRunners.modifyEntryExport({
+        entrypoint,
+        exportStatement: 'export default AppWrapper;'
+      });
+      const code = templates.index({
+        mountId: mountId,
+        imports: createImportStatements(importStatements),
+        renderFunction,
+        exportStatement
+      });
+
+      const entryFile = _path.default.resolve(internalDirectory, `./${entryName}/${_constants.ENTRY_POINT_FILE_NAME}`);
+
+      entrypoint.entry = entryFile; // generate entry file.
+
+      if (config.source.enableAsyncEntry) {
+        const {
+          code: asyncEntryCode
+        } = await hookRunners.modifyAsyncEntry({
+          entrypoint,
+          code: `import('./${_constants.ENTRY_BOOTSTRAP_FILE_NAME}');`
+        });
+
+        _utils.fs.outputFileSync(entryFile, asyncEntryCode, 'utf8');
+
+        const bootstrapFile = _path.default.resolve(internalDirectory, `./${entryName}/${_constants.ENTRY_BOOTSTRAP_FILE_NAME}`);
+
+        _utils.fs.outputFileSync(bootstrapFile, code, 'utf8');
+      } else {
+        _utils.fs.outputFileSync(entryFile, code, 'utf8');
+      }
+    }
+  }
+};
+
+exports.generateCode = generateCode;

package/dist/js/node/analyze/getBundleEntry.js

@@ -0,0 +1,89 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getBundleEntry = void 0;
+
+var _path = _interopRequireDefault(require("path"));
+
+var _utils = require("@modern-js/utils");
+
+var _getFileSystemEntry = require("./getFileSystemEntry");
+
+var _constants = require("./constants");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+const ensureExtensions = file => {
+  if (!_path.default.extname(file)) {
+    return (0, _utils.findExists)(_constants.JS_EXTENSIONS.map(ext => `${file}${ext}`)) || file;
+  }
+
+  return file;
+};
+
+const ifAlreadyExists = (entrypoints, checked) => entrypoints.some(entrypoint => {
+  if (ensureExtensions(entrypoint.entry) === ensureExtensions(checked.entry)) {
+    // reset entryName
+    checked.entryName = entrypoint.entryName;
+    return true;
+  } // filesystem routes entrypoint conflict with normal entrypoint.
+
+
+  if (entrypoint.entry.startsWith(checked.entry) || checked.entry.startsWith(entrypoint.entry)) {
+    throw new Error(`Entry configuration conflicts\n Your configuration: ${checked.entry}.\n Default entrypoint: ${entrypoint.entry}\n Please reset source.entries or set source.disableDefaultEntries to disable the default entry rules.`);
+  }
+
+  return false;
+});
+
+const getBundleEntry = (appContext, config) => {
+  const {
+    appDirectory,
+    packageName
+  } = appContext;
+  const {
+    source: {
+      disableDefaultEntries,
+      entries,
+      entriesDir
+    }
+  } = config;
+  const defaults = disableDefaultEntries ? [] : (0, _getFileSystemEntry.getFileSystemEntry)(appContext, config); // merge entrypoints from user config with directory convention.
+
+  if (entries) {
+    Object.keys(entries).forEach(name => {
+      const value = entries[name];
+      const entrypoint = typeof value === 'string' ? {
+        entryName: name,
+        entry: (0, _utils.ensureAbsolutePath)(appDirectory, value),
+        isAutoMount: true,
+        fileSystemRoutes: _utils.fs.statSync((0, _utils.ensureAbsolutePath)(appDirectory, value)).isDirectory() ? {} : undefined
+      } : {
+        entryName: name,
+        entry: (0, _utils.ensureAbsolutePath)(appDirectory, value.entry),
+        isAutoMount: !value.disableMount,
+        fileSystemRoutes: value.enableFileSystemRoutes ? {} : undefined
+      };
+
+      if (!ifAlreadyExists(defaults, entrypoint)) {
+        defaults.push(entrypoint);
+      }
+    });
+  }
+
+  if (!disableDefaultEntries) {
+    // find main entry point which server route is '/'.
+    const entriesDirAbs = (0, _utils.ensureAbsolutePath)(appDirectory, entriesDir);
+    const found = defaults.find(({
+      entryName,
+      entry
+    }) => entryName === packageName || _path.default.dirname(entry) === entriesDirAbs);
+    found && (found.entryName = _utils.MAIN_ENTRY_NAME);
+  }
+
+  return defaults;
+};
+
+exports.getBundleEntry = getBundleEntry;