@modern-js/module-tools 1.0.0-alpha.3

package/dist/types/utils/tspaths-transform/index.d.ts

@@ -0,0 +1,15 @@
+export interface TransformOption {
+  filename: string;
+  baseUrl: string;
+  paths: Record<string, string[] | string>;
+}
+interface TransformDtsAlaisOption {
+  filenames?: string[];
+  baseUrl: string;
+  paths: Record<string, string[] | string>;
+}
+export declare const transformDtsAlias: (option: TransformDtsAlaisOption) => {
+  path: string;
+  content: string;
+}[];
+export {};

package/dist/types/utils/tspaths-transform/utils.d.ts

@@ -0,0 +1,4 @@
+import type * as tt from '@babel/types';
+import type { NodePath } from '@babel/traverse';
+export declare function matchesPattern(calleePath: NodePath, pattern: string): boolean;
+export declare function isImportCall(calleePath: NodePath<tt.CallExpression>): boolean;

package/dist/types/utils/valide.d.ts

@@ -0,0 +1,12 @@
+import type { NormalizedConfig } from '@modern-js/core';
+export interface IValideOption {
+  modernConfig: NormalizedConfig;
+  tsconfigPath: string;
+}
+export declare const valideBeforeTask: ({
+  modernConfig,
+  tsconfigPath
+}: IValideOption) => void;
+export declare const modernConfigValid: (modernConfig: NormalizedConfig, option: {
+  tsconfigPath: string;
+}) => string | null;

package/modern.config.js

@@ -0,0 +1,6 @@
+/** @type {import('@modern-js/module-tools').UserConfig} */
+module.exports = {
+  output: {
+    disableSourceMap: true,
+  },
+};

package/package.json

@@ -0,0 +1,95 @@
+{
+  "name": "@modern-js/module-tools",
+  "version": "1.0.0-alpha.3",
+  "bin": {
+    "modern": "./bin/modern.js"
+  },
+  "jsnext:source": "./src/index.ts",
+  "types": "./dist/types/index.d.ts",
+  "main": "./dist/js/node/index.js",
+  "module": "./dist/js/treeshaking/index.js",
+  "jsnext:modern": "./dist/js/modern/index.js",
+  "exports": {
+    ".": {
+      "node": {
+        "import": "./dist/js/modern/index.js",
+        "require": "./dist/js/node/index.js"
+      },
+      "default": "./dist/js/treeshaking/index.js"
+    },
+    "./cli": "./dist/js/node/index.js",
+    "./build": "./dist/js/node/build.js"
+  },
+  "typesVersions": {
+    "*": {
+      "build": [
+        "./dist/types/build.d.ts"
+      ]
+    }
+  },
+  "dependencies": {
+    "@babel/generator": "^7.15.0",
+    "@babel/parser": "^7.15.2",
+    "@babel/runtime": "^7",
+    "@babel/traverse": "^7.15.0",
+    "@babel/types": "^7.15.0",
+    "@modern-js/babel-compiler": "^1.0.0-alpha.3",
+    "@modern-js/babel-preset-module": "^1.0.0-alpha.3",
+    "@modern-js/core": "^1.0.0-alpha.3",
+    "@modern-js/css-config": "^1.0.0-alpha.3",
+    "@modern-js/i18n-cli-language-detector": "^1.0.0-alpha.3",
+    "@modern-js/module-tools-hooks": "^1.0.0-alpha.3",
+    "@modern-js/new-action": "^1.0.0-alpha.3",
+    "@modern-js/plugin": "^1.0.0-alpha.3",
+    "@modern-js/plugin-analyze": "^1.0.0-alpha.3",
+    "@modern-js/plugin-changeset": "^1.0.0-alpha.3",
+    "@modern-js/plugin-fast-refresh": "^1.0.0-alpha.3",
+    "@modern-js/plugin-i18n": "^1.0.0-alpha.3",
+    "@modern-js/style-compiler": "^1.0.0-alpha.3",
+    "@modern-js/utils": "^1.0.0-alpha.3",
+    "chalk": "^4.1.2",
+    "chokidar": "^3.5.2",
+    "dotenv": "^10.0.0",
+    "execa": "^5.1.1",
+    "fast-glob": "^3.2.5",
+    "glob": "^7.1.7",
+    "globby": "^11",
+    "inquirer": "^8.1.5",
+    "json5": "^2.2.0",
+    "lodash.merge": "^4.6.2",
+    "normalize-path": "^3.0.0",
+    "p-map": "^4",
+    "process.argv": "^0.6.0",
+    "signale": "^1.4.0",
+    "tsconfig-paths": "^3.10.1"
+  },
+  "devDependencies": {
+    "@babel/preset-typescript": "^7.15.0",
+    "@modern-js/babel-chain": "^1.0.0-alpha.3",
+    "@types/babel__core": "^7.1.15",
+    "@types/babel__generator": "^7.6.3",
+    "@types/babel__traverse": "^7.14.2",
+    "@types/glob": "^7.1.4",
+    "@types/inquirer": "^8.1.1",
+    "@types/jest": "^26",
+    "@types/lodash.merge": "^4.6.6",
+    "@types/node": "^14",
+    "@types/normalize-path": "^3.0.0",
+    "@types/signale": "^1.4.2",
+    "commander": "^8.1.0",
+    "typescript": "^4",
+    "@modern-js/plugin-testing": "^1.0.0-alpha.3",
+    "@modern-js/module-tools": "^1.0.0-alpha.3"
+  },
+  "sideEffects": false,
+  "modernConfig": {
+    "output": {
+      "packageMode": "node-js"
+    }
+  },
+  "scripts": {
+    "new": "modern new",
+    "build": "modern build",
+    "test": "modern test --passWithNoTests"
+  }
+}

