Add experimental type definition

This is without macros in anticipation of the next change.

Author: novemberborn

experimental.d.ts

@@ -0,0 +1,201 @@
+export {
+	AssertAssertion,
+	AssertionError,
+	Assertions,
+	CommitDiscardOptions,
+	Constructor,
+	DeepEqualAssertion,
+	ExecutionContext,
+	FailAssertion,
+	FalseAssertion,
+	FalsyAssertion,
+	ImplementationResult,
+	IsAssertion,
+	LogFn,
+	MetaInterface,
+	NotAssertion,
+	NotDeepEqualAssertion,
+	NotRegexAssertion,
+	NotThrowsAssertion,
+	NotThrowsAsyncAssertion,
+	PassAssertion,
+	PlanFn,
+	RegexAssertion,
+	SnapshotAssertion,
+	SnapshotOptions,
+	Subscribable,
+	ThrowsAssertion,
+	ThrowsAsyncAssertion,
+	ThrowsExpectation,
+	TimeoutFn,
+	TrueAssertion,
+	TruthyAssertion,
+	TryFn,
+	TryResult
+} from '.';
+
+import {ExecutionContext, ImplementationResult, MetaInterface} from '.';
+
+export type Implementation<Context = unknown> = (t: ExecutionContext<Context>) => ImplementationResult;
+export type ImplementationWithArgs<Args extends any[], Context = unknown> = (t: ExecutionContext<Context>, ...args: Args) => ImplementationResult;
+
+export interface TestInterface<Context = unknown> {
+	/** Declare a concurrent test. */
+	(title: string, implementation: Implementation<Context>): void;
+
+	/** Declare a concurrent test. */
+	<Args extends any[]> (title: string, implementation: ImplementationWithArgs<Args, Context>, ...args: Args): void;
+
+	/** Declare a hook that is run once, after all tests have passed. */
+	after: AfterInterface<Context>;
+
+	/** Declare a hook that is run after each passing test. */
+	afterEach: AfterInterface<Context>;
+
+	/** Declare a hook that is run once, before all tests. */
+	before: BeforeInterface<Context>;
+
+	/** Declare a hook that is run before each test. */
+	beforeEach: BeforeInterface<Context>;
+
+	/** Declare a test that is expected to fail. */
+	failing: FailingInterface<Context>;
+
+	/** Declare tests and hooks that are run serially. */
+	serial: SerialInterface<Context>;
+
+	only: OnlyInterface<Context>;
+	skip: SkipInterface<Context>;
+	todo: TodoDeclaration;
+	meta: MetaInterface;
+}
+
+export interface AfterInterface<Context = unknown> {
+	/** Declare a hook that is run once, after all tests have passed. */
+	(implementation: Implementation<Context>): void;
+
+	/** Declare a hook that is run once, after all tests have passed. */
+	<Args extends any[]> (implementation: ImplementationWithArgs<Args, Context>, ...args: Args): void;
+
+	/** Declare a hook that is run once, after all tests have passed. */
+	(title: string, implementation: Implementation<Context>): void;
+
+	/** Declare a hook that is run once, after all tests have passed. */
+	<Args extends any[]> (title: string, implementation: ImplementationWithArgs<Args, Context>, ...args: Args): void;
+
+	/** Declare a hook that is run once, after all tests are done. */
+	always: AlwaysInterface<Context>;
+
+	skip: HookSkipInterface<Context>;
+}
+
+export interface AlwaysInterface<Context = unknown> {
+	/** Declare a hook that is run once, after all tests are done. */
+	(implementation: Implementation<Context>): void;
+
+	/** Declare a hook that is run once, after all tests are done. */
+	<Args extends any[]> (implementation: ImplementationWithArgs<Args, Context>, ...args: Args): void;
+
+	/** Declare a hook that is run once, after all tests are done. */
+	(title: string, implementation: Implementation<Context>): void;
+
+	/** Declare a hook that is run once, after all tests are done. */
+	<Args extends any[]> (title: string, implementation: ImplementationWithArgs<Args, Context>, ...args: Args): void;
+
+	skip: HookSkipInterface<Context>;
+}
+
+export interface BeforeInterface<Context = unknown> {
+	/** Declare a hook that is run once, before all tests. */
+	(implementation: Implementation<Context>): void;
+
+	/** Declare a hook that is run once, before all tests. */
+	<Args extends any[]> (implementation: ImplementationWithArgs<Args, Context>, ...args: Args): void;
+
+	/** Declare a hook that is run once, before all tests. */
+	(title: string, implementation: Implementation<Context>): void;
+
+	/** Declare a hook that is run once, before all tests. */
+	<Args extends any[]> (title: string, implementation: ImplementationWithArgs<Args, Context>, ...args: Args): void;
+
+	skip: HookSkipInterface<Context>;
+}
+
+export interface FailingInterface<Context = unknown> {
+	/** Declare a concurrent test. The test is expected to fail. */
+	(title: string, implementation: Implementation<Context>): void;
+
+	/** Declare a concurrent test. The test is expected to fail. */
+	<Args extends any[]> (title: string, implementation: ImplementationWithArgs<Args, Context>, ...args: Args): void;
+
+	only: OnlyInterface<Context>;
+	skip: SkipInterface<Context>;
+}
+
+export interface HookSkipInterface<Context = unknown> {
+	/** Skip this hook. */
+	(implementation: Implementation<Context>): void;
+
+	/** Skip this hook. */
+	<Args extends any[]> (implementation: ImplementationWithArgs<Args, Context>, ...args: Args): void;
+
+	/** Skip this hook. */
+	(title: string, implementation: Implementation<Context>): void;
+
+	/** Skip this hook. */
+	<Args extends any[]> (title: string, implementation: ImplementationWithArgs<Args, Context>, ...args: Args): void;
+}
+
+export interface OnlyInterface<Context = unknown> {
+	/** Declare a test. Only this test and others declared with `.only()` are run. */
+	(title: string, implementation: Implementation<Context>): void;
+
+	/** Declare a test. Only this test and others declared with `.only()` are run. */
+	<Args extends any[]> (title: string, implementation: ImplementationWithArgs<Args, Context>, ...args: Args): void;
+}
+
+export interface SerialInterface<Context = unknown> {
+	/** Declare a serial test. */
+	(title: string, implementation: Implementation<Context>): void;
+
+	/** Declare a serial test. */
+	<Args extends any[]> (title: string, implementation: ImplementationWithArgs<Args, Context>, ...args: Args): void;
+
+	/** Declare a serial hook that is run once, after all tests have passed. */
+	after: AfterInterface<Context>;
+
+	/** Declare a serial hook that is run after each passing test. */
+	afterEach: AfterInterface<Context>;
+
+	/** Declare a serial hook that is run once, before all tests. */
+	before: BeforeInterface<Context>;
+
+	/** Declare a serial hook that is run before each test. */
+	beforeEach: BeforeInterface<Context>;
+
+	/** Declare a serial test that is expected to fail. */
+	failing: FailingInterface<Context>;
+
+	only: OnlyInterface<Context>;
+	skip: SkipInterface<Context>;
+	todo: TodoDeclaration;
+}
+
+export interface SkipInterface<Context = unknown> {
+	/** Skip this test. */
+	(title: string, implementation: Implementation<Context>): void;
+
+	/** Skip this test. */
+	<Args extends any[]> (title: string, implementation: ImplementationWithArgs<Args, Context>, ...args: Args): void;
+}
+
+export interface TodoDeclaration {
+	/** Declare a test that should be implemented later. */
+	(title: string): void;
+}
+
+/** Call to declare a test, or chain to declare hooks or test modifiers */
+declare const test: TestInterface;
+
+/** Call to declare a test, or chain to declare hooks or test modifiers */
+export default test;

