@modern-js/core 1.9.1 → 1.9.2

package/dist/js/modern/config/schema/server.js

@@ -0,0 +1,170 @@
+import { ENTRY_NAME_PATTERN } from '@modern-js/utils';
+const SERVER_ROUTE_OBJECT = {
+  type: 'object',
+  properties: {
+    path: {
+      type: 'string'
+    },
+    headers: {
+      type: 'object'
+    }
+  },
+  additionalProperties: false
+};
+export const server = {
+  type: 'object',
+  additionalProperties: false,
+  properties: {
+    port: {
+      type: 'number'
+    },
+    ssr: {
+      if: {
+        type: 'object'
+      },
+      then: {
+        properties: {
+          disableLoadable: {
+            type: 'boolean'
+          },
+          disableHelmet: {
+            type: 'boolean'
+          },
+          disableRedirect: {
+            type: 'boolean'
+          },
+          enableAsyncData: {
+            type: 'boolean'
+          },
+          enableProductWarning: {
+            type: 'boolean'
+          },
+          timeout: {
+            type: 'number'
+          },
+          asyncDataTimeout: {
+            type: 'number'
+          }
+        }
+      },
+      else: {
+        type: 'boolean'
+      }
+    },
+    ssrByEntries: {
+      type: 'object',
+      patternProperties: {
+        [ENTRY_NAME_PATTERN]: {
+          if: {
+            type: 'object'
+          },
+          then: {
+            properties: {
+              disableLoadable: {
+                type: 'boolean'
+              },
+              disableHelmet: {
+                type: 'boolean'
+              },
+              disableRedirect: {
+                type: 'boolean'
+              },
+              enableProductWarning: {
+                type: 'boolean'
+              },
+              enableAsyncData: {
+                type: 'boolean'
+              },
+              timeout: {
+                type: 'number'
+              },
+              asyncDataTimeout: {
+                type: 'number'
+              }
+            },
+            additionalProperties: false
+          },
+          else: {
+            type: 'boolean'
+          }
+        }
+      }
+    },
+    routes: {
+      type: 'object',
+      patternProperties: {
+        [ENTRY_NAME_PATTERN]: {
+          if: {
+            type: 'object'
+          },
+          then: {
+            properties: {
+              route: {
+                oneOf: [{
+                  type: 'string'
+                }, {
+                  type: 'array',
+                  items: {
+                    oneOf: [{
+                      type: 'string'
+                    }, SERVER_ROUTE_OBJECT]
+                  }
+                }, SERVER_ROUTE_OBJECT]
+              },
+              disableSpa: {
+                type: 'boolean'
+              }
+            },
+            additionalProperties: false
+          },
+          else: {
+            oneOf: [{
+              type: 'string'
+            }, {
+              type: 'array',
+              items: {
+                type: 'string'
+              }
+            }]
+          }
+        }
+      }
+    },
+    publicRoutes: {
+      type: 'object',
+      patternProperties: {
+        [ENTRY_NAME_PATTERN]: {
+          type: ['string']
+        }
+      }
+    },
+    baseUrl: {
+      oneOf: [{
+        type: 'string'
+      }, {
+        type: 'array',
+        items: [{
+          type: 'string'
+        }]
+      }]
+    },
+    middleware: {
+      instanceof: ['Array', 'Function']
+    },
+    renderHook: {
+      instanceof: 'Function'
+    },
+    logger: {
+      type: ['object', 'boolean']
+    },
+    metrics: {
+      type: ['object', 'boolean']
+    },
+    proxy: {
+      type: 'object'
+    },
+    enableMicroFrontendDebug: {
+      type: 'boolean'
+    }
+  }
+};

package/dist/js/modern/config/schema/source.js

@@ -0,0 +1,59 @@
+import { ENTRY_NAME_PATTERN } from '@modern-js/utils';
+export const source = {
+  type: 'object',
+  additionalProperties: false,
+  properties: {
+    entries: {
+      type: 'object',
+      patternProperties: {
+        [ENTRY_NAME_PATTERN]: {
+          if: {
+            type: 'object'
+          },
+          then: {
+            required: ['entry'],
+            properties: {
+              entry: {
+                type: ['string', 'array']
+              },
+              disableMount: {
+                type: 'boolean'
+              },
+              enableFileSystemRoutes: {
+                type: 'boolean'
+              }
+            },
+            additionalProperties: false
+          },
+          else: {
+            type: ['string', 'array']
+          }
+        }
+      }
+    },
+    alias: {
+      typeof: ['object', 'function']
+    },
+    disableDefaultEntries: {
+      type: 'boolean'
+    },
+    envVars: {
+      type: 'array'
+    },
+    globalVars: {
+      type: 'object'
+    },
+    moduleScopes: {
+      instanceof: ['Array', 'Function']
+    },
+    entriesDir: {
+      type: 'string'
+    },
+    configDir: {
+      type: 'string'
+    },
+    include: {
+      type: ['array']
+    }
+  }
+};