package/src/.eslintrc.json

@@ -0,0 +1,5 @@
+{
+  "rules": {
+    "react-hooks/rules-of-hooks": "off"
+  }
+}

package/src/cli/build.ts

@@ -0,0 +1,39 @@
+import { Import } from '@modern-js/utils';
+import type { Command } from 'commander';
+import type { IBuildOption } from '../commands/build';
+
+const local: typeof import('../locale') = Import.lazy(
+  '../locale/index',
+  require,
+);
+const commands: typeof import('../commands') = Import.lazy(
+  '../commands',
+  require,
+);
+
+export const buildCli = (program: Command) => {
+  // TODO: 初始化环境变量
+  program
+    .command('build')
+    .usage('[options]')
+    .description(local.i18n.t(local.localeKeys.command.build.describe))
+    .option('-w, --watch', local.i18n.t(local.localeKeys.command.build.watch))
+    .option(
+      '--tsconfig [tsconfig]',
+      local.i18n.t(local.localeKeys.command.build.tsconfig),
+      './tsconfig.json',
+    )
+    .option(
+      '--style-only',
+      local.i18n.t(local.localeKeys.command.build.style_only),
+    )
+    .option(
+      '--platform [platform]',
+      local.i18n.t(local.localeKeys.command.build.platform),
+    )
+    .option('--no-tsc', local.i18n.t(local.localeKeys.command.build.no_tsc))
+    .option('--no-clear', local.i18n.t(local.localeKeys.command.build.no_clear))
+    .action(async (subCommand: IBuildOption) => {
+      await commands.build(subCommand);
+    });
+};

package/src/cli/dev.ts

