@modern-js/core 1.0.0-alpha.3

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

@@ -0,0 +1,167 @@
+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'
+    },
+    measure: {
+      type: 'object'
+    },
+    proxy: {
+      type: 'object'
+    }
+  }
+};

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,33 @@
+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']
+    }
+  }
+};

package/dist/js/modern/context.js

@@ -0,0 +1,25 @@
+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({});
+export const useAppContext = () => AppContext.use();
+export const useConfigContext = () => ConfigContext.use();
+export const useResolvedConfigContext = () => ResolvedConfigContext.use();
+export const initAppContext = (appDirectory, plugins, configFile) => ({
+  appDirectory,
+  configFile,
+  ip: address.ip(),
+  port: 0,
+  packageName: require(path.resolve(appDirectory, './package.json')).name,
+  srcDirectory: path.resolve(appDirectory, './src'),
+  distDirectory: '',
+  sharedDirectory: path.resolve(appDirectory, './shared'),
+  nodeModulesDirectory: path.resolve(appDirectory, './node_modules'),
+  internalDirectory: path.resolve(appDirectory, './node_modules/.modern-js'),
+  plugins,
+  htmlTemplates: {},
+  serverRoutes: [],
+  entrypoints: []
+});

package/dist/js/modern/index.js

@@ -0,0 +1,137 @@
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (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 = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { 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 { createAsyncManager, createContext, createAsyncWorkflow, createParallelWorkflow } from '@modern-js/plugin';
+import { enable } from '@modern-js/plugin/node';
+import { compatRequire, pkgUp, ensureAbsolutePath, logger } from '@modern-js/utils';
+import { program } from "./utils/commander";
+import { resolveConfig, defineConfig, loadUserConfig } from "./config";
+import { loadPlugins } from "./loadPlugins";
+import { AppContext, ConfigContext, initAppContext, ResolvedConfigContext, useAppContext, useConfigContext, useResolvedConfigContext } from "./context";
+import { initWatcher } from "./initWatcher";
+import { loadEnv } from "./loadEnv";
+export { defaultsConfig } from "./config";
+program.name('modern').usage('<command> [options]').version(process.env.MODERN_JS_VERSION || '0.1.0');
+const hooksMap = {
+  config: createParallelWorkflow(),
+  validateSchema: createParallelWorkflow(),
+  // eslint-disable-next-line @typescript-eslint/no-invalid-void-type
+  prepare: createAsyncWorkflow(),
+  commands: createAsyncWorkflow(),
+  watchFiles: createParallelWorkflow(),
+  fileChange: createAsyncWorkflow(),
+  // eslint-disable-next-line @typescript-eslint/no-invalid-void-type
+  beforeExit: createAsyncWorkflow()
+};
+export const manager = createAsyncManager(hooksMap);
+export const {
+  createPlugin,
+  registe: registerHook,
+  useRunner: mountHook
+} = manager;
+export const usePlugins = plugins => plugins.forEach(plugin => manager.usePlugin(compatRequire(require.resolve(plugin))));
+export { defineConfig, createContext, AppContext, useAppContext, useConfigContext, useResolvedConfigContext };
+
+const initAppDir = async () => {
+  const pkg = await pkgUp({
+    cwd: process.cwd()
+  });
+
+  if (!pkg) {
+    throw new Error(`no package.json found in current work dir: ${process.cwd()}`);
+  }
+
+  return path.dirname(pkg);
+};
+
+const createCli = () => {
+  let hooksRunner;
+  let isRestart = false;
+
+  const init = async (argv = []) => {
+    manager.clear();
+    const appDirectory = await initAppDir();
+    loadEnv(appDirectory);
+    const loaded = await loadUserConfig(appDirectory);
+    const plugins = loadPlugins(appDirectory, loaded.config.plugins || []);
+    plugins.forEach(plugin => plugin.cli && manager.usePlugin(plugin.cli));
+    const appContext = initAppContext(appDirectory, plugins, loaded.filePath);
+    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 resolved = await resolveConfig(loaded, extraConfigs, extraSchemas, isRestart, argv); // 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) {
+    enable();
+    const {
+      loadedConfig,
+      appContext,
+      resolved
+    } = await init(argv);
+    initWatcher(loadedConfig, appContext.appDirectory, resolved, hooksRunner, argv);
+    await hooksRunner.commands({
+      program
+    });
+    manager.run(() => program.parse(process.argv));
+  }
+
+  async function restart() {
+    isRestart = true;
+
+    try {
+      logger.info('Restart...\n');
+      await init();
+      return true;
+    } catch (err) {
+      logger.error(err);
+    }
+
+    return false;
+  }
+
+  return {
+    init,
+    run,
+    restart
+  };
+};
+
+export const cli = createCli();

package/dist/js/modern/initWatcher.js

@@ -0,0 +1,51 @@
+import path from 'path';
+import crypto from 'crypto';
+import fs from 'fs';
+import chokidar from 'chokidar';
+import { isDev, createDebugger } 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, resovledConfig, hooksRunner, argv) => {
+  // only add fs watcher on dev mode.
+  if (isDev() && argv[0] === 'dev') {
+    const {
+      source: {
+        configDir
+      }
+    } = resovledConfig;
+    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,
+      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
+        });
+      }
+    });
+    watcher.on('unlink', name => {
+      debug(`remove file: %s`, name);
+
+      if (hashMap.has(name)) {
+        hashMap.delete(name);
+      }
+    });
+    watcher.on('error', err => {
+      throw err;
+    });
+  }
+};

