@prismicio/simulator 0.1.4 → 0.2.0

package/src/channel/ChannelReceiver.ts

@@ -1,43 +1,45 @@
-import {
+import type {
 	ExtractSuccessResponseMessage,
-	InternalEmitterRequestType,
 	InternalEmitterTransactions,
-	InternalReceiverRequestType,
 	RequestMessage,
 	ResponseMessage,
 	SuccessResponseMessage,
 	TransactionsHandlers,
 	UnknownRequestMessage,
 	UnknownResponseMessage,
-	UnknownTransaction,
-} from "./types";
+	UnknownTransaction} from "./types";
+import {
+	InternalEmitterRequestType,
+	InternalReceiverRequestType
+} from "./types"
 
-import { NotReadyError } from "./errors";
+import { NotReadyError } from "./errors"
 
-import {
-	ChannelNetwork,
+import type {
 	ChannelNetworkOptions,
-	PostRequestOptions,
-} from "./ChannelNetwork";
+	PostRequestOptions} from "./ChannelNetwork";
+import {
+	ChannelNetwork
+} from "./ChannelNetwork"
 import {
 	createErrorResponseMessage,
 	createSuccessResponseMessage,
 	isRequestMessage,
 	validateMessage,
-} from "./messages";
+} from "./messages"
 
 export type ChannelReceiverOptions = {
-	readyTimeout: number;
-};
+	readyTimeout: number
+}
 
 export const channelReceiverDefaultOptions: ChannelReceiverOptions &
 	Partial<ChannelNetworkOptions> = {
 	readyTimeout: 20000,
 	requestIDPrefix: "receiver-",
-};
+}
 
 export type AllChannelReceiverOptions = ChannelReceiverOptions &
-	ChannelNetworkOptions;
+	ChannelNetworkOptions
 
 export abstract class ChannelReceiver<
 	TEmitterTransactions extends Record<string, UnknownTransaction> = Record<
@@ -49,33 +51,31 @@ export abstract class ChannelReceiver<
 	TEmitterTransactions,
 	ChannelReceiverOptions & TOptions
 > {
-	private _ready = false;
+	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 response = await this.postRequest<
 			RequestMessage<InternalReceiverRequestType.Ready>,
@@ -83,39 +83,37 @@ 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"];
+							message as InternalEmitterTransactions["connect"]["request"]
 						this.options = {
 							...this.options,
 							...data,
@@ -123,32 +121,32 @@ export abstract class ChannelReceiver<
 							debug: this.options.debug,
 							requestIDPrefix: this.options.requestIDPrefix,
 							readyTimeout: this.options.readyTimeout,
-						};
+						}
 
 						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(
+								;(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 +154,7 @@ export abstract class ChannelReceiver<
 				// Ignore unknown messages
 			} else {
 				// Should not be possible, but who knows :shrug:
-				throw error;
+				throw error
 			}
 		}
 	}
@@ -172,13 +170,13 @@ export abstract class ChannelReceiver<
 		if (!this._ready) {
 			throw new NotReadyError(
 				"Receiver is not ready, use `ChannelReceiver.ready()` first",
-			);
+			)
 		}
 
 		return this.postRequest(
 			this.createRequestMessage(type, data),
 			undefined,
 			options,
-		);
+		)
 	}
 }

package/src/channel/errors.ts

@@ -1,53 +1,53 @@
-import { UnknownErrorResponseMessage } from ".";
+import type { UnknownErrorResponseMessage } from "."
 
-import { UnknownRequestMessage } from "./types";
+import type { UnknownRequestMessage } from "./types"
 
 export class ResponseError<
 	TErrorResponse extends UnknownErrorResponseMessage,
 > extends Error {
-	public response: TErrorResponse;
+	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;
+	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,23 @@
-export { ChannelNetwork, channelNetworkDefaultOptions } from "./ChannelNetwork";
+export { ChannelNetwork, channelNetworkDefaultOptions } from "./ChannelNetwork"
 export type {
 	PostRequestOptions,
 	ChannelNetworkOptions,
-} from "./ChannelNetwork";
+} from "./ChannelNetwork"
 
