@modern-js/core 1.2.0 → 1.3.2

package/src/config/schema/server.ts

@@ -1,106 +0,0 @@
-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' },
-    metrics: { type: 'object' },
-    proxy: { type: 'object' },
-    enableMicroFrontendDebug: { type: 'boolean' },
-  },
-};

package/src/config/schema/source.ts

@@ -1,34 +0,0 @@
-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/src/config/schema/tools.ts

@@ -1,15 +0,0 @@
-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/src/context.ts

@@ -1,46 +0,0 @@
-import path from 'path';
-import { createContext } from '@modern-js/plugin';
-import address from 'address';
-import type { IAppContext } from '@modern-js/types';
-import { UserConfig } from './config';
-import { NormalizedConfig } from './config/mergeConfig';
-
-export type { IAppContext };
-
-export const AppContext = createContext<IAppContext>({} as IAppContext);
-
-export const ConfigContext = createContext<UserConfig>({} as UserConfig);
-
-export const ResolvedConfigContext = createContext<NormalizedConfig>(
-  {} as NormalizedConfig,
-);
-
-export const useAppContext = () => AppContext.use().value;
-
-export const useConfigContext = () => ConfigContext.use().value;
-
-export const useResolvedConfigContext = () => ResolvedConfigContext.use().value;
-
-export const initAppContext = (
-  appDirectory: string,
-  plugins: Array<{
-    cli: any;
-    server: any;
-  }>,
-  configFile: string | false,
-): IAppContext => ({
-  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/src/index.ts

@@ -1,277 +0,0 @@
-import path from 'path';
-import {
-  compatRequire,
-  pkgUp,
-  ensureAbsolutePath,
-  logger,
-  INTERNAL_PLUGINS,
-} from '@modern-js/utils';
-import {
-  createAsyncManager,
-  createAsyncWorkflow,
-  createParallelWorkflow,
-  ParallelWorkflow,
-  AsyncWorkflow,
-  Progresses2Runners,
-  createAsyncWaterfall,
-  AsyncWaterfall,
-} from '@modern-js/plugin';
-import { enable } from '@modern-js/plugin/node';
-
-import type { Hooks } from '@modern-js/types';
-import { program, Command } from './utils/commander';
-import {
-  resolveConfig,
-  defineConfig,
-  loadUserConfig,
-  UserConfig,
-  ToolsConfig,
-} from './config';
-import { loadPlugins } from './loadPlugins';
-import {
-  AppContext,
-  ConfigContext,
-  IAppContext,
-  initAppContext,
-  ResolvedConfigContext,
-  useAppContext,
-  useConfigContext,
-  useResolvedConfigContext,
-} from './context';
-import { initWatcher } from './initWatcher';
-import { NormalizedConfig } from './config/mergeConfig';
-import { loadEnv } from './loadEnv';
-
-export type { Hooks };
-export { defaultsConfig, mergeConfig } from './config';
-
-export * from '@modern-js/plugin';
-export * from '@modern-js/plugin/node';
-
-program
-  .name('modern')
-  .usage('<command> [options]')
-  .version(process.env.MODERN_JS_VERSION || '0.1.0');
-
-export type HooksRunner = Progresses2Runners<{
-  config: ParallelWorkflow<void>;
-  resolvedConfig: AsyncWaterfall<{
-    resolved: NormalizedConfig;
-  }>;
-  validateSchema: ParallelWorkflow<void>;
-  prepare: AsyncWorkflow<void, void>;
-  commands: AsyncWorkflow<
-    {
-      program: Command;
-    },
-    void
-  >;
-  watchFiles: ParallelWorkflow<void>;
-  fileChange: AsyncWorkflow<
-    {
-      filename: string;
-    },
-    void
-  >;
-  beforeExit: AsyncWorkflow<void, void>;
-}>;
-
-const hooksMap = {
-  config: createParallelWorkflow(),
-  resolvedConfig: createAsyncWaterfall<{
-    resolved: NormalizedConfig;
-  }>(),
-  validateSchema: createParallelWorkflow(),
-  // eslint-disable-next-line @typescript-eslint/no-invalid-void-type
-  prepare: createAsyncWorkflow<void, void>(),
-  commands: createAsyncWorkflow<
-    {
-      program: Command;
-    },
-    // eslint-disable-next-line @typescript-eslint/no-invalid-void-type
-    void
-  >(),
-  watchFiles: createParallelWorkflow(),
-  fileChange: createAsyncWorkflow<
-    {
-      filename: string;
-    },
-    // eslint-disable-next-line @typescript-eslint/no-invalid-void-type
-    void
-  >(),
-  // eslint-disable-next-line @typescript-eslint/no-invalid-void-type
-  beforeExit: createAsyncWorkflow<void, void>(),
-};
-
-export const manager = createAsyncManager<Hooks, typeof hooksMap>(hooksMap);
-
-export const {
-  createPlugin,
-  registe: registerHook,
-  useRunner: mountHook,
-} = manager;
-
-export const usePlugins = (plugins: string[]) =>
-  plugins.forEach(plugin =>
-    manager.usePlugin(compatRequire(require.resolve(plugin))),
-  );
-
-export {
-  defineConfig,
-  AppContext,
-  ResolvedConfigContext,
-  useAppContext,
-  useConfigContext,
-  useResolvedConfigContext,
-  ConfigContext,
-};
-
-export type { NormalizedConfig, IAppContext, UserConfig, ToolsConfig };
-
-const initAppDir = async (): Promise<string> => {
-  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);
-};
-
-export interface CoreOptions {
-  configFile?: string;
-  plugins?: typeof INTERNAL_PLUGINS;
-  beforeUsePlugins: (
-    plugins: any,
-    config: any,
-  ) => { cli: any; cliPath: any; server: any; serverPath: any }[];
-}
-
-const createCli = () => {
-  let hooksRunner: HooksRunner;
-  let isRestart = false;
-
-  const init = async (argv: string[] = [], options?: CoreOptions) => {
-    enable();
-
-    manager.clear();
-
-    const appDirectory = await initAppDir();
-
-    loadEnv(appDirectory);
-
-    const loaded = await loadUserConfig(appDirectory, options?.configFile);
-
-    let plugins = loadPlugins(
-      appDirectory,
-      loaded.config.plugins || [],
-      options?.plugins,
-    );
-
-    if (options?.beforeUsePlugins) {
-      plugins = options.beforeUsePlugins(plugins, loaded.config);
-    }
-
-    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 config = await resolveConfig(
-      loaded,
-      extraConfigs as any,
-      extraSchemas as any,
-      isRestart,
-      argv,
-    );
-
-    const { resolved } = await hooksRunner.resolvedConfig({
-      resolved: config,
-    });
-
-    // update context value
-    manager.run(() => {
-      ConfigContext.set(loaded.config);
-      ResolvedConfigContext.set(resolved);
-      AppContext.set({
-        ...appContext,
-        port: resolved.server.port!,
-        distDirectory: ensureAbsolutePath(appDirectory, resolved.output.path!),
-      });
-    });
-
-    await hooksRunner.prepare();
-
-    return { loadedConfig: loaded, appContext, resolved };
-  };
-
-  async function run(argv: string[], options?: CoreOptions) {
-    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() {
-    isRestart = true;
-
-    logger.info('Restart...\n');
-
-    let hasGetError = false;
-    try {
-      await init(process.argv.slice(2));
-    } 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 { loadUserConfig, initAppDir, initAppContext };

package/src/initWatcher.ts

@@ -1,77 +0,0 @@
-import crypto from 'crypto';
-import fs from 'fs';
-import path from 'path';
-import { isDev, createDebugger } from '@modern-js/utils';
-import chokidar from 'chokidar';
-import { LoadedConfig } from './config';
-import { HooksRunner } from '.';
-
-const debug = createDebugger('watch-files');
-
-const md5 = (data: string) =>
-  crypto.createHash('md5').update(data).digest('hex');
-
-const hashMap = new Map<string, string>();
-
-export const initWatcher = async (
-  loaded: LoadedConfig,
-  appDirectory: string,
-  configDir: string | undefined,
-  hooksRunner: HooksRunner,
-  argv: string[],
-  // eslint-disable-next-line max-params
-) => {
-  // only add fs watcher on dev mode.
-  if (isDev() && argv[0] === 'dev') {
-    const extraFiles = await hooksRunner.watchFiles();
-
-    const configPath = path.join(appDirectory, configDir!);
-
-    const watched = [
-      `${configPath}/html`,
-      ...(extraFiles as any),
-      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/src/loadEnv.ts

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

package/src/loadPlugins.ts

@@ -1,91 +0,0 @@
-import {
-  isDepExists,
-  createDebugger,
-  compatRequire,
-  INTERNAL_PLUGINS,
-} from '@modern-js/utils';
-
-const debug = createDebugger('load-plugins');
-
-export interface PluginConfigItem {
-  cli?: string;
-  server?: string;
-}
-
-export type PluginConfig = Array<PluginConfigItem>;
-
-/**
- * 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: string, plugin: PluginConfigItem) => {
-  const tryResolve = (name: string) => {
-    let filePath = '';
-    try {
-      filePath = require.resolve(name, { paths: [appDirectory] });
-      delete require.cache[filePath];
-    } catch (err) {
-      if ((err as any).code === 'MODULE_NOT_FOUND') {
-        throw new Error(`Can not find plugin ${name}.`);
-      }
-      throw err;
-    }
-    return filePath;
-  };
-
-  const resolved: PluginConfigItem = {};
-
-  if (typeof plugin === 'string' || plugin.cli) {
-    resolved.cli =
-      typeof plugin === 'string' ? tryResolve(plugin) : 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: string,
-  pluginConfig: PluginConfig,
-  internalPlugins?: typeof INTERNAL_PLUGINS,
-) => {
-  const plugins = [
-    ...Object.keys(internalPlugins || INTERNAL_PLUGINS)
-      .filter(name => isDepExists(appDirectory, name))
-      .map(name => (internalPlugins || INTERNAL_PLUGINS)[name]),
-    ...pluginConfig,
-  ];
-
-  return plugins.map(plugin => {
-    const { cli, server } = resolvePlugin(appDirectory, plugin);
-
-    debug(`resolve plugin %s: %s`, plugin, {
-      cli,
-      server,
-    });
-
-    const cliPlugin = cli && { ...compatRequire(cli), pluginPath: cli };
-    const serverPlugin = server && {
-      ...compatRequire(server),
-      pluginPath: server,
-    };
-
-    return {
-      cli: cliPlugin,
-      cliPath: typeof plugin === 'string' ? plugin : plugin.cli,
-      server: serverPlugin,
-      serverPath: typeof plugin === 'string' ? undefined : plugin.server,
-    };
-  });
-};

package/src/utils/commander.ts

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