feat: process assertion

src/plugin/assert/index.ts

@@ -0,0 +1,4 @@
+import * as tsd from './tsd';
+import * as tssert from './tssert';
+
+export const assert = new Map(Object.entries({ tsd, tssert }));

src/plugin/assert/tsd/index.ts

@@ -0,0 +1,36 @@
+import type ts from 'byots';
+import type { Assertion } from '../../types';
+import type { Compiler } from '../../../typescript/types';
+import { createAssertionDiagnostic } from '../../diagnostics';
+
+export function expectType(assertion: Assertion, compiler: Compiler): ts.Diagnostic | undefined {
+  return createAssertionDiagnostic('Not yet implemented.', compiler.sourceFile, assertion.node.getStart());
+}
+
+export function expectNotType(assertion: Assertion, compiler: Compiler): ts.Diagnostic | undefined {
+  return createAssertionDiagnostic('Not yet implemented.', compiler.sourceFile, assertion.node.getStart());
+}
+
+export function expectAssignable(assertion: Assertion, compiler: Compiler): ts.Diagnostic | undefined {
+  return createAssertionDiagnostic('Not yet implemented.', compiler.sourceFile, assertion.node.getStart());
+}
+
+export function expectNotAssignable(assertion: Assertion, compiler: Compiler): ts.Diagnostic | undefined {
+  return createAssertionDiagnostic('Not yet implemented.', compiler.sourceFile, assertion.node.getStart());
+}
+
+export function expectError(assertion: Assertion, compiler: Compiler): ts.Diagnostic | undefined {
+  return createAssertionDiagnostic('Not yet implemented.', compiler.sourceFile, assertion.node.getStart());
+}
+
+export function expectDeprecated(assertion: Assertion, compiler: Compiler): ts.Diagnostic | undefined {
+  return createAssertionDiagnostic('Not yet implemented.', compiler.sourceFile, assertion.node.getStart());
+}
+
+export function expectNotDeprecated(assertion: Assertion, compiler: Compiler): ts.Diagnostic | undefined {
+  return createAssertionDiagnostic('Not yet implemented.', compiler.sourceFile, assertion.node.getStart());
+}
+
+export function printType(assertion: Assertion, compiler: Compiler): ts.Diagnostic | undefined {
+  return createAssertionDiagnostic('Not yet implemented.', compiler.sourceFile, assertion.node.getStart());
+}

src/plugin/assert/tssert/index.ts

@@ -0,0 +1,16 @@
+import type ts from 'byots';
+import type { Assertion } from '../../types';
+import type { Compiler } from '../../../typescript/types';
+import { createAssertionDiagnostic } from '../../diagnostics';
+
+export function expectType(assertion: Assertion, compiler: Compiler): ts.Diagnostic | undefined {
+  return createAssertionDiagnostic('Not yet implemented.', compiler.sourceFile, assertion.node.getStart());
+}
+
+export function assignableTo(assertion: Assertion, compiler: Compiler): ts.Diagnostic | undefined {
+  return createAssertionDiagnostic('Not yet implemented.', compiler.sourceFile, assertion.node.getStart());
+}
+
+export function notAssignableTo(assertion: Assertion, compiler: Compiler): ts.Diagnostic | undefined {
+  return createAssertionDiagnostic('Not yet implemented.', compiler.sourceFile, assertion.node.getStart());
+}

src/plugin/diagnostics.ts