-export { ChannelEmitter, channelEmitterDefaultOptions } from "./ChannelEmitter";
+export { ChannelEmitter, channelEmitterDefaultOptions } from "./ChannelEmitter"
 export type {
 	ChannelEmitterOptions,
 	AllChannelEmitterOptions,
-} from "./ChannelEmitter";
+} from "./ChannelEmitter"
 
 export {
 	ChannelReceiver,
 	channelReceiverDefaultOptions,
-} from "./ChannelReceiver";
+} from "./ChannelReceiver"
 export type {
 	ChannelReceiverOptions,
 	AllChannelReceiverOptions,
-} from "./ChannelReceiver";
+} from "./ChannelReceiver"
 
 export {
 	createRequestMessage,
@@ -28,7 +28,7 @@ export {
 	isResponseMessage,
 	isSuccessResponseMessage,
 	isErrorResponseMessage,
-} from "./messages";
+} from "./messages"
 
 export {
 	ResponseError,
@@ -38,12 +38,12 @@ export {
 	NotReadyError,
 	PortNotSetError,
 	ChannelNotSetError,
-} from "./errors";
+} from "./errors"
 
 export {
 	InternalEmitterRequestType,
 	InternalReceiverRequestType,
-} from "./types";
+} from "./types"
 export type {
 	// Messages
 	RequestMessage,
@@ -72,4 +72,4 @@ export type {
 	InternalEmitterTransactions,
 	// Receiver
 	InternalReceiverTransactions,
-} from "./types";
+} from "./types"

package/src/channel/messages.ts

@@ -1,6 +1,4 @@
-import statuses from "statuses";
-
-import {
+import type {
 	ErrorResponseMessage,
 	RequestMessage,
 	SuccessResponseMessage,
@@ -9,9 +7,19 @@ import {
 	UnknownRequestMessage,
 	UnknownResponseMessage,
 	UnknownSuccessResponseMessage,
-} from "./types";
+} from "./types"
+
+// Adapted from https://github.com/jshttp/statuses/blob/770a97d931c1bb40ebbfefdbb77f0419601890b5/codes.json
+const statuses = {
+	200: "ok",
+	201: "created",
+
+	400: "bad request",
+	500: "internal server error",
+	501: "not implemented",
+}
 
-let requestID = 0;
+let requestID = 0
 
 export const createRequestMessage = <
 	TType extends string = string,
@@ -25,58 +33,58 @@ export const createRequestMessage = <
 		requestID: `${prefix}${requestID++}`,
 		type,
 		data,
-	};
-};
+	}
+}
 
 export const createSuccessResponseMessage = <TData = undefined>(
 	requestID: string,
 	data: TData,
-	status: keyof typeof statuses.message = 200,
+	status: keyof typeof statuses = 200,
 ): SuccessResponseMessage<TData> => {
 	if (status >= 400) {
 		throw new TypeError(
 			`Invalid success status code, expected status to be within \`[100;400[\`, got \`${status}\``,
-		);
+		)
 	}
 
 	return {
 		requestID,
 		status,
-		msg: statuses.message[status]?.replace(/\.$/, "").toLowerCase() ?? "",
+		msg: statuses[status] ?? "",
 		data,
-	};
-};
+	}
+}
 
 export const createErrorResponseMessage = <TError = undefined>(
 	requestID: string,
 	error: TError,
-	status: keyof typeof statuses.message = 400,
+	status: keyof typeof statuses = 400,
 ): ErrorResponseMessage<TError> => {
 	if (status < 400) {
 		throw new TypeError(
-			`Invalid error status code, expected status to be within \`[500;600[\`, got \`${status}\``,
-		);
+			`Invalid error status code, expected status to be within \`[400;600[\`, got \`${status}\``,
+		)
 	}
 
 	return {
 		requestID,
 		status,
-		msg: statuses.message[status]?.replace(/\.$/, "").toLowerCase() ?? "",
+		msg: statuses[status] ?? "",
 		error,
-	};
-};
+	}
+}
 
 export const validateMessage = (message: unknown): UnknownMessage => {
 	if (typeof message !== "object" || message === null) {
 		throw new TypeError(
 			`Invalid message received, expected message to be of type \`object\`, got \`${typeof message}\``,
-		);
+		)
 	} else if (
 		!Object.keys(message).every((key) =>
 			["requestID", "type", "data", "status", "msg", "error"].includes(key),
 		)
 	) {
-		throw new TypeError(`Invalid message received: ${JSON.stringify(message)}`);
+		throw new TypeError(`Invalid message received: ${JSON.stringify(message)}`)
 	} else if (
 		typeof (message as Record<string, unknown>).requestID !== "string"
 	) {
@@ -84,32 +92,32 @@ export const validateMessage = (message: unknown): UnknownMessage => {
 			`Invalid message received, expected \`message.requestID\` to be of type \`string\`, got \`${typeof (
 				message as Record<string, unknown>
 			).id}\``,
-		);
+		)
 	}
 
