@modern-js/babel-compiler 1.0.0-alpha.3

package/tests/compiler.test.ts

@@ -0,0 +1,106 @@
+import * as path from 'path';
+import { fs } from '@modern-js/utils';
+import * as babel from '@babel/core';
+import {
+  isRes,
+  getDistFilePath,
+  resolveSourceMap,
+  compiler,
+} from '../src/compiler';
+import { defaultDistFileExtMap } from '../src/constants';
+
+describe('compiler', () => {
+  it('isRes', () => {
+    const res_1 = isRes({ code: '' });
+    expect(res_1).toBe(true);
+    const res_2 = isRes(null);
+    expect(res_2).toBe(false);
+  });
+
+  it('getDistFilePath', () => {
+    const distpath_1 = getDistFilePath({
+      rootDir: '/project',
+      filepath: '/project/src/b.js',
+      distDir: '/project/dist',
+      extMap: defaultDistFileExtMap,
+    });
+    expect(distpath_1).toBe('/project/dist/src/b.js');
+
+    const distpath_2 = getDistFilePath({
+      rootDir: '/project/src',
+      filepath: '/project/src/b.js',
+      distDir: '/project/dist',
+      extMap: defaultDistFileExtMap,
+    });
+    expect(distpath_2).toBe('/project/dist/b.js');
+  });
+
+  it('resolveSourceMap', () => {
+    const projectDir = path.join(__dirname, './fixtures/resolveSourceMap');
+    fs.removeSync(path.join(projectDir, 'dist'));
+    const babelRes = babel.transformFileSync(
+      path.join(projectDir, 'src/index.js'),
+      { sourceMaps: true, cwd: projectDir },
+    );
+    const distFilePath = path.join(projectDir, 'dist/far.js');
+    const sourcemap_1 = resolveSourceMap({
+      babelRes: babelRes as babel.BabelFileResult,
+      distFilePath,
+      enableVirtualDist: true,
+    });
+    expect(sourcemap_1.sourceMapPath).toBe(
+      path.join(projectDir, 'dist/far.js.map'),
+    );
+    // TODO test sourcemap content
+
+    const sourcemap_2 = resolveSourceMap({
+      babelRes: babelRes as babel.BabelFileResult,
+      distFilePath,
+    });
+    expect(fs.readFileSync(sourcemap_2.sourceMapPath, 'utf-8')).toBe(
+      sourcemap_2.sourcemap,
+    );
+  });
+
+  it('compiler', () => {
+    const projectPath = path.join(__dirname, './fixtures/compiler');
+    const sourceFilePath = path.join(projectPath, './src/index.js');
+    const distPath = path.join(projectPath, 'dist');
+
+    compiler({
+      rootDir: path.join(projectPath, 'src'),
+      filepath: sourceFilePath,
+    });
+    expect(fs.existsSync(path.join(distPath, 'index.js'))).toBe(true);
+    fs.removeSync(distPath);
+
+    const dist1Path = path.join(projectPath, 'dist1');
+    compiler({
+      rootDir: path.join(projectPath, 'src'),
+      filepath: sourceFilePath,
+      distDir: dist1Path,
+      babelConfig: { sourceMaps: true },
+    });
+    expect(fs.existsSync(dist1Path)).toBe(true);
+    fs.removeSync(dist1Path);
+
+    compiler({
+      rootDir: path.join(projectPath, 'src'),
+      filepath: sourceFilePath,
+      babelConfig: { sourceMaps: true },
+    });
+    expect(fs.existsSync(path.join(distPath, 'index.js'))).toBe(true);
+    expect(fs.existsSync(path.join(distPath, 'index.js.map'))).toBe(true);
+    fs.removeSync(distPath);
+
+    compiler({
+      rootDir: path.join(projectPath, 'src'),
+      filepath: sourceFilePath,
+      enableVirtualDist: true,
+      babelConfig: { sourceMaps: true },
+    });
+    expect(fs.existsSync(path.join(distPath, 'index.js'))).toBe(false);
+    expect(fs.existsSync(path.join(distPath, 'index.js.map'))).toBe(false);
+    fs.removeSync(distPath);
+  });
+});

package/tests/compilerErrorResult.test.ts