@@ -0,0 +1,24 @@
+import { Import } from '@modern-js/utils';
+import type { Command } from 'commander';
+import type { IDevOption } from '@/commands/dev';
+
+const local: typeof import('../locale') = Import.lazy('../locale', require);
+const commands: typeof import('../commands') = Import.lazy(
+  '../commands',
+  require,
+);
+
+export const devCli = (program: Command) => {
+  program
+    .command('dev')
+    .usage('[options]')
+    .description(local.i18n.t(local.localeKeys.command.dev.describe))
+    .option(
+      '--tsconfig [tsconfig]',
+      local.i18n.t(local.localeKeys.command.build.tsconfig),
+      './tsconfig.json',
+    )
+    .action(async (params: IDevOption) => {
+      await commands.dev(params);
+    });
+};

package/src/cli/index.ts

@@ -0,0 +1,3 @@
+export * from './build';
+export * from './dev';
+export * from './new';

package/src/cli/new.ts

@@ -0,0 +1,32 @@
+import type { Command } from 'commander';
+import { Import } from '@modern-js/utils';
+
+const newAction: typeof import('@modern-js/new-action') = Import.lazy(
+  '@modern-js/new-action',
+  require,
+);
+const local: typeof import('../locale') = Import.lazy('../locale', require);
+
+export const newCli = (program: Command, locale?: string) => {
+  program
+    .command('new')
+    .usage('[options]')
+    .description(local.i18n.t(local.localeKeys.command.new.describe))
+    .option(
+      '-d, --debug',
+      local.i18n.t(local.localeKeys.command.new.debug),
+      false,
+    )
+    .option(
+      '-c, --config <config>',
+      local.i18n.t(local.localeKeys.command.new.config),
+    )
+    .option(
+      '--dist-tag <tag>',
+      local.i18n.t(local.localeKeys.command.new.distTag),
+    )
+    .option('--registry', local.i18n.t(local.localeKeys.command.new.registry))
+    .action(async options => {
+      await newAction.ModuleNewAction({ ...options, locale });
+    });
+};

package/src/commands/build.ts

@@ -0,0 +1,81 @@
+import * as path from 'path';
+import { fs, Import } from '@modern-js/utils';
+import type { Platform } from '@/types';
+
+const tsConfigutils: typeof import('../utils/tsconfig') = Import.lazy(
+  '../utils/tsconfig',
+  require,
+);
+
+const valid: typeof import('../utils/valide') = Import.lazy(
+  '../utils/valide',
+  require,
+);
+const buildFeature: typeof import('../features/build') = Import.lazy(
+  '../features/build',
+  require,
+);
+const core: typeof import('@modern-js/core') = Import.lazy(
+  '@modern-js/core',
+  require,
+);
+const dotenv: typeof import('dotenv') = Import.lazy('dotenv', require);
+
+export interface IBuildOption {
+  watch: boolean;
+  tsconfig: string;
+  platform: boolean | Exclude<Platform, 'all'>;
+  styleOnly: boolean;
+  tsc: boolean;
+  clear: boolean;
+}
+
+export const build = async ({
+  watch = false,
+  tsconfig: tsconfigName,
+  tsc,
+  clear = true,
+  platform,
+}: IBuildOption) => {
+  const {
+    value: { appDirectory },
+  } = core.useAppContext();
+  const modernConfig = core.useResolvedConfigContext().value;
+  const {
+    output: { path: outputPath = 'dist' },
+  } = modernConfig;
+  const tsconfigPath = path.join(appDirectory, tsconfigName);
+  dotenv.config();
+  const isTsProject = tsConfigutils.existTsConfigFile(tsconfigPath);
+  const enableTscCompiler = isTsProject && tsc;
+
+  valid.valideBeforeTask({ modernConfig, tsconfigPath });
+
+  if (clear) {
+    fs.removeSync(path.join(appDirectory, outputPath));
+  }
+
+  // TODO: 一些配置只需要从modernConfig中获取
+  await buildFeature.build(
+    {
+      enableWatchMode: watch,
+      isTsProject,
+      platform,
+      sourceDir: 'src',
+      tsconfigName,
+      enableTscCompiler,
+    },
+    modernConfig,
+  );
+
+  process.on('SIGBREAK', () => {
+    console.info('exit');
+    const tempTsconfigFilePath = path.join(
+      appDirectory,
+      './tsconfig.temp.json',
+    );
+    if (fs.existsSync(tempTsconfigFilePath)) {
+      fs.removeSync(tempTsconfigFilePath);
+    }
+  });
+};