-	return message as UnknownMessage;
-};
+	return message as UnknownMessage
+}
 
 export const isRequestMessage = (
 	message: UnknownMessage,
 ): message is UnknownRequestMessage => {
-	return "type" in message;
-};
+	return "type" in message
+}
 
 export const isResponseMessage = (
 	message: UnknownMessage,
 ): message is UnknownResponseMessage => {
-	return !("type" in message);
-};
+	return !("type" in message)
+}
 
 export const isSuccessResponseMessage = (
 	message: UnknownMessage,
 ): message is UnknownSuccessResponseMessage => {
-	return isResponseMessage(message) && !("error" in message);
-};
+	return isResponseMessage(message) && !("error" in message)
+}
 
 export const isErrorResponseMessage = (
 	message: UnknownMessage,
 ): message is UnknownErrorResponseMessage => {
-	return isResponseMessage(message) && !("data" in message);
-};
+	return isResponseMessage(message) && !("data" in message)
+}

package/src/channel/types.ts

@@ -1,61 +1,61 @@
 // Messages
 export type MessageBase = {
-	requestID: string;
-};
+	requestID: string
+}
 
 export type RequestMessage<TType extends string = string, TData = void> = {
-	type: TType;
-	data: TData;
-} & MessageBase;
+	type: TType
+	data: TData
+} & MessageBase
 
 export type ResponseMessageBase = {
-	status: number;
-	msg: string;
-} & MessageBase;
+	status: number
+	msg: string
+} & MessageBase
 
 export type SuccessResponseMessage<TData = void> = {
-	data: TData;
-	error?: never;
-} & ResponseMessageBase;
+	data: TData
+	error?: never
+} & ResponseMessageBase
 
 export type ErrorResponseMessage<TError = unknown> = {
-	data?: never;
-	error: unknown | TError;
-} & ResponseMessageBase;
+	data?: never
+	error: unknown | TError
+} & ResponseMessageBase
 
 export type ResponseMessage<TData = void, TError = unknown> =
 	| SuccessResponseMessage<TData>
-	| ErrorResponseMessage<TError>;
+	| ErrorResponseMessage<TError>
 
 export type ExtractSuccessResponseMessage<
 	TResponse extends UnknownResponseMessage,
-> = Extract<TResponse, { error?: never }>;
+> = Extract<TResponse, { error?: never }>
 
 export type ExtractErrorResponseMessage<
 	TResponse extends UnknownResponseMessage,
-> = Extract<TResponse, { data?: never }>;
+> = Extract<TResponse, { data?: never }>
 
 // Unknown messages
-export type UnknownRequestMessage = RequestMessage<string, unknown>;
+export type UnknownRequestMessage = RequestMessage<string, unknown>
 
-export type UnknownSuccessResponseMessage = SuccessResponseMessage<unknown>;
+export type UnknownSuccessResponseMessage = SuccessResponseMessage<unknown>
 
-export type UnknownErrorResponseMessage = ErrorResponseMessage<unknown>;
+export type UnknownErrorResponseMessage = ErrorResponseMessage<unknown>
 
 export type UnknownResponseMessage =
 	| UnknownSuccessResponseMessage