package/dist/js/modern/loadEnv.js

@@ -0,0 +1,12 @@
+import path from 'path';
+import fs from 'fs';
+import dotenv from 'dotenv';
+import dotenvExpand from 'dotenv-expand';
+export const loadEnv = (appDirectory, mode = process.env.NODE_ENV) => {
+  [`.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);
+  });
+};

package/dist/js/modern/loadPlugins.js

@@ -0,0 +1,66 @@
+import { isDepExists, createDebugger, compatRequire, INTERNAL_PLUGINS } from '@modern-js/utils';
+const debug = createDebugger('load-plugins');
+
+/**
+ * Try to resolve plugin entry file path.
+ * @param appDirectory - Application root directory.
+ * @param plugin - Plugin name or plugin name with options.
+ * @returns Resolved file path.
+ */
+const resolvePlugin = (appDirectory, plugin) => {
+  const tryResolve = name => {
+    let filePath = '';
+
+    try {
+      filePath = require.resolve(name, {
+        paths: [appDirectory]
+      });
+      delete require.cache[filePath];
+    } catch (err) {
+      if (err.code === 'MODULE_NOT_FOUND') {
+        throw new Error(`Can not find plugin ${name}.`);
+      }
+
+      throw err;
+    }
+
+    return filePath;
+  };
+
+  const resolved = {};
+
+  if (plugin.cli) {
+    resolved.cli = tryResolve(plugin.cli);
+  }
+
+  if (plugin.server) {
+    resolved.server = tryResolve(plugin.server);
+  }
+
+  return resolved;
+};
+/**
+ * Load internal plugins which in @modern-js scope and user's custom plugins.
+ * @param appDirectory - Application root directory.
+ * @param pluginsConfig - Plugins declared in the user configuration.
+ * @returns Plugin Objects has been required.
+ */
+
+
+export const loadPlugins = (appDirectory, pluginConfig) => {
+  const plugins = [...Object.keys(INTERNAL_PLUGINS).filter(name => isDepExists(appDirectory, name)).map(name => INTERNAL_PLUGINS[name]), ...pluginConfig];
+  return plugins.map(plugin => {
+    const {
+      cli,
+      server
+    } = resolvePlugin(appDirectory, plugin);
+    debug(`resolve plugin %s: %s`, plugin, {
+      cli,
+      server
+    });
+    return {
+      cli: cli && compatRequire(cli),
+      server: server && compatRequire(server)
+    };
+  });
+};

package/dist/js/modern/utils/commander.js

@@ -0,0 +1,19 @@
+import { program, Command } from 'commander';
+
+if (!program.hasOwnProperty('commandsMap')) {
+  Object.defineProperty(program, 'commandsMap', {
+    get() {
+      const map = new Map();
+
+      for (const command of program.commands) {
+        map.set(command._name, command);
+      }
+
+      return map;
+    },
+
+    configurable: false
+  });
+}
+
+export { program, Command };

package/dist/js/modern/utils/repeatKeyWarning.js

@@ -0,0 +1,18 @@
+import { traverseSchema } from "../config/schema";
+export const deepGet = (obj, key) => {
+  for (const p of key.split('.')) {
+    // eslint-disable-next-line no-param-reassign
+    obj = obj ? obj[p] : undefined;
+  }
+
+  return obj;
+};
+export const repeatKeyWarning = (schema, jsConfig, pkgConfig) => {
+  const keys = traverseSchema(schema);
+
+  for (const key of keys) {
+    if (deepGet(jsConfig, key) !== undefined && deepGet(pkgConfig, key) !== undefined) {
+      throw new Error(`The same configuration ${key} exists in modern.config.js and package.json.\n Please remove it from package.json.`);
+    }
+  }
+};

package/dist/js/node/config/defaults.js

@@ -0,0 +1,109 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.defaults = void 0;
+const sourceDefaults = {
+  entries: undefined,
+  disableDefaultEntries: false,
+  entriesDir: './src',
+  configDir: './config',
+  apiDir: './api',
+  envVars: [],
+  globalVars: undefined,
+  alias: undefined,
+  moduleScopes: undefined,
+  include: []
+};
+const outputDefaults = {
+  assetPrefix: '/',
+  htmlPath: 'html',
+  jsPath: 'static/js',
+  cssPath: 'static/css',
+  mediaPath: 'static/media',
+  path: 'dist',
+  title: '',
+  titleByEntries: undefined,
+  meta: {
+    charset: {
+      charset: 'utf-8'
+    },
+    viewport: 'width=device-width, initial-scale=1.0, shrink-to-fit=no, viewport-fit=cover, minimum-scale=1.0, maximum-scale=1.0, user-scalable=no',
+    'http-equiv': {
+      'http-equiv': 'x-ua-compatible',
+      content: 'ie=edge'
+    },
+    renderer: 'webkit',
+    layoutmode: 'standard',
+    imagemode: 'force',
+    'wap-font-scale': 'no',
+    'format-detection': 'telephone=no'
+  },
+  metaByEntries: undefined,
+  inject: 'head',
+  injectByEntries: undefined,
+  mountId: 'root',
+  favicon: '',
+  faviconByEntries: undefined,
+  copy: undefined,
+  scriptExt: undefined,
+  disableHtmlFolder: false,
+  disableCssModuleExtension: false,
+  disableCssExtract: false,
+  enableCssModuleTSDeclaration: false,
+  disableMinimize: false,
+  enableInlineStyles: false,
+  enableInlineScripts: false,
+  disableSourceMap: false,
+  disableInlineRuntimeChunk: false,
+  disableAssetsCache: false,
+  enableLatestDecorators: false,
+  polyfill: 'entry',
+  dataUriLimit: 10000,
+  templateParameters: {},
+  templateParametersByEntries: undefined,
+  cssModuleLocalIdentName: '[name]__[local]--[hash:base64:5]',
+  enableModernMode: false,
+  federation: undefined,
+  disableNodePolyfill: false,
+  enableTsLoader: false
+};
+const serverDefaults = {
+  routes: undefined,
+  publicRoutes: undefined,
+  ssr: undefined,
+  ssrByEntries: undefined,
+  baseUrl: '/',
+  port: 8080
+};
+const devDefaults = {
+  assetPrefix: false
+};
+const deployDefaults = {
+  microFrontend: {
+    enableHtmlEntry: false
+  },
+  domain: '',
+  domainByEntries: undefined
+};
+const toolsDefaults = {
+  webpack: undefined,
+  babel: undefined,
+  postcss: undefined,
+  autoprefixer: undefined,
+  lodash: undefined,
+  devServer: undefined,
+  tsLoader: undefined,
+  terser: undefined,
+  minifyCss: undefined
+};
+const defaults = {
+  source: sourceDefaults,
+  output: outputDefaults,
+  server: serverDefaults,
+  dev: devDefaults,
+  deploy: deployDefaults,
+  tools: toolsDefaults
+};
+exports.defaults = defaults;