chore: create type tests

index.d.ts

@@ -12,5 +12,36 @@ export type Part<Body, Fallback> =
 	| { json: false; headers: Record<string, string>; body: Fallback }
 	| { json: true; headers: Record<string, string>; body: Body };
 
-export * from 'meros/browser';
-export * from 'meros/node';
+// TODO: is there a way to compose the `meros/{node,browser}` here without having to duplicate the entire signature? And maintain jsdocs
+
+// -- NODE
+
+import type { IncomingMessage } from 'node:http';
+
+export function meros<T = object>(
+	response: IncomingMessage,
+	options: { multiple: true },
+): Promise<IncomingMessage | AsyncGenerator<ReadonlyArray<Part<T, Buffer>>>>;
+export function meros<T = object>(
+	response: IncomingMessage,
+	options?: { multiple: false },
+): Promise<IncomingMessage | AsyncGenerator<Part<T, Buffer>>>;
+export function meros<T = object>(
+	response: IncomingMessage,
+	options?: Options,
+): Promise<IncomingMessage | AsyncGenerator<Part<T, Buffer>>>;
+
+// -- BROWSER
+
+export function meros<T = object>(
+	response: Response,
+	options: { multiple: true },
+): Promise<Response | AsyncGenerator<ReadonlyArray<Part<T, string>>>>;
+export function meros<T = object>(
+	response: Response,
+	options?: { multiple: false },
+): Promise<Response | AsyncGenerator<Part<T, string>>>;
+export function meros<T = object>(
+	response: Response,
+	options?: Options,
+): Promise<Response | AsyncGenerator<Part<T, string>>>;

src/browser.types.ts

@@ -0,0 +1,52 @@
+import { type Part } from 'meros';
+import { meros } from 'meros/browser';
+
+declare function assert<T>(thing: T): void;
+
+declare const response: Response;
+
+type Result = { name: string };
+type ThePart<T> = Part<T, string>;
+type Unwrapped<T> = Promise<Response | AsyncGenerator<ThePart<T>>>;
+
+assert<Unwrapped<Result>>(meros<Result>(response));
+
+{
+	const result = await meros<Result>(response);
+	if (!(result instanceof Response)) {
+		for await (let item of result) {
+			assert<ThePart<Result>>(item);
+
+			if (item.json) assert<Result>(item.body);
+			else assert<string>(item.body);
+
+			// @ts-expect-error
+			assert<{ foo: string }>(item.body);
+
+			assert<boolean>(item.json);
+			assert<Record<string, string>>(item.headers);
+		}
+	}
+}
+
+{
+	const result = await meros<Result>(response, { multiple: true });
+	if (!(result instanceof Response)) {
+		for await (let parts of result) {
+			assert<readonly ThePart<Result>[]>(parts);
+
+			for (let item of parts) {
+				assert<ThePart<Result>>(item);
+
+				if (item.json) assert<Result>(item.body);
+				else assert<string>(item.body);
+
+				// @ts-expect-error
+				assert<{ foo: string }>(item.body);
+
+				assert<boolean>(item.json);
+				assert<Record<string, string>>(item.headers);
+			}
+		}
+	}
+}

src/index.types.ts

@@ -0,0 +1,53 @@
+import { IncomingMessage } from 'http';
+import type { Part } from 'meros';
+import { meros } from 'meros';
+
+declare function assert<T>(thing: T): void;
+
+type Wrapped<T, B, F> = Promise<B | AsyncGenerator<Part<T, F>>>;
+
+type Result = { name: string };
+
+declare const responseNode: IncomingMessage;
+assert<Wrapped<Result, IncomingMessage, Buffer>>(meros<Result>(responseNode));
+
+{
+	type P = Part<Result, Buffer>;
+	const result = await meros<Result>(responseNode);
+	if (!(result instanceof IncomingMessage)) {
+		for await (let item of result) {
+			assert<P>(item);
+
+			if (item.json) assert<Result>(item.body);
+			else assert<Buffer>(item.body);
+
+			// @ts-expect-error
+			assert<{ foo: string }>(item.body);
+
+			assert<boolean>(item.json);
+			assert<Record<string, string>>(item.headers);
+		}
+	}
+}
+
+declare const responseBrowser: Response;
+assert<Wrapped<Result, Response, string>>(meros<Result>(responseBrowser));
+
+{
+	type P = Part<Result, string>;
+	const result = await meros<Result>(responseBrowser);
+	if (!(result instanceof Response)) {
+		for await (let item of result) {
+			assert<P>(item);
+
+			if (item.json) assert<Result>(item.body);
+			else assert<string>(item.body);
+
+			// @ts-expect-error
+			assert<{ foo: string }>(item.body);
+
+			assert<boolean>(item.json);
+			assert<Record<string, string>>(item.headers);
+		}
+	}
+}

src/node.types.ts

@@ -0,0 +1,53 @@
+import { IncomingMessage } from 'http';
+import type { Part } from 'meros';
+import { meros } from 'meros/node';
+
+declare function assert<T>(thing: T): void;
+
+declare const response: IncomingMessage;
+
+type Result = { name: string };
+type ThePart<T> = Part<T, Buffer>;
+type Unwrapped<T> = Promise<IncomingMessage | AsyncGenerator<ThePart<T>>>;
+
+assert<Unwrapped<Result>>(meros<Result>(response));
+
+{
+	const result = await meros<Result>(response);
+	if (!(result instanceof IncomingMessage)) {
+		for await (let item of result) {
+			assert<ThePart<Result>>(item);
+
+			if (item.json) assert<Result>(item.body);
+			else assert<Buffer>(item.body);
+
+			// @ts-expect-error
+			assert<{ foo: string }>(item.body);
+
+			assert<boolean>(item.json);
+			assert<Record<string, string>>(item.headers);
+		}
+	}
+}
+
+{
+	const result = await meros<Result>(response, { multiple: true });
+	if (!(result instanceof IncomingMessage)) {
+		for await (let parts of result) {
+			assert<readonly ThePart<Result>[]>(parts);
+
+			for (let item of parts) {
+				assert<ThePart<Result>>(item);
+
+				if (item.json) assert<Result>(item.body);
+				else assert<Buffer>(item.body);
+
+				// @ts-expect-error
+				assert<{ foo: string }>(item.body);
+
+				assert<boolean>(item.json);
+				assert<Record<string, string>>(item.headers);
+			}
+		}
+	}
+}