Drop tsd for tests in favor of expect-type

`tsd` is a somewhat heavy-weight dependency that is unnecessary considering that `expect-type` is already a depdency of `type-fest`.

Author: trevorade

.github/contributing.md

@@ -6,7 +6,7 @@
 - Please help review the other open pull requests. If there are no open pull requests, provide some feedback on some of the open issues.
 - Create a new file in the `test-d` directory and write at least one type test.
 	- See the other tests for inspiration.
-	- If it makes sense, also write a negative test using [`expectNotAssignable()`](https://github.com/SamVerschueren/tsd#expectnotassignabletexpression-any) or, to test other diagnostics, [`expectError()`](https://github.com/SamVerschueren/tsd#expecterrort--anyexpression-t).
+	- If it makes sense, also write a negative test using [`expectTypeOf().not`](https://github.com/mmkal/expect-type#features) or, to test other diagnostics, `@ts-expect-error`.
 - Don't use one-character type names like `T` and `U`. Use descriptive names. See the existing types for inspiration.
 - Write a good documentation comment that includes:
 	- Write a short and clear description of what the type does.

package.json

@@ -15,7 +15,7 @@
 		"node": ">=14.16"
 	},
 	"scripts": {
-		"test": "xo && tsd && tsc && node script/test/source-files-extension.js"
+		"test": "xo && tsc && node script/test/source-files-extension.js"
 	},
 	"files": [
 		"index.d.ts",
@@ -36,7 +36,6 @@
 	"devDependencies": {
 		"@sindresorhus/tsconfig": "~0.7.0",
 		"expect-type": "^0.14.2",
-		"tsd": "^0.24.1",
 		"typescript": "^4.8.3",
 		"xo": "^0.52.2"
 	},

test-d/async-return-type.ts

@@ -1,4 +1,4 @@
-import {expectNotAssignable, expectType} from 'tsd';
+import {expectTypeOf} from 'expect-type';
 import type {AsyncReturnType} from '../index';
 
 async function asyncFunction(): Promise<number> {
@@ -9,6 +9,6 @@ type Value = AsyncReturnType<typeof asyncFunction>;
 
 // eslint-disable-next-line @typescript-eslint/no-floating-promises
 asyncFunction().then(value => {
-	expectType<Value>(value);
-	expectNotAssignable<string>(value);
+	expectTypeOf(value).toEqualTypeOf<Value>();
+	expectTypeOf(value).not.toMatchTypeOf<string>();
 });

test-d/asyncify.ts

@@ -1,19 +1,20 @@
-import {expectType, expectError} from 'tsd';
+import {expectTypeOf} from 'expect-type';
 import type {Asyncify} from '../index';
 
 declare function getFooSync(name: string): RegExp;
 declare function getFooWithThisArgSync(this: Date, name: string): RegExp;
 
 // Basic usage.
 declare const getFooAsync1: Asyncify<typeof getFooSync>;
-expectType<(name: string) => Promise<RegExp>>(getFooAsync1);
+expectTypeOf(getFooAsync1).toEqualTypeOf<(name: string) => Promise<RegExp>>();
 
 // Noops with async functions.
 declare const getFooAsync2: Asyncify<typeof getFooAsync1>;
-expectType<typeof getFooAsync1>(getFooAsync2);
+expectTypeOf(getFooAsync2).toEqualTypeOf<typeof getFooAsync1>();
 
 // Respects `thisArg`.
 declare const getFooWithThisArgAsync1: Asyncify<typeof getFooWithThisArgSync>;
 const callResult = getFooWithThisArgAsync1.call(new Date(), 'foo');
-expectType<Promise<RegExp>>(callResult);
-expectError(getFooWithThisArgAsync1.call('not-date', 'foo'));
+expectTypeOf(callResult).toEqualTypeOf<Promise<RegExp>>();
+// @ts-expect-error
+void getFooWithThisArgAsync1.call('not-date', 'foo');

test-d/camel-case.ts

@@ -1,52 +1,52 @@
-import {expectType, expectAssignable} from 'tsd';
+import {expectTypeOf} from 'expect-type';
 import type {CamelCase, Split} from '../index';
 
 // Split
 const prefixSplit: Split<'--very-prefixed', '-'> = ['', '', 'very', 'prefixed'];
-expectType<['', '', 'very', 'prefixed']>(prefixSplit);
+expectTypeOf(prefixSplit).toEqualTypeOf<['', '', 'very', 'prefixed']>();
 
 // CamelCase
 const camelFromPascal: CamelCase<'FooBar'> = 'fooBar';
-expectType<'fooBar'>(camelFromPascal);
+expectTypeOf(camelFromPascal).toEqualTypeOf<'fooBar'>();
 
 const camelFromKebab: CamelCase<'foo-bar'> = 'fooBar';
-expectType<'fooBar'>(camelFromKebab);
+expectTypeOf(camelFromKebab).toEqualTypeOf<'fooBar'>();
 
 const camelFromComplexKebab: CamelCase<'foo-bar-abc-123'> = 'fooBarAbc123';
-expectType<'fooBarAbc123'>(camelFromComplexKebab);
+expectTypeOf(camelFromComplexKebab).toEqualTypeOf<'fooBarAbc123'>();
 
 const camelFromSpace: CamelCase<'foo bar'> = 'fooBar';
-expectType<'fooBar'>(camelFromSpace);
+expectTypeOf(camelFromSpace).toEqualTypeOf<'fooBar'>();
 
 const camelFromSnake: CamelCase<'foo_bar'> = 'fooBar';
-expectType<'fooBar'>(camelFromSnake);
+expectTypeOf(camelFromSnake).toEqualTypeOf<'fooBar'>();
 
 const noDelimiterFromMono: CamelCase<'foobar'> = 'foobar';
-expectType<'foobar'>(noDelimiterFromMono);
+expectTypeOf(noDelimiterFromMono).toEqualTypeOf<'foobar'>();
 
 const camelFromMixed: CamelCase<'foo-bar_abc xyzBarFoo'> = 'fooBarAbcXyzBarFoo';
-expectType<'fooBarAbcXyzBarFoo'>(camelFromMixed);
+expectTypeOf(camelFromMixed).toEqualTypeOf<'fooBarAbcXyzBarFoo'>();
 
 const camelFromVendorPrefixedCssProperty: CamelCase<'-webkit-animation'> = 'webkitAnimation';
-expectType<'webkitAnimation'>(camelFromVendorPrefixedCssProperty);
+expectTypeOf(camelFromVendorPrefixedCssProperty).toEqualTypeOf<'webkitAnimation'>();
 
 const camelFromDoublePrefixedKebab: CamelCase<'--very-prefixed'> = 'veryPrefixed';
-expectType<'veryPrefixed'>(camelFromDoublePrefixedKebab);
+expectTypeOf(camelFromDoublePrefixedKebab).toEqualTypeOf<'veryPrefixed'>();
 
 const camelFromRepeatedSeparators: CamelCase<'foo____bar'> = 'fooBar';
-expectType<'fooBar'>(camelFromRepeatedSeparators);
+expectTypeOf(camelFromRepeatedSeparators).toEqualTypeOf<'fooBar'>();
 
 const camelFromUppercase: CamelCase<'FOO'> = 'foo';
-expectType<'foo'>(camelFromUppercase);
+expectTypeOf(camelFromUppercase).toEqualTypeOf<'foo'>();
 
 const camelFromLowercase: CamelCase<'foo'> = 'foo';
-expectType<'foo'>(camelFromLowercase);
+expectTypeOf(camelFromLowercase).toEqualTypeOf<'foo'>();
 
 const camelFromScreamingSnakeCase: CamelCase<'FOO_BAR'> = 'fooBar';
-expectType<'fooBar'>(camelFromScreamingSnakeCase);
+expectTypeOf(camelFromScreamingSnakeCase).toEqualTypeOf<'fooBar'>();
 
 const camelFromScreamingKebabCase: CamelCase<'FOO-BAR'> = 'fooBar';
-expectType<'fooBar'>(camelFromScreamingKebabCase);
+expectTypeOf(camelFromScreamingKebabCase).toEqualTypeOf<'fooBar'>();
 
 // Verifying example
 type CamelCasedProperties<T> = {
@@ -62,11 +62,11 @@ type RawOptions = {
 	'OTHER-FIELD': boolean;
 };
 
-expectAssignable<CamelCasedProperties<RawOptions>>({
+expectTypeOf({
 	dryRun: true,
 	fullFamilyName: 'bar.js',
 	foo: 123,
 	bar: 'foo',
 	quzQux: 6,
 	otherField: false,
-});
+}).toMatchTypeOf<CamelCasedProperties<RawOptions>>();

test-d/camel-cased-properties-deep.ts

@@ -1,15 +1,15 @@
-import {expectType} from 'tsd';
+import {expectTypeOf} from 'expect-type';
 import type {CamelCasedPropertiesDeep} from '../index';
 
 declare const foo: CamelCasedPropertiesDeep<{A: {B: number; C: Array<{D: string}>}}>;
 
-expectType<{a: {b: number; c: Array<{d: string}>}}>(foo);
+expectTypeOf(foo).toEqualTypeOf<{a: {b: number; c: Array<{d: string}>}}>();
 
 declare const fooBar: CamelCasedPropertiesDeep<() => {a: string}>;
-expectType<() => {a: string}>(fooBar);
+expectTypeOf(fooBar).toEqualTypeOf<() => {a: string}>();
 
 declare const bar: CamelCasedPropertiesDeep<Set<{fooBar: string}>>;
-expectType<Set<{fooBar: string}>>(bar);
+expectTypeOf(bar).toEqualTypeOf<Set<{fooBar: string}>>();
 
 // Verify example
 type User = {
@@ -46,4 +46,4 @@ const result: CamelCasedPropertiesDeep<UserWithFriends> = {
 		},
 	],
 };
-expectType<CamelCasedPropertiesDeep<UserWithFriends>>(result);
+expectTypeOf(result).toEqualTypeOf<CamelCasedPropertiesDeep<UserWithFriends>>();

test-d/camel-cased-properties.ts

@@ -1,15 +1,15 @@
-import {expectType} from 'tsd';
+import {expectTypeOf} from 'expect-type';
 import type {CamelCasedProperties} from '../index';
 
 declare const foo: CamelCasedProperties<{A: number; B: {C: string}}>;
 
-expectType<{a: number; b: {C: string}}>(foo);
+expectTypeOf(foo).toEqualTypeOf<{a: number; b: {C: string}}>();
 
 declare const bar: CamelCasedProperties<Array<{helloWorld: string}>>;
-expectType<Array<{helloWorld: string}>>(bar);
+expectTypeOf(bar).toEqualTypeOf<Array<{helloWorld: string}>>();
 
 declare const fooBar: CamelCasedProperties<() => {a: string}>;
-expectType<() => {a: string}>(fooBar);
+expectTypeOf(fooBar).toEqualTypeOf<() => {a: string}>();
 
 // Verify example
 type User = {
@@ -21,4 +21,4 @@ const result: CamelCasedProperties<User> = {
 	userId: 1,
 	userName: 'Tom',
 };
-expectType<CamelCasedProperties<User>>(result);
+expectTypeOf(result).toEqualTypeOf<CamelCasedProperties<User>>();

test-d/class.ts

@@ -1,4 +1,3 @@
-import {expectError} from 'tsd';
 import type {Constructor} from '../index';
 
 class Foo {
@@ -15,7 +14,9 @@ function fn(Cls: Constructor<Foo>): Foo {
 }
 
 function fn2(Cls: Constructor<Foo, [number, number]>): Foo {
-	expectError(new Cls(1, ''));
+	// @ts-expect-error
+	// eslint-disable-next-line no-new
+	new Cls(1, '');
 	return new Cls(1, 2);
 }
 

test-d/conditional-except.ts

@@ -1,4 +1,4 @@
-import {expectType} from 'tsd';
+import {expectTypeOf} from 'expect-type';
 import type {ConditionalExcept, Primitive} from '../index';
 
 class Awesome {
@@ -19,10 +19,10 @@ type Example = {
 };
 
 declare const exampleConditionalExcept: ConditionalExcept<Example, string>;
-expectType<{b?: string | number; c?: string; d: Record<string, unknown>}>(exampleConditionalExcept);
+expectTypeOf(exampleConditionalExcept).toEqualTypeOf<{b?: string | number; c?: string; d: Record<string, unknown>}>();
 
 declare const awesomeConditionalExcept: ConditionalExcept<Awesome, Primitive>;
-expectType<{run: () => void}>(awesomeConditionalExcept);
+expectTypeOf(awesomeConditionalExcept).toEqualTypeOf<{run: () => void}>();
 
 declare const exampleConditionalExceptWithUndefined: ConditionalExcept<Example, string | undefined>;
-expectType<{b?: string | number; d: Record<string, unknown>}>(exampleConditionalExceptWithUndefined);
+expectTypeOf(exampleConditionalExceptWithUndefined).toEqualTypeOf<{b?: string | number; d: Record<string, unknown>}>();

test-d/conditional-keys.ts

@@ -1,4 +1,4 @@
-import {expectType} from 'tsd';
+import {expectTypeOf} from 'expect-type';
 import type {ConditionalKeys} from '../index';
 
 type Example = {
@@ -9,7 +9,7 @@ type Example = {
 };
 
 declare const exampleConditionalKeys: ConditionalKeys<Example, string>;
-expectType<'a'>(exampleConditionalKeys);
+expectTypeOf(exampleConditionalKeys).toEqualTypeOf<'a'>();
 
 declare const exampleConditionalKeysWithUndefined: ConditionalKeys<Example, string | undefined>;
-expectType<'a' | 'c'>(exampleConditionalKeysWithUndefined);
+expectTypeOf(exampleConditionalKeysWithUndefined).toEqualTypeOf<'a' | 'c'>();