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

package/src/utils/readline.ts

@@ -0,0 +1,28 @@
+import * as readline from 'readline';
+
+// eslint-disable-next-line @typescript-eslint/no-extraneous-class
+export class ReadlineUtils {
+  static clearPrevLine(
+    output: NodeJS.WriteStream & {
+      fd: 1;
+    },
+  ) {
+    ReadlineUtils.clearLine(output, 1);
+  }
+
+  static clearLine(
+    output: NodeJS.WriteStream & {
+      fd: 1;
+    },
+    n = 1,
+    dir: 1 | -1 = -1,
+  ) {
+    // -1 向上，1 向下
+    const dx = dir === 1 ? 1 : -1;
+    for (let i = 0; i < n; i++) {
+      readline.moveCursor(output, 0, dx);
+      readline.clearLine(output, 0);
+      readline.cursorTo(output, 0);
+    }
+  }
+}

package/src/utils/tsconfig.ts

@@ -0,0 +1,37 @@
+import { fs, Import } from '@modern-js/utils';
+
+const json5: typeof import('json5') = Import.lazy('json5', require);
+
+export interface ITsconfig {
+  compilerOptions?:
+    | {
+        rootDir?: string;
+        baseUrl?: string;
+        declaration?: boolean;
+        emitDeclarationOnly?: boolean;
+        isolatedModules?: boolean;
+        allowJs?: boolean;
+        outDir?: string;
+        paths?: Record<string, string[]>;
+      }
+    | undefined;
+  include?: string[];
+  exclude?: string[];
+}
+
+export const readTsConfig = <T extends null | ITsconfig>(
+  tsconfigPath: string,
+  noExistReturn: T = null as T,
+): ITsconfig | T => {
+  // 如果不存在，则返回 noExistReturn
+  if (!fs.existsSync(tsconfigPath)) {
+    return noExistReturn;
+  }
+  const content = fs.readFileSync(tsconfigPath, 'utf-8');
+  return json5.parse(content);
+};
+
+export const existTsConfigFile = (tsconfigAbsolutePath: string) => {
+  const tsconfig = readTsConfig(tsconfigAbsolutePath);
+  return Boolean(tsconfig);
+};

package/src/utils/tspaths-transform/constants.ts

@@ -0,0 +1,19 @@
+export const defaultTransformedFunctions = [
+  'require',
+  'require.resolve',
+  'System.import',
+
+  // Jest methods
+  'jest.genMockFromModule',
+  'jest.mock',
+  'jest.unmock',
+  'jest.doMock',
+  'jest.dontMock',
+  'jest.setMock',
+  'jest.requireActual',
+  'jest.requireMock',
+
+  // Older Jest methods
+  'require.requireActual',
+  'require.requireMock',
+];

package/src/utils/tspaths-transform/index.ts

