@prismicio/simulator 0.1.4 → 0.2.0-pr.22.b846d30

package/src/channel/ChannelNetwork.ts

@@ -1,20 +1,9 @@
-import {
-	ExtractErrorResponseMessage,
-	ExtractSuccessResponseMessage,
-	RequestMessage,
-	TransactionsHandlers,
-	UnknownRequestMessage,
-	UnknownResponseMessage,
-	UnknownTransaction,
-} from "./types";
-
 import {
 	PortNotSetError,
 	RequestTimeoutError,
 	ResponseError,
 	TooManyConcurrentRequestsError,
-} from "./errors";
-
+} from "./errors"
 import {
 	createErrorResponseMessage,
 	createRequestMessage,
@@ -22,133 +11,125 @@ import {
 	isRequestMessage,
 	isSuccessResponseMessage,
 	validateMessage,
-} from "./messages";
+} from "./messages"
+import type {
+	ExtractErrorResponseMessage,
+	ExtractSuccessResponseMessage,
+	RequestMessage,
+	TransactionsHandlers,
+	UnknownRequestMessage,
+	UnknownResponseMessage,
+	UnknownTransaction,
+} from "./types"
 
 export type PostRequestOptions = {
-	timeout?: number;
-};
+	timeout?: number
+}
 
 export type ChannelNetworkOptions = {
-	debug: boolean;
-	maximumRequestConcurrency: number;
-	defaultTimeout: number;
-	requestIDPrefix: string;
-};
+	debug: boolean
+	maximumRequestConcurrency: number
+	defaultTimeout: number
+	requestIDPrefix: string
+}
 
 export const channelNetworkDefaultOptions: ChannelNetworkOptions = {
 	debug: false,
 	maximumRequestConcurrency: 20,
 	defaultTimeout: 5000,
 	requestIDPrefix: "channel-",
-};
+}
 
 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>;
-	public options: ChannelNetworkOptions & TOptions;
+	public requestHandlers: TransactionsHandlers<TPartnerTransactions>
+	public options: ChannelNetworkOptions & TOptions
 
-	private _port: MessagePort | null = null;
+	private _port: MessagePort | null = null
 	protected get port(): MessagePort {
 		if (!this._port) {
-			throw new PortNotSetError();
+			throw new PortNotSetError()
 		}
 
-		return this._port;
+		return this._port
 	}
 	protected set port(port: MessagePort | null) {
 		// Destroy old port
 		if (this._port) {
-			this._port.onmessage = null;
+			this._port.onmessage = null
 		}
 
-		this._port = port;
+		this._port = port
 		if (this._port) {
-			this._port.onmessage = this.onMessage.bind(this);
+			this._port.onmessage = this.onMessage.bind(this)
 		}
 	}
 
 	// eslint-disable-next-line @typescript-eslint/no-explicit-any
-	private _pendingRequests: Map<string, (response: any) => void> = new Map();
+	private _pendingRequests: Map<string, (response: any) => void> = new Map()
 
 	constructor(
 		requestHandlers: TransactionsHandlers<TPartnerTransactions>,
 		options: Partial<ChannelNetworkOptions> & TOptions,
 	) {
-		this.requestHandlers = requestHandlers;
-		this.options = { ...channelNetworkDefaultOptions, ...options };
+		this.requestHandlers = requestHandlers
+		this.options = { ...channelNetworkDefaultOptions, ...options }
 	}
 
 	public createRequestMessage<TType extends string = string, TData = undefined>(
 		type: TType,
 		data: TData,
 	): RequestMessage<TType, TData> {
-		return createRequestMessage(type, data, this.options.requestIDPrefix);
+		return createRequestMessage(type, data, this.options.requestIDPrefix)
 	}
 
 	protected async onMessage(event: MessageEvent<unknown>): Promise<void> {
 		if (this.options.debug) {
 			// eslint-disable-next-line no-console
-			console.debug(event.data);
+			console.debug(event.data)
 		}
 
 		try {
-			const message = validateMessage(event.data);
+			const message = validateMessage(event.data)
 
 			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);
+						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
-					this._pendingRequests.get(message.requestID)!(message);
-					this._pendingRequests.delete(message.requestID);
+					this._pendingRequests.get(message.requestID)!(message)
+					this._pendingRequests.delete(message.requestID)
 				}
 			}
 		} catch (error) {
 			if (error instanceof TypeError) {
-				console.warn(error.message);
+				console.warn(error.message)
 			} else {
 				// Should not be possible, but who knows :shrug:
-				throw error;
+				throw error
 			}
 		}
 	}
