chore: use vitest instead of jest

Author: dummdidumm

__test__/api/parseExpressionAt.test.ts

@@ -1,22 +1,18 @@
-import { generateSource, Parser } from '../utils'
+import { describe, it, expect } from 'vitest';
+import { generateSource, Parser } from '../utils';
 
 function parseExpressionAt(input: string, pos: number) {
   return Parser.parseExpressionAt(input, pos, {
     sourceType: 'module',
     ecmaVersion: 'latest',
-    locations: true
-  })
+    locations: true,
+  });
 }
 
-describe('parseExpressionAt API', function() {
-  it('normal', function() {
-    const node = parseExpressionAt(generateSource([
-      `<tag prop={`,
-      `  (): void => {}`,
-      `} />`
-    ]), 14)
-
-    expect(node.type).toEqual('ArrowFunctionExpression')
-  })
-})
+describe('parseExpressionAt API', function () {
+  it('normal', function () {
+    const node = parseExpressionAt(generateSource([`<tag prop={`, `  (): void => {}`, `} />`]), 14);
 
+    expect(node.type).toEqual('ArrowFunctionExpression');
+  });
+});

__test__/arrow-function/type.test.ts

@@ -1,43 +1,41 @@
-import { equalNode, generateSource, parseSource } from '../utils'
-import ArrowFunctionTypeSnapshot from '../__snapshot__/arrow-function/type'
+import { describe, it } from 'vitest';
+import { equalNode, generateSource, parseSource } from '../utils';
+import ArrowFunctionTypeSnapshot from '../__snapshot__/arrow-function/type';
 
 const issue38File = `
 let defaultHashSize = 0
 export const getHashPlaceholderGenerator = (): any => {
   let nextIndex = 0;
   return (optionName: string, hashSize: number = defaultHashSize) => {}
 }
-`
+`;
 
-const issue39File = `export const getPureFunctions = ({ treeshake }: NormalizedInputOptions): PureFunctions => {};`
+const issue39File = `export const getPureFunctions = ({ treeshake }: NormalizedInputOptions): PureFunctions => {};`;
 
 describe('arrow-function type test', () => {
   it('assignment pattern', () => {
-    const node = parseSource(generateSource([
-      `(x = 42): void => {}`
-    ]))
+    const node = parseSource(generateSource([`(x = 42): void => {}`]));
 
-    equalNode(node, ArrowFunctionTypeSnapshot.AssignmentPattern)
-  })
+    equalNode(node, ArrowFunctionTypeSnapshot.AssignmentPattern);
+  });
 
   it('issue 32', () => {
-    const node = parseSource(generateSource([
-      `const testApp = async(app: string, index: number) => {`,
-      `};`
-    ]))
+    const node = parseSource(
+      generateSource([`const testApp = async(app: string, index: number) => {`, `};`])
+    );
 
-    equalNode(node, ArrowFunctionTypeSnapshot.Issue32)
-  })
+    equalNode(node, ArrowFunctionTypeSnapshot.Issue32);
+  });
 
   it('issue 38', () => {
-    const node = parseSource(issue38File)
+    const node = parseSource(issue38File);
 
-    equalNode(node, ArrowFunctionTypeSnapshot.Issue38)
-  })
+    equalNode(node, ArrowFunctionTypeSnapshot.Issue38);
+  });
 
   it('issue 39', () => {
-    const node = parseSource(issue39File)
+    const node = parseSource(issue39File);
 
-    equalNode(node, ArrowFunctionTypeSnapshot.Issue39)
-  })
-})
+    equalNode(node, ArrowFunctionTypeSnapshot.Issue39);
+  });
+});

__test__/assert/index.test.ts

@@ -1,38 +1,39 @@
-import { equalNode, parseSource, parseSourceShouldThrowError } from '../utils'
-import AssertionSnapshot from '../__snapshot__/assert'
+import { describe, it, expect } from 'vitest';
+import { equalNode, parseSource, parseSourceShouldThrowError } from '../utils';
+import AssertionSnapshot from '../__snapshot__/assert';
 
 describe('assert', () => {
   it('import assert', () => {
-    const node = parseSource(`import json from './foo.json' assert { type: 'json' };`)
+    const node = parseSource(`import json from './foo.json' assert { type: 'json' };`);
 
-    equalNode(node, AssertionSnapshot.ImportAssert)
-  })
+    equalNode(node, AssertionSnapshot.ImportAssert);
+  });
 
   it('import with', () => {
-    const node = parseSource(`import json from './foo.json' with { type: 'json' };`)
+    const node = parseSource(`import json from './foo.json' with { type: 'json' };`);
 
-    equalNode(node, AssertionSnapshot.ImportWith)
-  })
+    equalNode(node, AssertionSnapshot.ImportWith);
+  });
 
   it('import with duplicate', () => {
     const res = parseSourceShouldThrowError(
       `import json from './foo.json' with { type: 'json', type: 'json' };`,
       'Duplicated key in attributes',
       '(1:63)'
-    )
+    );
 
-    expect(res).toBe(true)
-  })
+    expect(res).toBe(true);
+  });
 
   it('dynamic import assert', () => {
-    const node = parseSource(`import("./foo.json", { with: { type: "json" } });`)
+    const node = parseSource(`import("./foo.json", { with: { type: "json" } });`);
 
-    equalNode(node, AssertionSnapshot.DynamicImportAssert)
-  })
+    equalNode(node, AssertionSnapshot.DynamicImportAssert);
+  });
 
   it('export all as assert', () => {
-    const node = parseSource(`export * as name from "./foo.json" with { type: "json" };`)
+    const node = parseSource(`export * as name from "./foo.json" with { type: "json" };`);
 
-    equalNode(node, AssertionSnapshot.ExportAllAsAssert)
-  })
-})
+    equalNode(node, AssertionSnapshot.ExportAllAsAssert);
+  });
+});