package/dist/js/modern/config/schema/tools.js

@@ -0,0 +1,36 @@
+export const tools = {
+  type: 'object',
+  additionalProperties: false,
+  properties: {
+    webpack: {
+      typeof: ['object', 'function']
+    },
+    babel: {
+      typeof: ['object', 'function']
+    },
+    postcss: {
+      typeof: ['object', 'function']
+    },
+    lodash: {
+      typeof: ['object', 'function']
+    },
+    devServer: {
+      type: 'object'
+    },
+    tsLoader: {
+      typeof: ['object', 'function']
+    },
+    autoprefixer: {
+      typeof: ['object', 'function']
+    },
+    terser: {
+      typeof: ['object', 'function']
+    },
+    minifyCss: {
+      typeof: ['object', 'function']
+    },
+    styledComponents: {
+      typeof: ['object', 'function']
+    }
+  }
+};

package/dist/js/modern/config/types/electron.js

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

package/dist/js/modern/config/types/index.js

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

package/dist/js/modern/context.js

@@ -0,0 +1,63 @@
+import path from 'path';
+import { createContext } from '@modern-js/plugin';
+import address from 'address';
+export const AppContext = createContext({});
+export const ConfigContext = createContext({});
+export const ResolvedConfigContext = createContext({});
+/**
+ * Set app context.
+ * @param value new app context. It will override previous app context.
+ */
+
+export const setAppContext = value => AppContext.set(value);
+/**
+ * Get app context, including directories, plugins and some static infos.
+ */
+
+export const useAppContext = () => AppContext.use().value;
+/**
+ * Get original content of user config.
+ */
+
+export const useConfigContext = () => ConfigContext.use().value;
+/**
+ * Get normalized content of user config.
+ */
+
+export const useResolvedConfigContext = () => ResolvedConfigContext.use().value;
+export const initAppContext = ({
+  appDirectory,
+  plugins,
+  configFile,
+  options,
+  serverConfigFile
+}) => {
+  const {
+    metaName = 'modern-js',
+    srcDir = 'src',
+    distDir = '',
+    sharedDir = 'shared'
+  } = options || {};
+  return {
+    metaName,
+    appDirectory,
+    configFile,
+    serverConfigFile,
+    ip: address.ip(),
+    port: 0,
+    packageName: require(path.resolve(appDirectory, './package.json')).name,
+    srcDirectory: path.resolve(appDirectory, srcDir),
+    distDirectory: distDir,
+    sharedDirectory: path.resolve(appDirectory, sharedDir),
+    nodeModulesDirectory: path.resolve(appDirectory, './node_modules'),
+    internalDirectory: path.resolve(appDirectory, `./node_modules/.${metaName}`),
+    plugins,
+    htmlTemplates: {},
+    serverRoutes: [],
+    entrypoints: [],
+    checkedEntries: [],
+    apiOnly: false,
+    internalDirAlias: `@_${metaName.replace(/-/g, '_')}_internal`,
+    internalSrcAlias: `@_${metaName.replace(/-/g, '_')}_src`
+  };
+};

package/dist/js/modern/index.js