@@ -0,0 +1,119 @@
+import { CompilerErrorResult } from '../src/compilerErrorResult';
+
+describe('CompilerErrorResult Class', () => {
+  it('call constructor without params', () => {
+    const cer_1 = new CompilerErrorResult();
+    expect(Array.isArray(cer_1._messageDetails)).toBe(true);
+    expect(cer_1._messageDetails.length).toBe(0);
+  });
+
+  it('call constructor with params', () => {
+    const cer_1 = new CompilerErrorResult({ code: 1, message: 'fail' });
+    expect(Array.isArray(cer_1._messageDetails)).toBe(true);
+    expect(cer_1._messageDetails.length).toBe(0);
+
+    const cer_2 = new CompilerErrorResult({
+      code: 1,
+      message: 'fail',
+      messageDetails: [{ content: 'error', filename: 'far.js' }],
+    });
+    expect(Array.isArray(cer_1._messageDetails)).toBe(true);
+    expect(cer_2._messageDetails.length).toBe(1);
+  });
+
+  it('use init', () => {
+    const cer_1 = new CompilerErrorResult();
+    cer_1.init({ code: 1, message: 'fail' });
+    expect(Array.isArray(cer_1._messageDetails)).toBe(true);
+    expect(cer_1._messageDetails.length).toBe(0);
+
+    const cer_2 = new CompilerErrorResult();
+    cer_2.init({
+      code: 1,
+      message: 'fail',
+      messageDetails: [{ content: 'error', filename: 'far.js' }],
+    });
+    expect(Array.isArray(cer_1._messageDetails)).toBe(true);
+    expect(cer_2._messageDetails.length).toBe(1);
+  });
+
+  it('update diff messageDetails', () => {
+    const cer_1 = new CompilerErrorResult({ code: 1, message: 'fail' });
+    const firstCount = cer_1._messageDetails.length;
+    cer_1.update([{ content: 'error', filename: 'far.js' }]);
+    const secondCount = cer_1._messageDetails.length;
+    cer_1.update([{ content: 'error', filename: 'bar.js' }]);
+    const thirdCount = cer_1._messageDetails.length;
+    expect(firstCount).toBe(0);
+    expect(secondCount).toBe(1);
+    expect(thirdCount).toBe(2);
+  });
+
+  it('update same messageDetails', () => {
+    const cer_1 = new CompilerErrorResult({ code: 1, message: 'fail' });
+    const firstCount = cer_1._messageDetails.length;
+    cer_1.update([{ content: 'error-1', filename: 'far.js' }]);
+    const secondCount = cer_1._messageDetails.length;
+    cer_1.update([{ content: 'error-2', filename: 'far.js' }]);
+    const thirdCount = cer_1._messageDetails.length;
+    expect(firstCount).toBe(0);
+    expect(secondCount).toBe(1);
+    expect(thirdCount).toBe(1);
+  });
+
+  it('remove by file name', () => {
+    const cer_1 = new CompilerErrorResult({
+      code: 1,
+      message: 'fail',
+      messageDetails: [{ content: 'error-1', filename: 'far.js' }],
+    });
+    const firstCount = cer_1._messageDetails.length;
+    cer_1.removeByFileName('far.js');
+    const secondCount = cer_1._messageDetails.length;
+    expect(firstCount).toBe(1);
+    expect(secondCount).toBe(0);
+  });
+
+  it('check exist error', () => {
+    const cer_1 = new CompilerErrorResult();
+    expect(cer_1.checkExistError()).toBe(false);
+    const cer_2 = new CompilerErrorResult({
+      code: 1,
+      message: 'fail',
+      messageDetails: [{ content: 'error-1', filename: 'far.js' }],
+    });
+    expect(cer_2.checkExistError()).toBe(true);
+  });
+
+  it('get value', () => {
+    const cer_1 = new CompilerErrorResult();
+    expect(cer_1.value).toStrictEqual({
+      code: 1,
+      message: `Compilation failure 0 files with Babel.`,
+      messageDetails: [],
+    });
+    const cer_2 = new CompilerErrorResult({
+      code: 1,
+      message: 'fail',
+      messageDetails: [{ content: 'error-1', filename: 'far.js' }],
+    });
+    expect(cer_2.value).toStrictEqual({
+      code: 1,
+      message: `Compilation failure 1 files with Babel.`,
+      messageDetails: [{ content: 'error-1', filename: 'far.js' }],
+    });
+  });
+
+  it('_messageDetails', () => {
+    const cer_1 = new CompilerErrorResult();
+    expect(cer_1._messageDetails).toStrictEqual([]);
+    const cer_2 = new CompilerErrorResult({
+      code: 1,
+      message: 'fail',
+      messageDetails: [{ content: 'error-1', filename: 'far.js' }],
+    });
+    expect(cer_2._messageDetails).toStrictEqual([
+      { content: 'error-1', filename: 'far.js' },
+    ]);
+  });
+});

