@modern-js/babel-compiler 1.2.0 → 1.2.3

package/src/getFinalOption.ts

@@ -1,93 +0,0 @@
-import * as glob from 'glob';
-import type { IOptions } from 'glob';
-import { DEFAULT_EXTENSIONS } from '@babel/core';
-import {
-  Extensions,
-  ExtensionsFunc,
-  ICompilerOptions,
-  IFinaleCompilerOptions,
-} from './type';
-import { mergeDefaultOption } from './defaults';
-
-export const getGlobPattern = (dir: string, extensions: Extensions) => {
-  if (extensions.length > 1) {
-    return `${dir}/**/*{${extensions.join(',')}}`;
-  } else if (extensions.length === 1) {
-    return `${dir}/**/*${extensions[0]}`;
-  } else {
-    return `${dir}/**/*`;
-  }
-};
-export const getFinalExtensions = (
-  extensions: Extensions | ExtensionsFunc | undefined,
-) => {
-  const isExtensions = (
-    ext: Extensions | ExtensionsFunc | undefined,
-  ): ext is Extensions => Array.isArray(ext);
-
-  const isExtensionsFunc = (
-    ext: Extensions | ExtensionsFunc | undefined,
-  ): ext is ExtensionsFunc => typeof ext === 'function';
-
-  if (isExtensions(extensions)) {
-    return [...extensions, ...DEFAULT_EXTENSIONS];
-  } else if (isExtensionsFunc(extensions)) {
-    return extensions(DEFAULT_EXTENSIONS);
-  } else {
-    return DEFAULT_EXTENSIONS;
-  }
-};
-
-export const getFilesFromDir = ({
-  dir,
-  finalExt = [],
-  ignore = [],
-}: {
-  dir: string;
-  finalExt?: string[];
-  ignore?: IOptions['ignore'];
-}) => {
-  let globFindFilenames: string[] = [];
-  const globPattern = getGlobPattern(dir, finalExt);
-
-  globFindFilenames = glob.sync(globPattern, { ignore });
-
-  return globFindFilenames;
-};
-
-export const getFinalCompilerOption = (
-  option: ICompilerOptions,
-): IFinaleCompilerOptions => {
-  const optionWithDefault = mergeDefaultOption(option);
-  const {
-    sourceDir,
-    ignore,
-    enableWatch = false,
-    watchDir,
-    extensions = DEFAULT_EXTENSIONS,
-  } = option;
-  let globFindFilenames: string[] = [];
-
-  const finalExt = getFinalExtensions(extensions);
-  if (sourceDir) {
-    globFindFilenames = getFilesFromDir({
-      dir: sourceDir,
-      ignore,
-      finalExt,
-    });
-  }
-
-  if (enableWatch) {
-    // 开启watch模式，清空通过 sourceDir 找到的文件，而改为使用watchDirs
-    globFindFilenames = getFilesFromDir({
-      dir: watchDir as string,
-      ignore,
-      finalExt,
-    });
-  }
-
-  return {
-    ...optionWithDefault,
-    filenames: [...optionWithDefault.filenames, ...globFindFilenames],
-  };
-};

package/src/index.ts

@@ -1,35 +0,0 @@
-import { ICompilerOptions, ICompilerResult, BabelOptions } from './type';
-import { getFinalCompilerOption } from './getFinalOption';
-import { build } from './build';
-import { buildWatch, BuildWatchEmitter } from './buildWatch';
-import { validate } from './validate';
-
-export async function compiler(
-  compilerOptions: ICompilerOptions & { enableWatch: true },
-  babelOptions?: BabelOptions,
-): Promise<BuildWatchEmitter>;
-export async function compiler(
-  compilerOptions: ICompilerOptions & { enableWatch?: false },
-  babelOptions?: BabelOptions,
-): Promise<ICompilerResult>;
-
-export async function compiler(
-  compilerOptions: ICompilerOptions,
-  babelOptions: BabelOptions = {},
-) {
-  const validRet = validate(compilerOptions);
-
-  if (validRet) {
-    return validRet;
-  }
-  const finalCompilerOption = getFinalCompilerOption(compilerOptions);
-
-  if (compilerOptions.enableWatch) {
-    return buildWatch(finalCompilerOption, babelOptions);
-  } else {
-    return build(finalCompilerOption, babelOptions);
-  }
-}
-
-export * from './buildWatch';
-export * from './type';