@@ -0,0 +1,139 @@
+import * as path from 'path';
+import * as parser from '@babel/parser';
+import traverse, { NodePath } from '@babel/traverse';
+import generator from '@babel/generator';
+import * as t from '@babel/types';
+import { createMatchPath } from 'tsconfig-paths';
+import { fs } from '@modern-js/utils';
+import { defaultTransformedFunctions } from './constants';
+import { matchesPattern, isImportCall } from './utils';
+
+export interface TransformOption {
+  filename: string;
+  baseUrl: string;
+  paths: Record<string, string[] | string>;
+}
+
+const getPathsMap = (
+  paths: Record<string, string | string[]>,
+  sourceDirName = 'src',
+) => {
+  const pathKeys = Object.keys(paths);
+  const pathsMap: Record<string, string[]> = {};
+  const replaceSrcToTypes = (s: string) => s.replace(sourceDirName, 'types');
+  for (const key of pathKeys) {
+    const p = paths[key];
+    if (typeof p === 'string') {
+      pathsMap[key] = [replaceSrcToTypes(p)];
+    } else {
+      pathsMap[key] = (paths[key] as string[]).map(sp => replaceSrcToTypes(sp));
+    }
+  }
+  return pathsMap;
+};
+
+function mapPathString(
+  nodePath: NodePath<t.StringLiteral>,
+  { filename, baseUrl, paths }: TransformOption,
+) {
+  if (!t.isStringLiteral(nodePath)) {
+    return;
+  }
+
+  const sourcePath = nodePath.node.value;
+  const currentFile = filename;
+  const pathsMap = getPathsMap(paths);
+  const matchPath = createMatchPath(baseUrl, pathsMap, ['index']);
+  const result = matchPath(
+    sourcePath,
+    packageJsonPath => {
+      if (!fs.existsSync(packageJsonPath)) {
+        return undefined;
+      }
+      return fs.readJSONSync(packageJsonPath);
+    },
+    filePath => fs.existsSync(filePath),
+    ['.d.ts'],
+  );
+  if (result) {
+    const relativePath = path.relative(
+      path.dirname(currentFile),
+      path.dirname(result),
+    );
+    const fileName = path.basename(result);
+    // 如果是同级文件，则返回的是 ''
+    const filePath = path.normalize(
+      `${relativePath.length === 0 ? '.' : relativePath}/${fileName}`,
+    );
+    const replaceString = filePath.startsWith('.') ? filePath : `./${filePath}`;
+    nodePath.replaceWith(t.stringLiteral(replaceString));
+  }
+}
+
+const transformCall =
+  (option: TransformOption) => (nodePath: NodePath<t.CallExpression>) => {
+    const calleePath = nodePath.get('callee') as NodePath;
+    const isNormalCall = defaultTransformedFunctions.some(pattern =>
+      matchesPattern(calleePath, pattern),
+    );
+    if (isNormalCall || isImportCall(nodePath)) {
+      mapPathString(
+        nodePath.get('arguments.0') as NodePath<t.StringLiteral>,
+        option,
+      );
+    }
+  };
+
+const transformImport =
+  (option: TransformOption) => (nodePath: NodePath<t.ImportDeclaration>) => {
+    mapPathString(nodePath.get('source'), option);
+  };
+
+const transformExport =
+  (option: TransformOption) => (nodePath: NodePath<t.ExportDeclaration>) => {
+    mapPathString(nodePath.get('source') as NodePath<t.StringLiteral>, option);
+  };
+
+const transfromSingleFileAlias = ({
+  filename,
+  baseUrl,
+  paths,
+}: TransformOption) => {
+  const sourceCode = fs.readFileSync(filename, 'utf-8');
+  const ast = parser.parse(sourceCode, {
+    sourceType: 'module',
+    errorRecovery: true, // 防止typescript不支持的语法出现而报错
+    plugins: ['typescript'],
+  });
+  traverse(ast as any, {
+    CallExpression: transformCall({ filename, baseUrl, paths }) as any,
+    ImportDeclaration: transformImport({
+      filename,
+      baseUrl,
+      paths,
+    }) as any,
+    ExportDeclaration: transformExport({
+      filename,
+      baseUrl,
+      paths,
+    }) as any,
+  });
+  return generator(ast as any).code;
+};
+
+interface TransformDtsAlaisOption {
+  filenames?: string[];
+  baseUrl: string;
+  paths: Record<string, string[] | string>;
+}
+export const transformDtsAlias = (option: TransformDtsAlaisOption) => {
+  const { filenames = [], baseUrl, paths } = option;
+  const transformResult: { path: string; content: string }[] = [];
+  for (const filename of filenames) {
+    transformResult.push({
+      path: filename,
+      content: transfromSingleFileAlias({ filename, baseUrl, paths }),
+    });
+  }
+  return transformResult;
+};

package/src/utils/tspaths-transform/utils.ts

@@ -0,0 +1,25 @@
+import { Import } from '@modern-js/utils';
+import type * as tt from '@babel/types';
+import type { NodePath } from '@babel/traverse';
+
+const t: typeof import('@babel/types') = Import.lazy('@babel/types', require);
+
+export function matchesPattern(calleePath: NodePath, pattern: string) {
+  const { node } = calleePath;
+
+  if (t.isMemberExpression(node)) {
+    return calleePath.matchesPattern(pattern);
+  }
+
+  if (!t.isIdentifier(node) || pattern.includes('.')) {
+    return false;
+  }
+
+  const name = pattern.split('.')[0];
+
+  return node.name === name;
+}
+
+export function isImportCall(calleePath: NodePath<tt.CallExpression>) {
+  return t.isImport(calleePath.node.callee);
+}

package/src/utils/valide.ts

@@ -0,0 +1,37 @@
+import { validAlias } from '@modern-js/utils';
+import type { NormalizedConfig } from '@modern-js/core';
+
+export interface IValideOption {
+  modernConfig: NormalizedConfig;
+  tsconfigPath: string;
+}
+
+export const valideBeforeTask = ({
+  modernConfig,
+  tsconfigPath,
+}: IValideOption) => {
+  const modernConfigValidResult = modernConfigValid(modernConfig, {
+    tsconfigPath,
+  });
+  if (modernConfigValidResult) {
+    console.error(modernConfigValidResult);
+    // eslint-disable-next-line no-process-exit
+    process.exit(0);
+  }
+};
+
+export const modernConfigValid = (
+  modernConfig: NormalizedConfig,
+  option: { tsconfigPath: string },
+) => {
+  const valids = [validAlias];
+
+  for (const validFn of valids) {
+    const result = validFn(modernConfig, option);
+    if (result) {
+      return result;
+    }
+  }
+
+  return null;
+};

package/tsconfig.json

@@ -0,0 +1,13 @@
+{
+  "extends": "@modern-js/tsconfig/base",
+  "compilerOptions": {
+    "declaration": false,
+    "jsx": "preserve",
+    "baseUrl": "./",
+    "isolatedModules": true,
+    "paths": {
+      "@/*": ["./src/*"]
+    }
+  },
+  "include": ["src"]
+}

package/types.d.ts

@@ -0,0 +1 @@
+declare module '@modern-js/runtime/*' {}