package/tests/constants.test.ts

@@ -0,0 +1,12 @@
+import { defaultDistFileExtMap } from '../src/constants';
+
+describe('constants', () => {
+  it('defaultDistFileExtMap', () => {
+    expect(defaultDistFileExtMap).toStrictEqual({
+      '.js': '.js',
+      '.jsx': '.js',
+      '.ts': '.js',
+      '.tsx': '.js',
+    });
+  });
+});

package/tests/defaults.test.ts

@@ -0,0 +1,29 @@
+import { mergeDefaultOption } from '../src/defaults';
+
+describe('defaults', () => {
+  it('should merge default option', () => {
+    const option_1 = mergeDefaultOption({
+      rootDir: './',
+      distDir: './dist',
+      filenames: ['far.js'],
+    });
+    expect(option_1).toStrictEqual({
+      rootDir: './',
+      distDir: './dist',
+      filenames: ['far.js'],
+      enableWatch: false,
+      enableVirtualDist: false,
+      extensions: [],
+      distFileExtMap: {
+        '.js': '.js',
+        '.jsx': '.js',
+        '.ts': '.js',
+        '.tsx': '.js',
+      },
+      ignore: [],
+      quiet: false,
+      verbose: false,
+      clean: false,
+    });
+  });
+});

package/tests/fixtures/build/src/error

@@ -0,0 +1 @@
+conts a = 1;

package/tests/fixtures/build/src/error1

@@ -0,0 +1 @@
+conts a = 1;

package/tests/fixtures/buildWatch/src/error

@@ -0,0 +1,2 @@
+// eslint-disable-next-line
+conts a = 1;

package/tests/fixtures/compiler/src/index.js

@@ -0,0 +1,2 @@
+const a = 1;
+console.info('this is test', a);

package/tests/fixtures/resolveSourceMap/dist/far.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["index.js"],"names":["a","console","info"],"mappings":"AAAA,MAAMA,CAAC,GAAG,CAAV;AACAC,OAAO,CAACC,IAAR,CAAaF,CAAb","sourcesContent":["const a = 1;\nconsole.info(a);\n"],"file":"/Users/admin/github/modern.js/packages/toolkit/compiler/babel/tests/fixtures/resolveSourceMap/dist/far.js"}

package/tests/fixtures/resolveSourceMap/src/index.js

@@ -0,0 +1,2 @@
+const a = 1;
+console.info(a);

package/tests/fixtures/utils/far

@@ -0,0 +1,2 @@
+const far = 1;
+//# sourceMappingURL=far.js.map

package/tests/getFinalOption.test.ts

