@prismicio/simulator 0.2.0 → 0.2.1

package/src/SimulatorClient.ts

@@ -1,32 +1,20 @@
-import type {
-	APITransactions,
-	ClientTransactions} from "./types";
-import {
-	APIRequestType,
-	ClientRequestType
-} from "./types"
-
-import type { SimulatorAPIOptions } from "./SimulatorAPI"
 import type {
 	AllChannelEmitterOptions,
 	TransactionMethod,
 	TransactionsHandlers,
-	TransactionsMethods} from "./channel";
-import {
-	ChannelEmitter
+	TransactionsMethods,
 } from "./channel"
+import { ChannelEmitter } from "./channel"
+import type { SimulatorAPIOptions } from "./SimulatorAPI"
+import type { APITransactions, ClientTransactions } from "./types"
+import { APIRequestType, ClientRequestType } from "./types"
 
-export const simulatorClientDefaultOptions: Partial<AllChannelEmitterOptions> =
-	{
-		requestIDPrefix: "client-",
-	}
+export const simulatorClientDefaultOptions: Partial<AllChannelEmitterOptions> = {
+	requestIDPrefix: "client-",
+}
 
 export class SimulatorClient
-	extends ChannelEmitter<
-		APITransactions,
-		Partial<AllChannelEmitterOptions>,
-		SimulatorAPIOptions
-	>
+	extends ChannelEmitter<APITransactions, Partial<AllChannelEmitterOptions>, SimulatorAPIOptions>
 	implements TransactionsMethods<ClientTransactions>
 {
 	constructor(
@@ -36,8 +24,7 @@ export class SimulatorClient
 	) {
 		// True if `options.debug` is true or `debug=true` is among query parameters
 		const debug =
-			options?.debug ||
-			/[?&]debug=true/i.test(decodeURIComponent(window.location.search))
+			options?.debug || /[?&]debug=true/i.test(decodeURIComponent(window.location.search))
 
 		super(
 			target,
@@ -66,11 +53,10 @@ export class SimulatorClient
 		}
 	}
 
-	[ClientRequestType.Ping]: TransactionMethod<
-		ClientTransactions[ClientRequestType.Ping]
-	> = async () => {
-		return await this.postFormattedRequest(ClientRequestType.Ping)
-	};
+	[ClientRequestType.Ping]: TransactionMethod<ClientTransactions[ClientRequestType.Ping]> =
+		async () => {
+			return await this.postFormattedRequest(ClientRequestType.Ping)
+		};
 
 	[ClientRequestType.SetSliceZone]: TransactionMethod<
 		ClientTransactions[ClientRequestType.SetSliceZone]
@@ -81,9 +67,6 @@ export class SimulatorClient
 	[ClientRequestType.ScrollToSlice]: TransactionMethod<
 		ClientTransactions[ClientRequestType.ScrollToSlice]
 	> = async (data) => {
-		return await this.postFormattedRequest(
-			ClientRequestType.ScrollToSlice,
-			data,
-		)
+		return await this.postFormattedRequest(ClientRequestType.ScrollToSlice, data)
 	}
 }

package/src/channel/ChannelEmitter.ts