package/src/type.ts

@@ -1,76 +0,0 @@
-import { TransformOptions } from '@babel/core';
-import type { IOptions } from 'glob';
-
-export type BabelOptions = TransformOptions;
-export type Extensions = string[];
-export type ExtensionsFunc = (defaultExtensions: Extensions) => Extensions;
-
-export interface ICompilerOptions {
-  rootDir: string;
-  distDir: string;
-  sourceDir?: string;
-  watchDir?: string;
-  enableWatch?: boolean;
-  enableVirtualDist?: boolean;
-  extensions?: Extensions | ExtensionsFunc;
-  filenames?: string[];
-  distFileExtMap?: Record<string, string>;
-  ignore?: IOptions['ignore'];
-  quiet?: boolean;
-  verbose?: boolean;
-  clean?: boolean;
-}
-
-export interface ICompilerOptionsWithDefault {
-  rootDir: string;
-  enableVirtualDist?: boolean;
-  sourceDir?: string;
-  watchDir?: string;
-  enableWatch?: boolean;
-  distDir: string;
-  extensions: Extensions | ExtensionsFunc;
-  filenames: string[];
-  distFileExtMap?: Record<string, string>;
-  ignore: IOptions['ignore'];
-  quiet?: boolean;
-  verbose?: boolean;
-  clean?: boolean;
-}
-
-export interface IFinaleCompilerOptions {
-  rootDir: string;
-  filenames: string[];
-  ignore?: IOptions['ignore'];
-  enableVirtualDist?: boolean;
-  distDir: string;
-  watchDir?: string;
-  enableWatch?: boolean;
-  distFileExtMap?: Record<string, string>;
-  quiet?: boolean;
-  verbose?: boolean;
-  clean?: boolean;
-}
-
-export interface BuildOptions {
-  babelOptions: BabelOptions;
-}
-
-export interface IVirtualDist {
-  distPath: string;
-  sourceMapPath: string;
-  code: string;
-  sourcemap: string;
-}
-
-export interface ICompilerMessageDetail {
-  filename: string;
-  content: string;
-}
-
-export interface ICompilerResult {
-  code: number;
-  message: string;
-  messageDetails?: ICompilerMessageDetail[];
-  virtualDists?: IVirtualDist[];
-  removeFiles?: string[];
-}

package/src/utils.ts

@@ -1,5 +0,0 @@
-import * as path from 'path';
-
-export function addSourceMappingUrl(code: string, loc: string): string {
-  return `${code}\n//# sourceMappingURL=${path.normalize(path.basename(loc))}`;
-}

package/src/validate.ts

@@ -1,47 +0,0 @@
-import { logger } from '@modern-js/utils';
-import { ICompilerOptions, ICompilerResult } from './type';
-
-export const sourceDirAndFileNamesValidMessage =
-  'At least one of the sourceDir and filenames configurations must be configured';
-export const watchDirValidMessage =
-  'should set watchDir when enableWatch is true';
-
-export const validateSourceDirAndFileNames = (
-  compilerOptions: ICompilerOptions,
-): ICompilerResult | null => {
-  const { sourceDir, filenames, quiet } = compilerOptions;
-  if (!sourceDir && !filenames) {
-    if (!quiet) {
-      logger.error(sourceDirAndFileNamesValidMessage);
-    }
-    return {
-      code: 1,
-      message: sourceDirAndFileNamesValidMessage,
-      virtualDists: [],
-    };
-  }
-
-  return null;
-};
-
-export const validateWatchDir = (
-  compilerOptions: ICompilerOptions,
-): ICompilerResult | null => {
-  const { watchDir, enableWatch, quiet } = compilerOptions;
-  if (enableWatch && !watchDir) {
-    if (!quiet) {
-      logger.error(watchDirValidMessage);
-    }
-    return { code: 1, message: watchDirValidMessage, virtualDists: [] };
-  }
-
-  return null;
-};
-
-export const validate = (compilerOptions: ICompilerOptions) => {
-  if (compilerOptions.enableWatch) {
-    return validateWatchDir(compilerOptions);
-  }
-
-  return validateSourceDirAndFileNames(compilerOptions);
-};

package/tests/.eslintrc.js

@@ -1,6 +0,0 @@
-module.exports = {
-  extends: ['@modern-js'],
-  parserOptions: {
-    project: require.resolve('./tsconfig.json'),
-  },
-};

package/tests/build.test.ts