@@ -0,0 +1,106 @@
+import * as path from 'path';
+import { DEFAULT_EXTENSIONS } from '@babel/core';
+import {
+  getFinalCompilerOption,
+  getFilesFromDir,
+  getFinalExtensions,
+  getGlobPattern,
+} from '../src/getFinalOption';
+import { defaultDistFileExtMap } from '../src/constants';
+
+const projectDir = path.join(__dirname, './fixtures/getFinalOption');
+const sourceDir = path.join(projectDir, 'sourceDir');
+const watchDir = path.join(projectDir, 'watchDir');
+
+describe('get final compilerOption', () => {
+  it('getGlobPattern', () => {
+    const pattern_1 = getGlobPattern(sourceDir, ['.js']);
+    expect(pattern_1).toBe(`${sourceDir}/**/*.js`);
+    const pattern_2 = getGlobPattern(watchDir, ['.js', '.jsx']);
+    expect(pattern_2).toBe(`${watchDir}/**/*{.js,.jsx}`);
+    const pattern_3 = getGlobPattern(watchDir, []);
+    expect(pattern_3).toBe(`${watchDir}/**/*`);
+  });
+
+  it('getFinalExtensions', () => {
+    const finalexts_1 = getFinalExtensions(['.ts', '.tsx']);
+    expect(finalexts_1).toStrictEqual(['.ts', '.tsx', ...DEFAULT_EXTENSIONS]);
+    const finalexts_2 = getFinalExtensions(defaultExts => [
+      '.ts',
+      '.tsx',
+      ...defaultExts,
+    ]);
+    expect(finalexts_2).toStrictEqual(['.ts', '.tsx', ...DEFAULT_EXTENSIONS]);
+    const finalexts_3 = getFinalExtensions(() => ['.ts', '.tsx']);
+    expect(finalexts_3).toStrictEqual(['.ts', '.tsx']);
+    const finalexts_4 = getFinalExtensions(undefined);
+    expect(finalexts_4).toStrictEqual(DEFAULT_EXTENSIONS);
+  });
+
+  it('getFilesFromDir', () => {
+    const files_1 = getFilesFromDir({ dir: watchDir, finalExt: ['.js'] });
+    expect(files_1.length).toBe(1);
+    const files_2 = getFilesFromDir({
+      dir: watchDir,
+      finalExt: ['.js', '.jsx'],
+    });
+    expect(files_2.length).toBe(2);
+    const files_3 = getFilesFromDir({
+      dir: watchDir,
+      finalExt: ['.js', '.jsx'],
+      ignore: ['**/far.js'],
+    });
+    expect(files_3.length).toBe(1);
+    const files_4 = getFilesFromDir({ dir: watchDir });
+    expect(files_4.length).toBe(2);
+  });
+
+  it('getFinalCompilerOption', () => {
+    const baseOption = {
+      rootDir: projectDir,
+      distDir: path.join(projectDir, 'dist'),
+    };
+    const baseFinalOption = {
+      ...baseOption,
+      enableWatch: false,
+      enableVirtualDist: false,
+      extensions: [],
+      distFileExtMap: defaultDistFileExtMap,
+      ignore: [],
+      quiet: false,
+      verbose: false,
+      clean: false,
+    };
+    const option_1 = getFinalCompilerOption({ ...baseOption });
+    expect(option_1).toStrictEqual({
+      ...baseFinalOption,
+      filenames: [],
+    });
+    const option_2 = getFinalCompilerOption({ ...baseOption, sourceDir });
+    expect(option_2.filenames.length).toBe(1);
+    expect(option_2.filenames[0]).toBe(path.join(sourceDir, './bar.js'));
+    const option_3 = getFinalCompilerOption({ ...baseOption, watchDir });
+    expect(option_3.filenames.length).toBe(0);
+    const option_4 = getFinalCompilerOption({
+      ...baseOption,
+      enableWatch: true,
+      watchDir,
+    });
+    expect(option_4.filenames.length).toBe(2);
+    expect(
+      option_4.filenames.every(filename =>
+        [
+          path.join(watchDir, './far.js'),
+          path.join(watchDir, './foo.jsx'),
+        ].includes(filename),
+      ),
+    ).toBe(true);
+
+    const option_5 = getFinalCompilerOption({
+      ...baseOption,
+      filenames: ['./c.js'],
+      sourceDir,
+    });
+    expect(option_5.filenames.length).toBe(2);
+  });
+});

package/tests/index.test.ts

@@ -0,0 +1,89 @@
+import * as path from 'path';
+import { logger } from '@modern-js/utils';
+import { compiler } from '../src';
+import {
+  sourceDirAndFileNamesValidMessage,
+  watchDirValidMessage,
+} from '../src/validate';
+
+const projectDir = path.join(__dirname, './fixtures/lib');
+const srcDir = path.join(projectDir, 'src');
+const distDir = path.join(projectDir, 'dist');
+
+const originalLogInfo = logger.info;
+const originalLogError = logger.error;
+
+describe('babel compiler', () => {
+  let testLogs: any[] = [];
+  const mockedLogInfo = (s: string | number | Error | undefined) =>
+    testLogs.push(s);
+  beforeEach(() => {
+    logger.info = mockedLogInfo;
+    logger.error = mockedLogInfo;
+  });
+
+  it('normal compiler', async () => {
+    const ret = await compiler(
+      {
+        rootDir: srcDir,
+        filenames: [path.join(srcDir, 'index.js')],
+        distDir,
+        enableVirtualDist: true,
+      },
+      {},
+    );
+
+    expect(ret.code).toBe(0);
+    expect(ret.virtualDists?.length).toBe(1);
+  });
+
+  it('compiler with valid', async () => {
+    const ret = await compiler(
+      {
+        rootDir: srcDir,
+        distDir,
+        enableVirtualDist: true,
+      },
+      {},
+    );
+
+    expect(ret.code).toBe(1);
+    expect(ret.message).toBe(sourceDirAndFileNamesValidMessage);
+
+    const ret_1 = await compiler(
+      {
+        rootDir: srcDir,
+        distDir,
+        filenames: [path.join(srcDir, 'index.js')],
+        enableWatch: true,
+        enableVirtualDist: true,
+      },
+      {},
+    );
+
+    expect((ret_1 as any).code).toBe(1);
+    expect((ret_1 as any).message).toBe(watchDirValidMessage);
+  });
+
+  it('compiler in watch mode', async () => {
+    const emitter = await compiler(
+      {
+        rootDir: srcDir,
+        filenames: [path.join(srcDir, 'index.js')],
+        distDir,
+        enableWatch: true,
+        watchDir: srcDir,
+        enableVirtualDist: true,
+      },
+      {},
+    );
+
+    expect('on' in emitter).toBe(true);
+  });
+
+  afterEach(() => {
+    logger.info = originalLogInfo;
+    logger.error = originalLogError;
+    testLogs = [];
+  });
+});