@@ -1,3 +1,13 @@
+import type { ChannelNetworkOptions, PostRequestOptions } from "./ChannelNetwork"
+import { ChannelNetwork } from "./ChannelNetwork"
+import type { AllChannelReceiverOptions } from "./ChannelReceiver"
+import { ChannelNotSetError, ConnectionTimeoutError, NotReadyError } from "./errors"
+import {
+	createErrorResponseMessage,
+	createSuccessResponseMessage,
+	isRequestMessage,
+	validateMessage,
+} from "./messages"
 import type {
 	ExtractSuccessResponseMessage,
 	InternalEmitterTransactions,
@@ -5,56 +15,27 @@ import type {
 	TransactionsHandlers,
 	UnknownRequestMessage,
 	UnknownResponseMessage,
-	UnknownTransaction} from "./types";
-import {
-	InternalEmitterRequestType,
-	InternalReceiverRequestType
+	UnknownTransaction,
 } from "./types"
-
-import {
-	ChannelNotSetError,
-	ConnectionTimeoutError,
-	NotReadyError,
-} from "./errors"
-
-import type {
-	ChannelNetworkOptions,
-	PostRequestOptions} from "./ChannelNetwork";
-import {
-	ChannelNetwork
-} from "./ChannelNetwork"
-import type { AllChannelReceiverOptions } from "./ChannelReceiver"
-import {
-	createErrorResponseMessage,
-	createSuccessResponseMessage,
-	isRequestMessage,
-	validateMessage,
-} from "./messages"
+import { InternalEmitterRequestType, InternalReceiverRequestType } from "./types"
 
 export type ChannelEmitterOptions = {
 	connectTimeout: number
 }
 
-export const channelEmitterDefaultOptions: ChannelEmitterOptions &
-	Partial<ChannelNetworkOptions> = {
-	connectTimeout: 20000,
-	requestIDPrefix: "emitter-",
-}
+export const channelEmitterDefaultOptions: ChannelEmitterOptions & Partial<ChannelNetworkOptions> =
+	{
+		connectTimeout: 20000,
+		requestIDPrefix: "emitter-",
+	}
 
-export type AllChannelEmitterOptions = ChannelEmitterOptions &
-	ChannelNetworkOptions
+export type AllChannelEmitterOptions = ChannelEmitterOptions & ChannelNetworkOptions
 
 export abstract class ChannelEmitter<
-	TReceiverTransactions extends Record<string, UnknownTransaction> = Record<
-		string,
-		never
-	>,
+	TReceiverTransactions extends Record<string, UnknownTransaction> = Record<string, never>,
 	TOptions extends Record<string, unknown> = Record<string, unknown>,
 	TReceiverOptions extends Record<string, unknown> = Record<string, unknown>,
-> extends ChannelNetwork<
-	TReceiverTransactions,
-	ChannelEmitterOptions & TOptions
-> {
+> extends ChannelNetwork<TReceiverTransactions, ChannelEmitterOptions & TOptions> {
 	private _target: HTMLIFrameElement
 	private _channel: MessageChannel | null = null
 	protected get channel(): MessageChannel {
@@ -99,9 +80,7 @@ export abstract class ChannelEmitter<
 	 * Initiates connection to receiver
 	 *
 	 * @param receiverOptions - Options to configure the receiver with
-	 * @param newOrigin - Indicates to the emitter that we're connecting to a new
-	 *   origin
-	 *
+	 * @param newOrigin - Indicates to the emitter that we're connecting to a new origin
 	 * @returns Success connect message
 	 */
 	connect(
@@ -157,9 +136,7 @@ export abstract class ChannelEmitter<
 						>(request, (request) => {
 							// Target content window is checked in previous statement
 							// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-							this._target.contentWindow!.postMessage(request, "*", [
-								this.channel.port2,
-							])
+							this._target.contentWindow!.postMessage(request, "*", [this.channel.port2])
 						})
 
 						// Finish by aknowledging ready
@@ -232,10 +209,7 @@ export abstract class ChannelEmitter<
 						this.postResponse(
 							createErrorResponseMessage(message.requestID, undefined),
 							(response) => {
-								;(event.source as WindowProxy).postMessage(
-									response,
-									event.origin,
-								)
+								;(event.source as WindowProxy).postMessage(response, event.origin)
 							},
 						)
 						break
@@ -261,15 +235,9 @@ export abstract class ChannelEmitter<
 		options: PostRequestOptions = {},
 	): Promise<ExtractSuccessResponseMessage<TResponse>> {
 		if (!this._connected) {
-			throw new NotReadyError(
-				"Emitter is not connected, use `ChannelEmitter.connect()` first",
-			)
+			throw new NotReadyError("Emitter is not connected, use `ChannelEmitter.connect()` first")
 		}
 
-		return this.postRequest(
-			this.createRequestMessage(type, data),
-			undefined,
-			options,
-		)
+		return this.postRequest(this.createRequestMessage(type, data), undefined, options)
 	}
 }

package/src/channel/ChannelNetwork.ts

@@ -1,20 +1,9 @@
-import type {
-	ExtractErrorResponseMessage,
-	ExtractSuccessResponseMessage,
-	RequestMessage,
-	TransactionsHandlers,
-	UnknownRequestMessage,
-	UnknownResponseMessage,
-	UnknownTransaction,
-} from "./types"
-
 import {
 	PortNotSetError,
 	RequestTimeoutError,
 	ResponseError,
 	TooManyConcurrentRequestsError,
 } from "./errors"
-
 import {
 	createErrorResponseMessage,
 	createRequestMessage,
@@ -23,6 +12,15 @@ import {
 	isSuccessResponseMessage,
 	validateMessage,
 } from "./messages"
+import type {
+	ExtractErrorResponseMessage,
+	ExtractSuccessResponseMessage,
+	RequestMessage,
+	TransactionsHandlers,
+	UnknownRequestMessage,
+	UnknownResponseMessage,
+	UnknownTransaction,
+} from "./types"
 
 export type PostRequestOptions = {
 	timeout?: number
@@ -43,10 +41,7 @@ export const channelNetworkDefaultOptions: ChannelNetworkOptions = {
 }
 
 export abstract class ChannelNetwork<
-	TPartnerTransactions extends Record<string, UnknownTransaction> = Record<
-		string,
-		never
-	>,
+	TPartnerTransactions extends Record<string, UnknownTransaction> = Record<string, never>,
 	TOptions extends Record<string, unknown> = Record<string, unknown>,
 > {
 	public requestHandlers: TransactionsHandlers<TPartnerTransactions>
@@ -101,41 +96,27 @@ export abstract class ChannelNetwork<
 
 			if (isRequestMessage(message)) {
 				if (!this.requestHandlers[message.type]) {
-					this.postResponse(
-						createErrorResponseMessage(message.requestID, undefined, 501),
-					)
+					this.postResponse(createErrorResponseMessage(message.requestID, undefined, 501))
 				} else {
 					try {
 						// TODO: Figure out why type cannot be inferred on its own anymore
 						const response = await this.requestHandlers[message.type](message, {
-							success: createSuccessResponseMessage.bind(
-								this,
-								message.requestID,
-							) as Parameters<
+							success: createSuccessResponseMessage.bind(this, message.requestID) as Parameters<
 								(typeof this.requestHandlers)[string]
 							>[1]["success"],
-							error: createErrorResponseMessage.bind(
-								this,
-								message.requestID,
-							) as Parameters<
+							error: createErrorResponseMessage.bind(this, message.requestID) as Parameters<
 								(typeof this.requestHandlers)[string]
 							>[1]["error"],
 						})
 
 						this.postResponse(response)
 					} catch (error) {
-						this.postResponse(
-							createErrorResponseMessage(message.requestID, error, 500),
-						)
+						this.postResponse(createErrorResponseMessage(message.requestID, error, 500))
 					}
 				}
 			} else {
 				if (!this._pendingRequests.has(message.requestID)) {
-					console.error(
-						`Unknown request ID received in response: ${JSON.stringify(
-							message,
-						)}`,
-					)
+					console.error(`Unknown request ID received in response: ${JSON.stringify(message)}`)
 				} else {
 					// Pending requests are checked in previous statement
 					// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
@@ -170,37 +151,31 @@ export abstract class ChannelNetwork<
 			throw new TooManyConcurrentRequestsError(request)
 		}
 
-		return new Promise<ExtractSuccessResponseMessage<TResponse>>(
-			(resolve, reject) => {
-				const requestTimeout = setTimeout(() => {
-					if (this._pendingRequests.has(request.requestID)) {
-						this._pendingRequests.delete(request.requestID)
-					}
-					reject(new RequestTimeoutError(request))
-				}, options.timeout || this.options.defaultTimeout)
-
-				this._pendingRequests.set(
-					request.requestID,
-					(response: TResponse): void => {
-						clearTimeout(requestTimeout)
-
-						if (isSuccessResponseMessage(response)) {
-							resolve(response as ExtractSuccessResponseMessage<TResponse>)
-						} else {
-							reject(new ResponseError(response as ExtractErrorResponseMessage<TResponse>))
-						}
-					},
-				)
-
-				postMessage(request)
-			},
-		)
+		return new Promise<ExtractSuccessResponseMessage<TResponse>>((resolve, reject) => {
+			const requestTimeout = setTimeout(() => {
+				if (this._pendingRequests.has(request.requestID)) {
+					this._pendingRequests.delete(request.requestID)
+				}
+				reject(new RequestTimeoutError(request))
+			}, options.timeout || this.options.defaultTimeout)
+
+			this._pendingRequests.set(request.requestID, (response: TResponse): void => {
+				clearTimeout(requestTimeout)
+
+				if (isSuccessResponseMessage(response)) {
+					resolve(response as ExtractSuccessResponseMessage<TResponse>)
+				} else {
+					reject(new ResponseError(response as ExtractErrorResponseMessage<TResponse>))
+				}
+			})
+
+			postMessage(request)
+		})
 	}
 
 	protected postResponse<TResponse extends UnknownResponseMessage>(
 		response: TResponse,
-		postMessage = (response: TResponse): void =>
-			this.port.postMessage(response),
+		postMessage = (response: TResponse): void => this.port.postMessage(response),
 	): TResponse {
 		if (this.options.debug) {
 			// eslint-disable-next-line no-console

package/src/channel/ChannelReceiver.ts

@@ -1,3 +1,12 @@
+import type { ChannelNetworkOptions, PostRequestOptions } from "./ChannelNetwork"
+import { ChannelNetwork } from "./ChannelNetwork"
+import { NotReadyError } from "./errors"
+import {
+	createErrorResponseMessage,
+	createSuccessResponseMessage,
+	isRequestMessage,
+	validateMessage,
+} from "./messages"
 import type {
 	ExtractSuccessResponseMessage,
 	InternalEmitterTransactions,
@@ -7,26 +16,9 @@ import type {
 	TransactionsHandlers,
 	UnknownRequestMessage,
 	UnknownResponseMessage,
-	UnknownTransaction} from "./types";
-import {
-	InternalEmitterRequestType,
-	InternalReceiverRequestType
+	UnknownTransaction,
 } from "./types"
-
-import { NotReadyError } from "./errors"
-
-import type {
-	ChannelNetworkOptions,
-	PostRequestOptions} from "./ChannelNetwork";
-import {
-	ChannelNetwork
-} from "./ChannelNetwork"
-import {
-	createErrorResponseMessage,
-	createSuccessResponseMessage,
-	isRequestMessage,
-	validateMessage,
-} from "./messages"
+import { InternalEmitterRequestType, InternalReceiverRequestType } from "./types"
 
 export type ChannelReceiverOptions = {
 	readyTimeout: number
@@ -38,19 +30,12 @@ export const channelReceiverDefaultOptions: ChannelReceiverOptions &
 	requestIDPrefix: "receiver-",
 }
 
-export type AllChannelReceiverOptions = ChannelReceiverOptions &
-	ChannelNetworkOptions
+export type AllChannelReceiverOptions = ChannelReceiverOptions & ChannelNetworkOptions
 
 export abstract class ChannelReceiver<
-	TEmitterTransactions extends Record<string, UnknownTransaction> = Record<
-		string,
-		never
-	>,
+	TEmitterTransactions extends Record<string, UnknownTransaction> = Record<string, never>,
 	TOptions extends Record<string, unknown> = Record<string, unknown>,
-> extends ChannelNetwork<
-	TEmitterTransactions,
-	ChannelReceiverOptions & TOptions
-> {
+> extends ChannelNetwork<TEmitterTransactions, ChannelReceiverOptions & TOptions> {
 	private _ready = false
 
 	constructor(
@@ -72,10 +57,7 @@ export abstract class ChannelReceiver<
 
 		this._ready = false
 
-		const request = this.createRequestMessage(
-			InternalReceiverRequestType.Ready,
-			undefined,
-		)
+		const request = this.createRequestMessage(InternalReceiverRequestType.Ready, undefined)
 
 		const response = await this.postRequest<
 			RequestMessage<InternalReceiverRequestType.Ready>,
@@ -112,8 +94,7 @@ export abstract class ChannelReceiver<
 						this.port = event.ports[0]
 
 						// Update options
-						const { data } =
-							message as InternalEmitterTransactions["connect"]["request"]
+						const { data } = message as InternalEmitterTransactions["connect"]["request"]
 						this.options = {
 							...this.options,
 							...data,
@@ -123,10 +104,7 @@ export abstract class ChannelReceiver<
 							readyTimeout: this.options.readyTimeout,
 						}
 
-						const response = createSuccessResponseMessage(
-							message.requestID,
-							undefined,
-						)
+						const response = createSuccessResponseMessage(message.requestID, undefined)
 
 						this.postResponse(response)
 						break
@@ -135,10 +113,7 @@ export abstract class ChannelReceiver<
 						this.postResponse(
 							createErrorResponseMessage(message.requestID, undefined),
 							(response) => {
-								;(event.source as WindowProxy).postMessage(
-									response,
-									event.origin,
-								)
+								;(event.source as WindowProxy).postMessage(response, event.origin)
 							},
 						)
 						break
@@ -168,15 +143,9 @@ export abstract class ChannelReceiver<
 		options: PostRequestOptions = {},
 	): Promise<ExtractSuccessResponseMessage<TResponse>> {
 		if (!this._ready) {
-			throw new NotReadyError(
-				"Receiver is not ready, use `ChannelReceiver.ready()` first",
-			)
+			throw new NotReadyError("Receiver is not ready, use `ChannelReceiver.ready()` first")
 		}
 
-		return this.postRequest(
-			this.createRequestMessage(type, data),
-			undefined,
-			options,
-		)
+		return this.postRequest(this.createRequestMessage(type, data), undefined, options)
 	}
 }

package/src/channel/errors.ts

@@ -1,10 +1,7 @@
 import type { UnknownErrorResponseMessage } from "."
-
 import type { UnknownRequestMessage } from "./types"
 
-export class ResponseError<
-	TErrorResponse extends UnknownErrorResponseMessage,
-> extends Error {
+export class ResponseError<TErrorResponse extends UnknownErrorResponseMessage> extends Error {
 	public response: TErrorResponse
 
 	constructor(errorResponse: TErrorResponse) {
@@ -28,9 +25,7 @@ export class TooManyConcurrentRequestsError extends Error {
 		this.request = request
 	}
 }
-export class RequestTimeoutError<
-	TRequest extends UnknownRequestMessage,
-> extends Error {
+export class RequestTimeoutError<TRequest extends UnknownRequestMessage> extends Error {
 	public request: UnknownRequestMessage
 
 	constructor(request: TRequest) {

package/src/channel/index.ts

@@ -1,23 +1,11 @@
 export { ChannelNetwork, channelNetworkDefaultOptions } from "./ChannelNetwork"
-export type {
-	PostRequestOptions,
-	ChannelNetworkOptions,
-} from "./ChannelNetwork"
+export type { PostRequestOptions, ChannelNetworkOptions } from "./ChannelNetwork"
 
 export { ChannelEmitter, channelEmitterDefaultOptions } from "./ChannelEmitter"
-export type {
-	ChannelEmitterOptions,
-	AllChannelEmitterOptions,
-} from "./ChannelEmitter"
+export type { ChannelEmitterOptions, AllChannelEmitterOptions } from "./ChannelEmitter"
 
-export {
-	ChannelReceiver,
-	channelReceiverDefaultOptions,
-} from "./ChannelReceiver"
-export type {
-	ChannelReceiverOptions,
-	AllChannelReceiverOptions,
-} from "./ChannelReceiver"
+export { ChannelReceiver, channelReceiverDefaultOptions } from "./ChannelReceiver"
+export type { ChannelReceiverOptions, AllChannelReceiverOptions } from "./ChannelReceiver"
 
 export {
 	createRequestMessage,
@@ -40,10 +28,7 @@ export {
 	ChannelNotSetError,
 } from "./errors"
 
-export {
-	InternalEmitterRequestType,
-	InternalReceiverRequestType,
-} from "./types"
+export { InternalEmitterRequestType, InternalReceiverRequestType } from "./types"
 export type {
 	// Messages
 	RequestMessage,

package/src/channel/messages.ts

@@ -21,10 +21,7 @@ const statuses = {
 
 let requestID = 0
 
-export const createRequestMessage = <
-	TType extends string = string,
-	TData = undefined,
->(
+export const createRequestMessage = <TType extends string = string, TData = undefined>(
 	type: TType,
 	data: TData,
 	prefix = "",
@@ -85,9 +82,7 @@ export const validateMessage = (message: unknown): UnknownMessage => {
 		)
 	) {
 		throw new TypeError(`Invalid message received: ${JSON.stringify(message)}`)
-	} else if (
-		typeof (message as Record<string, unknown>).requestID !== "string"
-	) {
+	} else if (typeof (message as Record<string, unknown>).requestID !== "string") {
 		throw new TypeError(
 			`Invalid message received, expected \`message.requestID\` to be of type \`string\`, got \`${typeof (
 				message as Record<string, unknown>
@@ -98,15 +93,11 @@ export const validateMessage = (message: unknown): UnknownMessage => {
 	return message as UnknownMessage
 }
 
-export const isRequestMessage = (
-	message: UnknownMessage,
-): message is UnknownRequestMessage => {
+export const isRequestMessage = (message: UnknownMessage): message is UnknownRequestMessage => {
 	return "type" in message
 }
 
-export const isResponseMessage = (
-	message: UnknownMessage,
-): message is UnknownResponseMessage => {
+export const isResponseMessage = (message: UnknownMessage): message is UnknownResponseMessage => {
 	return !("type" in message)
 }
 

package/src/channel/types.ts

@@ -27,13 +27,15 @@ export type ResponseMessage<TData = void, TError = unknown> =
 	| SuccessResponseMessage<TData>
 	| ErrorResponseMessage<TError>
 
-export type ExtractSuccessResponseMessage<
-	TResponse extends UnknownResponseMessage,
-> = Extract<TResponse, { error?: never }>
+export type ExtractSuccessResponseMessage<TResponse extends UnknownResponseMessage> = Extract<
+	TResponse,
+	{ error?: never }
+>
 
-export type ExtractErrorResponseMessage<
-	TResponse extends UnknownResponseMessage,
-> = Extract<TResponse, { data?: never }>
+export type ExtractErrorResponseMessage<TResponse extends UnknownResponseMessage> = Extract<
+	TResponse,
+	{ data?: never }
+>
 
 // Unknown messages
 export type UnknownRequestMessage = RequestMessage<string, unknown>
@@ -42,9 +44,7 @@ export type UnknownSuccessResponseMessage = SuccessResponseMessage<unknown>
 
 export type UnknownErrorResponseMessage = ErrorResponseMessage<unknown>
 
-export type UnknownResponseMessage =
-	| UnknownSuccessResponseMessage
-	| UnknownErrorResponseMessage
+export type UnknownResponseMessage = UnknownSuccessResponseMessage | UnknownErrorResponseMessage
 
 export type UnknownMessage = UnknownRequestMessage | UnknownResponseMessage
 
@@ -58,19 +58,13 @@ export type Transaction<
 }
 
 export type TransactionMethod<
-	TTransaction extends Transaction<
-		UnknownRequestMessage,
-		UnknownResponseMessage
-	>,
+	TTransaction extends Transaction<UnknownRequestMessage, UnknownResponseMessage>,
 > = (
 	data: TTransaction["request"]["data"],
 ) => Promise<ExtractSuccessResponseMessage<TTransaction["response"]>>
 
 export type TransactionHandler<
-	TTransaction extends Transaction<
-		UnknownRequestMessage,
-		UnknownResponseMessage
-	>,
+	TTransaction extends Transaction<UnknownRequestMessage, UnknownResponseMessage>,
 > = (
 	request: TTransaction["request"],
 	response: {
@@ -85,23 +79,16 @@ export type TransactionHandler<
 	},
 ) => Promise<TTransaction["response"]> | TTransaction["response"]
 
-export type TransactionsMethods<
-	TTransactions extends Record<string, UnknownTransaction>,
-> = {
+export type TransactionsMethods<TTransactions extends Record<string, UnknownTransaction>> = {
 	[Key in keyof TTransactions]: TransactionMethod<TTransactions[Key]>
 }
 
-export type TransactionsHandlers<
-	TTransactions extends Record<string, UnknownTransaction>,
-> = {
+export type TransactionsHandlers<TTransactions extends Record<string, UnknownTransaction>> = {
 	[Key in keyof TTransactions]: TransactionHandler<TTransactions[Key]>
 }
 
 // Unknown transactions
-export type UnknownTransaction = Transaction<
-	UnknownRequestMessage,
-	UnknownResponseMessage
->
+export type UnknownTransaction = Transaction<UnknownRequestMessage, UnknownResponseMessage>
 
 export type UnknownTransactionMethod = TransactionMethod<UnknownTransaction>
 
@@ -118,10 +105,7 @@ export type InternalEmitterTransactions<
 	[InternalEmitterRequestType.Connect]: Transaction<
 		RequestMessage<
 			InternalEmitterRequestType.Connect,
-			| Partial<
-					Omit<TReceiverOptions, "debug" | "requestIDPrefix" | "readyTimeout">
-			  >
-			| undefined
+			Partial<Omit<TReceiverOptions, "debug" | "requestIDPrefix" | "readyTimeout">> | undefined
 		>
 	>
 }