@@ -1,122 +0,0 @@
-import * as path from 'path';
-import * as glob from 'glob';
-import { fs, logger } from '@modern-js/utils';
-import { build } from '../src/build';
-
-const projectDir = path.join(__dirname, './fixtures/build');
-const srcDir = path.join(projectDir, 'src');
-const distDir = path.join(projectDir, 'dist');
-
-const originalLogInfo = logger.info;
-const originalLogError = logger.error;
-
-describe('test build', () => {
-  let testLogs: any[] = [];
-  const mockedLogInfo = (s: string | number | Error | undefined) =>
-    testLogs.push(s);
-  beforeEach(() => {
-    logger.info = mockedLogInfo;
-    logger.error = mockedLogInfo;
-  });
-
-  it('normal build and success', async () => {
-    const filenames = [path.join(srcDir, './index.js')];
-    await build({ rootDir: srcDir, filenames, distDir });
-    const globFindFiles = glob.sync(`${distDir}/**/*.js`);
-    expect(globFindFiles.length).toBe(1);
-  });
-
-  it('build with enableVirtualDist and success', async () => {
-    const filenames = [path.join(srcDir, './index.js')];
-    const ret_1 = await build({
-      rootDir: srcDir,
-      filenames,
-      distDir,
-    });
-    expect(ret_1.code).toBe(0);
-    expect(ret_1.message.includes('Successfully compiled')).toBe(true);
-    expect(ret_1.virtualDists?.length).toBe(0);
-
-    const ret = await build({
-      rootDir: srcDir,
-      filenames,
-      distDir,
-      enableVirtualDist: true,
-    });
-
-    expect(ret.code).toBe(0);
-    expect(ret.virtualDists?.length).toBe(1);
-  });
-
-  it('build with quiet and success', async () => {
-    const filenames = [path.join(srcDir, './index.js')];
-    await build({
-      rootDir: srcDir,
-      filenames,
-      distDir,
-    });
-    expect(testLogs.length).toBe(1);
-    testLogs = [];
-
-    await build({
-      rootDir: srcDir,
-      filenames,
-      distDir,
-      quiet: true,
-    });
-    expect(testLogs.length).toBe(0);
-  });
-
-  it('build with clean and success', async () => {
-    fs.ensureFileSync(path.join(distDir, './test1.js'));
-    fs.ensureFileSync(path.join(distDir, './test2.js'));
-    const filenames = [path.join(srcDir, './index.js')];
-    await build({
-      rootDir: srcDir,
-      filenames,
-      distDir,
-      clean: true,
-    });
-    const globFindFiles = glob.sync(`${distDir}/**/*.js`);
-    expect(globFindFiles.length).toBe(1);
-  });
-
-  it('build multiple files and success', async () => {
-    const filenames = [
-      path.join(srcDir, './index.js'),
-      path.join(srcDir, './far.js'),
-    ];
-    const ret = await build({ rootDir: srcDir, filenames, distDir });
-    expect(ret.code).toBe(0);
-    expect(ret.message.includes('files')).toBe(true);
-    expect((testLogs[0] as string).includes('files')).toBe(true);
-  });
-
-  it('build and fail', async () => {
-    const filenames = [path.join(srcDir, './error')];
-    const ret = await build({ rootDir: srcDir, filenames, distDir });
-    expect(ret.code).toBe(1);
-    expect(ret.messageDetails?.length).toBe(1);
-    expect(ret.message.includes('Compilation failure')).toBe(true);
-    expect(testLogs.length).toBe(1);
-    expect((testLogs[0] as string).includes('Compilation failure')).toBe(true);
-  });
-
-  it('build multiple files and fail', async () => {
-    const filenames = [
-      path.join(srcDir, './error'),
-      path.join(srcDir, './error1'),
-    ];
-    const ret = await build({ rootDir: srcDir, filenames, distDir });
-    expect(ret.code).toBe(1);
-    expect(ret.message.includes('files')).toBe(true);
-    expect((testLogs[0] as string).includes('files')).toBe(true);
-  });
-
-  afterEach(() => {
-    logger.info = originalLogInfo;
-    logger.error = originalLogError;
-    testLogs = [];
-    fs.removeSync(distDir);
-  });
-});

package/tests/buildWatch.test.ts