-	| UnknownErrorResponseMessage;
+	| UnknownErrorResponseMessage
 
-export type UnknownMessage = UnknownRequestMessage | UnknownResponseMessage;
+export type UnknownMessage = UnknownRequestMessage | UnknownResponseMessage
 
 // Transactions
 export type Transaction<
 	TRequest extends UnknownRequestMessage,
 	TResponse extends UnknownResponseMessage = ResponseMessage<void>,
 > = {
-	request: TRequest;
-	response: TResponse;
-};
+	request: TRequest
+	response: TResponse
+}
 
 export type TransactionMethod<
 	TTransaction extends Transaction<
@@ -64,7 +64,7 @@ export type TransactionMethod<
 	>,
 > = (
 	data: TTransaction["request"]["data"],
-) => Promise<ExtractSuccessResponseMessage<TTransaction["response"]>>;
+) => Promise<ExtractSuccessResponseMessage<TTransaction["response"]>>
 
 export type TransactionHandler<
 	TTransaction extends Transaction<
@@ -77,35 +77,35 @@ export type TransactionHandler<
 		success: (
 			data: ExtractSuccessResponseMessage<TTransaction["response"]>["data"],
 			status?: number,
-		) => ExtractSuccessResponseMessage<TTransaction["response"]>;
+		) => ExtractSuccessResponseMessage<TTransaction["response"]>
 		error: (
 			error: ExtractErrorResponseMessage<TTransaction["response"]>["error"],
 			status?: number,
-		) => ExtractErrorResponseMessage<TTransaction["response"]>;
+		) => ExtractErrorResponseMessage<TTransaction["response"]>
 	},
-) => Promise<TTransaction["response"]> | TTransaction["response"];
+) => Promise<TTransaction["response"]> | TTransaction["response"]
 
 export type TransactionsMethods<
 	TTransactions extends Record<string, UnknownTransaction>,
 > = {
-	[Key in keyof TTransactions]: TransactionMethod<TTransactions[Key]>;
-};
+	[Key in keyof TTransactions]: TransactionMethod<TTransactions[Key]>
+}
 
 export type TransactionsHandlers<
 	TTransactions extends Record<string, UnknownTransaction>,
 > = {
-	[Key in keyof TTransactions]: TransactionHandler<TTransactions[Key]>;
-};
+	[Key in keyof TTransactions]: TransactionHandler<TTransactions[Key]>
+}
 
 // Unknown transactions
 export type UnknownTransaction = Transaction<
 	UnknownRequestMessage,
 	UnknownResponseMessage
->;
+>
 
-export type UnknownTransactionMethod = TransactionMethod<UnknownTransaction>;
+export type UnknownTransactionMethod = TransactionMethod<UnknownTransaction>
 
-export type UnknownTransactionHandler = TransactionHandler<UnknownTransaction>;
+export type UnknownTransactionHandler = TransactionHandler<UnknownTransaction>
 
 // Emitter
 export enum InternalEmitterRequestType {
@@ -123,8 +123,8 @@ export type InternalEmitterTransactions<
 			  >
 			| undefined
 		>
-	>;
-};
+	>
+}
 
 // Receiver
 export enum InternalReceiverRequestType {
@@ -134,5 +134,5 @@ export enum InternalReceiverRequestType {
 export type InternalReceiverTransactions = {
 	[InternalReceiverRequestType.Ready]: Transaction<
 		RequestMessage<InternalReceiverRequestType.Ready>
-	>;
-};
+	>
+}

package/src/globalExtensions.ts

@@ -1,13 +1,13 @@
-import { SimulatorAPI } from "./SimulatorAPI";
-import { SimulatorClient } from "./SimulatorClient";
+import type { SimulatorAPI } from "./SimulatorAPI"
+import type { SimulatorClient } from "./SimulatorClient"
 
 declare global {
 	interface Window {
 		prismic?: {
 			sliceSimulator?: {
-				api?: SimulatorAPI[];
-				client?: SimulatorClient[];
-			};
-		};
+				api?: SimulatorAPI[]
+				client?: SimulatorClient[]
+			}
+		}
 	}
 }