@@ -0,0 +1,169 @@
+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 path from 'path';
+import { pkgUp, program, ensureAbsolutePath, logger, DEFAULT_SERVER_CONFIG } from '@modern-js/utils';
+import { enable } from '@modern-js/plugin/node';
+import { initCommandsMap } from "./utils/commander";
+import { resolveConfig, loadUserConfig, addServerConfigToDeps } from "./config";
+import { loadPlugins } from "./loadPlugins";
+import { AppContext, ConfigContext, initAppContext, ResolvedConfigContext } from "./context";
+import { initWatcher } from "./initWatcher";
+import { loadEnv } from "./loadEnv";
+import { manager } from "./manager";
+export * from "./config";
+export * from '@modern-js/plugin';
+export * from '@modern-js/plugin/node'; // TODO: remove export after refactor all plugins
+
+export { manager, mountHook, usePlugins, createPlugin, registerHook } from "./manager";
+// TODO: remove export after refactor all plugins
+export { AppContext, ConfigContext, ResolvedConfigContext, useAppContext, useConfigContext, useResolvedConfigContext } from "./pluginAPI";
+program.name('modern').usage('<command> [options]').version(process.env.MODERN_JS_VERSION || '0.1.0');
+
+const initAppDir = async cwd => {
+  if (!cwd) {
+    // eslint-disable-next-line no-param-reassign
+    cwd = process.cwd();
+  }
+
+  const pkg = await pkgUp({
+    cwd
+  });
+
+  if (!pkg) {
+    throw new Error(`no package.json found in current work dir: ${cwd}`);
+  }
+
+  return path.dirname(pkg);
+};
+
+export const mergeOptions = options => {
+  const defaultOptions = {
+    serverConfigFile: DEFAULT_SERVER_CONFIG
+  };
+  return _objectSpread(_objectSpread({}, defaultOptions), options);
+};
+
+const createCli = () => {
+  let hooksRunner;
+  let isRestart = false;
+  let restartWithExistingPort = 0;
+  let restartOptions;
+
+  const init = async (argv = [], options) => {
+    var _mergedOptions$option, _mergedOptions$option2;
+
+    enable();
+    manager.clear();
+    const mergedOptions = mergeOptions(options);
+    restartOptions = mergedOptions;
+    const appDirectory = await initAppDir();
+    initCommandsMap();
+    const metaName = (_mergedOptions$option = mergedOptions === null || mergedOptions === void 0 ? void 0 : (_mergedOptions$option2 = mergedOptions.options) === null || _mergedOptions$option2 === void 0 ? void 0 : _mergedOptions$option2.metaName) !== null && _mergedOptions$option !== void 0 ? _mergedOptions$option : 'MODERN';
+    loadEnv(appDirectory, process.env[`${metaName.toUpperCase()}_ENV`]);
+    const loaded = await loadUserConfig(appDirectory, mergedOptions === null || mergedOptions === void 0 ? void 0 : mergedOptions.configFile, mergedOptions === null || mergedOptions === void 0 ? void 0 : mergedOptions.packageJsonConfig);
+    const plugins = loadPlugins(appDirectory, loaded.config, {
+      internalPlugins: mergedOptions === null || mergedOptions === void 0 ? void 0 : mergedOptions.plugins,
+      transformPlugin: mergedOptions === null || mergedOptions === void 0 ? void 0 : mergedOptions.transformPlugin
+    });
+    plugins.forEach(plugin => plugin.cli && manager.usePlugin(plugin.cli));
+    const appContext = initAppContext({
+      appDirectory,
+      plugins,
+      configFile: loaded.filePath,
+      options: mergedOptions === null || mergedOptions === void 0 ? void 0 : mergedOptions.options,
+      serverConfigFile: mergedOptions === null || mergedOptions === void 0 ? void 0 : mergedOptions.serverConfigFile
+    }); // 将 server.config 加入到 loaded.dependencies，以便对文件监听做热更新
+
+    addServerConfigToDeps(loaded.dependencies, appDirectory, mergedOptions.serverConfigFile);
+    manager.run(() => {
+      ConfigContext.set(loaded.config);
+      AppContext.set(appContext);
+    });
+    hooksRunner = await manager.init();
+    ['SIGINT', 'SIGTERM', 'unhandledRejection', 'uncaughtException'].forEach(event => {
+      process.on(event, async err => {
+        await hooksRunner.beforeExit();
+
+        if (err instanceof Error) {
+          logger.error(err.stack);
+        }
+
+        process.nextTick(() => {
+          // eslint-disable-next-line no-process-exit
+          process.exit(1);
+        });
+      });
+    });
+    const extraConfigs = await hooksRunner.config();
+    const extraSchemas = await hooksRunner.validateSchema();
+    const config = await resolveConfig(loaded, extraConfigs, extraSchemas, restartWithExistingPort, argv, options === null || options === void 0 ? void 0 : options.onSchemaError);
+    const {
+      resolved
+    } = await hooksRunner.resolvedConfig({
+      resolved: config
+    }); // update context value
+
+    manager.run(() => {
+      ConfigContext.set(loaded.config);
+      ResolvedConfigContext.set(resolved);
+      AppContext.set(_objectSpread(_objectSpread({}, appContext), {}, {
+        port: resolved.server.port,
+        distDirectory: ensureAbsolutePath(appDirectory, resolved.output.path)
+      }));
+    });
+    await hooksRunner.prepare();
+    return {
+      loadedConfig: loaded,
+      appContext,
+      resolved
+    };
+  };
+
+  async function run(argv, options) {
+    const {
+      loadedConfig,
+      appContext,
+      resolved
+    } = await init(argv, options);
+    await hooksRunner.commands({
+      program
+    });
+    initWatcher(loadedConfig, appContext.appDirectory, resolved.source.configDir, hooksRunner, argv);
+    manager.run(() => program.parse(process.argv));
+  }
+
+  async function restart() {
+    var _AppContext$use$value, _AppContext$use$value2;
+
+    isRestart = true;
+    restartWithExistingPort = isRestart ? (_AppContext$use$value = (_AppContext$use$value2 = AppContext.use().value) === null || _AppContext$use$value2 === void 0 ? void 0 : _AppContext$use$value2.port) !== null && _AppContext$use$value !== void 0 ? _AppContext$use$value : 0 : 0;
+    logger.info('Restart...\n');
+    let hasGetError = false;
+    const runner = manager.useRunner();
+    await runner.beforeRestart();
+
+    try {
+      await init(process.argv.slice(2), restartOptions);
+    } catch (err) {
+      console.error(err);
+      hasGetError = true;
+    } finally {
+      if (!hasGetError) {
+        manager.run(() => program.parse(process.argv));
+      }
+    }
+  }
+
+  return {
+    init,
+    run,
+    restart
+  };
+};
+
+export const cli = createCli();
+export { initAppDir, initAppContext };