@@ -163,54 +144,46 @@ export abstract class ChannelNetwork<
 	): Promise<ExtractSuccessResponseMessage<TResponse>> {
 		if (this.options.debug) {
 			// eslint-disable-next-line no-console
-			console.debug(request);
+			console.debug(request)
 		}
 
 		if (this._pendingRequests.size >= this.options.maximumRequestConcurrency) {
-			throw new TooManyConcurrentRequestsError(request);
+			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);
-
-						isSuccessResponseMessage(response)
-							? resolve(response as ExtractSuccessResponseMessage<TResponse>)
-							: 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
-			console.debug(response);
+			console.debug(response)
 		}
 
-		postMessage(response);
+		postMessage(response)
 
-		return response;
+		return response
 	}
 }

package/src/channel/ChannelReceiver.ts

@@ -1,8 +1,15 @@
+import type { ChannelNetworkOptions, PostRequestOptions } from "./ChannelNetwork"
+import { ChannelNetwork } from "./ChannelNetwork"
+import { NotReadyError } from "./errors"
 import {
+	createErrorResponseMessage,
+	createSuccessResponseMessage,
+	isRequestMessage,
+	validateMessage,
+} from "./messages"
+import type {
 	ExtractSuccessResponseMessage,
-	InternalEmitterRequestType,
 	InternalEmitterTransactions,
-	InternalReceiverRequestType,
 	RequestMessage,
 	ResponseMessage,
 	SuccessResponseMessage,
@@ -10,72 +17,47 @@ import {
 	UnknownRequestMessage,
 	UnknownResponseMessage,
 	UnknownTransaction,
-} from "./types";
-
-import { NotReadyError } from "./errors";
-
-import {
-	ChannelNetwork,
-	ChannelNetworkOptions,
-	PostRequestOptions,
-} from "./ChannelNetwork";
-import {
-	createErrorResponseMessage,
-	createSuccessResponseMessage,
-	isRequestMessage,
-	validateMessage,
-} from "./messages";
+} from "./types"
+import { InternalEmitterRequestType, InternalReceiverRequestType } from "./types"
 
 export type ChannelReceiverOptions = {
-	readyTimeout: number;
-};
+	readyTimeout: number
+}
 
 export const channelReceiverDefaultOptions: ChannelReceiverOptions &
 	Partial<ChannelNetworkOptions> = {
 	readyTimeout: 20000,
 	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
-> {
-	private _ready = false;
+> extends ChannelNetwork<TEmitterTransactions, ChannelReceiverOptions & TOptions> {
+	private _ready = false
 
 	constructor(
 		requestHandlers: TransactionsHandlers<TEmitterTransactions>,
 		options: Partial<AllChannelReceiverOptions> & TOptions,
 	) {
-		super(requestHandlers, { ...channelReceiverDefaultOptions, ...options });
+		super(requestHandlers, { ...channelReceiverDefaultOptions, ...options })
 
 		window.addEventListener("message", (event) => {
-			this._onPublicMessage(event);
-		});
+			this._onPublicMessage(event)
+		})
 	}
 
-	/**
-	 * Tells the emitter that receiver is ready
-	 */
+	/** Tells the emitter that receiver is ready */
 	public async ready(): Promise<SuccessResponseMessage> {
 		if (window.parent === window) {
-			throw new Error("Receiver is currently not embedded as an iframe");
+			throw new Error("Receiver is currently not embedded as an iframe")
 		}
 
-		this._ready = false;
+		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>,
@@ -83,39 +65,36 @@ export abstract class ChannelReceiver<
 		>(
 			request,
 			(request) => {
-				window.parent.postMessage(request, "*");
+				window.parent.postMessage(request, "*")
 			},
 			{
 				timeout: this.options.readyTimeout,
 			},
-		);
+		)
 
-		this._ready = true;
+		this._ready = true
 
-		return response;
+		return response
 	}
 