@@ -1,251 +0,0 @@
-import * as path from 'path';
-import { fs, logger } from '@modern-js/utils';
-import {
-  buildWatch,
-  BuildWatchEmitter,
-  runBuildWatch,
-  BuildWatchEvent,
-} from '../src/buildWatch';
-import { ICompilerResult } from '../src/type';
-
-const projectDir = path.join(__dirname, './fixtures/buildWatch');
-const srcDir = path.join(projectDir, 'src');
-const distDir = path.join(projectDir, 'dist');
-
-const originalLogInfo = logger.info;
-const originalLogError = logger.error;
-
-describe('test build watch', () => {
-  let testLogs: any[] = [];
-  const mockedLogInfo = (s: string | number | Error | undefined) =>
-    testLogs.push(s);
-  beforeEach(() => {
-    logger.info = mockedLogInfo;
-    logger.error = mockedLogInfo;
-  });
-
-  it('class BuildWatchEmitter', async () => {
-    let run = false;
-    const emitter = new BuildWatchEmitter();
-    emitter.setInitFn(() => {
-      run = true;
-    });
-    await emitter.watch();
-    expect(run).toBe(true);
-
-    const emitter_1 = new BuildWatchEmitter();
-    emitter_1.setInitFn(true as any);
-    const ret = await emitter_1.watch();
-    expect(ret).toBe(null);
-  });
-
-  it('runBuildWatch and success', async () => {
-    let done: any;
-    const promise = new Promise(resolve => (done = resolve));
-    let compiling = false;
-    const emitter = new BuildWatchEmitter();
-    emitter.on(BuildWatchEvent.firstCompiler, (result: ICompilerResult) => {
-      expect(result.code).toBe(0);
-    });
-    emitter.on(BuildWatchEvent.compiling, () => {
-      expect(compiling).toBe(true);
-    });
-    emitter.on(BuildWatchEvent.watchingCompiler, (result: ICompilerResult) => {
-      expect(result.code).toBe(0);
-      watcher.close();
-      done();
-    });
-    const filenames = [path.join(srcDir, 'index.js')];
-    compiling = true;
-    const watcher = await runBuildWatch(
-      { rootDir: srcDir, filenames, distDir, watchDir: srcDir },
-      {},
-      emitter,
-    );
-    compiling = false;
-    watcher.on('ready', () => {
-      fs.ensureFileSync(path.join(srcDir, 'far.js'));
-      compiling = true;
-    });
-    return promise;
-  });
-
-  it('runBuildWatch and fail', async () => {
-    let done: any;
-    const promise = new Promise(resolve => (done = resolve));
-    const emitter = new BuildWatchEmitter();
-    emitter.on(BuildWatchEvent.firstCompiler, (result: ICompilerResult) => {
-      expect(result.code).toBe(1);
-      expect(result.messageDetails?.length).toBe(1);
-    });
-    emitter.on(BuildWatchEvent.watchingCompiler, (result: ICompilerResult) => {
-      expect(result.code).toBe(1);
-      expect(result.messageDetails?.length).toBe(2);
-      watcher.close();
-      done();
-    });
-    const filenames = [path.join(srcDir, 'error')];
-    const watcher = await runBuildWatch(
-      { rootDir: srcDir, filenames, distDir, watchDir: srcDir },
-      {},
-      emitter,
-    );
-    watcher.on('ready', () => {
-      fs.ensureFileSync(path.join(srcDir, 'error1.js'));
-      fs.writeFileSync(path.join(srcDir, 'error1.js'), 'conta a = 1');
-    });
-    return promise;
-  });
-
-  it('buildWatch and success', async () => {
-    let done: any;
-    const promise = new Promise(resolve => (done = resolve));
-    const emitter = buildWatch({
-      rootDir: srcDir,
-      watchDir: srcDir,
-      filenames: [path.join(srcDir, 'index.js')],
-      distDir,
-      enableVirtualDist: true,
-      clean: true,
-    });
-    let compiling = false;
-    emitter.on(BuildWatchEvent.compiling, () => {
-      expect(compiling).toBe(true);
-    });
-    emitter.on(BuildWatchEvent.firstCompiler, (result: ICompilerResult) => {
-      expect(result.code).toBe(0);
-      expect(result.virtualDists?.length).toBe(1);
-    });
-    emitter.on(BuildWatchEvent.watchingCompiler, (result: ICompilerResult) => {
-      expect(result.code).toBe(0);
-      expect(result.virtualDists?.length).toBe(1);
-      expect(result.virtualDists![0].distPath.includes('far.js')).toBe(true);
-      watcher?.close();
-      done();
-    });
-
-    compiling = true;
-    const watcher = await emitter.watch();
-    compiling = false;
-    if (watcher) {
-      watcher.on('ready', () => {
-        fs.ensureFileSync(path.join(srcDir, 'far.js'));
-        compiling = true;
-      });
-    }
-    return promise;
-  });
-
-  it('buildWatch and fail', async () => {
-    let done: any;
-    const promise = new Promise(resolve => (done = resolve));
-    const emitter = buildWatch({
-      rootDir: srcDir,
-      watchDir: srcDir,
-      filenames: [path.join(srcDir, 'error')],
-      distDir,
-      enableVirtualDist: true,
-      clean: true,
-    });
-    let compiling = false;
-    emitter.on(BuildWatchEvent.compiling, () => {
-      expect(compiling).toBe(true);
-    });
-    emitter.on(BuildWatchEvent.firstCompiler, (result: ICompilerResult) => {
-      expect(result.code).toBe(1);
-      expect(result.messageDetails?.length).toBe(1);
-    });
-    emitter.on(BuildWatchEvent.watchingCompiler, (result: ICompilerResult) => {
-      expect(result.code).toBe(1);
-      expect(result.messageDetails?.length).toBe(2);
-      watcher?.close();
-      done();
-    });
-
-    compiling = true;
-    const watcher = await emitter.watch();
-    compiling = false;
-    if (watcher) {
-      watcher.on('ready', () => {
-        fs.ensureFileSync(path.join(srcDir, 'error1.js'));
-        fs.writeFileSync(path.join(srcDir, 'error1.js'), 'cast a = 1;');
-        compiling = true;
-      });
-    }
-    return promise;
-  });
-
-  it('buildWatch and remove file', async () => {
-    let done: any;
-    const promise = new Promise(resolve => (done = resolve));
-    const emitter = buildWatch({
-      rootDir: srcDir,
-      watchDir: srcDir,
-      filenames: [path.join(srcDir, 'index.js')],
-      distDir,
-      enableVirtualDist: true,
-      clean: true,
-      quiet: true,
-    });
-
-    emitter.on(BuildWatchEvent.watchingCompiler, (result: ICompilerResult) => {
-      expect(result.code).toBe(0);
-      expect(result.message.includes('remove file')).toBe(true);
-      expect(result.removeFiles?.length).toBe(1);
-      watcher?.close();
-      done();
-    });
-
-    fs.ensureFileSync(path.join(srcDir, 'far.js'));
-    const watcher = await emitter.watch();
-
-    if (watcher) {
-      watcher.on('ready', () => {
-        fs.removeSync(path.join(srcDir, 'far.js'));
-      });
-    }
-    return promise;
-  });
-
-  it('buildWatch and reRight file', async () => {
-    let done: any;
-    const promise = new Promise(resolve => (done = resolve));
-    fs.ensureFileSync(path.join(srcDir, 'error1.js'));
-    fs.writeFileSync(path.join(srcDir, 'error1.js'), 'cast a = 1;');
-    const emitter = buildWatch({
-      rootDir: srcDir,
-      watchDir: srcDir,
-      filenames: [path.join(srcDir, 'error'), path.join(srcDir, 'error1.js')],
-      distDir,
-      enableVirtualDist: true,
-      clean: true,
-    });
-
-    emitter.on(BuildWatchEvent.firstCompiler, (result: ICompilerResult) => {
-      expect(result.code).toBe(1);
-      expect(result.messageDetails?.length).toBe(2);
-    });
-    emitter.on(BuildWatchEvent.watchingCompiler, (result: ICompilerResult) => {
-      expect(result.code).toBe(1);
-      expect(result.messageDetails?.length).toBe(1);
-      watcher?.close();
-      done();
-    });
-
-    const watcher = await emitter.watch();
-    if (watcher) {
-      watcher.on('ready', () => {
-        fs.writeFileSync(path.join(srcDir, 'error1.js'), 'const a = 1;');
-      });
-    }
-    return promise;
-  });
-
-  afterEach(() => {
-    logger.info = originalLogInfo;
-    logger.error = originalLogError;
-    testLogs = [];
-    fs.removeSync(path.join(srcDir, 'far.js'));
-    fs.removeSync(path.join(srcDir, 'error1.js'));
-  });
-});