package/dist/js/modern/initWatcher.js

@@ -0,0 +1,62 @@
+import crypto from 'crypto';
+import fs from 'fs';
+import path from 'path';
+import { isDev, chokidar, createDebugger, isTest } from '@modern-js/utils';
+const debug = createDebugger('watch-files');
+
+const md5 = data => crypto.createHash('md5').update(data).digest('hex');
+
+const hashMap = new Map();
+export const initWatcher = async (loaded, appDirectory, configDir, hooksRunner, argv) => {
+  // only add fs watcher on dev mode.
+  if ((isDev() || isTest()) && argv[0] === 'dev') {
+    const extraFiles = await hooksRunner.watchFiles();
+    const configPath = path.join(appDirectory, configDir);
+    const watched = [`${configPath}/html`, ...extraFiles, loaded === null || loaded === void 0 ? void 0 : loaded.filePath, ...loaded.dependencies].filter(Boolean);
+    debug(`watched: %o`, watched);
+    const watcher = chokidar.watch(watched, {
+      cwd: appDirectory,
+      ignoreInitial: true,
+      ignorePermissionErrors: true,
+      ignored: [/node_modules/, '**/__test__/**', '**/*.test.(js|jsx|ts|tsx)', '**/*.spec.(js|jsx|ts|tsx)', '**/*.stories.(js|jsx|ts|tsx)']
+    });
+    watcher.on('change', changed => {
+      const lastHash = hashMap.get(changed);
+      const currentHash = md5(fs.readFileSync(path.join(appDirectory, changed), 'utf8'));
+
+      if (currentHash !== lastHash) {
+        debug(`file change: %s`, changed);
+        hashMap.set(changed, currentHash);
+        hooksRunner.fileChange({
+          filename: changed,
+          eventType: 'change'
+        });
+      }
+    });
+    watcher.on('add', name => {
+      debug(`add file: %s`, name);
+      const currentHash = md5(fs.readFileSync(path.join(appDirectory, name), 'utf8'));
+      hashMap.set(name, currentHash);
+      hooksRunner.fileChange({
+        filename: name,
+        eventType: 'add'
+      });
+    });
+    watcher.on('unlink', name => {
+      debug(`remove file: %s`, name);
+
+      if (hashMap.has(name)) {
+        hashMap.delete(name);
+      }
+
+      hooksRunner.fileChange({
+        filename: name,
+        eventType: 'unlink'
+      });
+    });
+    watcher.on('error', err => {
+      throw err;
+    });
+    return watcher;
+  }
+};

package/dist/js/modern/loadEnv.js

@@ -0,0 +1,14 @@
+import fs from 'fs';
+import path from 'path';
+import dotenv from 'dotenv';
+import dotenvExpand from 'dotenv-expand';
+export const loadEnv = (appDirectory, mode = process.env.NODE_ENV) => {
+  // Don't change the order of the filenames， since they are ordered by the priority.
+  // Files on the left have more priority than files on the right.
+  [`.env.${mode}.local`, '.env.local', `.env.${mode}`, '.env'].map(name => path.resolve(appDirectory, name)).filter(filePath => fs.existsSync(filePath) && !fs.statSync(filePath).isDirectory()).forEach(filePath => {
+    const envConfig = dotenv.config({
+      path: filePath
+    });
+    dotenvExpand(envConfig);
+  });
+};