package/src/commands/dev.ts

@@ -0,0 +1,41 @@
+import * as path from 'path';
+import { Import } from '@modern-js/utils';
+
+const devFeature: typeof import('../features/dev') = Import.lazy(
+  '../features/dev',
+  require,
+);
+const core: typeof import('@modern-js/core') = Import.lazy(
+  '@modern-js/core',
+  require,
+);
+const dotenv: typeof import('dotenv') = Import.lazy('dotenv', require);
+const tsConfigutils: typeof import('../utils/tsconfig') = Import.lazy(
+  '../utils/tsconfig',
+  require,
+);
+const valid: typeof import('../utils/valide') = Import.lazy(
+  '../utils/valide',
+  require,
+);
+
+export interface IDevOption {
+  tsconfig: string;
+}
+
+export const dev = async (option: IDevOption) => {
+  const { tsconfig: tsconfigName } = option;
+  const appContext = core.useAppContext().value;
+  const modernConfig = core.useResolvedConfigContext().value;
+  const { appDirectory } = appContext;
+  const tsconfigPath = path.join(appDirectory, tsconfigName);
+
+  dotenv.config();
+
+  valid.valideBeforeTask({ modernConfig, tsconfigPath });
+
+  const isTsProject = tsConfigutils.existTsConfigFile(tsconfigPath);
+
+  // await devFeature.showMenu({ isTsProject, appDirectory });
+  await devFeature.devStorybook({ isTsProject, appDirectory });
+};

package/src/commands/index.ts

@@ -0,0 +1,2 @@
+export { dev } from './dev';
+export { build } from './build';

package/src/features/build/build-platform.ts

@@ -0,0 +1,76 @@
+import { Import, chalk } from '@modern-js/utils';
+import type { LoggerText } from './logger';
+
+const core: typeof import('@modern-js/core') = Import.lazy(
+  '@modern-js/core',
+  require,
+);
+const execa: typeof import('execa') = Import.lazy('execa', require);
+const lg: typeof import('./logger') = Import.lazy('./logger', require);
+const pMap: typeof import('p-map') = Import.lazy('p-map', require);
+
+export type Platform = 'all' | 'docs' | 'storybook';
+
+export interface IBuildPlatformOption {
+  platform: Platform;
+  isTsProject?: boolean;
+}
+
+export const buildPlatform = async (option: IBuildPlatformOption) => {
+  const { isTsProject = false, platform } = option;
+  const lm = new lg.LoggerManager();
+  // 获取platforms的参数
+  const buildTasks = await (core.mountHook() as any).platformBuild({
+    isTsProject,
+  });
+
+  if (buildTasks.length <= 0) {
+    console.info(
+      chalk.yellow(
+        'No build tasks detected.\nYou can use the `new` command to enable the more features',
+      ),
+    );
+    return;
+  }
+
+  const loggerMap: Record<string, LoggerText> = {};
+  const taskMapper = buildTasks
+    .filter((task: any) => platform === 'all' || task.name === platform)
+    .map((params: any) => {
+      const logger = lm.createLoggerText({ title: params.title });
+      loggerMap[params.name] = logger;
+      return {
+        logger,
+        ...params,
+      };
+    });
+
+  if (taskMapper.length <= 0) {
+    console.info(chalk.yellow(`'${platform}' is undefined task`));
+    return;
+  }
+
+  lm.showCompiling();
+  await pMap(taskMapper, async ({ taskPath, params, logger }: any) => {
+    const childProcess = execa.node(taskPath, params, {
+      stdio: 'pipe',
+      all: true,
+    });
+
+    lm.addStdout(logger, childProcess.stdout, {
+      event: { data: true, error: true },
+    });
+
+    lm.addStderr(logger, childProcess.stderr);
+
+    await childProcess;
+    // lm.disappearCompiling();
+    // console.info(lg.colors.title(title));
+    // console.info(a.all);
+  });
+
+  lm.disappearCompiling();
+  for (const key of Object.keys(loggerMap)) {
+    console.info(loggerMap[key].value);
+  }
+};