@@ -80,3 +80,14 @@ throw (() => {
 })()
 `;
 }
+
+export function createAssertionDiagnostic(message: string, file: ts.SourceFile, start: number): ts.Diagnostic {
+  return {
+    category: ts.DiagnosticCategory.Error,
+    code: -42,
+    file,
+    start,
+    length: undefined,
+    messageText: message,
+  };
+}

src/plugin/transform.ts

@@ -1,11 +1,13 @@
 import ts from 'byots';
+import { assert } from './assert';
 import MagicString from 'magic-string';
 import type { TransformResult } from 'vite';
 import { reportDiagnostics } from './diagnostics';
 import type { Compiler } from '../typescript/types';
 import { API_PROPERTY_KEY } from '../common/internal';
 import { createCompiler } from '../typescript/compiler';
-import type { Assertion, TransformSettings } from './types';
+import { createError, ErrorCode } from '../common/error';
+import type { APIName, Assertion, TransformSettings } from './types';
 
 export function transform({ code, fileName, report, typescript }: TransformSettings): TransformResult {
   const compiler = createCompiler({ config: typescript.config, fileName });
@@ -39,19 +41,15 @@ function getAssertions(sourceFile: ts.SourceFile, typeChecker: ts.TypeChecker):
       const expressionType = typeChecker.getTypeAtLocation(expression);
       const assertionProperty = expressionType.getProperty(API_PROPERTY_KEY);
 
-      if (!assertionProperty) {
-        return;
-      }
-
-      const assertionPropertyType = typeChecker.getTypeOfSymbolAtLocation(assertionProperty, expression);
-      const assertionPropertyValue = typeChecker.typeToString(assertionPropertyType).slice(1, -1);
-      const [apiName, functionName] = assertionPropertyValue.split(':');
+      if (assertionProperty) {
+        const assertionPropertyType = typeChecker.getTypeOfSymbolAtLocation(assertionProperty, expression);
+        const assertionPropertyValue = typeChecker.typeToString(assertionPropertyType).slice(1, -1);
+        const [apiName, functionName] = assertionPropertyValue.split(':');
 
-      if (!apiName || !functionName) {
-        return;
+        if (apiName && functionName) {
+          assertions.push({ apiName: apiName as APIName, functionName, node });
+        }
       }
-
-      assertions.push({ apiName, functionName, node });
     }
 
     node.forEachChild(visit);
@@ -65,8 +63,21 @@ function getAssertions(sourceFile: ts.SourceFile, typeChecker: ts.TypeChecker):
 function processAssertions(assertions: Assertion[], compiler: Compiler): ts.Diagnostic[] {
   const diagnostics: ts.Diagnostic[] = [];
 
-  // eslint-disable-next-line no-console
-  console.log({ assertions, compiler });
+  assertions.forEach((assertion) => {
+    const api = assert.get(assertion.apiName);
+
+    if (!api) {
+      throw createError(ErrorCode.UNEXPECTED_ERROR, {
+        message: `The ${assertion.apiName} API could not be loaded.`,
+      });
+    }
+
+    const diagnostic = api[assertion.functionName as keyof typeof api](assertion, compiler);
+
+    if (diagnostic) {
+      diagnostics.push(diagnostic);
+    }
+  });
 
   return diagnostics;
 }

src/plugin/types.ts

@@ -32,8 +32,10 @@ export interface ErrorObject {
   column: number;
 }
 
+export type APIName = 'tsd' | 'tssert';
+
 export interface Assertion {
-  apiName: string;
+  apiName: APIName;
   functionName: string;
   node: ts.Node;
 }

test/tsd.test.ts

@@ -13,9 +13,13 @@
 //     // expect("life").toBe(42);
 //   });
 // });
-import { expectType, expectType as assertType } from '../src/api/tsd';
+
+import { test } from 'vitest';
 import * as tsd from '../src/api/tsd';
+import { expectType, expectType as assertType } from '../src/api/tsd';
 
-expectType<string>('hello');
-assertType<string>('hello');
-tsd.expectType<string>('hello');
+test('test-1', () => {
+  expectType<string>('hello');
+  assertType<string>('hello');
+  tsd.expectType<string>('hello');
+});

test/tssert.test.ts

@@ -14,13 +14,16 @@
 //   });
 // });
 
-import { expectType, expectType as assertType } from '../src/api/tssert';
+import { test } from 'vitest';
 import * as tssert from '../src/api/tssert';
+import { expectType, expectType as assertType } from '../src/api/tssert';
 
-expectType<string>('hello');
-assertType<string>('hello');
-tssert.expectType<string>('hello');
+test('test-1', () => {
+  expectType<string>('hello');
+  assertType<string>('hello');
+  tssert.expectType<string>('hello');
 
-expectType<string>().assignableTo('hello');
-expectType<number>().not.assignableTo('hello');
-tssert.expectType<number>().not.assignableTo('hello');
+  expectType<string>().assignableTo('hello');
+  expectType<number>().not.assignableTo('hello');
+  tssert.expectType<number>().not.assignableTo('hello');
+});