-	/**
-	 * Handles public messages
-	 */
+	/** Handles public messages */
 	private _onPublicMessage(event: MessageEvent<unknown>): void {
 		try {
-			const message = validateMessage(event.data);
+			const message = validateMessage(event.data)
 
 			if (isRequestMessage(message)) {
 				if (this.options.debug) {
 					// eslint-disable-next-line no-console
-					console.debug(event.data);
+					console.debug(event.data)
 				}
 
 				switch (message.type) {
 					case InternalEmitterRequestType.Connect:
 						// Set port
-						this.port = event.ports[0];
+						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,32 +102,26 @@ export abstract class ChannelReceiver<
 							debug: this.options.debug,
 							requestIDPrefix: this.options.requestIDPrefix,
 							readyTimeout: this.options.readyTimeout,
-						};
+						}
 
-						const response = createSuccessResponseMessage(
-							message.requestID,
-							undefined,
-						);
+						const response = createSuccessResponseMessage(message.requestID, undefined)
 
-						this.postResponse(response);
-						break;
+						this.postResponse(response)
+						break
 
 					default:
 						this.postResponse(
 							createErrorResponseMessage(message.requestID, undefined),
 							(response) => {
-								(event.source as WindowProxy).postMessage(
-									response,
-									event.origin,
-								);
+								;(event.source as WindowProxy).postMessage(response, event.origin)
 							},
-						);
-						break;
+						)
+						break
 				}
 			} else {
 				// Forward response messages to default message handler if necessary
 				if (!this._ready) {
-					this.onMessage(event);
+					this.onMessage(event)
 				}
 			}
 		} catch (error) {
@@ -156,7 +129,7 @@ export abstract class ChannelReceiver<
 				// Ignore unknown messages
 			} else {
 				// Should not be possible, but who knows :shrug:
-				throw error;
+				throw error
 			}
 		}
 	}
@@ -170,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,53 +1,48 @@
-import { UnknownErrorResponseMessage } from ".";
+import type { UnknownErrorResponseMessage } from "."
+import type { UnknownRequestMessage } from "./types"
 
-import { UnknownRequestMessage } from "./types";
-
-export class ResponseError<
-	TErrorResponse extends UnknownErrorResponseMessage,
-> extends Error {
-	public response: TErrorResponse;
+export class ResponseError<TErrorResponse extends UnknownErrorResponseMessage> extends Error {
+	public response: TErrorResponse
 
 	constructor(errorResponse: TErrorResponse) {
-		super(errorResponse.msg);
+		super(errorResponse.msg)
 
-		this.response = errorResponse;
+		this.response = errorResponse
 	}
 }
 
 export class ConnectionTimeoutError extends Error {
 	constructor() {
-		super("Connection timed out");
+		super("Connection timed out")
 	}
 }
 export class TooManyConcurrentRequestsError extends Error {
-	public request: UnknownRequestMessage;
+	public request: UnknownRequestMessage
 
 	constructor(request: UnknownRequestMessage) {
-		super(`Too many concurrent requests`);
+		super(`Too many concurrent requests`)
 
-		this.request = request;
+		this.request = request
 	}
 }
-export class RequestTimeoutError<
-	TRequest extends UnknownRequestMessage,
-> extends Error {
-	public request: UnknownRequestMessage;
+export class RequestTimeoutError<TRequest extends UnknownRequestMessage> extends Error {
+	public request: UnknownRequestMessage
 
 	constructor(request: TRequest) {
-		super(`Request \`${request.requestID}\` timed out`);
+		super(`Request \`${request.requestID}\` timed out`)
 
-		this.request = request;
+		this.request = request
 	}
 }
 
 export class NotReadyError extends Error {}
 export class PortNotSetError extends Error {
 	constructor() {
-		super("Port is not set");
+		super("Port is not set")
 	}
 }
 export class ChannelNotSetError extends Error {
 	constructor() {
-		super("Channel is not set");
+		super("Channel is not set")
 	}
 }

package/src/channel/index.ts

@@ -1,23 +1,11 @@
-export { ChannelNetwork, channelNetworkDefaultOptions } from "./ChannelNetwork";
-export type {
-	PostRequestOptions,
-	ChannelNetworkOptions,
-} from "./ChannelNetwork";
+export { ChannelNetwork, channelNetworkDefaultOptions } from "./ChannelNetwork"
+export type { PostRequestOptions, ChannelNetworkOptions } from "./ChannelNetwork"
 
-export { ChannelEmitter, channelEmitterDefaultOptions } from "./ChannelEmitter";
-export type {
-	ChannelEmitterOptions,
-	AllChannelEmitterOptions,
-} from "./ChannelEmitter";
+export { ChannelEmitter, channelEmitterDefaultOptions } 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,
@@ -28,7 +16,7 @@ export {
 	isResponseMessage,
 	isSuccessResponseMessage,
 	isErrorResponseMessage,
-} from "./messages";
+} from "./messages"
 
 export {
 	ResponseError,
@@ -38,12 +26,9 @@ export {
 	NotReadyError,
 	PortNotSetError,
 	ChannelNotSetError,
-} from "./errors";
+} from "./errors"
 
-export {
-	InternalEmitterRequestType,
-	InternalReceiverRequestType,
-} from "./types";
+export { InternalEmitterRequestType, InternalReceiverRequestType } from "./types"
 export type {
 	// Messages
 	RequestMessage,
@@ -72,4 +57,4 @@ export type {
 	InternalEmitterTransactions,
 	// Receiver
 	InternalReceiverTransactions,
-} from "./types";
+} from "./types"