package/src/features/build/build-watch.ts

@@ -0,0 +1,93 @@
+import * as path from 'path';
+import * as os from 'os';
+import { Import } from '@modern-js/utils';
+
+import type { NormalizedConfig } from '@modern-js/core';
+import type { IBuildConfig, ITaskMapper } from '../../types';
+
+const core: typeof import('@modern-js/core') = Import.lazy(
+  '@modern-js/core',
+  require,
+);
+const execa: typeof import('execa') = Import.lazy('execa', require);
+const lg: typeof import('./logger') = Import.lazy('./logger', require);
+const pMap: typeof import('p-map') = Import.lazy('p-map', require);
+const utils: typeof import('./utils') = Import.lazy('./utils', require);
+const constants: typeof import('./constants') = Import.lazy(
+  './constants',
+  require,
+);
+
+export const buildInWatchMode = async (
+  config: IBuildConfig,
+  _: NormalizedConfig,
+) => {
+  const { appDirectory } = core.useAppContext().value;
+  const { sourceDir, enableTscCompiler } = config;
+  const srcRootDir = path.join(appDirectory, sourceDir);
+  const concurrency = os.cpus().length;
+  const lm = new lg.LoggerManager();
+  const codeLog = lm.createLoggerText({
+    title: constants.runBabelCompilerTitle,
+  });
+  const dtsLog = lm.createLoggerText({ title: constants.runTscWatchTitle });
+  const styleLog = lm.createLoggerText({
+    title: constants.runStyleCompilerTitle,
+  });
+  const initCodeMapper = utils.getCodeInitMapper(config);
+  const taskMapper: ITaskMapper[] = [
+    ...utils.getCodeMapper({
+      logger: codeLog,
+      taskPath: require.resolve('../../tasks/build-watch-source-code'),
+      config,
+      willCompilerDirOrFile: sourceDir,
+      initMapper: initCodeMapper,
+      srcRootDir,
+    }),
+    ...(enableTscCompiler ? utils.getDtsMapper(config, dtsLog) : []),
+    {
+      logger: styleLog,
+      taskPath: require.resolve('../../tasks/build-watch-style'),
+    },
+  ];
+  lm.on('data', () => {
+    console.info(constants.clearFlag);
+    enableTscCompiler && console.info(dtsLog.value);
+    console.info(codeLog.value);
+    console.info(styleLog.value);
+  });
+  await pMap(
+    taskMapper,
+    async ({ logger, taskPath, params }) => {
+      const childProcess = execa.node(taskPath, params, { stdio: 'pipe' });
+      if (logger === codeLog) {
+        lm.addStdout(logger, childProcess.stdout, {
+          event: { error: true, data: true },
+          // colors: { data: s => s },
+        });
+        lm.addStderr(logger, childProcess.stderr);
+      }
+
+      if (logger === dtsLog) {
+        lm.addStdout(logger, childProcess.stdout, {
+          event: { data: true, error: true },
+          colors: {
+            // tsc 的log信息无论是错误还是正确都是从 data event 中获取到的
+            data: s => s,
+          },
+        });
+      }
+
+      if (logger === styleLog) {
+        lm.addStdout(logger, childProcess.stdout, {
+          event: { error: true, data: true },
+          // colors: { data: s => s },
+        });
+        lm.addStderr(logger, childProcess.stderr);
+      }
+
+      await childProcess;
+    },
+    { concurrency },
+  );
+};

package/src/features/build/build.ts