package/tests/tsconfig.json

@@ -0,0 +1,15 @@
+{
+  "extends": "@modern-js/tsconfig/base",
+  "compilerOptions": {
+    "declaration": true,
+    "jsx": "preserve",
+    "baseUrl": "./",
+    "outDir": "./out",
+    "emitDeclarationOnly": true,
+    "isolatedModules": true,
+    "paths": {
+      "@/*": ["../src/*"]
+    },
+    "types": ["node", "jest"]
+  }
+}

package/tests/utils.test.ts

@@ -0,0 +1,18 @@
+import * as path from 'path';
+import { fs } from '@modern-js/utils';
+import { addSourceMappingUrl } from '../src/utils';
+
+describe('utils test', () => {
+  it('addSourceMappingUrl should right', () => {
+    const code = 'const far = 1;';
+    const mapLoc = `far.js.map`;
+    const codeWithSourceMappingUrl = addSourceMappingUrl(code, mapLoc);
+    const rightCodeWithSourceMappingUrl = fs.readFileSync(
+      path.join(__dirname, './fixtures/utils/far'),
+      'utf-8',
+    );
+    expect(codeWithSourceMappingUrl.trim()).toEqual(
+      rightCodeWithSourceMappingUrl.trim(),
+    );
+  });
+});

package/tests/validate.test.ts

@@ -0,0 +1,68 @@
+import {
+  validate,
+  validateWatchDir,
+  validateSourceDirAndFileNames,
+  sourceDirAndFileNamesValidMessage,
+  watchDirValidMessage,
+} from '../src/validate';
+
+describe('valide', () => {
+  const baseOption = { rootDir: './', distDir: './dist', quiet: true };
+
+  it('valide sourceDir and filenams config', () => {
+    const ret_1 = validateSourceDirAndFileNames({
+      ...baseOption,
+      sourceDir: './src',
+    });
+    expect(ret_1).toBe(null);
+    const ret_2 = validateSourceDirAndFileNames({
+      ...baseOption,
+      filenames: ['./far.js'],
+    });
+    expect(ret_2).toBe(null);
+
+    const ret_3 = validateSourceDirAndFileNames({
+      ...baseOption,
+      sourceDir: './src',
+      filenames: ['./far.js'],
+    });
+    expect(ret_3).toBe(null);
+
+    const ret_4 = validateSourceDirAndFileNames({ ...baseOption });
+    expect(ret_4).toStrictEqual({
+      code: 1,
+      message: sourceDirAndFileNamesValidMessage,
+      virtualDists: [],
+    });
+  });
+
+  it('valid watchDir config', () => {
+    const ret_1 = validateWatchDir({ ...baseOption, enableWatch: true });
+    expect(ret_1).toStrictEqual({
+      code: 1,
+      message: watchDirValidMessage,
+      virtualDists: [],
+    });
+
+    const ret_2 = validateWatchDir({
+      ...baseOption,
+      enableWatch: true,
+      watchDir: './src',
+    });
+    expect(ret_2).toBe(null);
+  });
+
+  it('validate', () => {
+    const ret_1 = validate({ ...baseOption, sourceDir: './src' });
+    expect(ret_1).toBe(null);
+    const ret_2 = validate({ ...baseOption, filenames: ['./far.js'] });
+    expect(ret_2).toBe(null);
+    const ret_3 = validate({
+      ...baseOption,
+      sourceDir: './src',
+      enableWatch: true,
+      watchDir: './src',
+    });
+    expect(ret_3).toBe(null);
+  });
+});

package/tsconfig.json

@@ -0,0 +1,16 @@
+{
+  "extends": "@modern-js/tsconfig/base",
+  "compilerOptions": {
+    "declaration": true,
+    "jsx": "preserve",
+    "baseUrl": "./",
+    "outDir": "./out",
+    "emitDeclarationOnly": true,
+    "isolatedModules": true,
+    "paths": {
+      "@/*": ["./src/*"]
+    },
+    "types": ["node", "jest"]
+  },
+  "include": ["src"]
+}