package.json

@@ -16,7 +16,8 @@
 		"lib",
 		"*.js",
 		"!*.config.js",
-		"index.d.ts"
+		"index.d.ts",
+		"experimental.d.ts"
 	],
 	"keywords": [
 		"🦄",

test-d/experimental.ts

@@ -0,0 +1,106 @@
+import {expectError} from 'tsd';
+import test, {ExecutionContext, Implementation, ImplementationWithArgs} from '../experimental';
+
+test('title', t => t.pass());
+
+expectError(test<[string]>('explicit argument type', t => t.pass(), 42));
+
+expectError(test<[string]>('missing argument', (t: ExecutionContext) => t.pass()));
+
+test<string[]>('optional arguments', t => t.pass());
+test<string[]>('optional arguments, with values', t => t.pass(), 'foo', 'bar');
+
+expectError(test('argument type inferred from implementation', (t, string) => t.is(string, 'foo'), 42));
+
+expectError(test('argument type inferred in implementation', (t, string) => t.is(string, 'foo'), 42));
+
+{
+	const implementation: Implementation = t => t.pass();
+	expectError(test('unexpected arguments', implementation, 'foo'));
+}
+
+{
+	const implementation: ImplementationWithArgs<[string]> = (t, string) => t.is(string, 'foo');
+	test('unexpected arguments', implementation, 'foo');
+}
+
+test.failing<[string]>('failing test with arguments', (t, string) => t.is(string, 'foo'), 'foo');
+test.only<[string]>('only test with arguments', (t, string) => t.is(string, 'foo'), 'foo');
+test.skip<[string]>('serial test with arguments', (t, string) => t.is(string, 'foo'), 'foo');
+
+test.after.always.skip<[string]>('after.always hook with args', (t, string) => t.is(string, 'foo'), 'foo');
+test.after.always.skip<[string]>((t, string) => t.is(string, 'foo'), 'foo');
+test.after.always<[string]>('after.always hook with args', (t, string) => t.is(string, 'foo'), 'foo');
+test.after.always<[string]>((t, string) => t.is(string, 'foo'), 'foo');
+test.after.skip<[string]>('after hook with args', (t, string) => t.is(string, 'foo'), 'foo');
+test.after.skip<[string]>((t, string) => t.is(string, 'foo'), 'foo');
+test.after<[string]>('after hook with args', (t, string) => t.is(string, 'foo'), 'foo');
+test.after<[string]>((t, string) => t.is(string, 'foo'), 'foo');
+test.afterEach.always.skip<[string]>('after.always hook with args', (t, string) => t.is(string, 'foo'), 'foo');
+test.afterEach.always.skip<[string]>((t, string) => t.is(string, 'foo'), 'foo');
+test.afterEach.always<[string]>('after.always hook with args', (t, string) => t.is(string, 'foo'), 'foo');
+test.afterEach.always<[string]>((t, string) => t.is(string, 'foo'), 'foo');
+test.afterEach.skip<[string]>('after hook with args', (t, string) => t.is(string, 'foo'), 'foo');
+test.afterEach.skip<[string]>((t, string) => t.is(string, 'foo'), 'foo');
+test.afterEach<[string]>('after hook with args', (t, string) => t.is(string, 'foo'), 'foo');
+test.afterEach<[string]>((t, string) => t.is(string, 'foo'), 'foo');
+test.before.skip<[string]>('before hook with args', (t, string) => t.is(string, 'foo'), 'foo');
+test.before.skip<[string]>((t, string) => t.is(string, 'foo'), 'foo');
+test.before<[string]>('before hook with args', (t, string) => t.is(string, 'foo'), 'foo');
+test.before<[string]>((t, string) => t.is(string, 'foo'), 'foo');
+test.beforeEach.skip<[string]>('before hook with args', (t, string) => t.is(string, 'foo'), 'foo');
+test.beforeEach.skip<[string]>((t, string) => t.is(string, 'foo'), 'foo');
+test.beforeEach<[string]>('before hook with args', (t, string) => t.is(string, 'foo'), 'foo');
+test.beforeEach<[string]>((t, string) => t.is(string, 'foo'), 'foo');
+
+test.serial('title', t => t.pass());
+
+expectError(test.serial<[string]>('explicit argument type', t => t.pass(), 42));
+
+expectError(test.serial<[string]>('missing argument', (t: ExecutionContext) => t.pass()));
+
+test.serial<string[]>('optional arguments', t => t.pass());
+test.serial<string[]>('optional arguments, with values', t => t.pass(), 'foo', 'bar');
+
+expectError(test.serial('argument type inferred from implementation', (t, string) => t.is(string, 'foo'), 42));
+
+expectError(test.serial('argument type inferred in implementation', (t, string) => t.is(string, 'foo'), 42));
+
+{
+	const implementation: Implementation = t => t.pass();
+	expectError(test.serial('unexpected arguments', implementation, 'foo'));
+}
+
+{
+	const implementation: ImplementationWithArgs<[string]> = (t, string) => t.is(string, 'foo');
+	test.serial('unexpected arguments', implementation, 'foo');
+}
+
+test.serial.failing<[string]>('failing test with arguments', (t, string) => t.is(string, 'foo'), 'foo');
+test.serial.only<[string]>('only test with arguments', (t, string) => t.is(string, 'foo'), 'foo');
+test.serial.skip<[string]>('serial test with arguments', (t, string) => t.is(string, 'foo'), 'foo');
+
+test.serial.after.always.skip<[string]>('after.always hook with args', (t, string) => t.is(string, 'foo'), 'foo');
+test.serial.after.always.skip<[string]>((t, string) => t.is(string, 'foo'), 'foo');
+test.serial.after.always<[string]>('after.always hook with args', (t, string) => t.is(string, 'foo'), 'foo');
+test.serial.after.always<[string]>((t, string) => t.is(string, 'foo'), 'foo');
+test.serial.after.skip<[string]>('after hook with args', (t, string) => t.is(string, 'foo'), 'foo');
+test.serial.after.skip<[string]>((t, string) => t.is(string, 'foo'), 'foo');
+test.serial.after<[string]>('after hook with args', (t, string) => t.is(string, 'foo'), 'foo');
+test.serial.after<[string]>((t, string) => t.is(string, 'foo'), 'foo');
+test.serial.afterEach.always.skip<[string]>('after.always hook with args', (t, string) => t.is(string, 'foo'), 'foo');
+test.serial.afterEach.always.skip<[string]>((t, string) => t.is(string, 'foo'), 'foo');
+test.serial.afterEach.always<[string]>('after.always hook with args', (t, string) => t.is(string, 'foo'), 'foo');
+test.serial.afterEach.always<[string]>((t, string) => t.is(string, 'foo'), 'foo');
+test.serial.afterEach.skip<[string]>('after hook with args', (t, string) => t.is(string, 'foo'), 'foo');
+test.serial.afterEach.skip<[string]>((t, string) => t.is(string, 'foo'), 'foo');
+test.serial.afterEach<[string]>('after hook with args', (t, string) => t.is(string, 'foo'), 'foo');
+test.serial.afterEach<[string]>((t, string) => t.is(string, 'foo'), 'foo');
+test.serial.before.skip<[string]>('before hook with args', (t, string) => t.is(string, 'foo'), 'foo');
+test.serial.before.skip<[string]>((t, string) => t.is(string, 'foo'), 'foo');
+test.serial.before<[string]>('before hook with args', (t, string) => t.is(string, 'foo'), 'foo');
+test.serial.before<[string]>((t, string) => t.is(string, 'foo'), 'foo');
+test.serial.beforeEach.skip<[string]>('before hook with args', (t, string) => t.is(string, 'foo'), 'foo');
+test.serial.beforeEach.skip<[string]>((t, string) => t.is(string, 'foo'), 'foo');
+test.serial.beforeEach<[string]>('before hook with args', (t, string) => t.is(string, 'foo'), 'foo');
+test.serial.beforeEach<[string]>((t, string) => t.is(string, 'foo'), 'foo');