@@ -0,0 +1,111 @@
+/* eslint-disable max-statements */
+import * as path from 'path';
+import * as os from 'os';
+import { Import } from '@modern-js/utils';
+import type { NormalizedConfig } from '@modern-js/core';
+import type { IBuildConfig, ITaskMapper } from '../../types';
+
+const pMap: typeof import('p-map') = Import.lazy('p-map', require);
+const utils: typeof import('./utils') = Import.lazy('./utils', require);
+const execa: typeof import('execa') = Import.lazy('execa', require);
+const lg: typeof import('./logger') = Import.lazy('./logger', require);
+const constants: typeof import('./constants') = Import.lazy(
+  './constants',
+  require,
+);
+const core: typeof import('@modern-js/core') = Import.lazy(
+  '@modern-js/core',
+  require,
+);
+
+export const buildSourceCode = async (
+  config: IBuildConfig,
+  _: NormalizedConfig,
+) => {
+  const { sourceDir, enableTscCompiler } = config;
+  const { appDirectory } = core.useAppContext().value;
+  const concurrency = os.cpus().length;
+  const srcRootDir = path.join(appDirectory, sourceDir);
+  const lm = new lg.LoggerManager();
+  const codeLog = lm.createLoggerText({
+    title: constants.runBabelCompilerTitle,
+  });
+  const dtsLog = lm.createLoggerText({ title: constants.runTscTitle });
+  const styleLog = lm.createLoggerText({
+    title: constants.runStyleCompilerTitle,
+  });
+  const copyLog = lm.createLoggerText({ title: 'Copy Log:' });
+  const initCodeMapper = utils.getCodeInitMapper(config);
+  const taskMapper: ITaskMapper[] = [
+    ...utils.getCodeMapper({
+      logger: codeLog,
+      taskPath: require.resolve('../../tasks/build-source-code'),
+      config,
+      willCompilerDirOrFile: sourceDir,
+      initMapper: initCodeMapper,
+      srcRootDir,
+    }),
+    ...(enableTscCompiler ? utils.getDtsMapper(config, dtsLog) : []),
+    {
+      logger: styleLog,
+      taskPath: require.resolve('../../tasks/build-style'),
+    },
+    {
+      logger: copyLog,
+      taskPath: require.resolve('../../tasks/copy-assets'),
+    },
+  ];
+
+  lm.showCompiling();
+  await pMap(
+    taskMapper,
+    async ({ logger, taskPath, params }) => {
+      const childProcess = execa.node(taskPath, params, { stdio: 'pipe' });
+
+      if (logger === codeLog || logger === copyLog) {
+        lm.addStdout(logger, childProcess.stdout, {
+          event: { data: true, error: true },
+        });
+        lm.addStderr(logger, childProcess.stderr);
+      }
+
+      if (logger === dtsLog) {
+        lm.addStdout(dtsLog, childProcess.stdout, {
+          event: { data: true, error: true },
+        });
+        lm.addStderr(dtsLog, childProcess.stderr);
+      }
+      if (logger === styleLog) {
+        lm.addStdout(logger, childProcess.stdout, {
+          event: { data: true, error: true },
+        });
+        lm.addStderr(logger, childProcess.stderr);
+      }
+      await childProcess;
+    },
+    { concurrency },
+  );
+
+  lm.disappearCompiling();
+  enableTscCompiler && console.info(dtsLog.value);
+  console.info(codeLog.value);
+  if (styleLog.hasMessages()) {
+    console.info(styleLog.value);
+  }
+
+  if (copyLog.hasMessages()) {
+    console.info(copyLog.value);
+  }
+
+  if (
+    dtsLog.hasErrorMessage ||
+    codeLog.hasErrorMessage ||
+    styleLog.hasErrorMessage ||
+    copyLog.hasErrorMessage
+  ) {
+    // eslint-disable-next-line no-process-exit
+    process.exit(1);
+  }
+};
+
+/* eslint-enable max-statements */